From 4b7276f5d71c7afc8718905e5dcaef54c2bd9112 Mon Sep 17 00:00:00 2001
From: DKChan <524912269@qq.com>
Date: Sat, 7 Nov 2026 06:58:39 +0800
Subject: [PATCH 1/5] =?UTF-8?q?docs(=E5=BE=85=E5=8A=9E=E6=B8=85=E5=8D=95):?=
 =?UTF-8?q?=20=E7=BB=93=E7=AE=97=E6=98=8E=E7=BB=86=E6=96=87=E6=A1=88?=
 =?UTF-8?q?=E5=85=A5=E8=A1=A8=E6=9D=A1=E9=80=80=E5=BD=B9=EF=BC=8C=E6=94=B9?=
 =?UTF-8?q?=E7=AB=8B=E9=80=90=E8=A1=8C=E6=96=87=E5=AD=97=E5=88=97=E8=A1=A8?=
 =?UTF-8?q?=E9=80=80=E5=BD=B9=E4=B8=8E=E6=88=98=E6=96=97=E7=94=BB=E9=9D=A2?=
 =?UTF-8?q?=E4=BC=98=E5=8C=96=E4=B8=A4=E6=9D=A1=EF=BC=882026-11-07=20?=
 =?UTF-8?q?=E7=94=A8=E6=88=B7=E4=BB=A4=EF=BC=89?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

用户裁定：撤掉结算期逐行滚动文字列表、保留伤害飘字与攻击特效；日志零文案只存字段；战斗画面优化另立待办。日志核查结论：playtest_logger.gd:130-143 已逐行全字段落盘、开新与续玩均开会话，零缺漏，与裁定不符处是日志多带 text 与平铺 display_name 两处中文文案；动画特效走 target/target_id 不依赖行文案（battle_stage_view.gd:328-341）。08-Alpha版本标准「逐行结算排播」行定值删行（同表「战斗演出链」行已覆盖保留面），落文归文档设计段。凭据：文档域闸 --docs【验收通过】无新增红 exit=0；开工现查 5c4d6000 的 run 111 未落定（非红，不等待）。
---
 待办清单.md | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/待办清单.md b/待办清单.md
index 7a110d22..14003875 100644
--- a/待办清单.md
+++ b/待办清单.md
@@ -53,11 +53,21 @@
 
 **状态**：待文档设计
 
-#### 结算明细文案入表——玩家可见明细文案归属改数据表承载（2026-11-06 登记，来源=批次移交）
+#### 结算期逐行文字列表退役与日志零文案（2026-11-07 登记，来源=会话提及）
 
-**实况**：迭代 53 反哺点 4 归属裁决在案＝文案入数据表行（2026-11-06 用户裁）；规范句已落 [战斗结算](design/gdd/systems/战斗循环/战斗结算.md) v1.8 明细流水节（显示名等玩家可见文案＝数据面字段，代码读表拼行、禁代码写死文案字串）；现行代码硬编码面＝结算明细扩展行标签文案（如减半标签，reward_grant.gd:226 一族）。
+**实况**：用户裁定撤掉战斗屏结算期逐行滚动的文字列表，保留伤害飘字与攻击特效；日志零文案只存字段。现行日志已逐行全字段落盘（game/presentation/playtest_logger.gd:130-143；开新／续玩均开会话，game/presentation/main.gd:247/:295）——零缺漏、无需补采，与裁定不符处是日志多带中文文案两处（text 与平铺的 display_name）。文字列表消费面＝game/presentation/views/battle_log_view.gd:173-260 与 game/presentation/row_pacer.gd:100；动画特效走 target／target_id，不依赖行文案（game/presentation/views/battle_stage_view.gd:328-341）。[战斗结算](design/gdd/systems/战斗循环/战斗结算.md) v1.8 明细流水节规范句仍写「文案入表、代码读表拼行」，与本裁定相反。
 
-**缺口**：还差表结构设计讨论——承载表与字段形态、基础行文案是否同批入表、读表拼行接线面。
+**缺口**：还差设计讨论——文字列表退役范围（飘字与特效保留面）、日志两处中文字段清理、[08-Alpha版本标准](design/gdd/08-Alpha版本标准.md)「逐行结算排播」行删行（同表「战斗演出链」行已覆盖保留面）、[battle](design/ux/battle.md) 不可整体跳过承诺与[战斗表现](design/gdd/systems/战斗循环/战斗表现.md) 因果可读验收判据改写。
+
+**改动面**：文档＋游戏代码
+
+**状态**：待文档设计
+
+#### 战斗画面优化——动画演出与美术表现（2026-11-07 登记，来源=会话提及）
+
+**实况**：用户令单独立条，专门承接战斗画面优化；文字列表退役先行，本条开工待用户发令。承接面＝[战斗表现](design/gdd/systems/战斗循环/战斗表现.md) 输入清单（受击／弹道／退场／来源格可读化／高光兑现强化）与 P1 后置行；现行动画基础＝站桩闪白／弹道／灰化（game/presentation/views/battle_stage_view.gd:327-363），演出链已在 [08-Alpha版本标准](design/gdd/08-Alpha版本标准.md) 标在役。美术资产按用户自立批处理，本条不代跑。
+
+**缺口**：还差画面优化的设计讨论——动画密度与节奏、素材范围、验收判据（战斗表现.md:149「能说出这一行来自哪步操作」须改写）。
 
 **改动面**：文档＋游戏代码
 

From 9f21236f8044b9bb5dfaf48778f0fa66ea398bcb Mon Sep 17 00:00:00 2001
From: DKChan <524912269@qq.com>
Date: Sat, 7 Nov 2026 07:11:15 +0800
Subject: [PATCH 2/5] =?UTF-8?q?=E5=B7=A5=E7=A8=8B(=E6=B3=A8=E9=87=8A?=
 =?UTF-8?q?=E6=A0=87=E8=AE=B0=E8=AF=8D=E6=8D=A2=E4=BB=A3=C2=B7oracle?=
 =?UTF-8?q?=E2=86=92=E5=88=A4=E6=8D=AE=E5=87=BA=E5=A4=84):=20=E7=94=A8?=
 =?UTF-8?q?=E6=88=B7=202026-11-07=20=E4=BB=A4=E2=80=94=E2=80=94=E5=88=A4?=
 =?UTF-8?q?=E6=8D=AE=E5=87=BA=E5=A4=84=E6=B3=A8=E8=AE=B0=E7=9A=84=E6=A0=87?=
 =?UTF-8?q?=E8=AE=B0=E8=AF=8D=E6=94=B9=E7=94=A8=E9=A1=B9=E7=9B=AE=E5=B7=B2?=
 =?UTF-8?q?=E6=9C=89=E4=B8=AD=E6=96=87=E5=90=8D=EF=BC=8C=E9=81=BF=E5=85=8D?=
 =?UTF-8?q?=20Oracle=20=E8=A2=AB=E8=AF=BB=E6=88=90=E6=95=B0=E6=8D=AE?=
 =?UTF-8?q?=E5=BA=93=E3=80=82=E6=B3=A8=E9=87=8A=E6=A0=BC=E5=BC=8F=E5=8F=A5?=
 =?UTF-8?q?=E3=80=81=E6=9C=BA=E6=A3=80=E6=AD=A3=E5=88=99=E3=80=81=E6=A0=87?=
 =?UTF-8?q?=E8=AF=86=E7=AC=A6=E3=80=81=E5=8D=A1=E7=89=87=E4=B8=8E=E7=99=BB?=
 =?UTF-8?q?=E8=AE=B0=E5=90=8C=E6=AD=A5=E6=8D=A2=E4=BB=A3=EF=BC=9B=E9=9B=B6?=
 =?UTF-8?q?=E8=A1=8C=E4=B8=BA=E6=94=B9=E5=8A=A8=E3=80=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

改动面 112 文件 572+/572-：game/tests/** 与 game/probe/** 共 106 件 545 行 `# oracle:`→`# 判据出处:`；tools/capability_audit.py 正则字面量换中文＋ORACLE_*→CRITERION_*／check_oracle_markers→check_criterion_markers／oracle_marked(flagged)→criterion_* 共 11 行；test-conventions.md:119 格式句＋:155 措辞；待办清单与需求卡片-QA覆盖余量收口批各 1 处字面量；coverage_enum.py:21 与 camp_scene_layout_test.gd:101 旁支措辞；ui_click_probe.gd 对拍局部变量 oracle→expected 7 处；auto_player.gd 三处 safe_set 真值措辞。不动：历史审计报告两份、test-oracle-anchor 分支名、git 史、生成日志；指针格式/扫描面/判红条件/验收义务全不变。

读数（区内实跑）：改前 capability_audit --strict「417 注记函数·红项 0」→改后「417 判据出处注记函数·红项 0」exit=0；新标记 545 行/106 文件，现行义务面 oracle 残留 0（在册沿革除外）；diff 自检 game/ 非注释新增行仅 6 行且全在 ui_click_probe.gd 的 expected 变量段；112 改动文件 CRLF=0；py_compile tools/capability_audit.py OK；--docs exit=0【验收通过】无新增红；--gates exit=0（静态扫描绿、闸壳 bash -n ×13 失败 0）。
---
 design/engineering/test-conventions.md        |  4 +-
 game/probe/board_shot_probe.gd                |  6 +-
 game/probe/fx_probe.gd                        |  2 +-
 game/probe/fx_shot_probe.gd                   |  6 +-
 game/probe/layout_probe.gd                    |  4 +-
 game/probe/level_map_shot_probe.gd            |  6 +-
 game/probe/level_map_viewport_probe.gd        | 22 +++----
 game/probe/probe_coverage_recorder.gd         |  2 +-
 game/probe/screen_flow_probe.gd               | 26 ++++-----
 game/probe/shot_probe.gd                      | 22 +++----
 game/probe/t17_defer_probe.gd                 |  2 +-
 game/probe/type_glow_shot_probe.gd            |  2 +-
 game/probe/ui_click_probe.gd                  | 58 +++++++++----------
 game/probe/ui_contrast_probe.gd               |  2 +-
 game/probe/ui_input_probe.gd                  | 24 ++++----
 game/probe/ui_probe.gd                        | 28 ++++-----
 game/probe/ui_struct_probe.gd                 | 22 +++----
 game/probe/ui_tune_probe.gd                   | 12 ++--
 game/sim/auto_player.gd                       |  6 +-
 game/tests/smoke_boot.gd                      |  6 +-
 game/tests/system_test.gd                     | 16 ++---
 .../unit/battle_settlement/boss_gate_test.gd  |  4 +-
 .../damage_controller_test.gd                 | 26 ++++-----
 .../battle_settlement/damage_math_test.gd     | 10 ++--
 .../battle_settlement/effect_port_test.gd     |  8 +--
 .../extended_row_violation_test.gd            |  2 +-
 .../battle_settlement/refresh_feats_test.gd   | 26 ++++-----
 .../battle_settlement/roll_multiplier_test.gd | 14 ++---
 .../round_flow_skill_pool_test.gd             | 30 +++++-----
 .../battle_settlement/seal_polarity_test.gd   | 32 +++++-----
 .../settlement_wiring_snapshot_test.gd        |  2 +-
 .../battle_settlement/skill_unlock_test.gd    | 10 ++--
 .../battle_settlement/trigger_cond_test.gd    |  2 +-
 .../variant_placement_test.gd                 |  8 +--
 .../tests/unit/contracts/source_guard_test.gd |  4 +-
 .../unit/contracts/system_contracts_test.gd   | 50 ++++++++--------
 game/tests/unit/core/adventure_feats_test.gd  |  8 +--
 .../unit/core/auto_player_deduce_test.gd      |  2 +-
 .../unit/core/battle_driver_drive_test.gd     |  8 +--
 game/tests/unit/core/board_gen_reward_test.gd | 10 ++--
 game/tests/unit/core/board_generator_test.gd  | 14 ++---
 .../tests/unit/core/breakpoint_resume_test.gd |  2 +-
 .../core/config_db_cross_validator_test.gd    |  8 +--
 .../unit/core/config_db_resolver_test.gd      | 14 ++---
 .../unit/core/curio_refresh_paid_test.gd      |  2 +-
 game/tests/unit/core/effect_words_t1_test.gd  |  2 +-
 .../unit/core/encapsulation_p2_sweep_test.gd  | 12 ++--
 .../unit/core/encapsulation_sweep_test.gd     | 20 +++----
 game/tests/unit/core/feat_vouchers_test.gd    |  2 +-
 game/tests/unit/core/hero_ledger_test.gd      |  2 +-
 .../unit/core/level_map_type_vis_test.gd      | 18 +++---
 .../unit/core/level_shop_economy_test.gd      | 28 ++++-----
 .../unit/core/level_table_validate_test.gd    |  8 +--
 .../unit/core/meta_progression_forge_test.gd  | 22 +++----
 .../tests/unit/core/minesweeper_rules_test.gd | 14 ++---
 .../unit/core/node_map_generator_test.gd      | 22 +++----
 game/tests/unit/core/node_map_growth_test.gd  | 10 ++--
 .../unit/core/playtest_logger_guard_test.gd   |  2 +-
 game/tests/unit/core/pool_case_d_test.gd      | 10 ++--
 game/tests/unit/core/run_time_fatal_test.gd   | 12 ++--
 .../unit/core/save_boot_no_activate_test.gd   |  8 +--
 .../unit/core/save_manager_domain_test.gd     |  6 +-
 .../unit/core/save_slot_isolation_test.gd     |  6 +-
 .../tests/unit/core/save_slot_summary_test.gd |  6 +-
 game/tests/unit/core/settle_segments_test.gd  |  2 +-
 game/tests/unit/core/treasure_effects_test.gd |  2 +-
 game/tests/unit/core/treasure_items_test.gd   |  2 +-
 .../unit/core/tree_requires_level_test.gd     |  2 +-
 game/tests/unit/core/tree_rules_v11_test.gd   |  4 +-
 game/tests/unit/cross_system_flow_test.gd     | 10 ++--
 .../data_config/config_db_fatal_oob_test.gd   |  4 +-
 game/tests/unit/data_config/config_db_test.gd | 14 ++---
 .../data_config/counter_prefix_fatal_test.gd  |  4 +-
 .../data_config/effect_kind_retired_test.gd   |  4 +-
 game/tests/unit/data_config/elite_row_test.gd | 12 ++--
 .../unit/data_config/forge_table_test.gd      | 10 ++--
 .../unit/data_config/level_gen_params_test.gd |  8 +--
 .../reward_dangling_treasure_test.gd          |  4 +-
 .../unit/data_config/rng_service_test.gd      | 10 ++--
 .../unit/data_config/rng_stream_boot_test.gd  |  2 +-
 .../data_config/table_structure_guard_test.gd | 22 +++----
 .../treasure_target_violation_test.gd         |  4 +-
 game/tests/unit/example_test.gd               |  2 +-
 game/tests/unit/node_map_determinism_test.gd  |  4 +-
 .../presentation/animation_frame_spec_test.gd |  6 +-
 .../unit/presentation/battle_narrator_test.gd | 14 ++---
 .../presentation/camp_scene_layout_test.gd    | 10 ++--
 .../unit/presentation/confirm_dialog_test.gd  |  6 +-
 .../unit/presentation/forge_workbench_test.gd |  4 +-
 .../unit/presentation/hud_presenter_test.gd   |  8 +--
 .../presentation/level_map_info_fog_test.gd   | 16 ++---
 .../unit/presentation/modal_flow_test.gd      |  2 +-
 .../unit/presentation/pacing_queue_test.gd    |  6 +-
 .../palette_token_pairwise_test.gd            |  4 +-
 .../presentation/player_copy_sweep_test.gd    | 16 ++---
 .../presentation_encapsulation_sweep_test.gd  | 16 ++---
 .../unit/presentation/reward_overlay_test.gd  |  6 +-
 .../presentation/seal_mark_params_test.gd     |  8 +--
 .../unit/presentation/settings_store_test.gd  |  8 +--
 .../presentation/stage_background_test.gd     | 14 ++---
 .../presentation/standee_fx_sweep_test.gd     |  2 +-
 .../standee_present_values_test.gd            |  4 +-
 .../presentation/terrain_tile_sets_test.gd    |  8 +--
 .../presentation/theme_projection_test.gd     | 24 ++++----
 .../tune_sim_batch_parity_test.gd             |  4 +-
 .../tests/unit/presentation/type_glow_test.gd | 12 ++--
 .../unit/presentation/ui_font_asset_test.gd   |  2 +-
 game/tests/unit/save_rng_roundtrip_test.gd    |  6 +-
 .../需求卡片-QA覆盖余量收口批-2026-11-07.md   |  2 +-
 tools/capability_audit.py                     | 22 +++----
 tools/coverage_enum.py                        |  2 +-
 待办清单.md                                   |  2 +-
 112 files changed, 572 insertions(+), 572 deletions(-)

diff --git a/design/engineering/test-conventions.md b/design/engineering/test-conventions.md
index 0550d090..1f6612fe 100644
--- a/design/engineering/test-conventions.md
+++ b/design/engineering/test-conventions.md
@@ -116,7 +116,7 @@
 
 **判据出处行锚（2026-11-05 立，自 2026-11-05 起对文件名日期不早于该日的需求卡片生效；旧卡不回头改，被编入迭代开工前由写卡段按本粒度补挂）**：对照表「需求点」列每行必须带**判据出处行锚**——该行验收判据所依据的现行文档句子，格式「`<文档相对路径>:<行号>`」。现行文档＝`design/` 全域现行文档（含 `ux/` 交互规格与 art-bible 的判据行）；已退役的需求卡片不是现行文档，不得充当判据出处。作用＝断言预期值从规格句抄出，不从实现反推：实现行为与规格句冲突时断言红；规格缺席的行写不出锚，即停卡退回写卡段（那是需求澄清缺口，不是测试缺口）。机检＝`tools/pipeline_gate.py` 判据 C5（锚格式与指向存在性，按卡文件名日期分流）＋`tools/capability_audit.py` 链式锚检查（断言→套件→能力行→系统文档，见 §8.9）。
 
-**测试函数的判据出处注记（2026-11-06 立）**：`game/tests/**` 与 `game/probe/**` 内每个**验证函数**（函数体含 `check(`／`check_quiet(`／`_problems.append(`／`push_error(` 判定调用的函数——定义行与 `_check(` 前缀不作判定计）必须带至少一条**判据出处注记**，格式「`# oracle: <design/相对路径>:<行号> <判据一句>`」——指针在前、判据摘要句在后，断言预期值的出处随断言走：断言红时读注记即达出处文档句，零查表。指针空间＝`design/` 全域现行文档（行为测试锚 owner 系统文档「验收标准」句或 `ux/` 规格句；惯例类测试〔封装扫描、判定通道纪律、驱动契约〕锚规约条款行）；`game/sim/` 不进扫描面（测量面直构惯例）。与链式锚的分工：链式锚（断言→套件→能力行→系统文档）不变、属义务清单层；本注记属执行证据层、写在断言文件内，非独立账本（§8.9 法则 4 不变）。写新测试函数时当场挂注记；被指规格句改行号时随批维护指针——死指针即红。局限如实声明：注记是被动文本，句内容改而行数不变时机检抓不到（与卡片判据 C5 同限）。机检＝`tools/capability_audit.py` 判据出处注记道（覆盖检查＋指针存在性；扫描面零文件自检红）。规格缺席写不出锚＝发现规格缺口：记发现不造锚、收尾呈报，禁锚到非现行文档凑数。
+**测试函数的判据出处注记（2026-11-06 立）**：`game/tests/**` 与 `game/probe/**` 内每个**验证函数**（函数体含 `check(`／`check_quiet(`／`_problems.append(`／`push_error(` 判定调用的函数——定义行与 `_check(` 前缀不作判定计）必须带至少一条**判据出处注记**，格式「`# 判据出处: <design/相对路径>:<行号> <判据一句>`」——指针在前、判据摘要句在后，断言预期值的出处随断言走：断言红时读注记即达出处文档句，零查表。指针空间＝`design/` 全域现行文档（行为测试锚 owner 系统文档「验收标准」句或 `ux/` 规格句；惯例类测试〔封装扫描、判定通道纪律、驱动契约〕锚规约条款行）；`game/sim/` 不进扫描面（测量面直构惯例）。与链式锚的分工：链式锚（断言→套件→能力行→系统文档）不变、属义务清单层；本注记属执行证据层、写在断言文件内，非独立账本（§8.9 法则 4 不变）。写新测试函数时当场挂注记；被指规格句改行号时随批维护指针——死指针即红。局限如实声明：注记是被动文本，句内容改而行数不变时机检抓不到（与卡片判据 C5 同限）。机检＝`tools/capability_audit.py` 判据出处注记道（覆盖检查＋指针存在性；扫描面零文件自检红）。规格缺席写不出锚＝发现规格缺口：记发现不造锚、收尾呈报，禁锚到非现行文档凑数。
 
 **验收档申报（2026-11-04 立，自 2026-11-05 起对文件名日期不早于该日的需求卡片生效；旧卡不回头改）**：每张需求卡片在头部信息区（与设计事实源声明同区）申报一个验收档，三档：高／中／低。判据＝失败代价单维——这条改动做错了，后果随存档或结算传播的（存档写读与迁移、RNG 流、战斗结算公式与乘区、经济入账、数值表结构校验）＝高；后果玩家可见但不损持久状态的（常规玩法逻辑、门控、交互逻辑、呈现数据面）＝中；后果即看即知且无状态残留的（文案、纯呈现样式、布局微调）＝低。一张卡触多档按最高档申报；申报由写卡段落笔，用户批卡（U0）时确认或改判。档位只调节 §8.7 审计深度——闸机与 CI 的域划分、选闸算法、全量强制档一概不因档位变化，真实入口、判据绑定面、禁削弱等验收闭合判据全部照旧。未申报档位的卡一律按高档全量审计。机检＝`tools/pipeline_gate.py` 判据 C4：卡内须含「验收档：高／中／低」申报行。
 
@@ -152,7 +152,7 @@
 2. 抽查判据绑定面：断言从真实入口进入、钉在被测改动的特有可观测提交面上，且当轮真实跑批执行过；
 3. 检查测试削弱：删除断言、放宽阈值、缩小扫描面、换下层直调，逐处要卡片申报或用户批准。
 4. 核对内部字段直查的受控例外：直查行是否已在对照表注明理由（该行为无公开可观测面可钉）。
-5. 核对判据出处：抽查断言的预期值能否从其判据出处行锚（§8.3）的规格句独立写出——预期值只在实现里有的（同义反复，oracle 镜像实现），判红。
+5. 核对判据出处：抽查断言的预期值能否从其判据出处行锚（§8.3）的规格句独立写出——预期值只在实现里有的（同义反复，判据镜像实现），判红。
 
 **审计深度分级（2026-11-04 立）**：审计按卡内申报的验收档（§8.3）逐卡定深度；梯度只落在昂贵的判断件上，机械且堵造假向量的两件（削弱检查、例外核对）三档全保留不抽。中/低档省略的测试复跑以远端 CI 读数为执行证据——`tools/ci_check.sh <合并提交>` 的现查输出（commit＋run 号＋conclusion）是机器产物，run 号在远端永久可复核，审计报告照抄该行即可；照抄前先核对读数必须是「绿」——「未验」（零触发批跑闸步全跳过）与「不可判」不作证据，那种批的回补办法是等一次含代码面的合回或用户自发全量回归（2026-11-04 用户裁：回执等待件退役，证据由落盘文件改为现查读数；「不采信实现者自述已全绿」的口径不变）：
 
diff --git a/game/probe/board_shot_probe.gd b/game/probe/board_shot_probe.gd
index 76dcdade..325c4c19 100644
--- a/game/probe/board_shot_probe.gd
+++ b/game/probe/board_shot_probe.gd
@@ -26,7 +26,7 @@ var _cur_settlement = null   # 当关 settlement（身份回调读取面——
 
 
 func _ready() -> void:
-# oracle: design/engineering/test-conventions.md:84 （棋盘截图取证——渲染闸采集组）
+# 判据出处: design/engineering/test-conventions.md:84 （棋盘截图取证——渲染闸采集组）
 	# 运行前提=窗口化真渲染面（shot_probe 同款护栏——headless 下 frame_post_draw 永不触发+视口纹理恒空）
 	if DisplayServer.get_name() == "headless":
 		print("[board_shot] FAIL — 本探针必须窗口化运行（headless 无渲染面，截图必空）；现行事实源=tools/render_gate.sh 取证段")
@@ -182,7 +182,7 @@ func _ready() -> void:
 # 判据：环外径像素 ÷ 格边 落 0.82±1px；封印格最外圈 1px 框最暗值与相邻未封印未开格同位框最暗值差 ≤1/255
 #（halo 在 0.455×格边归零——格边框不应被压暗；相邻未开格同砖纹理同套瓦片为无封印参照）。
 func _seal_evidence(tag: String, view: Node, settlement: Object, off_img: Image, out: String) -> void:
-# oracle: design/engineering/test-conventions.md:84 （封印印记像素取证组）
+# 判据出处: design/engineering/test-conventions.md:84 （封印印记像素取证组）
 	var ms = settlement.minesweeper
 	var seal_cell := Vector2i(-9, -9)
 	var ref_cell := Vector2i(-9, -9)
@@ -290,7 +290,7 @@ func _probe_identity_lookup(c: Vector2i):
 # 双帧逐像素比对：所有变化像素必须落在生效格的内缘带内
 # （de < cell÷8——带外含砖心零侵入＝禁整格染色／禁越圈）；每个生效格须有实绘像素（不空转）。
 func _check_dual_frames(tag: String, view, glow_cells: Dictionary, off_img: Image, on_img: Image) -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	var board = view.board()
 	if board == null:
 		_problems.append("%s 双帧比对取板失败（view.board() 为 null）" % tag)
diff --git a/game/probe/fx_probe.gd b/game/probe/fx_probe.gd
index 5ea3d1ad..365a8d6b 100644
--- a/game/probe/fx_probe.gd
+++ b/game/probe/fx_probe.gd
@@ -8,7 +8,7 @@ extends Node
 
 
 func _ready() -> void:
-# oracle: design/gdd/systems/战斗循环/战斗表现.md:148 （结算演出——挖掘期零打扰组）
+# 判据出处: design/gdd/systems/战斗循环/战斗表现.md:148 （结算演出——挖掘期零打扰组）
 	await get_tree().process_frame
 	var problems: Array = []
 
diff --git a/game/probe/fx_shot_probe.gd b/game/probe/fx_shot_probe.gd
index 71c2daa7..a953779b 100644
--- a/game/probe/fx_shot_probe.gd
+++ b/game/probe/fx_shot_probe.gd
@@ -21,7 +21,7 @@ var _problems: Array = []
 
 
 func _ready() -> void:
-# oracle: design/engineering/test-conventions.md:84 （特效截图取证——渲染闸采集组）
+# 判据出处: design/engineering/test-conventions.md:84 （特效截图取证——渲染闸采集组）
 	var args := OS.get_cmdline_user_args()
 	out_dir = args[0] if args.size() >= 1 and args[0] != "" else "user://qa-fx"
 	DirAccess.make_dir_recursive_absolute(out_dir)
@@ -108,7 +108,7 @@ func _ready() -> void:
 
 
 func _snap(tag: String) -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	await RenderingServer.frame_post_draw
 	var img: Image = get_viewport().get_texture().get_image()
 	if img == null or img.is_empty():
@@ -118,7 +118,7 @@ func _snap(tag: String) -> void:
 
 
 func _fail(msg: String) -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	_problems.append(msg)
 	push_error("[fx_shot_probe] FAIL — " + msg)
 	get_tree().quit(1)
diff --git a/game/probe/layout_probe.gd b/game/probe/layout_probe.gd
index 3b9f88e1..e0e8ddf9 100644
--- a/game/probe/layout_probe.gd
+++ b/game/probe/layout_probe.gd
@@ -19,7 +19,7 @@ var _est_reads: Dictionary = {}    # 逐档 13/14 板推定读数留痕（label
 
 
 func _ready() -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:264 （战斗屏三区几何与棋盘格边长——分辨率档位组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:264 （战斗屏三区几何与棋盘格边长——分辨率档位组）
 	await get_tree().process_frame
 	var main: Node = load("res://presentation/main.tscn").instantiate()
 	add_child(main)
@@ -59,7 +59,7 @@ func _ready() -> void:
 
 # 一份不变量断言，逐档代入——代码量与档数无关
 func _check_one(label: String, main: Node) -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:264 （单档几何断言组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:264 （单档几何断言组）
 	var vr: Rect2 = get_viewport().get_visible_rect()
 	if vr.size != Vector2(VIEWPORTS[0]["size"]) and vr.size.y < 1.0:
 		_problems.append("[%s] 逻辑视口退化 %s" % [label, vr.size])
diff --git a/game/probe/level_map_shot_probe.gd b/game/probe/level_map_shot_probe.gd
index a201979c..f637f333 100644
--- a/game/probe/level_map_shot_probe.gd
+++ b/game/probe/level_map_shot_probe.gd
@@ -11,7 +11,7 @@ extends Node
 const SEED_L3 := 910212   # 深图固定种子（与 level_map_viewport_probe 同源——图确定性承载）
 
 func _ready() -> void:
-# oracle: design/engineering/test-conventions.md:84 （关卡画面截图取证——载入守卫组）
+# 判据出处: design/engineering/test-conventions.md:84 （关卡画面截图取证——载入守卫组）
 	var args := OS.get_cmdline_user_args()
 	var out_dir := args[0] if args.size() > 0 else "user://"
 	await get_tree().process_frame
@@ -45,7 +45,7 @@ func _settle() -> void:
 
 
 func _make_runner(entry: bool, node_id: int):
-# oracle: design/engineering/test-conventions.md:84 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:84 （判定上报通道——验证函数组）
 	var rng = load("res://core/rng_service.gd").new()
 	rng.new_adventure(SEED_L3)
 	var runner = load("res://core/level_runner.gd").new(get_node("/root/ConfigDB"), rng)
@@ -85,7 +85,7 @@ func _deepest_with_outs(screen, runner) -> int:
 
 
 func _shot(out_dir: String, fname: String) -> void:
-# oracle: design/engineering/test-conventions.md:84 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:84 （判定上报通道——验证函数组）
 	DirAccess.make_dir_recursive_absolute(out_dir)   # 落盘目录自建（save_png 对缺目录静默失败——刷新链不预建）
 	var img := get_viewport().get_texture().get_image()
 	var err := img.save_png(out_dir.path_join(fname))
diff --git a/game/probe/level_map_viewport_probe.gd b/game/probe/level_map_viewport_probe.gd
index a83c93d3..42118dbe 100644
--- a/game/probe/level_map_viewport_probe.gd
+++ b/game/probe/level_map_viewport_probe.gd
@@ -22,14 +22,14 @@ var _runner   # 当前停点的单关 runner（open_choices 驱动随记——
 
 
 func _check(desc: String, ok: bool) -> void:
-# oracle: design/ux/level-map.md:3 （判定上报通道——验证函数组）
+# 判据出处: design/ux/level-map.md:3 （判定上报通道——验证函数组）
 	_checks += 1
 	if not ok:
 		_problems.append(desc)
 
 
 func _ready() -> void:
-# oracle: design/ux/level-map.md:3 （关卡画面视口跟随——卷轴视口组）
+# 判据出处: design/ux/level-map.md:3 （关卡画面视口跟随——卷轴视口组）
 	await get_tree().process_frame
 	await get_tree().process_frame
 	var host := Control.new()
@@ -62,7 +62,7 @@ func _ready() -> void:
 
 ## R1 浅图整幅居中无裁切＋画布入视口件承载（画布=视口首子件——setup 注入序）
 func _probe_shallow_no_crop(screen, vp) -> void:
-# oracle: design/ux/level-map.md:3 （浅层不裁切组）
+# 判据出处: design/ux/level-map.md:3 （浅层不裁切组）
 	_runner = _make_runner_entry(1, SEED_L1)
 	screen.open_choices(_cand_nodes(_runner), _runner)
 	await get_tree().process_frame
@@ -81,7 +81,7 @@ func _probe_shallow_no_crop(screen, vp) -> void:
 
 ## R5 前置＋深图入口停点：锚点=入口组包围盒中心夹紧（spec :101——多入口并列取包围盒居中）
 func _probe_deep_entry_clamp(screen, vp) -> void:
-# oracle: design/ux/level-map.md:3 （深层入口钳制组）
+# 判据出处: design/ux/level-map.md:3 （深层入口钳制组）
 	_runner = _make_runner_entry(3, SEED_L3)
 	screen.open_choices(_cand_nodes(_runner), _runner)
 	await get_tree().process_frame
@@ -175,7 +175,7 @@ func _probe_clamp_bounds_and_columns(screen, vp) -> void:
 
 ## R6 拖拽不触发选路提交；阈值另一侧完整点击仍提交（提交语义零改动）
 func _probe_drag_no_submit(screen, vp) -> void:
-# oracle: design/ux/level-map.md:3 （判定上报通道——验证函数组）
+# 判据出处: design/ux/level-map.md:3 （判定上报通道——验证函数组）
 	# 重建到中段可居中停点（候选=停点出边——候选节点居屏中可拖可达）
 	var stops := _centerable_stops(screen, vp)
 	if stops.size() < 3:
@@ -214,7 +214,7 @@ func _probe_drag_no_submit(screen, vp) -> void:
 
 ## R2 停点切换后当前节点居中（视口中线投影 x=640±2——视口满屏宽即屏中线）
 func _probe_follow_anchor(screen, vp) -> void:
-# oracle: design/ux/level-map.md:3 （判定上报通道——验证函数组）
+# 判据出处: design/ux/level-map.md:3 （判定上报通道——验证函数组）
 	var stops := _centerable_stops(screen, vp)
 	if stops.size() < 3:
 		_problems.append("R2 可居中停点不足（=%d）" % stops.size())
@@ -230,7 +230,7 @@ func _probe_follow_anchor(screen, vp) -> void:
 
 ## R7 平滑滚动有 tween 中间帧；减动效开＝位置即达（画布坐标域判定）
 func _probe_smooth_scroll_reduced_motion(screen, vp) -> void:
-# oracle: design/ux/level-map.md:3 （判定上报通道——验证函数组）
+# 判据出处: design/ux/level-map.md:3 （判定上报通道——验证函数组）
 	var saved_scale: float = UiKit.motion_scale
 	UiKit.motion_scale = 1.0
 	var stops := _centerable_stops(screen, vp)
@@ -270,7 +270,7 @@ func _probe_smooth_scroll_reduced_motion(screen, vp) -> void:
 
 ## R8 指引件可见性与几何（深图超窗——像素级判据②③）
 func _probe_guidance_chrome(screen, vp) -> void:
-# oracle: design/ux/level-map.md:3 （判定上报通道——验证函数组）
+# 判据出处: design/ux/level-map.md:3 （判定上报通道——验证函数组）
 	var band_l: Control = vp.get_node_or_null(NodePath("FadeL"))
 	var band_r: Control = vp.get_node_or_null(NodePath("FadeR"))
 	var chip: Control = vp.get_node_or_null(NodePath("PanHint"))
@@ -302,7 +302,7 @@ func _probe_shallow_guidance_hidden(screen, vp) -> void:
 
 ## 入口停点 runner（defer_entry——选路态挂起、候选=入口节点）
 func _make_runner_entry(level_index: int, seed_val: int):
-# oracle: design/ux/level-map.md:3 （判定上报通道——验证函数组）
+# 判据出处: design/ux/level-map.md:3 （判定上报通道——验证函数组）
 	var rng = load("res://core/rng_service.gd").new()
 	rng.new_adventure(seed_val)
 	var runner = load("res://core/level_runner.gd").new(get_node("/root/ConfigDB"), rng)
@@ -313,7 +313,7 @@ func _make_runner_entry(level_index: int, seed_val: int):
 
 ## 中段停点 runner（断点续玩重建——图由种子+参数档重生成同图，零 RNG 消耗）
 func _make_runner_at_stop(level_index: int, seed_val: int, node_id: int):
-# oracle: design/ux/level-map.md:3 （判定上报通道——验证函数组）
+# 判据出处: design/ux/level-map.md:3 （判定上报通道——验证函数组）
 	var rng = load("res://core/rng_service.gd").new()
 	rng.new_adventure(seed_val)
 	var runner = load("res://core/level_runner.gd").new(get_node("/root/ConfigDB"), rng)
@@ -388,7 +388,7 @@ func _extreme_node(pos: Dictionary, nodes: Array, first: bool) -> Dictionary:
 
 
 func _finish() -> void:
-# oracle: design/ux/level-map.md:3 （判定上报通道——验证函数组）
+# 判据出处: design/ux/level-map.md:3 （判定上报通道——验证函数组）
 	if _checks == 0:
 		_problems.append("零断言执行（断言数下限闸——三硬闸③）")
 	if _problems.is_empty():
diff --git a/game/probe/probe_coverage_recorder.gd b/game/probe/probe_coverage_recorder.gd
index c13abde8..b45dcfad 100644
--- a/game/probe/probe_coverage_recorder.gd
+++ b/game/probe/probe_coverage_recorder.gd
@@ -199,7 +199,7 @@ func _seen_into(node: Node, keys: Array[String]) -> void:
 # ---- 落盘（JSONP 式 .js——file:// 页面 <script src> 直载）----
 
 func dump_js() -> void:
-# oracle: design/engineering/test-conventions.md:30 （覆盖登记落盘守卫——判定上报通道组）
+# 判据出处: design/engineering/test-conventions.md:30 （覆盖登记落盘守卫——判定上报通道组）
 	var dir := DirAccess.open("res://")
 	if dir == null:
 		push_error("[coverage] res:// 打不开，登记未落盘")
diff --git a/game/probe/screen_flow_probe.gd b/game/probe/screen_flow_probe.gd
index db6b9082..0cde4ff0 100644
--- a/game/probe/screen_flow_probe.gd
+++ b/game/probe/screen_flow_probe.gd
@@ -76,14 +76,14 @@ func _seals_text(f: Dictionary) -> String:
 
 # ---- 流程状态位（与可见性是两回事，逐步单独判）----
 func _expect_adventure_seal(step: String, expect: bool) -> void:
-	# oracle: design/engineering/architecture/architecture.md:168 （状态位判据组）
+	# 判据出处: design/engineering/architecture/architecture.md:168 （状态位判据组）
 	var got: bool = main.run_scope != null and main.run_scope.is_adventure
 	if got != expect:
 		_problems.append("%s：流程状态位 is_adventure 应为 %s，实测 %s" % [step, str(expect), str(got)])
 
 
 func _expect_exclusive(step: String, expect: String) -> void:
-	# oracle: design/engineering/architecture/architecture.md:168 （屏级互斥组）
+	# 判据出处: design/engineering/architecture/architecture.md:168 （屏级互斥组）
 	var f: Dictionary = _screen_seals()
 	var pairs := [["菜单", "营地"], ["菜单", "冒险"], ["营地", "冒险"], ["终局", "营地"], ["终局", "菜单"]]
 	for pair in pairs:
@@ -110,7 +110,7 @@ func _frames(n: int = 2) -> void:
 
 # ---- ① boot：菜单独占 ----
 func _step_boot_menu() -> void:
-	# oracle: design/engineering/test-conventions.md:49 （boot 组）
+	# 判据出处: design/engineering/test-conventions.md:49 （boot 组）
 	_expect_exclusive("①boot", "菜单")
 	_expect_adventure_seal("①boot", false)
 	if main.ui.modals.menu.debug_overlay != null and main.ui.modals.menu.debug_overlay.visible:
@@ -119,7 +119,7 @@ func _step_boot_menu() -> void:
 
 # ---- ② 菜单 → 营地（真实按钮信号路径）----
 func _step_menu_to_camp() -> void:
-	# oracle: design/ux/camp.md:10 （菜单→营地组）
+	# 判据出处: design/ux/camp.md:10 （菜单→营地组）
 	# 营地经进档开层（卡② mn9 新路径——campbtn 已撤；槽模板注入隔离命名空间）
 	if not await ProbeUiUtil.open_camp_via_savesel(main, "smoke_screen_flow_camp"):
 		_problems.append("②菜单→营地：选档层新档钮缺失（新路径驱动中断）")
@@ -130,7 +130,7 @@ func _step_menu_to_camp() -> void:
 
 # ---- ③ 营地 → 菜单（回退路径：篝火二次确认动线——卡④ 营地唯一回菜单出口；选档层随关层收闭同收）----
 func _step_camp_back_to_menu() -> void:
-	# oracle: design/ux/camp.md:22 （营地→菜单组）
+	# 判据出处: design/ux/camp.md:22 （营地→菜单组）
 	if main.ui.modals.camp.scene == null:
 		_problems.append("③营地→菜单：营地场景根句柄缺失〔句柄子容器批 V1〕")
 		return
@@ -147,7 +147,7 @@ func _step_camp_back_to_menu() -> void:
 # ---- 选档界面开合（卡③ sl10）：函数直调开层（「进入存档」钮归卡② mn3）→屏级互斥采样→
 # 返回钮真实信号路径关闭→ESC 语境不响应（卡⑤ 契约 2 范围外——零实现即断言）。----
 func _step_save_select_open_back() -> void:
-	# oracle: design/gdd/systems/表现与支撑/存档序列化.md:61 （选档开合组）
+	# 判据出处: design/gdd/systems/表现与支撑/存档序列化.md:61 （选档开合组）
 	ProbeUiUtil.isolate_save(main, "smoke_screen_flow_savesel", false, false, true)
 	main.save_manager.slots.attach_slot_template("user://smoke_screen_flow_savesel_slot_%d.json")
 	var esb: Button = ProbeUiUtil.find_button(main.ui.screens.start_overlay, "进入存档", "prefix")
@@ -194,7 +194,7 @@ func seals_check_single(f: Dictionary) -> bool:
 
 
 func _step_menu_to_adventure() -> void:
-	# oracle: design/ux/level-map.md:11 （菜单→冒险组）
+	# 判据出处: design/ux/level-map.md:11 （菜单→冒险组）
 	# 开始冒险钮已随三入口化撤出——函数直调中间态（卡② mn10；卡④ 大门两分支换代）
 	main._start_adventure_from_menu()
 	await _frames(3)
@@ -208,7 +208,7 @@ func _step_menu_to_adventure() -> void:
 
 # ---- ⑤ 冒险内屏切换：关卡地图屏 ⇄ 战斗屏（屏内两态，屏级仍独占）----
 func _step_level_to_battle_and_back() -> void:
-	# oracle: design/ux/battle.md:57 （冒险内切换组）
+	# 判据出处: design/ux/battle.md:57 （冒险内切换组）
 	if not main.ui.modals.run.level_screen.visible:
 		_problems.append("⑤冒险内切换：前置不在关卡地图屏")
 		return
@@ -228,7 +228,7 @@ func _step_level_to_battle_and_back() -> void:
 
 # ---- ⑥ 放弃 → 终局（放弃路径＝回退路径的非正常出口）----
 func _step_abandon_to_end() -> void:
-	# oracle: design/ux/level-map.md:42 （放弃→终局组）
+	# 判据出处: design/ux/level-map.md:42 （放弃→终局组）
 	if main.run_scope == null or main.run_scope.adventure == null:
 		_problems.append("⑥放弃→终局：前置无冒险实例")
 		return
@@ -241,7 +241,7 @@ func _step_abandon_to_end() -> void:
 
 # ---- ⑦ 终局 → 菜单（终局出口返回开始界面）----
 func _step_end_back_to_menu() -> void:
-	# oracle: design/ux/settlement-summary.md:24 （终局→菜单组）
+	# 判据出处: design/ux/settlement-summary.md:24 （终局→菜单组）
 	if main.ui.modals.run.end_overlay == null or not main.ui.modals.run.end_overlay.visible:
 		_problems.append("⑦终局→菜单：前置不在终局")
 		return
@@ -254,7 +254,7 @@ func _step_end_back_to_menu() -> void:
 
 # ---- ③' 营地 Esc 浮窗＋HUD（卡⑤——真实键盘合成路径 push_input；四态路由＋三出口＋语境分支＋余额单口）----
 func _step_camp_esc_and_hud() -> void:
-	# oracle: design/ux/camp.md:45 （Esc 段组）
+	# 判据出处: design/ux/camp.md:45 （Esc 段组）
 	ProbeUiUtil.isolate_save(main, "smoke_screen_flow_esc", false, false, true)
 	if not await ProbeUiUtil.open_camp_via_savesel(main, "smoke_screen_flow_esc"):
 		_problems.append("[esc] 营地入口缺失（选档层新档钮驱动中断）〔ESC批 V1〕")
@@ -320,7 +320,7 @@ func _step_camp_esc_and_hud() -> void:
 # 判的是呈现形态换壳（近全屏面板→居中定尺寸窗壳 720×640）：窗几何/场景根留底/遮罩 0.6/关闭钮/
 # 互斥单开/ESC 优先序/窗内滚动/生涯同壳——行为面（开合路由）零改，只钉窗壳可观测提交面。
 func _step_camp_window_shell() -> void:
-	# oracle: design/ux/camp.md:45 （窗壳 V1–V8 组）
+	# 判据出处: design/ux/camp.md:45 （窗壳 V1–V8 组）
 	ProbeUiUtil.isolate_save(main, "smoke_screen_flow_winshell", false, false, true)
 	if not await ProbeUiUtil.open_camp_via_savesel(main, "smoke_screen_flow_winshell"):
 		_problems.append("[winshell] 营地入口缺失（选档层新档钮驱动中断）〔窗口化批 V1〕")
@@ -478,7 +478,7 @@ func _step_camp_window_shell() -> void:
 
 # 清窗经真实钮（逐窗巡检 visible→钮 pressed——栈 close 恢复账随层清空）
 func _close_all_windows(views: Dictionary) -> void:
-	# oracle: design/ux/camp.md:45 （清窗组）
+	# 判据出处: design/ux/camp.md:45 （清窗组）
 	for k: StringName in [&"forge", &"chest", &"dummy", &"board"]:
 		var w: Control = views[k]
 		if not w.visible:
diff --git a/game/probe/shot_probe.gd b/game/probe/shot_probe.gd
index 508a8f68..2fd6a340 100644
--- a/game/probe/shot_probe.gd
+++ b/game/probe/shot_probe.gd
@@ -46,7 +46,7 @@ func _ready() -> void:
 	await get_tree().process_frame
 	# ① 菜单（启动态）——无帮助文腿（玩法速览牌不在画面，checker 无对应断言段）；
 	#    无副标题件，菜单文字锚只剩标题
-	# oracle: design/engineering/code-conventions.md:54 模态覆盖层层级规则——boot 态顶层=start_overlay、菜单文字在屏（菜单组）
+	# 判据出处: design/engineering/code-conventions.md:54 模态覆盖层层级规则——boot 态顶层=start_overlay、菜单文字在屏（菜单组）
 	# 自检一：boot 态顶层可见全屏层=start_overlay（内容层树遍历——屏壳是容器不当候选：
 	# camp 壳 boot 态 vis=true 但成员恒隐，裸树遍历自顶向下会先命中透明壳）
 	var top: Node = null
@@ -83,7 +83,7 @@ func _ready() -> void:
 		_meta[String(pair[0])] = ProbeUiUtil.label_rect(main.ui.screens.start_overlay, String(pair[1]))
 	await _snap("menu")
 	# ①b 设置面（settingsbtn 真实信号路径，开合同款真实钮）
-	# oracle: design/gdd/systems/表现与支撑/设置与本地化.md:95 最小设置面已兑现：音量/减动效/全屏/退出，载体＝独立设置存储＋设置界面视图（设置组）
+	# 判据出处: design/gdd/systems/表现与支撑/设置与本地化.md:95 最小设置面已兑现：音量/减动效/全屏/退出，载体＝独立设置存储＋设置界面视图（设置组）
 	var setbtn: Button = ProbeUiUtil.find_button(main.ui.screens.start_overlay, "设置", "prefix")
 	if setbtn == null:
 		_problems.append("设置入口缺失（开始层 settingsbtn）")
@@ -103,7 +103,7 @@ func _ready() -> void:
 				ProbeUiUtil.push_click(main, set_close)
 				await get_tree().process_frame
 	# ①c 生涯页（函数直调中间态——卡② mn10：careerbtn 已撤，卡④ 笔记本改挂前无 UI 路径）
-	# oracle: design/ux/camp.md:45 生涯页与四子界面同壳同形态（生涯组）
+	# 判据出处: design/ux/camp.md:45 生涯页与四子界面同壳同形态（生涯组）
 	if true:
 		main._open_career()
 		for i in 3:
@@ -123,7 +123,7 @@ func _ready() -> void:
 				if main.ui.modals.menu.career_overlay.visible or not main.ui.screens.start_overlay.visible:
 					_problems.append("生涯页关闭后页未隐藏或开始层未恢复")
 	# ② 营地场景图（进档开层新路径——卡② mn9；截图=可点击场景图形态——卡④ 契约 9 V1 验收载体）
-	# oracle: design/ux/camp.md:16 营地＝可点击场景图（七物件命中区表——场景图形态组）
+	# 判据出处: design/ux/camp.md:16 营地＝可点击场景图（七物件命中区表——场景图形态组）
 	if not await ProbeUiUtil.open_camp_via_savesel(main, "smoke_shot_probe_camp"):
 		_problems.append("营地入口缺失（选档层新档钮——新路径驱动中断）〔句柄子容器批 V1〕")
 	else:
@@ -132,16 +132,16 @@ func _ready() -> void:
 		ProbeUiUtil.push_click_at(main, main.ui.modals.camp.scene.get_hotspot_rect(&"campfire").get_center())   # 收闭改接篝火动线（营地根态无关闭钮——卡④ T5）
 		await get_tree().process_frame
 		ProbeUiUtil.push_click(main, main.ui.modals.menu.confirm_dialog._confirm_btn)   # 二次确认离场（关层收闭——选档层随收）
-		# oracle: design/ux/camp.md:22 篝火＝离开营地回主菜单、必须二次确认（篝心动线组）
+		# 判据出处: design/ux/camp.md:22 篝火＝离开营地回主菜单、必须二次确认（篝心动线组）
 		await get_tree().process_frame
 		# ③ 关卡画面（开始冒险→停点出图——入口停点语义；函数直调中间态 mn10）
-		# oracle: design/ux/level-map.md:11 入口停点候选数＝入口个数（关卡画面出图组）
+		# 判据出处: design/ux/level-map.md:11 入口停点候选数＝入口个数（关卡画面出图组）
 		main._start_adventure_from_menu()
 		for i in 4:
 			await get_tree().process_frame
 			await _snap("level")
 			# GP 常驻徽章断言（读数=runner.gp 现值，刷新=写路径回执后重查〔open_choices〕）
-			# oracle: design/ux/level-map.md:77 GP 常驻徽章＝GP 图标+数字（冒险钱包读数；写路径回执后重查）
+			# 判据出处: design/ux/level-map.md:77 GP 常驻徽章＝GP 图标+数字（冒险钱包读数；写路径回执后重查）
 			var gp_label: Label = ProbeUiUtil.find_label(main.ui.modals.run.level_screen, "◈ ")
 			if gp_label == null or not gp_label.is_visible_in_tree():
 				_problems.append("GP 徽章不可见（关卡画面顶栏）")
@@ -150,7 +150,7 @@ func _ready() -> void:
 				if gp_label.text != expect:
 					_problems.append("GP 徽章读数不符: %s != %s" % [gp_label.text, expect])
 		# ④ 战斗（节点一——candidate_rect 命中矩形真点选路提交，ui_click_probe 同款）
-		# oracle: design/ux/battle.md:122 B 区构建：站桩/明细带/轮次指示（战斗出图与几何锚组）
+		# 判据出处: design/ux/battle.md:122 B 区构建：站桩/明细带/轮次指示（战斗出图与几何锚组）
 		if main.ui.modals.run.level_screen != null and main.ui.modals.run.level_screen.visible:
 			ProbeUiUtil.push_click_at(main, main.ui.modals.run.level_screen.candidate_rect(0).get_center())
 			for i in 10:
@@ -162,14 +162,14 @@ func _ready() -> void:
 			_meta["stage_view"] = _node_rect(main.ui.battle.stage)
 			_meta["board_zone"] = _node_rect(main.ui.battle.board_zone)
 			# draw calls 真机测量（基线 270→目标 <200；窗口化渲染帧读数，
-			# oracle: design/gdd/systems/表现与支撑/HUD框架.md:264 同屏 draw calls < 200（战斗屏性能预算组）
+			# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:264 同屏 draw calls < 200（战斗屏性能预算组）
 			# 取值时机=战斗截图同帧后一帧——呈现终态满负荷）
 			await get_tree().process_frame
 			var dc := int(Performance.get_monitor(Performance.RENDER_TOTAL_DRAW_CALLS_IN_FRAME))
 			_meta["battle_draw_calls"] = dc
 			print("[shot_probe] battle draw_calls=%d（基线 270/目标 <200）" % dc)
 			# ⑤ 状态面板（战斗屏状态角标真实信号路径；层在战斗屏之上开合）
-			# oracle: design/gdd/systems/表现与支撑/HUD框架.md:277 模态打开遮挡或输入锁定、关闭逐层恢复（状态面板组）
+			# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:277 模态打开遮挡或输入锁定、关闭逐层恢复（状态面板组）
 			var pb: Button = main.ui.battle.board_zone.status_badge
 			if pb == null or not pb.visible or pb.disabled:
 				_problems.append("状态面板入口角标缺失/置灰（战斗屏 board_zone）")
@@ -211,7 +211,7 @@ func _ready() -> void:
 
 
 func _snap(key: String) -> void:
-	# oracle: design/engineering/test-conventions.md:84 golden 测试项扩项——截图采集清单扩项、实跑截图冻结（截图采集组）
+	# 判据出处: design/engineering/test-conventions.md:84 golden 测试项扩项——截图采集清单扩项、实跑截图冻结（截图采集组）
 	await RenderingServer.frame_post_draw
 	await RenderingServer.frame_post_draw
 	var img: Image = get_viewport().get_texture().get_image()
diff --git a/game/probe/t17_defer_probe.gd b/game/probe/t17_defer_probe.gd
index ac0e411e..a319db74 100644
--- a/game/probe/t17_defer_probe.gd
+++ b/game/probe/t17_defer_probe.gd
@@ -13,7 +13,7 @@ var _problems: Array = []
 
 
 func _ready() -> void:
-# oracle: design/ux/battle.md:122 （明细带挖掘期收起——T17 视觉扩展时序组）
+# 判据出处: design/ux/battle.md:122 （明细带挖掘期收起——T17 视觉扩展时序组）
 	await get_tree().process_frame
 	main = load("res://presentation/main.tscn").instantiate()
 	add_child(main)
diff --git a/game/probe/type_glow_shot_probe.gd b/game/probe/type_glow_shot_probe.gd
index 0a4d3ecb..f11c8077 100644
--- a/game/probe/type_glow_shot_probe.gd
+++ b/game/probe/type_glow_shot_probe.gd
@@ -30,7 +30,7 @@ var _hero_pos := Vector2i.ZERO
 
 
 func _ready() -> void:
-# oracle: design/engineering/test-conventions.md:84 （微光截图取证——渲染闸采集组）
+# 判据出处: design/engineering/test-conventions.md:84 （微光截图取证——渲染闸采集组）
 	if DisplayServer.get_name() == "headless":
 		print("[type_glow_shot] FAIL — 本探针必须窗口化运行（headless 无渲染面，截图必空）")
 		get_tree().quit(1)
diff --git a/game/probe/ui_click_probe.gd b/game/probe/ui_click_probe.gd
index c1d03c48..0b9d1c69 100644
--- a/game/probe/ui_click_probe.gd
+++ b/game/probe/ui_click_probe.gd
@@ -61,7 +61,7 @@ func _ready() -> void:
 	if main.ui.modals.menu.debug_overlay.visible:
 		_problems.append("调试浮窗 boot 自动开（菜单优先失守）")
 	# ---- 营地购买合成点击路径（选档进档开层→购买→关闭全走真实按钮信号路径；
-	# oracle: design/gdd/systems/跨局循环/天赋树.md:198 （营地购买段——单币购买只扣钥石组）
+	# 判据出处: design/gdd/systems/跨局循环/天赋树.md:198 （营地购买段——单币购买只扣钥石组）
 	# 隔离存档换注 main.meta 保确定性（禁碰真实档 user://save.json）；陈旧档段首清理）----
 	for p0 in ["user://smoke_click_probe_reset.json", "user://smoke_click_probe_reset.json.tmp"]:
 		if FileAccess.file_exists(p0):
@@ -214,7 +214,7 @@ func _ready() -> void:
 		if main.ui.modals.camp.scene.visible or not main.ui.screens.start_overlay.visible:
 			_problems.append("营地关闭后未恢复开始层〔句柄子容器批 V1〕")
 	# ---- 选档界面行为走查（迭代 33 卡③）：sl5 空槽新档链／sl6 有档槽进档链／sl7 删档二次确认双路径
-	# oracle: design/gdd/systems/表现与支撑/存档序列化.md:61 （选档走查段——激活态建立组）
+	# 判据出处: design/gdd/systems/表现与支撑/存档序列化.md:61 （选档走查段——激活态建立组）
 	# ／sl8 消费方分派单口／sl12 动线序不回闪。开层=函数直调（「进入存档」钮归卡② mn3——中间态在案）；
 	# 隔离=attach_slot_template 注入命名空间，夹具按槽直写（卡① 注入口）。----
 	var csel_tpl := "user://smoke_click_probe_savesel_slot_%d.json"
@@ -318,7 +318,7 @@ func _ready() -> void:
 		_problems.append("[savesel] 关闭后层未隐藏或开始层未恢复（模态栈单口失守）")
 
 	# ---- 设置面段（隔离 store 换注禁碰真实 user://settings.cfg；真实按钮信号路径）----
-	# oracle: design/gdd/systems/表现与支撑/设置与本地化.md:4 （设置面段——最小设置面组）
+	# 判据出处: design/gdd/systems/表现与支撑/设置与本地化.md:4 （设置面段——最小设置面组）
 	for p0 in ["user://smoke_click_probe_settings.cfg"]:
 		if FileAccess.file_exists(p0):
 			DirAccess.remove_absolute(p0)
@@ -385,7 +385,7 @@ func _ready() -> void:
 		if ProbeUiUtil.find_button(main.ui.modals.menu.settings_overlay, "退出游戏", "prefix") != null:
 			_problems.append("设置面仍含退出游戏按钮（二轮 D1——只在一级菜单出现）")
 	# ---- 生涯页段（入口点击链+关闭回返，真实按钮信号路径；本页只读零写，
-	# oracle: design/ux/camp.md:45 （生涯页段——同壳同形态组）
+	# 判据出处: design/ux/camp.md:45 （生涯页段——同壳同形态组）
 	# 值断言归冒烟投影段与 ui_struct 结构族，此处只验开合路径与零跳转）----
 	# 生涯页驱动=函数直调中间态（卡② mn10——careerbtn 已撤，卡④ 笔记本改挂前无 UI 路径）
 	if true:
@@ -640,7 +640,7 @@ func _ready() -> void:
 				_run_modal_probes_once()
 				_play_one_action()
 	# ---- 预算耗尽收口（T17 硬锁批适配）：选件变强后 probe 可能活过预算不再战败——断点段前提
-	# oracle: design/ux/level-map.md:11 （主循环选路段——入口候选组）
+	# 判据出处: design/ux/level-map.md:11 （主循环选路段——入口候选组）
 	# （冒险终局面在案）须主动满足。收口驱动：任何停点层逐个推进（复用主循环分支语义）至
 	# level_screen 选路停点→真实放弃二击→终局面。战斗中则继续 autoplay 打完。
 	if not _done and not main.ui.modals.run.end_overlay.is_open():
@@ -689,7 +689,7 @@ func _ready() -> void:
 				_play_one_action()
 			# 排播期/Waiting 等待态=自然流逝（演播秒级、锁随队列空解除）
 	# T17 适配：战败或放弃二途皆达终局面（放弃=预算耗尽收口路径——见上），断点段前提不变。
-	# oracle: design/gdd/systems/表现与支撑/存档序列化.md:180 （断点段——断点域与续玩组）
+	# 判据出处: design/gdd/systems/表现与支撑/存档序列化.md:180 （断点段——断点域与续玩组）
 	await get_tree().process_frame
 	var bp_file := "user://smoke_click_probe_reset.json"
 	var iso_chk = load("res://core/save_manager.gd").new(bp_file)
@@ -721,7 +721,7 @@ func _ready() -> void:
 	# ① 战斗收口断点写盘断言保留（上方——冒险流直调中间态 mn10）。
 
 	# ---- 大门两分支断言段（卡④ T5 接收——卡② 移交落点；V3 断言面）----
-	# oracle: design/ux/camp.md:16 （大门段——点大门先出确认组）
+	# 判据出处: design/ux/camp.md:16 （大门段——点大门先出确认组）
 	# 驱动=营地场景根点选信号（真实路由）→组合根 _on_camp_object_pressed→确认弹窗。
 	# 无断点=两出口（是/否）；有断点=三出口（set_breakpoint 注入选路停点形——同下方开场行③先例）。
 	# 判据绑可观测提交面：点大门不直接进冒险（is_adventure 翻转只在 confirmed 后）；cancelled 恒=
@@ -746,7 +746,7 @@ func _ready() -> void:
 	await get_tree().process_frame
 	# R4 位次真点（营地交互修复批——位次与语义绑定钉）：真点前消费方前置读（gate_new 在册）→
 	# 按类型定位按钮行 child(0) 全局矩形中心真点——位次若错接，此点命中「否」，下方主证（翻转）即红。
-	# oracle: design/gdd/systems/表现与支撑/HUD框架.md:90 确认弹窗位次定值：推进在左、维持居右（R4 位次真点）
+	# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:90 确认弹窗位次定值：推进在左、维持居右（R4 位次真点）
 	if String(main._confirm_consumer) != "gate_new":
 		_problems.append("R4 前置：确认消费方非 gate_new（分派面漂移）〔营地交互批 V3〕")
 	var gate_row := _first_hbox(main.ui.modals.menu.confirm_dialog)
@@ -761,7 +761,7 @@ func _ready() -> void:
 	if String(main._confirm_consumer) != "":
 		_problems.append("R4 主证：确认后消费方未清零〔营地交互批 V3〕")
 	# 开局终态两钉（营地交互修复批——开始层隐藏收一处后的落点断言）：
-	# oracle: design/gdd/systems/冒险循环/关卡节点地图.md:78 关卡开始 → 呈现节点图选路停点（开局终态两钉）
+	# 判据出处: design/gdd/systems/冒险循环/关卡节点地图.md:78 关卡开始 → 呈现节点图选路停点（开局终态两钉）
 	# R1＝确认后开始层不可见（被测改动特有提交面——修复前该句恒红＝「开局被开始层盖住」缺陷本体）；
 	# R2＝关卡画面（选路停点）在位（开局终态呈现面，与既有 is_adventure 断言同批缺一即红）
 	if main.ui.screens.start_overlay.visible:
@@ -865,10 +865,10 @@ func _ready() -> void:
 
 
 # ---- 模态/tooltip/刷新链一次性覆盖（真实信号路径驱动） ----
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:277 （模态/tooltip 段——遮挡与输入锁组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:277 （模态/tooltip 段——遮挡与输入锁组）
 
 func _run_modal_probes_once() -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:277 （判定上报通道——验证函数组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:277 （判定上报通道——验证函数组）
 	# ⓪ 玩家面文案真实入口断言（迭代36 卡A wa1——C 区两段头随战斗常驻）
 	if not _tested_copy and main.ui.battle.info_panel != null and main.ui.battle.info_panel.visible:
 		_tested_copy = true
@@ -944,7 +944,7 @@ func _run_modal_probes_once() -> void:
 					rnr.effective_ac(), int(rnr.gp)]
 				if String(main.ui.modals.run.status_panel._attrs_label.text) != attr_expect:
 					_problems.append("状态面板属性行投影失真（sv6②——期望 %s 实测 %s）" % [attr_expect, main.ui.modals.run.status_panel._attrs_label.text])
-				# ③ _status_data() 直调对拍（sv7——键集恰八键＋curios/feats 独立 oracle）
+				# ③ _status_data() 直调对拍（sv7——键集恰八键＋curios/feats 独立预期表）
 				var sd: Dictionary = main.status_data()
 				var keys := ["balance", "hero_hp", "max_hp", "atk", "ac", "gp", "curios", "feats"]
 				var keys_ok: bool = (sd as Dictionary).size() == 8
@@ -952,18 +952,18 @@ func _run_modal_probes_once() -> void:
 					keys_ok = keys_ok and (sd as Dictionary).has(k)
 				if not keys_ok:
 					_problems.append("_status_data() 键集≠八键（sv7——实测 %s）" % str((sd as Dictionary).keys()))
-				var oracle: Array = []
+				var expected: Array = []
 				for rec in rnr.treasure_inventory.query_inventory(Callable()):
 					var rr: Dictionary = rec
-					oracle.append({"name": String(main.db.crossrun.treasure_items.row_by_id(String(rr.get("item_id", ""))).get("display_name", "")),
+					expected.append({"name": String(main.db.crossrun.treasure_items.row_by_id(String(rr.get("item_id", ""))).get("display_name", "")),
 						"used": bool(rr.get("used", false))})
 				var sd_curios: Array = (sd as Dictionary).get("curios", [])
-				var curios_ok: bool = (sd_curios as Array).size() == (oracle as Array).size()
+				var curios_ok: bool = (sd_curios as Array).size() == (expected as Array).size()
 				if curios_ok:
-					for i in (oracle as Array).size():
-						curios_ok = curios_ok and String((sd_curios[i] as Dictionary).get("name", "")) == String((oracle[i] as Dictionary).get("name", "")) 							and bool((sd_curios[i] as Dictionary).get("used", false)) == bool((oracle[i] as Dictionary).get("used", false))
+					for i in (expected as Array).size():
+						curios_ok = curios_ok and String((sd_curios[i] as Dictionary).get("name", "")) == String((expected[i] as Dictionary).get("name", "")) 							and bool((sd_curios[i] as Dictionary).get("used", false)) == bool((expected[i] as Dictionary).get("used", false))
 				if not curios_ok:
-					_problems.append("_status_data().curios 对拍独立 oracle 失守（sv7——实测 %s vs %s）" % [str(sd_curios), str(oracle)])
+					_problems.append("_status_data().curios 对拍独立预期表失守（sv7——实测 %s vs %s）" % [str(sd_curios), str(expected)])
 				var feats_expect: Array = load("res://presentation/hud_presenter.gd").feat_holdings_lines(main.db, rnr.feats_held())
 				if str((sd as Dictionary).get("feats", [])) != str(feats_expect):
 					_problems.append("_status_data().feats 对拍 feat_holdings_lines 失守（sv7）")
@@ -1045,7 +1045,7 @@ func _labels_with_text(labels: Array, needle: String) -> Array:
 
 
 func _play_one_action() -> void:
-# oracle: design/gdd/systems/排雷循环/排雷玩法.md:236 （判定上报通道——验证函数组）
+# 判据出处: design/gdd/systems/排雷循环/排雷玩法.md:236 （判定上报通道——验证函数组）
 	var settlement = main.run_scope.settlement
 	if settlement == null:
 		return   # 结算竞态防抖：battle_finished 与本轮动作调度同帧到达时 settlement 可能已被置空（基线既有噪声——加固）
@@ -1086,7 +1086,7 @@ func _play_one_action() -> void:
 
 
 func _random_unknown_adjacent(minesweeper) -> Vector2i:
-# oracle: design/gdd/systems/排雷循环/排雷玩法.md:236 （判定上报通道——验证函数组）
+# 判据出处: design/gdd/systems/排雷循环/排雷玩法.md:236 （判定上报通道——验证函数组）
 	var hero: Vector2i = minesweeper.hero_pos()
 	var cands: Array = []
 	for dy in range(-1, 2):
@@ -1102,13 +1102,13 @@ func _random_unknown_adjacent(minesweeper) -> Vector2i:
 
 
 func _click_stop() -> void:
-# oracle: design/gdd/systems/排雷循环/行动经济.md:262 （判定上报通道——验证函数组）
+# 判据出处: design/gdd/systems/排雷循环/行动经济.md:262 （判定上报通道——验证函数组）
 	# 停手走真实点击路径（AP 条「停手」钮 → 组合根 settle_batch——排雷玩法 D1×6① 回归载体）
 	ProbeUiUtil.push_click(main, main.ui.battle.board_zone.ap_bar._btn_stop)
 
 
 # ---- T1 D1：锁期/重放断言（每 run 一次，脚本化场景——演播期豁免的断言化承载） ----
-# oracle: design/gdd/systems/排雷循环/排雷玩法.md:236 （锁期/重放段——拒绝与锁组）
+# 判据出处: design/gdd/systems/排雷循环/排雷玩法.md:236 （锁期/重放段——拒绝与锁组）
 # 锁期断言（排播队列活跃=锁面）：注入封印击 → 直落被冻结不受理（封印未置）+ `_locked_click`
 # 缓存命中且为本注入（「最后一次」语义——注入帧内无并发点击）。
 # 重放断言（演播完边沿 pump_ended→_replay_locked_click 重入唯一动作通道）：缓存清空 +
@@ -1116,7 +1116,7 @@ func _click_stop() -> void:
 # 前提消失守卫：等重放期间出现停点层/战斗收场（注入时点恰逢终结演播）→ 静默弃测不计
 # problem（封印动作不杀伤，正常局不触发；断言实现形态取舍在代拍白名单内）。
 func _locktest_tick() -> void:
-# oracle: design/gdd/systems/排雷循环/排雷玩法.md:236 （判定上报通道——验证函数组）
+# 判据出处: design/gdd/systems/排雷循环/排雷玩法.md:236 （判定上报通道——验证函数组）
 	if _locktest_state == 2:
 		return
 	var settlement = main.run_scope.settlement
@@ -1173,7 +1173,7 @@ func _locktest_tick() -> void:
 
 
 func _locktest_pick_cell(minesweeper) -> Vector2i:
-# oracle: design/gdd/systems/排雷循环/排雷玩法.md:236 （判定上报通道——验证函数组）
+# 判据出处: design/gdd/systems/排雷循环/排雷玩法.md:236 （判定上报通道——验证函数组）
 	var hero: Vector2i = minesweeper.hero_pos()
 	for dy in range(-1, 2):
 		for dx in range(-1, 2):
@@ -1191,7 +1191,7 @@ func _locktest_pick_cell(minesweeper) -> Vector2i:
 # 断言两钉：①覆盖登记件停手键在场（零命中＝驱动空转假绿，即红）；②相位离开 Active（停手
 # 收轮）。前提消失守卫：点击后战局收场（终结演播竞态）→ 静默弃测不计 problem（正常局不触发）。
 func _stoptest_tick() -> void:
-# oracle: design/gdd/systems/排雷循环/排雷玩法.md:167 （停手＝玩家主动收轮——判定上报通道）
+# 判据出处: design/gdd/systems/排雷循环/排雷玩法.md:167 （停手＝玩家主动收轮——判定上报通道）
 	if _stoptest_state == 2:
 		return
 	var settlement = main.run_scope.settlement
@@ -1228,7 +1228,7 @@ func _stoptest_tick() -> void:
 
 
 func _stoptest_assert_hit() -> void:
-# oracle: design/gdd/systems/排雷循环/排雷玩法.md:167 （停手钮真输入命中登记——判定上报通道）
+# 判据出处: design/gdd/systems/排雷循环/排雷玩法.md:167 （停手钮真输入命中登记——判定上报通道）
 	var stop_btn: Button = main.ui.battle.board_zone.ap_bar._btn_stop
 	var stop_key := String(_recorder._node_keys.get(stop_btn.get_instance_id(), ""))
 	if stop_key == "" or not _recorder._hits.has(stop_key):
@@ -1236,7 +1236,7 @@ func _stoptest_assert_hit() -> void:
 
 
 func _first_hbox(node: Node) -> HBoxContainer:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:90 （位次真点定位——R4 判据面辅助）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:90 （位次真点定位——R4 判据面辅助）
 	if node is HBoxContainer:
 		return node
 	for ch in node.get_children():
@@ -1247,7 +1247,7 @@ func _first_hbox(node: Node) -> HBoxContainer:
 
 
 func _report_stall(st: Dictionary) -> void:
-# oracle: design/engineering/test-conventions.md:30 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:30 （判定上报通道——验证函数组）
 	var why := ""
 	if st.phase == "Waiting":
 		why = "结算停滞：Waiting 相位无推进（结算应同步走完——窗口段已删除）"
@@ -1263,7 +1263,7 @@ func _report_stall(st: Dictionary) -> void:
 
 
 func _dump_state() -> void:
-# oracle: design/engineering/test-conventions.md:30 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:30 （判定上报通道——验证函数组）
 	var diag: Dictionary = main.run_scope.settlement.diagnostic_snapshot()   # 诊断观测面（私有字段零直读）
 	print("  node_index=%s round=%s phase=%s ap=%s rap=%s" % [
 		str(main.run_scope.runner.node_index), str(main.run_scope.settlement.round_index),
diff --git a/game/probe/ui_contrast_probe.gd b/game/probe/ui_contrast_probe.gd
index 4459417e..ee9d97c3 100644
--- a/game/probe/ui_contrast_probe.gd
+++ b/game/probe/ui_contrast_probe.gd
@@ -88,7 +88,7 @@ func _ratio(a: Color, b: Color) -> float:
 
 
 func _ready() -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:281 （UI 文字对比度机检 ≥4.5:1 无区域例外——对比度组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:281 （UI 文字对比度机检 ≥4.5:1 无区域例外——对比度组）
 	var problems: Array = []
 	var pairs := _pairs()
 	for p in pairs:
diff --git a/game/probe/ui_input_probe.gd b/game/probe/ui_input_probe.gd
index a6861272..6cae1d92 100644
--- a/game/probe/ui_input_probe.gd
+++ b/game/probe/ui_input_probe.gd
@@ -242,7 +242,7 @@ func _ready() -> void:
 		_pre_fail("目标格选取失败 seal=%s dig=%s forbid=%s reveal=%s" % [seal_t, dig_t, forbid_t, reveal_t])
 		return
 	# ---- case① 悬停可挖域：motion → 悬停态到达（金框 + 十字光标）----
-	# oracle: design/gdd/systems/表现与支撑/HUD框架.md:269 悬停光标三语义随目标切换、已开格路径预览、可挖域常驻微光（case①-③ 输入面）
+	# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:269 悬停光标三语义随目标切换、已开格路径预览、可挖域常驻微光（case①-③ 输入面）
 	_push_motion(_pos(bv, seal_t))
 	await get_tree().process_frame
 	if bv.hover_probe() != seal_t:
@@ -271,7 +271,7 @@ func _ready() -> void:
 	if bv.mouse_default_cursor_shape != Input.CURSOR_ARROW:
 		_problems.append("case③ 移动光标缺失（%d）" % bv.mouse_default_cursor_shape)
 	# ---- case④ 右键封印：seal_place 到达组合根 + 核心封印态落位 ----
-	# oracle: design/gdd/systems/排雷循环/排雷玩法.md:231 封印受理与印记随挖消失（case④/④b）
+	# 判据出处: design/gdd/systems/排雷循环/排雷玩法.md:231 封印受理与印记随挖消失（case④/④b）
 	_push_click(_pos(bv, seal_t), MOUSE_BUTTON_RIGHT)
 	await get_tree().process_frame
 	if not _has_action(seal_t, "seal_place"):
@@ -285,14 +285,14 @@ func _ready() -> void:
 	if seal_unit == null or not seal_unit.seal_on:
 		_problems.append("case④b 封印印记未下发（seal_on=%s）" % ["无单元" if seal_unit == null else str(seal_unit.seal_on)])
 	# ---- case⑤ 双击 chord：禁入格双左击（核心拒挖零副作用）→ chord_attempted ----
-	# oracle: design/gdd/systems/排雷循环/排雷玩法.md:236 拒绝三源可辨、任何拒绝零副作用（case⑤ chord）
+	# 判据出处: design/gdd/systems/排雷循环/排雷玩法.md:236 拒绝三源可辨、任何拒绝零副作用（case⑤ chord）
 	_push_click(_pos(bv, forbid_t), MOUSE_BUTTON_LEFT)
 	_push_click(_pos(bv, forbid_t), MOUSE_BUTTON_LEFT)
 	await get_tree().process_frame
 	if _chords.is_empty() or _chords[_chords.size() - 1] != forbid_t:
 		_problems.append("case⑤ chord_attempted 未达（chords=%s）" % [str(_chords)])
 	# ---- case⑥ 左键挖：dig 到达组合根 + 核心揭格落位 ----
-	# oracle: design/gdd/systems/排雷循环/排雷玩法.md:231 挖掘受理与揭格落位（case⑥）
+	# 判据出处: design/gdd/systems/排雷循环/排雷玩法.md:231 挖掘受理与揭格落位（case⑥）
 	_push_click(_pos(bv, dig_t), MOUSE_BUTTON_LEFT)
 	await get_tree().process_frame
 	if not _has_action(dig_t, "dig"):
@@ -301,7 +301,7 @@ func _ready() -> void:
 	if not ms.is_revealed(dig_t):
 		_problems.append("case⑥ 核心揭格未落位（目标=%s）" % dig_t)
 	# ---- case⑦ 英雄精灵世界落位（回归闸）：精灵在 SubViewport 世界内，
-	# oracle: design/ux/battle.md:154 主角站桩立绘带落影、贴脚与缩放档（case⑦-⑩ 呈现落位）
+	# 判据出处: design/ux/battle.md:154 主角站桩立绘带落影、贴脚与缩放档（case⑦-⑩ 呈现落位）
 	# 落位 = 格×步距 + 脚底锚（横=格中线/纵=格底往上 25% 线=HERO_GROUND_FRAC 自底边口径——「脚踩
 	# 格子 1/4 处·从下往上数」；禁带壳层 _svp_container.position 居中偏移——上批误用壳层
 	# cell_origin 实测右偏 ~7 格+偏离格心，实机截图用户报缺陷）。素材缺位树（hero==null，字形
@@ -368,7 +368,7 @@ func _ready() -> void:
 		if bv._world.hero.position.distance_to(expect10b) > 0.5:
 			_problems.append("case⑩ 还原后英雄未复位（pos=%s expect=%s）" % [str(bv._world.hero.position), str(expect10b)])
 	# ---- case⑪ 贴图缺位回退（字形「人」回归闸）：texture 置 null + refresh → 英雄格数字 0 时字形
-	# oracle: design/gdd/systems/表现与支撑/HUD框架.md:264 棋盘格子与数字完整可见——贴图缺位回退字形保可读（case⑪）
+	# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:264 棋盘格子与数字完整可见——贴图缺位回退字形保可读（case⑪）
 	# 必须回退「人」（数字格仍显数字——回退判据与抑制判据同源）；验毕还原纹理重绘。 ----
 	if bv._world.hero != null:
 		var hp11: Vector2i = ms.hero_pos()
@@ -385,7 +385,7 @@ func _ready() -> void:
 		bv._hero_sprite.tex_idle = tex_saved
 		bv.refresh()
 	# ---- case⑭ 变异角标（flat_damage 未开格视觉标记；resolver 注入面+落位+复位） ----
-	# oracle: design/gdd/systems/排雷循环/地形变异.md:154 呈现按 effect/trigger/placement 数据路由、零特判（case⑭ 角标）
+	# 判据出处: design/gdd/systems/排雷循环/地形变异.md:154 呈现按 effect/trigger/placement 数据路由、零特判（case⑭ 角标）
 	var mark_t: Vector2i = _pick_forbidden(bv, ms)   # 任一未开格（禁入=未开非相邻）
 	if mark_t.x >= 0:
 		bv.set_variant_mark_resolver(func(_c): return "flat_damage")
@@ -399,7 +399,7 @@ func _ready() -> void:
 	else:
 		_problems.append("case⑭ 无未开格可验（板面异常）")
 	# ---- case⑮ 视野迷雾（三态呈态/半径圈/移动跟随/开关两态零扰动/提灯插值位；
-	# oracle: design/gdd/systems/表现与支撑/HUD框架.md:268 视野迷雾：灯光区随移动跟随、开关两态结算逐位一致（case⑮）
+	# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:268 视野迷雾：灯光区随移动跟随、开关两态结算逐位一致（case⑮）
 	#      纯呈现零逻辑——迷雾开关切换前后 minesweeper 状态摘要逐位一致） ----
 	var fogp: Dictionary = bv.fog_params_probe()
 	if int(bv.FOG_RADIUS) != 8 or int(fogp["lantern"]) != 0 or not fogp["enabled"]:
@@ -495,7 +495,7 @@ func _ready() -> void:
 			# attune_param_sum 只读出口→set_fog_glow_bonus〕→视野 +4 生效与卸装复原。
 			# settlement.attunement 手动注入=模拟 begin_battle enc 注入后的运行态〔注入面本体归
 			# 冒烟+单测覆盖〕；不重启冒险——case⑯ 起既有板面继续用）
-			# oracle: design/gdd/systems/跨局循环/元进度.md:156 解锁可见：装配强化下一局生效（case⑮ 装配链）
+			# 判据出处: design/gdd/systems/跨局循环/元进度.md:156 解锁可见：装配强化下一局生效（case⑮ 装配链）
 			main.save_manager.meta_state.set_attunement_equipped(["wide_scout_band"])
 			var p_lantern: Dictionary = main.build_adventure_params(main.save_manager, main.meta)
 			if not (p_lantern.get("attunement", []) as Array).has("wide_scout_band"):
@@ -514,7 +514,7 @@ func _ready() -> void:
 				_problems.append("case⑮ 卸装后 dist==R+1 格未复原遮蔽")
 			main.save_manager.meta_state.set_attunement_equipped([])
 	# ---- case⑯ 状态面板输入锁语义（R3——开层锁棋盘、关层恢复无残留；真实 push_input
-	# oracle: design/gdd/systems/表现与支撑/HUD框架.md:277 模态打开输入锁定、关闭逐层恢复（case⑯ R3）
+	# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:277 模态打开输入锁定、关闭逐层恢复（case⑯ R3）
 	# 路径：入口角标本体 press+release 真点击 → 状态面板开；锁期挖掘点击零穿透；「继续」关层后
 	# 同格挖掘重新到达——锁语义与既有模态同款，无状态残留。置于全 case 之尾：取格若需前沿移位
 	#（真实点击 move 扩大可挖域），其板面扰动不再波及任何既有断言——域恰 2 枚时 seal_t 带封印+
@@ -570,7 +570,7 @@ func _ready() -> void:
 				if not _has_action(status_dig, "dig") or not ms.is_revealed(status_dig):
 					_problems.append("case⑯ 关闭后挖掘未到达（恢复无残留验证失守）")
 	# ---- case⑰ 未开格类型微光（活板面走查：作用集恒等／开格灭／移动复亮
-	# oracle: design/gdd/systems/表现与支撑/HUD框架.md:267 类型微光出圈即灭入圈即亮、已开与封锁格恒无微光（case⑰）
+	# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:267 类型微光出圈即灭入圈即亮、已开与封锁格恒无微光（case⑰）
 	#      与出圈灭／相位门控／开关两态零扰动。与冒烟段数据面断言分工：此处走真实点击路径） ----
 	if not bool(bv.type_glow_probe().get("enabled", false)):
 		_problems.append("case⑰ 微光默认态非开（生产默认开——Q4 丙案）")
@@ -759,7 +759,7 @@ func _push_release(pos: Vector2, btn: int) -> void:
 
 
 func _pre_fail(why: String) -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	push_error("[ui_input_probe] FAIL — " + why)
 	print("[ui_input_probe] FAIL — " + why)
 	get_tree().quit(1)
diff --git a/game/probe/ui_probe.gd b/game/probe/ui_probe.gd
index cd7266f8..686712be 100644
--- a/game/probe/ui_probe.gd
+++ b/game/probe/ui_probe.gd
@@ -16,7 +16,7 @@ func _ready() -> void:
 	await get_tree().process_frame
 	var problems: Array = []
 	# ---- 放弃入口（台账 119）：默认隐藏（非冒险模式无冒险可放弃——开始层/调试两层）----
-	# oracle: design/ux/level-map.md:59 放弃冒险入口＝边缘动作、任意选路停点承载——非冒险模式无入口（默认隐藏）
+	# 判据出处: design/ux/level-map.md:59 放弃冒险入口＝边缘动作、任意选路停点承载——非冒险模式无入口（默认隐藏）
 	if main.ui.modals.run.level_screen.abandon_btn == null or main.ui.modals.run.level_screen.abandon_btn.visible:
 		print("[ui_probe] FAIL — 放弃按钮默认应隐藏（非冒险模式关）")
 		get_tree().quit(1)
@@ -24,7 +24,7 @@ func _ready() -> void:
 	# ---- 营地覆盖层（主菜单入口/开合/余额文案/购买禁用态；
 	# 隔离存档换注 main.meta 保确定性（禁碰真实档 user://save.json——SaveManager 路径注入纪律；
 	# 营地先行段只换 meta 不换 save_manager——冒险段换注零档在前）----
-	# oracle: design/ux/camp.md:45 五功能窗统一窗壳、五窗互斥单开、各窗自带关闭钮（营地开合组）
+	# 判据出处: design/ux/camp.md:45 五功能窗统一窗壳、五窗互斥单开、各窗自带关闭钮（营地开合组）
 	ProbeUiUtil.isolate_save(main, "smoke_ui_probe_camp", false, false, false)
 	if not await ProbeUiUtil.open_camp_via_savesel(main, "smoke_ui_probe_camp"):
 		problems.append("营地入口缺失（选档层新档钮——mn9 新路径驱动中断）〔句柄子容器批 V1〕")
@@ -36,12 +36,12 @@ func _ready() -> void:
 			problems.append("营地层打开时开始层未隐藏（规范 2.3 遮挡纪律）〔句柄子容器批 V1〕")
 		else:
 			# 天赋树子界面（场景点选真实路由——木桩命中区进树界面；卡④ T5 深员改指）
-			# oracle: design/ux/camp.md:20 木桩命中区→天赋树界面入口（场景点选路由）
+			# 判据出处: design/ux/camp.md:20 木桩命中区→天赋树界面入口（场景点选路由）
 			ProbeUiUtil.push_click_at(main, main.ui.modals.camp.scene.get_hotspot_rect(&"dummy").get_center())
 			await get_tree().process_frame
 			if not main.ui.modals.camp.tree.visible:
 				problems.append("天赋树子界面未打开（场景点选路由中断）〔营地图批 V2〕")
-			# oracle: design/ux/camp.md:41 钥石余额常驻画面顶部 HUD 栏（余额文案组）
+			# 判据出处: design/ux/camp.md:41 钥石余额常驻画面顶部 HUD 栏（余额文案组）
 			if not String(main.ui.modals.camp.tree._balance_label.text).begins_with("钥石"):
 				problems.append("营地余额文案缺失（%s）〔句柄子容器批 V1〕" % main.ui.modals.camp.tree._balance_label.text)
 			if main.ui.modals.camp.tree._tree_buy_btns.is_empty():
@@ -57,7 +57,7 @@ func _ready() -> void:
 				ProbeUiUtil.push_click(main, ProbeUiUtil.find_button(main.ui.modals.camp.tree, "返回营地"))   # 真点底栏返回钮→_emit_closed（camp_sub_view_base.gd:66-84）
 			await get_tree().process_frame
 			# 秘宝匣子界面（场景点选真实路由——宝箱命中区）
-			# oracle: design/ux/camp.md:18 宝箱命中区→秘宝匣界面入口
+			# 判据出处: design/ux/camp.md:18 宝箱命中区→秘宝匣界面入口
 			ProbeUiUtil.push_click_at(main, main.ui.modals.camp.scene.get_hotspot_rect(&"chest").get_center())
 			await get_tree().process_frame
 			if main.ui.modals.camp.treasure._workshop_rows.size() != 12:
@@ -76,7 +76,7 @@ func _ready() -> void:
 	await get_tree().process_frame
 	# ---- 入口选路停点（关卡开始即出节点图——level_started 后、首战前弹选路层；
 	# candidate_rect 命中矩形真点 pick 入口单候选进首战）----
-	# oracle: design/ux/level-map.md:11 入口停点候选数＝入口个数（入口单候选断言）
+	# 判据出处: design/ux/level-map.md:11 入口停点候选数＝入口个数（入口单候选断言）
 	# ---- 独立性断言（独立屏激活期战斗屏宿主整体隐藏，零透出）----
 	if not main.ui.modals.run.level_screen.visible:
 		problems.append("关卡开始未弹入口选路停点（level_screen 应可见）")
@@ -92,7 +92,7 @@ func _ready() -> void:
 		if not main.ui.screens.battle_root.visible or main.ui.modals.run.level_screen.visible:
 			problems.append("选路提交战斗节点后未切回战斗屏（屏级互斥恢复失守）")
 	# ---- 放弃入口·冒险模式可见 + 战斗中按下被拒（真实按钮路径——入口挂选路停点，战斗中拒绝为防御分支）----
-	# oracle: design/ux/level-map.md:42 放弃冒险（任意选路停点）→ 冒险落幕——战斗域单事务在飞时拒绝
+	# 判据出处: design/ux/level-map.md:42 放弃冒险（任意选路停点）→ 冒险落幕——战斗域单事务在飞时拒绝
 	if main.ui.modals.run.level_screen.abandon_btn == null or not main.ui.modals.run.level_screen.abandon_btn.visible:
 		problems.append("冒险模式放弃按钮未开放（选路停点入口在案）")
 	else:
@@ -101,7 +101,7 @@ func _ready() -> void:
 		if main.run_scope.adventure == null or String(main.run_scope.adventure.state) != "running":
 			problems.append("首战中放弃未被拒（战斗域单事务在飞——state 应保持 running）")
 	# ---- 既有断言（回归基线；A 区无进度条——节点链进度由关卡画面独立屏承载）----
-	# oracle: design/ux/battle.md:122 B 区构建组：主角与敌人站桩、明细带挖掘期收起、轮次指示、棋盘与 C 区/秘宝槽、首战进行中
+	# 判据出处: design/ux/battle.md:122 B 区构建组：主角与敌人站桩、明细带挖掘期收起、轮次指示、棋盘与 C 区/秘宝槽、首战进行中
 	if main.ui.battle.board_zone.board_view.cells_probe().is_empty():
 		problems.append("棋盘格未生成（cells=0）")
 	if main.ui.battle.board_zone.board_view.board() == null:
@@ -119,7 +119,7 @@ func _ready() -> void:
 		problems.append("B 区敌方站桩未构建（%d 个）" % main.ui.battle.stage.enemy_box.get_child_count())
 	if main.ui.battle.board_zone.ap_bar._dots.get_child_count() != int(main.db.run.action_economy.ap_per_round):
 			problems.append("D 区 AP 点阵数量错误（%d）" % main.ui.battle.board_zone.ap_bar._dots.get_child_count())
-	# oracle: design/gdd/systems/排雷循环/行动经济.md:258 开轮硬重置：行动点回到表值（AP 点阵数=ap_per_round）
+	# 判据出处: design/gdd/systems/排雷循环/行动经济.md:258 开轮硬重置：行动点回到表值（AP 点阵数=ap_per_round）
 	if main.ui.battle.board_zone.ap_bar.refresh_remaining_text() == "":
 		problems.append("D 区弃图刷新按钮文案缺失")
 	if main.ui.battle.board_zone.toast == null:
@@ -136,7 +136,7 @@ func _ready() -> void:
 	# E 区无道具面板——四区构建由其余断言覆盖
 
 	# ---- 敌方站桩投影（顺位徽标/意图三档动作动画占位——敌人系统×4，全站桩）----
-	# oracle: design/gdd/systems/表现与支撑/HUD框架.md:275 敌人呈现：意图占位三档可见性——普通攻击零表示、类型级提示（站桩投影组）
+	# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:275 敌人呈现：意图占位三档可见性——普通攻击零表示、类型级提示（站桩投影组）
 	# B 区站桩子件伴随件化（壳层 tooltip 载体）——断言口径见台账 171：
 	# 伴随件化（壳层 tooltip 载体），穿透明（子件 _name_label/_armor_icon/_intent_badge）改本体
 	# 探针出口 stage.enemy_body_at(i).name_line_probe()/intent_probe()——呈现口径逐字保持
@@ -163,7 +163,7 @@ func _ready() -> void:
 	elif not bool(main.ui.battle.stage.hero_standee.portrait_probe().get("has_tex", false)):
 		problems.append("主角立绘纹理未落位（显示档 hero=144——显示档批）")
 	# ---- BUG-0001 回归（tooltip 入树后 set_effects 槽位不错位——结算软锁修复沉淀）----
-	# oracle: design/gdd/systems/表现与支撑/HUD框架.md:274 状态槽图标+层数+剩余次数、悬停见来源（tooltip 回归组）
+	# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:274 状态槽图标+层数+剩余次数、悬停见来源（tooltip 回归组）
 	var slots_row = main.ui.battle.stage.hero_standee.slot_row   # BUG-0001 回归随组件迁入站桩（tooltip/槽位错位同源）
 	var probe_eff: Array = [{"effect_id": "attack_up", "display_name": "增伤", "layers": 1,
 		"remaining_settlements": 1, "source_class": "safe_cell", "round_index": 1, "effective_value": 50}]
@@ -189,7 +189,7 @@ func _ready() -> void:
 	# ---- 图标键回归（HUD框架 图标键契约：状态表九行全映射〔定稿 PNG 纹理〕、
 	# 格面资源 cell_type 九型全映射〔含 gp 键〕；查不到的键 fail-fast + ? 占位
 	# ——此处钉死映射不残缺，未知键断言由 _icon_tex/_badge_glyph 承担）----
-	# oracle: design/gdd/systems/表现与支撑/HUD框架.md:274 极性按键级表呈现——状态图标键映射不残缺（图标键回归组）
+	# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:274 极性按键级表呈现——状态图标键映射不残缺（图标键回归组）
 	for eid in ["attack_up", "ac_up", "alert", "weaken", "enrage", "off_guard", "sapped", "empower", "fortify"]:
 		if not StatusSlotRow.EFFECT_ICON.has(eid) or StatusSlotRow.EFFECT_ICON[eid] == null:
 			problems.append("状态图标九键纹理映射缺失（%s）" % eid)
@@ -214,7 +214,7 @@ func _ready() -> void:
 	# ---- L2 单场段（debug_session 单场原语 + 去饱和接口可用性；雾格机制已整体移除，不再断言变体呈现）----
 	# 单场无用户入口——探针直调 debug_session 原语（battle_created/ready 仍经组合根接线；
 	# _reset_run_scope 复现 _start_single 的提示去重复位）
-	# oracle: design/gdd/systems/排雷循环/地形变异.md:156 布置域：变异格全在初始展开区外（L2 布置域组）
+	# 判据出处: design/gdd/systems/排雷循环/地形变异.md:156 布置域：变异格全在初始展开区外（L2 布置域组）
 	main.begin_session(false)
 	main._debug.start_single(2)
 	await get_tree().process_frame
@@ -237,7 +237,7 @@ func _ready() -> void:
 	# ---- GP 终局行：summary gp_final 键取数+胜利面板 GP 行呈现（C5：GP 行只上冒险终局面板；
 	# 断言面 = summary 键，无影子账清零转存）----
 	# （置于战斗态断言之后——合成收束会灰化站桩并清 settlement 引用，具污染性）
-	# oracle: design/ux/settlement-summary.md:20 战利品行＝GP 增量+总量（冒险终局面板 GP 行组）
+	# 判据出处: design/ux/settlement-summary.md:20 战利品行＝GP 增量+总量（冒险终局面板 GP 行组）
 	var meta_saved = main.meta.save
 	for p2 in ["user://smoke_ui_probe_settle_scratch.json", "user://smoke_ui_probe_settle_scratch.json.tmp"]:
 		if FileAccess.file_exists(p2):
diff --git a/game/probe/ui_struct_probe.gd b/game/probe/ui_struct_probe.gd
index 5c452c57..4b74281e 100644
--- a/game/probe/ui_struct_probe.gd
+++ b/game/probe/ui_struct_probe.gd
@@ -89,7 +89,7 @@ func _ready() -> void:
 	# ---- 生涯页：入口=帐篷旁笔记本（卡④ T3 改挂——场景点选信号真实路由→组合根 _open_career）→
 	# 结构断言族→只读巡检（契约 3）+零动效契约+零跳转契约（提纲 P4 甲）→组合根真实路径关闭。
 	#（登记序/树序契约统一在全模态 _modal_registry_contract——boot 段跑）----
-	# oracle: design/ux/camp.md:19 帐篷旁笔记本→生涯记录；生涯页返回钮口径由结构校验兜底（生涯段）
+	# 判据出处: design/ux/camp.md:19 帐篷旁笔记本→生涯记录；生涯页返回钮口径由结构校验兜底（生涯段）
 	# 营地语境：开始层全程隐藏（笔记本入口在营地场景根——关生涯回营地不回开始层，卡④ T3 语境分支）
 	main._camp_pres.open_camp()   # 重开营地场景根（笔记本入口语境）
 	_settle()
@@ -106,7 +106,7 @@ func _ready() -> void:
 	if main.ui.modals.menu.career_overlay.visible or main.ui.screens.start_overlay.visible:
 		problems.append("[career] 关闭后页未隐藏或开始层回弹（营地语境分支失守）〔营地图批 V5〕")
 	# ---- Esc 浮窗结构段（卡⑤——三钮在位且仅三＋零动效契约＋登记序在册＋debug_badge 不波及）----
-	# oracle: design/ux/camp.md:45 ESC 优先序：有窗先关最上层窗、无窗才进浮窗；各窗自带关闭钮（Esc 段）
+	# 判据出处: design/ux/camp.md:45 ESC 优先序：有窗先关最上层窗、无窗才进浮窗；各窗自带关闭钮（Esc 段）
 	main._camp_pres.open_camp()
 	_settle()
 	var gpos_gate: Vector2 = main.ui.modals.camp.scene.get_hotspot_rect(&"gate").get_center()
@@ -213,7 +213,7 @@ func _ready() -> void:
 	_settle()
 
 	# ---- 冒险簇（真流推进：开冒险→地图选路态→选战斗节点→战斗 HUD）----
-	# oracle: design/ux/level-map.md:3 图上点击选路·候选按钮退役（冒险簇选路真点组）
+	# 判据出处: design/ux/level-map.md:3 图上点击选路·候选按钮退役（冒险簇选路真点组）
 	ProbeUiUtil.isolate_save(main, "smoke_ui_struct_probe_adv", true, false, true)
 	main.ui.modals.menu.debug_overlay.seed_edit.text = "42"   # 种子钉死（种子框默认为空=非首局随机，结构采样确定性禁依赖默认分支）
 	main._start_adventure_from_menu()
@@ -243,7 +243,7 @@ func _ready() -> void:
 		# ---- 图例层（旧模态、首过结构族）：ap_bar legend_toggled
 		# 信号真路径开（board_zone 信号→组合根 _on_legend_toggled→_open_modal）→结构断言族→
 		# closed 信号真路径关（close()→组合根 _on_modal_closed）。
-		# oracle: design/gdd/systems/表现与支撑/HUD框架.md:88 图例面板＝模态族：统一登记序栈、入栈出栈、关闭逐层恢复（图例组）
+		# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:88 图例面板＝模态族：统一登记序栈、入栈出栈、关闭逐层恢复（图例组）
 		main.ui.battle.board_zone.ap_bar._btn_legend.pressed.emit()   # 前提注入（保留 emit）：emit 选路路径下 battle_root 未及显示且输入锁在（实证在案），真点不可达——图例开启的真输入承载随「route 信号路径屏幕切换时序」发现一并呈报待裁
 		_settle()
 		if not main.ui.modals.run.legend_overlay.visible:
@@ -406,7 +406,7 @@ const _PAUSE_READONLY_SIGNALS: Array[String] = [
 
 
 func _status_readonly_contract(main: Node) -> void:
-	# oracle: design/engineering/code-conventions.md:21 视图零核心写调用、依赖单向（status 只读巡检组）
+	# 判据出处: design/engineering/code-conventions.md:21 视图零核心写调用、依赖单向（status 只读巡检组）
 	var overlay: Control = main.ui.modals.run.status_panel
 	var stack: Array = [overlay]
 	var conn_count := 0
@@ -453,7 +453,7 @@ func _status_zero_motion_contract(main: Node) -> void:
 # 清单外零连接。白名单={视图自身 _emit_closed〔返回钮〕, 组合根 _on_career_closed}；页内任何
 # 购买/导航/写入方向的新连接一律红，须先入册审查。
 func _career_readonly_contract(main: Node) -> void:
-	# oracle: design/engineering/code-conventions.md:21 视图零核心写调用、依赖单向（career 只读巡检组）
+	# 判据出处: design/engineering/code-conventions.md:21 视图零核心写调用、依赖单向（career 只读巡检组）
 	var overlay: Control = main.ui.modals.menu.career_overlay
 	var stack: Array = [overlay]
 	var conn_count := 0
@@ -500,7 +500,7 @@ func _career_zero_motion_contract(main: Node) -> void:
 # _career_registry_contract 的断言（career=状态面板后/确认弹窗前、树序同步）由本全量合同覆盖）
 # ⑭选档界面契约（卡③ sl1/sl2/sl3/sl4/sl9——呈现面全部来自喂入数据，视图零自判）
 func _save_select_contract(main: Node, tpl: String) -> void:
-	# oracle: design/gdd/systems/表现与支撑/存档序列化.md:61 三存档位独立文件、激活态由选档界面建立（选档契约组）
+	# 判据出处: design/gdd/systems/表现与支撑/存档序列化.md:61 三存档位独立文件、激活态由选档界面建立（选档契约组）
 	var sso: Node = main.ui.modals.menu.save_select_overlay
 	# sl1 三槽呈现：槽卡计数==3＋零滚动容器（禁滚动长列表形态——契约 1）
 	var rows: VBoxContainer = sso._rows_box
@@ -580,7 +580,7 @@ func _collect_labels(node: Node, out: Array[String]) -> void:
 
 
 func _modal_registry_contract(main: Node) -> void:
-	# oracle: design/engineering/code-conventions.md:54 模态覆盖层层级规则——新增覆盖层必须登记 z 序位置（登记序契约组）
+	# 判据出处: design/engineering/code-conventions.md:54 模态覆盖层层级规则——新增覆盖层必须登记 z 序位置（登记序契约组）
 	var list: Array = main.ui.flow.stack._list
 	# ① 登记册序==合同模态序（逐位点名——合同是登记序唯一事实源）
 	var contract_modals: Array = []
@@ -648,7 +648,7 @@ func _modal_registry_contract(main: Node) -> void:
 
 # ⑬career 零跳转契约（提纲 P4 甲——页内零「前往他处」入口：除「返回」外任何导航钮=红）
 func _career_nojump_contract(main: Node) -> void:
-	# oracle: design/ux/camp.md:19 生涯记录入口与返回钮口径由结构校验兜底——页内零导航入口（零跳转契约组）
+	# 判据出处: design/ux/camp.md:19 生涯记录入口与返回钮口径由结构校验兜底——页内零导航入口（零跳转契约组）
 	for nav in ["营地", "商店", "设置", "冒险", "继续上局", "退出", "前往"]:
 		if ProbeUiUtil.find_button(main.ui.modals.menu.career_overlay, nav, "contains") != null:
 			problems.append("[career][nojump] 页内出现导航入口「%s」（零跳转违约——生涯纯只读）" % nav)
@@ -658,7 +658,7 @@ func _career_nojump_contract(main: Node) -> void:
 # （名行基线离盒底 1px 同型高危写法返修回归闸；
 # 内容矩形=StandeeBody.content_rect()，最低绘制元素=底座下缘）
 func _standeefit_contract(main: Node) -> void:
-	# oracle: design/ux/battle.md:154 主角站桩立绘（无框立绘+落影）——站桩内容矩形⊆舞台（站桩适配组）
+	# 判据出处: design/ux/battle.md:154 主角站桩立绘（无框立绘+落影）——站桩内容矩形⊆舞台（站桩适配组）
 	var st: Node = main.ui.battle.stage
 	if st == null or st.hero_standee == null:
 		problems.append("[standee] 舞台/主角站桩缺失（断言中断）")
@@ -743,7 +743,7 @@ func _in_scroll(c: Control) -> bool:
 
 
 func _audit(screen: String, roots: Array) -> void:
-	# oracle: design/engineering/architecture/architecture.md:168 组合根交接面与呈现装配——屏结构审计宿主面（结构审计组）
+	# 判据出处: design/engineering/architecture/architecture.md:168 组合根交接面与呈现装配——屏结构审计宿主面（结构审计组）
 	for r in roots:
 		if r != null and is_instance_valid(r):
 			_force_layout(r)
diff --git a/game/probe/ui_tune_probe.gd b/game/probe/ui_tune_probe.gd
index e7509d2d..49896f61 100644
--- a/game/probe/ui_tune_probe.gd
+++ b/game/probe/ui_tune_probe.gd
@@ -43,7 +43,7 @@ func _ready() -> void:
 	# ① 全局浮层角标开窗（调试入口=UI 最顶层浮层，任何 UI 不遮挡——
 	# main 直接子层、LAYER_CONTRACT 末位 float 类；boot 菜单优先不开浮窗，角标真实点击路径开窗；
 	# 悬浮于菜单之上——开始层不隐藏；树序新基准=登记册末位（确认弹窗之后=绘制序最上））
-	# oracle: design/engineering/test-conventions.md:49 调试面＝DebugOverlay/DS_DEBUG——发布态恒隐无 UI 开启口、开发期临时启用（①开窗层级组）
+	# 判据出处: design/engineering/test-conventions.md:49 调试面＝DebugOverlay/DS_DEBUG——发布态恒隐无 UI 开启口、开发期临时启用（①开窗层级组）
 	main._show_debug_overlay()   # 发布态角标恒隐（main.gd:138 _debug_entry 缺省 false）——角标信号路径已退役（:123 同款先例），开窗经组合根直调承载
 	await get_tree().process_frame
 	if not main.ui.modals.menu.debug_overlay.visible:
@@ -57,7 +57,7 @@ func _ready() -> void:
 	if str(boosted_atk) not in main.ui.modals.menu.debug_overlay.effect_text() or str(boosted_hp) not in main.ui.modals.menu.debug_overlay.effect_text():
 		problems.append("生效预览未联动（%s）" % main.ui.modals.menu.debug_overlay.effect_text())
 	# ③ 应用（真实信号路径：apply_requested → 组合根）——E4 后加成零表写，生效断言移至 ⑧ 战斗快照
-	# oracle: design/engineering/test-conventions.md:49 调试面加成链路：滑条联动/应用/重置、hero 表运行期只读（②③④⑦组）
+	# 判据出处: design/engineering/test-conventions.md:49 调试面加成链路：滑条联动/应用/重置、hero 表运行期只读（②③④⑦组）
 	var apply_btn: Button = ProbeUiUtil.find_button(main.ui.modals.menu.debug_overlay, "应用并关闭")
 	if apply_btn == null:
 		problems.append("调试浮窗「应用并关闭」钮缺失")
@@ -72,7 +72,7 @@ func _ready() -> void:
 		ProbeUiUtil.push_click(main, reset_btn)
 	# ⑤ 批量模拟全链路（N=10——走 level_autoplay 与 headless 扫描同口径；表基线由组合根复位；
 	# 菜单态上下文未锁定=按钮可点，is_running 语义=模拟在跑〔18卡⑦ 与对局禁用态拆分〕）
-	# oracle: design/engineering/test-conventions.md:49 调试面批量模拟链路：N=10 输出关卡完成率/剩余 HP/败北节点（⑤组）
+	# 判据出处: design/engineering/test-conventions.md:49 调试面批量模拟链路：N=10 输出关卡完成率/剩余 HP/败北节点（⑤组）
 	main.ui.modals.menu.debug_overlay.set_sliders(100, 0)
 	main.ui.modals.menu.debug_overlay.set_sim_count(10)
 	# 折叠区控件真输入通道（test-conventions §2——先滚轮滚入可视区再点）：sim 钮在滚动列表 boot
@@ -155,7 +155,7 @@ func _ready() -> void:
 	# ⑨ 对局中可开（18卡⑦ P2 甲/T2 防护——S1+ 停机点回归闸）：战斗屏角标真实信号路径开窗；
 	# 棋盘输入不锁、状态角标不置灰（「默认开×遮挡复活」下必锁死的破约回归面）；
 	# 对局中批量模拟/两层调试两钮禁用；当局数据六项与只读访问器逐项一致；关闭钮真实路径收窗恢复
-	# oracle: design/engineering/test-conventions.md:49 调试面对局态：不锁棋盘输入/两钮禁用/当局数据只读一致（⑨组）
+	# 判据出处: design/engineering/test-conventions.md:49 调试面对局态：不锁棋盘输入/两钮禁用/当局数据只读一致（⑨组）
 	var dbg_badge: Button = main.ui.screens.debug_badge
 	if dbg_badge == null or dbg_badge.visible:
 		problems.append("对局中调试浮层角标非恒隐（发布态语义失守——卡⑦ 删写死行批）")
@@ -199,7 +199,7 @@ func _ready() -> void:
 	_overlay_zero_motion_contract(main, problems)
 	# ⑩ 种子三分单点断言（18卡⑦ C1——判定只落 _seed_value() 单点；对局态不影响本判定面）：
 	# 显式合法整数全场景优先（含首局）→ 首局（存档布尔 false）恒 42 → 非首局空框引擎熵连抽不全等 42
-	# oracle: design/engineering/architecture/architecture.md:168 seed_value＝组合根公开服务面（⑩种子三分判定单点组）
+	# 判据出处: design/engineering/architecture/architecture.md:168 seed_value＝组合根公开服务面（⑩种子三分判定单点组）
 	main.ui.modals.menu.debug_overlay.seed_edit.text = "777"
 	if main.seed_value() != 777:
 		problems.append("显式种子输入未优先（_seed_value != 777——C1 ①失守）")
@@ -240,7 +240,7 @@ func _ready() -> void:
 # 全连接巡检——白名单={视图自身八方法 + 注册面模态编排口 ui.flow.close（closed 外发消费——
 # 注册面批把该连接目标从组合根转发壳改为 flow 真方法，机检白名单随批登记同一连接）}；
 # 当局数据区块=纯标签零连接在此被一并约束（新增任何连接=红须入册审查）。
-# oracle: design/engineering/code-conventions.md:21 视图零核心写调用、依赖单向（白名单外零连接巡检组）
+# 判据出处: design/engineering/code-conventions.md:21 视图零核心写调用、依赖单向（白名单外零连接巡检组）
 func _overlay_readonly_contract(main: Node, problems: Array) -> void:
 	var overlay: Control = main.ui.modals.menu.debug_overlay
 	var stack: Array = [overlay]
diff --git a/game/sim/auto_player.gd b/game/sim/auto_player.gd
index 377dd8cd..c840b608 100644
--- a/game/sim/auto_player.gd
+++ b/game/sim/auto_player.gd
@@ -78,7 +78,7 @@ static func _deduce_single(minesweeper) -> Dictionary:
 # 〔轮末 weaken + 魔法 首次充能〕且雷上封印不阻连锁）· 卡死且刷新资源可用 → 轮内刷新
 # （经 settlement.player_request_refresh 核心编排）· 否则停手（残 AP 1:1 转存 RAP——下轮刷新资源）。
 # 推理规则集 = 棋盘生成 F1 measure_inferability 同族（single + subset——solver_rules=single_subset 冻结域）；
-# 口径差异 = unknown 集不含 棋盘生成 生成期 safe_set oracle（真实玩家约束的未知邻格含危险格）——比生成期闸
+# 口径差异 = unknown 集不含 棋盘生成 生成期 safe_set 真值（真实玩家约束的未知邻格含危险格）——比生成期闸
 # 保守，卡死率略高属口径诚实。输入只经 排雷玩法 查询面（reveal_record/is_revealed/has_seal/current_board
 # 的邻居与可达面），禁读棋盘雷区真值（测推理上界，非全知作弊）。
 # 待拍板（未实现）：非卡死主动刷新、囤刀倾泻 vs 即用即耗、完美板目标加权。
@@ -148,8 +148,8 @@ static func _deduce(minesweeper) -> Dictionary:
 							changed = true
 		# 0 格连锁算子（架构整改批补齐——与棋盘生成 _apply_chain_rule 对位）：safe 集中未揭示格
 		# 挖开必触发 0 格连锁（连锁只经安全格扩散=闭包集全安全，真实玩家挖 c 免费获得的信息面），
-		# 经 preview_reveal 真实闭包取新开格集并入 safe——双口径显式登记：unknown 不含 safe_set oracle
-		# 〔口径差异=board_generator 版含 oracle，本版 no-peek——:80-83 注释在账〕
+		# 经 preview_reveal 真实闭包取新开格集并入 safe——双口径显式登记：unknown 不含 safe_set 真值
+		# 〔口径差异=board_generator 版含真值，本版 no-peek——:80-83 注释在账〕
 		for c in (safe.keys() as Array).duplicate():
 			if board.is_safe(c) and not minesweeper.is_revealed(c):
 				for rc in minesweeper.preview_reveal(c):
diff --git a/game/tests/smoke_boot.gd b/game/tests/smoke_boot.gd
index 40b4f767..d62020a0 100644
--- a/game/tests/smoke_boot.gd
+++ b/game/tests/smoke_boot.gd
@@ -16,7 +16,7 @@ var _checks: int = 0
 
 
 func check(cond: bool, label: String) -> void:
-# oracle: design/engineering/architecture/architecture.md:10 （测试层级四级——冒烟存活检查组）
+# 判据出处: design/engineering/architecture/architecture.md:10 （测试层级四级——冒烟存活检查组）
 	_checks += 1
 	if cond:
 		print("  [PASS] " + label)
@@ -35,7 +35,7 @@ func _ready() -> void:
 
 # 开机前置面：autoload 注册与资源可加载（挂主屏之前先查，失败时主屏断言整段跳过）
 func _check_autoloads() -> void:
-# oracle: design/engineering/architecture/architecture.md:10 （测试层级四级——冒烟存活检查组）
+# 判据出处: design/engineering/architecture/architecture.md:10 （测试层级四级——冒烟存活检查组）
 	for autoload_name in ["ConfigDB", "RngService", "SaveManager", "MetaProgression"]:
 		var node: Node = get_node_or_null(NodePath("/root/" + autoload_name))
 		check(node != null, "autoload %s 在位" % autoload_name)
@@ -64,7 +64,7 @@ func _boot_main_scene() -> Node:
 
 # 主屏存活面：组合根装配句柄在位（main.X 一级句柄契约，探针挂载假设的启动侧证明）
 func _check_main_scene(main: Node) -> void:
-# oracle: design/engineering/architecture/architecture.md:10 （测试层级四级——冒烟存活检查组）
+# 判据出处: design/engineering/architecture/architecture.md:10 （测试层级四级——冒烟存活检查组）
 	check(main != null and main.is_inside_tree(), "主屏场景已实例化并在树")
 	if main == null:
 		return
diff --git a/game/tests/system_test.gd b/game/tests/system_test.gd
index 316b24b7..2ca2e06c 100644
--- a/game/tests/system_test.gd
+++ b/game/tests/system_test.gd
@@ -34,7 +34,7 @@ func _initialize() -> void:
 # （自 game/smoke/smoke_all.gd 剪切迁入——断言 label 逐字原样；G12 两套调用不随迁，
 # 归 source_guard_test.gd，断言迁移批 B G1）
 func _split_tail() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	await process_frame
 	await process_frame
 	var autoload_ok: bool = get_root().get_node_or_null("/root/ConfigDB") != null 		and get_root().get_node_or_null("/root/SaveManager") != null
@@ -54,7 +54,7 @@ func _split_tail() -> void:
 # ---- 三屏场景化断言（V2——独立实例化+关键节点在位+组合根树序/z 序保序）----
 # （自 game/smoke/smoke_all.gd 剪切迁入——label 与 cond 逐字原样，断言迁移批 B G1）
 func _smoke_scene_split() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	print("--- 迭代27 T1 三屏场景化（V2：屏壳独立实例化+组合根装配保序）---")
 	# ① 三屏壳独立实例化（F6 等价——headless 直挂；视图代码构建在屏壳 _ready）
 	var menu: Node = load("res://presentation/scenes/menu_screen.tscn").instantiate()
@@ -151,7 +151,7 @@ func _count_visible_buttons(node: Node) -> int:
 
 # ---- boot 链路时序后置条件（启动态六断言；只立行为可判断言，不造假时序）----
 func _smoke_boot_chain() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	print("--- 迭代28 T2 boot 链路时序后置条件（V2：六断言）---")
 	var main: Node = load("res://presentation/main.tscn").instantiate()
 	root.add_child(main)
@@ -216,7 +216,7 @@ func _smoke_boot_chain() -> void:
 
 
 func _smoke_run_lifecycle() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	print("--- 迭代27 T1 会话物化（V3：两连局复位+脏状态不残留）---")
 	var main: Node = load("res://presentation/main.tscn").instantiate()
 	root.add_child(main)
@@ -274,7 +274,7 @@ func _smoke_run_lifecycle() -> void:
 
 # ---- d6/d7 批量模拟互斥守卫（wd6/wd7——白盒置态直调入口，以守卫早退的可见后果为断言面）----
 func _smoke_sim_guards() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	print("--- 卡① T2：批量模拟互斥两守卫（d6/d7）---")
 	var main: Node = load("res://presentation/main.tscn").instantiate()
 	root.add_child(main)
@@ -348,7 +348,7 @@ func _face_snapshot(main: Node) -> Dictionary:
 # 阶段面断言：adv/run/set=alive|null|both（会话三面存活态）；恒活面每阶段必查；
 # 现值回调与 run_scope 成员必须同源（回调链无悬挂铁证）；extra=阶段附加判据。
 func _stage_faces(main: Node, tag: String, adv: String, run: String, set: String, extra: Dictionary = {}) -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	var snap := _face_snapshot(main)
 	var bad := ""
 	for k in ["bonus_meta", "bonus_save", "camp_meta", "camp_save", "rp_log", "rp_stage", "rp_board_zone", "rp_fx", "rp_board"]:
@@ -417,7 +417,7 @@ func _face_liveness(name: String, v, want: String) -> String:
 #（level_started→choices_presented 同步到达，无可观测中间态）——合并为 V3b 一处断言。
 # （自 game/smoke/smoke_all.gd 剪切迁入——label 与 cond 逐字原样，断言迁移批 B G1）
 func _smoke_lifecycle_matrix() -> void:
-# oracle: design/gdd/systems/冒险循环/冒险结构.md:284 （生命周期矩阵——三关序列组）
+# 判据出处: design/gdd/systems/冒险循环/冒险结构.md:284 （生命周期矩阵——三关序列组）
 	print("--- 迭代28 T3 生命周期存活性矩阵（V3：九阶段×五引用面）---")
 	var main: Node = load("res://presentation/main.tscn").instantiate()
 	root.add_child(main)
@@ -608,7 +608,7 @@ func _smoke_lifecycle_matrix() -> void:
 
 
 func _smoke_camp_hud_band() -> void:
-# oracle: design/ux/camp.md:41 （营地顶栏栏体定值与落座——几何/色值/吃点击五钉组）
+# 判据出处: design/ux/camp.md:41 （营地顶栏栏体定值与落座——几何/色值/吃点击五钉组）
 	print("--- 营地交互修复批 T3 顶栏栏体（R5：色值/铺满/不吃点击/首子件/徽章落座）---")
 	var main: Node = load("res://presentation/main.tscn").instantiate()
 	root.add_child(main)
diff --git a/game/tests/unit/battle_settlement/boss_gate_test.gd b/game/tests/unit/battle_settlement/boss_gate_test.gd
index 6691a46d..3cef9f24 100644
--- a/game/tests/unit/battle_settlement/boss_gate_test.gd
+++ b/game/tests/unit/battle_settlement/boss_gate_test.gd
@@ -8,13 +8,13 @@ const Kit := preload("res://tests/unit/test_kit.gd")
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/战斗循环/敌人系统.md:293 Boss 节点开战行集宿主（装载组）
+# 判据出处: design/gdd/systems/战斗循环/敌人系统.md:293 Boss 节点开战行集宿主（装载组）
 	_test_boss_node_spawns_boss_rowset()
 	quit(Kit.finish("boss_gate_test"))
 
 
 func _test_boss_node_spawns_boss_rowset() -> void:
-# oracle: design/gdd/systems/战斗循环/敌人系统.md:295 开战生成按遭遇坐标取行集（Boss 行集组）
+# 判据出处: design/gdd/systems/战斗循环/敌人系统.md:295 开战生成按遭遇坐标取行集（Boss 行集组）
 	var db = load("res://core/config_db.gd").new()
 	var load_ok: bool = db.load_tables("res://data/tables", true) and db.diagnostics_count("error") == 0
 	Kit.check("前置：表加载零 error", load_ok)
diff --git a/game/tests/unit/battle_settlement/damage_controller_test.gd b/game/tests/unit/battle_settlement/damage_controller_test.gd
index 8807bd03..b27446f5 100644
--- a/game/tests/unit/battle_settlement/damage_controller_test.gd
+++ b/game/tests/unit/battle_settlement/damage_controller_test.gd
@@ -23,7 +23,7 @@ var _rows: Array = []   # 当前 run 的行协议收集（_on_row 绑定法—
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/战斗循环/战斗结算.md:360 伤害单据编排宿主（装载组）
+# 判据出处: design/gdd/systems/战斗循环/战斗结算.md:360 伤害单据编排宿主（装载组）
 	var db = ConfigDBScript.new()
 	var load_ok: bool = db.load_tables("res://data/tables", true)
 	Kit.check("前置：表加载零 error", load_ok and db.diagnostics_count("error") == 0)
@@ -71,7 +71,7 @@ func _row_by_display_prefix(prefix: String) -> Dictionary:
 # ---- 五配方一次全流程 + 双跑逐位复现 ----
 
 func _run_recipe_sequence(db) -> Array:
-# oracle: design/gdd/systems/战斗循环/战斗结算.md:362 （五段全序——配方序列组）
+# 判据出处: design/gdd/systems/战斗循环/战斗结算.md:362 （五段全序——配方序列组）
 	_rows = []
 	var h = _harness(db)
 	var units = h.units
@@ -178,7 +178,7 @@ func _run_recipe_sequence(db) -> Array:
 
 
 func _test_five_recipes_and_replay(db) -> void:
-# oracle: design/gdd/systems/战斗循环/战斗结算.md:363 （同种子回放逐行相同组）
+# 判据出处: design/gdd/systems/战斗循环/战斗结算.md:363 （同种子回放逐行相同组）
 	var run1: Array = _run_recipe_sequence(db)
 	Kit.check("五配方序列产出 5 行伤害行", run1.size() == 5)
 	var run2: Array = _run_recipe_sequence(db)
@@ -188,7 +188,7 @@ func _test_five_recipes_and_replay(db) -> void:
 # ---- A 模式（开单即结——回切位） ----
 
 func _test_policy_immediate_mode(db) -> void:
-# oracle: design/gdd/systems/战斗循环/战斗结算.md:362 （结算策略即时面组）
+# 判据出处: design/gdd/systems/战斗循环/战斗结算.md:362 （结算策略即时面组）
 	_rows = []
 	var h = _harness(db)
 	if not h.spawn_ok:
@@ -204,7 +204,7 @@ func _test_policy_immediate_mode(db) -> void:
 # ---- 来源敌死亡：队列中未结单据作废（死亡即不动手） ----
 
 func _test_source_death_void(db) -> void:
-# oracle: design/gdd/systems/战斗循环/敌人系统.md:133 （摇定后兑现前被杀本拍作废组）
+# 判据出处: design/gdd/systems/战斗循环/敌人系统.md:133 （摇定后兑现前被杀本拍作废组）
 	_rows = []
 	var h = _harness(db)
 	if not h.spawn_ok:
@@ -238,7 +238,7 @@ func _unit_fixture() -> Dictionary:
 
 
 func _test_identical_content_dual_enemy(db: ConfigDb) -> void:
-# oracle: design/gdd/systems/战斗循环/敌人系统.md:303 （双敌同内容顺位组）
+# 判据出处: design/gdd/systems/战斗循环/敌人系统.md:303 （双敌同内容顺位组）
 	var a := _unit_fixture()
 	var b := _unit_fixture()
 	Kit.check("前置：双敌字典内容全同且非同一实例", a == b and not is_same(a, b))
@@ -268,7 +268,7 @@ func _test_identical_content_dual_enemy(db: ConfigDb) -> void:
 
 # d12 产发端增键：目标身份随行/随载荷下发（同名敌按 id 精确解析的产发半）
 func _test_target_id_payload(db: ConfigDb) -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	_rows = []
 	var h = _harness(db)
 	if not h.spawn_ok:
@@ -291,7 +291,7 @@ func _test_target_id_payload(db: ConfigDb) -> void:
 
 
 func _test_requires_gate_and_zero(db) -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	_rows = []
 	var h = _harness(db)
 	if not h.spawn_ok:
@@ -318,7 +318,7 @@ func _test_requires_gate_and_zero(db) -> void:
 # ---- 主角倒下：flush 余单全部作废（_halted 终止） ----
 
 func _test_hero_death_halt(db) -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	_rows = []
 	var h = _harness(db)
 	if not h.spawn_ok:
@@ -336,7 +336,7 @@ func _test_hero_death_halt(db) -> void:
 # ---- AC 合流：override 入参 / 表值兜底 / ac 型状态叠层（不入池） ----
 
 func _test_ac_merge(db) -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	_rows = []
 	var h = _harness(db)
 	if not h.spawn_ok:
@@ -364,7 +364,7 @@ func _test_ac_merge(db) -> void:
 # ---- 池乘区收口：池内加算 → clamp；ac 型不入池 ----
 
 func _test_pool_clamp(db) -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	_rows = []
 	var h = _harness(db)
 	if not h.spawn_ok:
@@ -422,7 +422,7 @@ func _test_pool_clamp(db) -> void:
 # ---- 个体池读数 / 个体 AC 合流（增益状态 v1.5——敌方状态个体化批）----
 
 func _test_pool_consumption_per_unit(db) -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	var h = _harness(db, 3)   # depth 3 = 混编行集（熊地精 1 + 地精 1–2，最少 2 只——个体对照面需 ≥2 敌）
 	if not h.spawn_ok:
 		return
@@ -442,7 +442,7 @@ func _test_pool_consumption_per_unit(db) -> void:
 
 
 func _test_defender_ac_per_unit(db) -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	var h = _harness(db, 3)
 	if not h.spawn_ok:
 		return
diff --git a/game/tests/unit/battle_settlement/damage_math_test.gd b/game/tests/unit/battle_settlement/damage_math_test.gd
index 8e468109..952c0bba 100644
--- a/game/tests/unit/battle_settlement/damage_math_test.gd
+++ b/game/tests/unit/battle_settlement/damage_math_test.gd
@@ -12,7 +12,7 @@ var db
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/战斗循环/战斗结算.md:360 （伤害公式宿主——装载组）
+# 判据出处: design/gdd/systems/战斗循环/战斗结算.md:360 （伤害公式宿主——装载组）
 	db = ConfigDBScript.new()
 	var load_ok: bool = db.load_tables("res://data/tables", true)
 	Kit.check("前置：settlement 表加载零 error", load_ok and db.diagnostics_count("error") == 0)
@@ -31,7 +31,7 @@ func _floor_val() -> int:
 # ---- F2 乘区：池内加算 → 池间乘算 → floor（单一取整规则）----
 
 func _test_pool_damage() -> void:
-# oracle: design/gdd/systems/战斗循环/战斗结算.md:360 （池伤害公式组）
+# 判据出处: design/gdd/systems/战斗循环/战斗结算.md:360 （池伤害公式组）
 	var d := _floor_val() + 9   # 表值推导的任意正探针量（非玩法行值）
 	Kit.check("中性双池 (0,0) 原样透传", DamageMathScript.pool_damage(d, 0, 0) == d)
 	Kit.check("负敌方池压低不增高", DamageMathScript.pool_damage(d, 0, int(db.combat.settlement.core.pool_clamp_lo)) <= d)
@@ -44,7 +44,7 @@ func _test_pool_damage() -> void:
 # ---- 克制分量：空桶不吃修正恒 0；落地下限保底（[1,+∞) 全来源）----
 
 func _test_counter_component() -> void:
-# oracle: design/gdd/systems/战斗循环/战斗结算.md:360 （计数器分量组）
+# 判据出处: design/gdd/systems/战斗循环/战斗结算.md:360 （计数器分量组）
 	var floor_v := _floor_val()
 	Kit.check("空桶（点数≤0）恒 0 不吃修正", DamageMathScript.counter_component(0, floor_v, floor_v) == 0
 		and DamageMathScript.counter_component(-1, 5, floor_v) == 0)
@@ -56,7 +56,7 @@ func _test_counter_component() -> void:
 # ---- 掷点折扣查档（纯函数）：满阈值恒全额；档位边界/末档语义与表数组一致 ----
 
 func _test_roll_discount_percent() -> void:
-# oracle: design/gdd/systems/战斗循环/战斗结算.md:360 （乘区折扣组）
+# 判据出处: design/gdd/systems/战斗循环/战斗结算.md:360 （乘区折扣组）
 	var threshold := 10   # 查档探针阈值（夹具值——档位参数本身全部来自表）
 	var bounds: Array = db.combat.settlement.damage_roll.roll_tier_bounds
 	var discounts: Array = db.combat.settlement.damage_roll.roll_tier_discounts
@@ -81,7 +81,7 @@ func _test_roll_discount_percent() -> void:
 # ---- 吃掷点分量算术：折扣→(暴击)→floor→+克制修正（单一取整链）----
 
 func _test_rolled_component() -> void:
-# oracle: design/gdd/systems/战斗循环/战斗结算.md:360 （掷点分量组）
+# 判据出处: design/gdd/systems/战斗循环/战斗结算.md:360 （掷点分量组）
 	var base := float(_floor_val() + 7)   # 表值推导探针基线
 	var crit_mult: int = int(db.combat.settlement.damage_roll.crit_multiplier)
 	Kit.check("满额折扣无暴击 = floor(基线) + 修正 0", DamageMathScript.rolled_component(base, 100, false, crit_mult, 0) == int(floor(base)))
diff --git a/game/tests/unit/battle_settlement/effect_port_test.gd b/game/tests/unit/battle_settlement/effect_port_test.gd
index 9394c55c..150dd4e6 100644
--- a/game/tests/unit/battle_settlement/effect_port_test.gd
+++ b/game/tests/unit/battle_settlement/effect_port_test.gd
@@ -19,7 +19,7 @@ var _db
 
 
 func _init() -> void:
-# oracle: design/engineering/architecture/architecture.md:144 （效果端口宿主——装载组）
+# 判据出处: design/engineering/architecture/architecture.md:144 （效果端口宿主——装载组）
 	_db = ConfigDBScript.new()
 	var load_ok: bool = _db.load_tables("res://data/tables", true)
 	Kit.check("前置：表加载零 error", load_ok and _db.diagnostics_count("error") == 0)
@@ -54,7 +54,7 @@ func _hero_attack_value(rows: Array) -> int:
 # ---- V1 端口单实例与真实发射路由 ----
 
 func _smoke_effect_port_wiring() -> void:
-# oracle: design/engineering/architecture/architecture.md:144 （端口单实例与六 Callable 路由组）
+# 判据出处: design/engineering/architecture/architecture.md:144 （端口单实例与六 Callable 路由组）
 	print("--- 效果端口：装配链单实例＋真实发射路由 ---")
 	# 充能跑（蓄力周转 charge_rotation 在册——attack_commit 订阅行 attack_bonus per 蓄力周转计数器）
 	var orch_c = _orch(TEST_SEED)
@@ -88,7 +88,7 @@ func _smoke_effect_port_wiring() -> void:
 # ---- V2 业务类零引擎直连（源码契约锚——theme_projection_test 源码锚惯例）----
 
 func _test_business_classes_engine_free() -> void:
-# oracle: design/engineering/architecture/architecture.md:144 （业务类零引擎直连组）
+# 判据出处: design/engineering/architecture/architecture.md:144 （业务类零引擎直连组）
 	print("--- 效果端口：业务类零引擎直连源码锚 ---")
 	for path in ["res://core/damage_controller.gd", "res://core/action_economy.gd"]:
 		var src := FileAccess.get_file_as_string(path)
@@ -100,7 +100,7 @@ func _test_business_classes_engine_free() -> void:
 # ---- V3 伤害域事实面闭集（合成行两对照——damage_taken 真实单据流）----
 
 func _test_biz_fact_face_closed() -> void:
-# oracle: design/engineering/architecture/architecture.md:144 （闭面四键 biz_fact 组）
+# 判据出处: design/engineering/architecture/architecture.md:144 （闭面四键 biz_fact 组）
 	print("--- 效果端口：业务发射事实面闭集 ---")
 	var orch = _orch(TEST_SEED)
 	Kit.check("V3 begin_battle 受理", orch.begin_battle(_enc([])))
diff --git a/game/tests/unit/battle_settlement/extended_row_violation_test.gd b/game/tests/unit/battle_settlement/extended_row_violation_test.gd
index fd3ac2c5..b0fdab8d 100644
--- a/game/tests/unit/battle_settlement/extended_row_violation_test.gd
+++ b/game/tests/unit/battle_settlement/extended_row_violation_test.gd
@@ -11,7 +11,7 @@ const Kit := preload("res://tests/unit/test_kit.gd")
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:199 （扩展行必载 effect_id——加载致命组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:199 （扩展行必载 effect_id——加载致命组）
 	var db = load("res://core/config_db.gd").new()
 	if not db.load_tables("res://data/tables", false):
 		push_error("[extended_row_violation_test] 表加载失败")
diff --git a/game/tests/unit/battle_settlement/refresh_feats_test.gd b/game/tests/unit/battle_settlement/refresh_feats_test.gd
index 01fc0c08..5eb5ebb5 100644
--- a/game/tests/unit/battle_settlement/refresh_feats_test.gd
+++ b/game/tests/unit/battle_settlement/refresh_feats_test.gd
@@ -154,7 +154,7 @@ func _seal_direct_with_expansion(orch) -> Vector2i:
 # 四条真实路径（敌方攻击/危险格/错误封印/地形）逐路驱动：每条至少一张主角承伤单据在案，
 # 且承伤计数器 == 主角承伤单据行数（每单据恰发射一次的全量判据——重复发射即计数器>行数）。
 func test_all_hero_damage_paths_emit_once() -> void:
-# oracle: design/gdd/systems/冒险循环/奇物.md:465 （换图生存：全局固定减伤全伤害路径恰一次组）
+# 判据出处: design/gdd/systems/冒险循环/奇物.md:465 （换图生存：全局固定减伤全伤害路径恰一次组）
 	print("--- V5 全局 damage_taken：四路径逐路恰一次 ---")
 	# ① 敌方攻击路径（Boss 战零挖掘连停三轮——干净样本：零地形零资源单据；多轮保证伤害技在案）
 	var orch1 = _orch(46001)
@@ -224,7 +224,7 @@ func _plan_seal(orch, target: Vector2i) -> Dictionary:
 # 同一伤害不得出现两次消费（重复发射=计数器>行数）：敌方路径与地形路径两样本逐位核对——
 # 地形单据带 hero_damage_consumed 标记，战斗段末 _resolve_board_flat_hero 跳过二次发射由此钉住。
 func test_no_duplicate_damage_taken_event() -> void:
-# oracle: design/gdd/systems/冒险循环/奇物.md:465 （受击事件零重复组）
+# 判据出处: design/gdd/systems/冒险循环/奇物.md:465 （受击事件零重复组）
 	print("--- V5 全局 damage_taken：无重复消费 ---")
 	var orch1 = _orch(46011)
 	var rows1 := _collect_hero_rows(orch1)
@@ -266,7 +266,7 @@ func _auto_dig(orch) -> void:
 
 # V2 矿脉储能：受理的付费挖格 RAP 恰 +1、AP 按表扣、板资源不变
 func test_reserve_on_accepted_dig() -> void:
-# oracle: design/gdd/systems/排雷循环/行动经济.md:256 （换图基座：挖格产 RAP 组）
+# 判据出处: design/gdd/systems/排雷循环/行动经济.md:256 （换图基座：挖格产 RAP 组）
 	print("--- V2 矿脉储能：付费挖格产 RAP ---")
 	var orch = _orch(46021)
 	Kit.check("V2 前置：战斗受理", orch.begin_battle(_enc(["vein_reserve"])))
@@ -304,7 +304,7 @@ func _drain_round_rap_accounting(orch) -> bool:
 
 # V3 省力周转：折价门槛与扣费（can 与执行同源；base 8→扣 4）
 func test_refresh_discount_gate_and_charge() -> void:
-# oracle: design/gdd/systems/排雷循环/行动经济.md:256 （刷新折扣门控与充能组）
+# 判据出处: design/gdd/systems/排雷循环/行动经济.md:256 （刷新折扣门控与充能组）
 	print("--- V3 省力周转：折价门槛与扣费 ---")
 	var orch = _orch(46022)
 	Kit.check("V3 前置：战斗受理", orch.begin_battle(_enc(["easy_swap"])))
@@ -326,7 +326,7 @@ func test_refresh_discount_gate_and_charge() -> void:
 
 # V3 双基座叠加：挖格产 RAP 与刷新折价同场生效
 func test_double_base_stack() -> void:
-# oracle: design/gdd/systems/冒险循环/奇物.md:465 （双基座叠加组）
+# 判据出处: design/gdd/systems/冒险循环/奇物.md:465 （双基座叠加组）
 	print("--- V3 双基座叠加 ---")
 	var orch = _orch(46023)
 	Kit.check("V3 前置：战斗受理", orch.begin_battle(_enc(["vein_reserve", "easy_swap"])))
@@ -343,7 +343,7 @@ func test_double_base_stack() -> void:
 
 # V12（refresh_feats 侧）：无专长基线——挖格零产 RAP、刷新按表基线扣、AP 保留、上限照旧
 func test_no_feats_baseline() -> void:
-# oracle: design/gdd/systems/冒险循环/奇物.md:465 （零专长基线组）
+# 判据出处: design/gdd/systems/冒险循环/奇物.md:465 （零专长基线组）
 	print("--- V12 无专长基线（refresh_feats 侧） ---")
 	var orch = _orch(46024)
 	Kit.check("V12 前置：战斗受理", orch.begin_battle(_enc([])))
@@ -379,7 +379,7 @@ func _br_count(orch) -> int:
 
 # V4 成功事实只在新板就位后发射：成功恰一次；非 Active／每轮上限／RAP 不足三拒面全零事实零换图
 func test_board_refresh_fact_only_on_success() -> void:
-# oracle: design/gdd/systems/排雷循环/行动经济.md:256 （弃图刷新事实面仅成功态组）
+# 判据出处: design/gdd/systems/排雷循环/行动经济.md:256 （弃图刷新事实面仅成功态组）
 	print("--- V4 成功刷新事实：拒绝零事实 ---")
 	_install_br_probe()
 	var orch = _orch(46031)
@@ -414,7 +414,7 @@ func test_board_refresh_fact_only_on_success() -> void:
 
 # V10 矿道红利：每次成功刷新 escrow 恰 +1 且 fx_grant_gp 行在案；拒绝零变化
 func test_mine_profit_gp() -> void:
-# oracle: design/gdd/systems/冒险循环/奇物.md:465 （换图资源：刷新固定 GP 收益组）
+# 判据出处: design/gdd/systems/冒险循环/奇物.md:465 （换图资源：刷新固定 GP 收益组）
 	print("--- V10 矿道红利：刷新固定 GP ---")
 	var orch = _orch(46032)
 	var gp_rows := {"n": 0}
@@ -461,7 +461,7 @@ func _damage_rows_by_source(rows: Array, source: String) -> Array:
 # V6 石层缓冲：全局固定减伤（危险格 pierce 8→6 两档钉死：单刷减 2·同轮多刷不叠加·未刷新轮不减；
 # 地形路径减后值=max(下限, effect_value−2)——含下限保持；敌方路径照常单次发射）
 func test_stone_mitigation_all_damage() -> void:
-# oracle: design/gdd/systems/冒险循环/奇物.md:465 （全局减伤全覆盖组）
+# 判据出处: design/gdd/systems/冒险循环/奇物.md:465 （全局减伤全覆盖组）
 	print("--- V6 石层缓冲：全局固定减伤 ---")
 	# S1 同轮双刷 → 危险格 pierce 8 减 2=6（叠加即 4——多刷不增钉死）
 	var orch1 = _orch(46041)
@@ -517,7 +517,7 @@ func test_stone_mitigation_all_damage() -> void:
 # V9 坑道小憩：轮末合计回复（白盒预置承载上限 3——计数器直改属数据面注入；
 # 自然累计 2 与满血未生效两形态分战场钉死）
 func test_rest_rotation_cap_and_clear() -> void:
-# oracle: design/gdd/systems/冒险循环/奇物.md:465 （轮末恢复 cap 与清账组）
+# 判据出处: design/gdd/systems/冒险循环/奇物.md:465 （轮末恢复 cap 与清账组）
 	print("--- V9 坑道小憩：轮末恢复 ---")
 	# R1 白盒预置 3 层 + 刷新闸（when<3 拒第 4 层）→ 停手回复 min(3, 缺血)——护甲降档保缺血 ≥3
 	var orch1 = _orch(46051)
@@ -575,7 +575,7 @@ func test_rest_rotation_cap_and_clear() -> void:
 
 # V8 蓄力周转：当轮攻击消费全部层数（上限 3 闸=白盒预置；战斗新建自然清空）
 func test_charge_layers_consumed_same_round() -> void:
-# oracle: design/gdd/systems/冒险循环/奇物.md:465 （充能当轮消耗组）
+# 判据出处: design/gdd/systems/冒险循环/奇物.md:465 （充能当轮消耗组）
 	print("--- V8 蓄力周转：攻击消费层 ---")
 	var orch1 = _orch(46061)
 	var rows1 := _collect_damage_rows(orch1)
@@ -602,7 +602,7 @@ func test_charge_layers_consumed_same_round() -> void:
 
 # V7 崩壁冲击：延迟群伤单（刷新时点零伤害行——战斗段末按存活目标结账）
 func test_blast_defers_to_combat_segment() -> void:
-# oracle: design/gdd/systems/战斗循环/战斗结算.md:362 （刷新群伤让位战斗段组）
+# 判据出处: design/gdd/systems/战斗循环/战斗结算.md:362 （刷新群伤让位战斗段组）
 	print("--- V7 崩壁冲击：延迟群伤 ---")
 	var orch = _orch(46071)
 	var rows := _collect_damage_rows(orch)
@@ -621,7 +621,7 @@ func test_blast_defers_to_combat_segment() -> void:
 
 # 七件 validate/在册/稀有度 cap 对表/跨表计数器引用闭合/desc 禁词
 func test_seven_feats_validate_and_pool() -> void:
-# oracle: design/gdd/systems/冒险循环/奇物.md:465 （换图系七件校验与池组）
+# 判据出处: design/gdd/systems/冒险循环/奇物.md:465 （换图系七件校验与池组）
 	print("--- V11 七件数据与池 ---")
 	var seven := {"vein_reserve": "excellent", "easy_swap": "excellent", "wall_blast": "excellent",
 		"charge_rotation": "excellent", "stone_mitigation": "common", "tunnel_rest": "common", "mine_profit": "rare"}
diff --git a/game/tests/unit/battle_settlement/roll_multiplier_test.gd b/game/tests/unit/battle_settlement/roll_multiplier_test.gd
index 50c6ff17..dce2cf8e 100644
--- a/game/tests/unit/battle_settlement/roll_multiplier_test.gd
+++ b/game/tests/unit/battle_settlement/roll_multiplier_test.gd
@@ -19,7 +19,7 @@ var _db
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/战斗循环/战斗结算.md:360 （掷点与乘区宿主——装载组）
+# 判据出处: design/gdd/systems/战斗循环/战斗结算.md:360 （掷点与乘区宿主——装载组）
 	_db = ConfigDBScript.new()
 	# 表加载失败不中止（承 G2/G3 同款：表损坏的红落在具体断言上——
 	# 诊断在此展开，后续断言按坏表实况逐条验红；collect_only=true 下成员照常赋值可评）
@@ -44,7 +44,7 @@ func _init() -> void:
 # 受理后不变量（encounter 受理后只读）。攻击单 base_value 贯通由 _smoke_damage_types 的
 # hero_atk_val=100 全链路行值承载（同夹具既有覆盖——派生读在攻击链上工作即行值随 override 走）----
 func _smoke_hero_atk_derived() -> void:
-# oracle: design/gdd/systems/战斗循环/战斗结算.md:360 （英雄攻击派生组）
+# 判据出处: design/gdd/systems/战斗循环/战斗结算.md:360 （英雄攻击派生组）
 	var rng_a = load("res://core/rng_service.gd").new()
 	rng_a.set_master_seed(4242)
 	var s_a = load("res://core/battle_orchestrator.gd").new(_db, rng_a)
@@ -67,7 +67,7 @@ func _smoke_hero_atk_derived() -> void:
 # → heavy 伤害 == light −1、ward == light +1（要求基线伤害 ≥ 2——地板 1 会吞 −1 位移）。
 # 承伤位移红线（卡片 §8 L3）：全局位移只允许 ±1 量级——非此量级 = 矩阵消费面有未盘点的第二落点（停机）。
 func _smoke_enemy_attack_type() -> void:
-# oracle: design/gdd/systems/战斗循环/敌人系统.md:295 （敌攻击类型行集组）
+# 判据出处: design/gdd/systems/战斗循环/敌人系统.md:295 （敌攻击类型行集组）
 	print("--- 敌方攻击类型轴（迭代 24 N3）---")
 	# ① 表列：20 行全填 normal（N3 全填不做差异化——Q9）
 	var at_ok := true
@@ -126,7 +126,7 @@ func _smoke_enemy_attack_type() -> void:
 # ---- 护甲等级掷点·行为面（折扣档分布 / nat20 暴击 / 伤害下限 / 棋盘来源必中）----
 
 func _smoke_armor_roll() -> void:
-# oracle: design/gdd/systems/战斗循环/增益状态.md:254 （护甲掷点与叠层合并组）
+# 判据出处: design/gdd/systems/战斗循环/增益状态.md:254 （护甲掷点与叠层合并组）
 	print("--- 护甲等级掷点（查档纯函数 + 暴击 + 伤害下限 + AC12 分布 + 棋盘必中）---")
 	# ① 查档纯函数：全掷点域逐位对照（AC10 / AC12）+ EV 锚（AC10 期望减免 21.25% —— registry 参考数）
 	var expect_ac10 := {100: 11, 75: 3, 50: 4, 25: 2}    # 掷 10-20 全额 / 7-9 / 3-6 / 1-2
@@ -345,7 +345,7 @@ func _auto_play_round(settlement, out: Dictionary) -> void:
 # 基线构成：基线 100——hero 攻击类型=normal（锻造工坊配置默认值，
 # hero.tres 无两轴字段）对轻甲中性 0 修正（目标 = L1 地精轻甲；AC 0 恒全额非暴击种子）。
 func _smoke_pool_wiring() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	print("--- 主角乘区接线 + 硬化折半方向 ---")
 	var base_row := _hero_attack_row_with({}, 100, 20260918)
 	var up_row := _hero_attack_row_with({"effects": ["attack_up"]}, 100, 20260918)
@@ -387,7 +387,7 @@ func _hero_attack_row_with(opts: Dictionary, hero_atk_val: int, seed_val: int) -
 # ---- 攻击类型 × 护甲克制 + 标错惩罚冒烟（护甲快照/克制矩阵/充能/反噬三选一）----
 
 func _smoke_damage_types() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	print("--- 攻击类型 × 护甲克制 + 标错惩罚 ---")
 	# ① 护甲类型快照传播（spawn 行值 → 单位字典）
 	var enemy_system = load("res://core/unit_container.gd").new(_db)
@@ -482,7 +482,7 @@ func _find_seal_target(minesweeper, want_mine: bool) -> Dictionary:
 # d_tick = max(damage_floor, pool_damage(floor(基线×档位%), 0, 0))，档位读数随行重建可归因）----
 
 func _smoke_attack_chain_fresh_pool() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	print("--- 战斗结算·fresh 池攻击链回归（Bug#2·掷点口径）---")
 	var rng = load("res://core/rng_service.gd").new()
 	rng.set_master_seed(20260913)
diff --git a/game/tests/unit/battle_settlement/round_flow_skill_pool_test.gd b/game/tests/unit/battle_settlement/round_flow_skill_pool_test.gd
index a0cbe34a..cbfb30c1 100644
--- a/game/tests/unit/battle_settlement/round_flow_skill_pool_test.gd
+++ b/game/tests/unit/battle_settlement/round_flow_skill_pool_test.gd
@@ -22,7 +22,7 @@ var _db
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/战斗循环/战斗结算.md:360 （轮内流与技能池宿主——装载组）
+# 判据出处: design/gdd/systems/战斗循环/战斗结算.md:360 （轮内流与技能池宿主——装载组）
 	_db = ConfigDBScript.new()
 	# 表加载失败不中止（承 G2/G3/G4/G5 同款：表损坏的红落在具体断言上——
 	# 诊断在此展开，后续断言按坏表实况逐条验红；collect_only=true 下成员照常赋值可评）
@@ -48,7 +48,7 @@ func _init() -> void:
 # ---- 完整战斗回放（自动玩家，确定性）——回放断言：同种子两遍步骤流逐行相同 ----
 
 func _smoke_full_battle(L: int, D: int, label: String) -> void:
-# oracle: design/gdd/systems/战斗循环/战斗结算.md:362 （全战斗回放——五段全序组）
+# 判据出处: design/gdd/systems/战斗循环/战斗结算.md:362 （全战斗回放——五段全序组）
 	print("--- 完整战斗回放：%s ---" % label)
 	var run1 = _run_battle(L, D)
 	var run2 = _run_battle(L, D)
@@ -83,7 +83,7 @@ func _smoke_full_battle(L: int, D: int, label: String) -> void:
 
 
 func _run_battle(L: int, D: int, axes: Dictionary = {}) -> Dictionary:
-# oracle: design/gdd/systems/战斗循环/战斗结算.md:362 （战斗驱动组）
+# 判据出处: design/gdd/systems/战斗循环/战斗结算.md:362 （战斗驱动组）
 	# 每遍全新 RngService（同 master 种子）——回放断言的隔离前提（地图战斗资源 AC"两套全新 RngService+地图战斗资源"同款）
 	var rng = load("res://core/rng_service.gd").new()
 	rng.set_master_seed(42)
@@ -148,7 +148,7 @@ func _auto_play_round(settlement, out: Dictionary) -> void:
 # ---- 行动经济·轮内刷新冒烟（方案 A：Active 相位当场换图继续挖）----
 
 func _smoke_active_refresh() -> void:
-# oracle: design/gdd/systems/排雷循环/行动经济.md:262 （停手转存储备与轮内刷新组）
+# 判据出处: design/gdd/systems/排雷循环/行动经济.md:262 （停手转存储备与轮内刷新组）
 	print("--- 行动经济·轮内刷新（方案 A）---")
 	var rng = load("res://core/rng_service.gd").new()
 	rng.set_master_seed(20260912)
@@ -255,7 +255,7 @@ func _active_refresh_replay() -> Array:
 # ---- 遭遇随机化冒烟（难度曲线与Boss Core Rule 8：区间骰/encounter 流/可回放/空表定值路径）----
 
 func _smoke_encounter_roll() -> void:
-# oracle: design/gdd/systems/战斗循环/敌人系统.md:296 （遭遇区间骰——摇号确定性组）
+# 判据出处: design/gdd/systems/战斗循环/敌人系统.md:296 （遭遇区间骰——摇号确定性组）
 	print("--- 遭遇随机化（unit_count 区间骰）---")
 	var counts: Array = []
 	for i in range(20):
@@ -390,7 +390,7 @@ func _encounter_replay(seed_val: int) -> Array:
 
 # 五段全序断言（战斗结算 验收"五段全序"+ 行型封闭 10 类）：逐轮行相位序 = 授予 → 增益/减益 → 战斗 → 衰减 → 判定。
 func _smoke_settlement_segments() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	print("--- 五段全序 + 行型封闭 ---")
 	Kit.check("segment_order 五段冻结在位（表值 = 拍板序恒等）",
 		Array(_db.combat.settlement.segment_order) == SettlementTable.FROZEN_SEGMENT_ORDER
@@ -509,7 +509,7 @@ func _smoke_skill_pool() -> void:
 
 # ① 数据面：技能表行集 + 普攻锁死 + 建议池行值 + 空池不可能（结构断言）
 func _smoke_skill_pool_data() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	Kit.check("技能表十六行（普攻/突刺/蓄力/重击/硬化 + 撕咬/毒爆/蛛网束缚 + 大地脉动 + 震地怒击/遏毒/岩崩 + 毒吐/盾击——前三批 + Boss 半血解锁技三行〔迭代14④ T5〕+ 普通敌错峰两行〔迭代 24 N2〕+ 触发条件批示范两行〔孤注守势/趁隙偷袭〕）", _db.combat.skill.rows.size() == 16)
 	var basic: Dictionary = _db.combat.skill.row_by_id("attack")
 	Kit.check("普攻行：倍率恒 1 · 冷却恒 0（域校验锁死——池恒非空的结构前提）",
@@ -726,7 +726,7 @@ func _fresh_rng(seed_val: int):
 # 单敌轨迹不独立复放——轨迹取数与其它流交错，无法脱离全序重建；
 # 同种子全战斗逐位复现由 ② 全对拍承载，单点定位归事件日志。
 func _smoke_skill_pool_replay_independence() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	var seed_val := -1
 	for s in range(1, 60):
 		var seqs := _record_pool_trajectories(s, 1)
@@ -780,7 +780,7 @@ func _record_pool_trajectories(seed_val: int, rounds: int) -> Dictionary:
 # 2026-10-28 重锚 [0.82, 1.02]（照酋长先例 ±0.10 绝对幅度，中值取理论稳态 0.92；旧带 [1.00,1.20] 系触发器前
 # 唯一特殊技＝突刺的池结构下登记，随池构成换代作废；撤销证明＝带宽回退旧值本断言复红）→ 宽带登记。
 func _smoke_skill_pool_ev_anchor() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	var bands := {"goblin": [0.82, 1.02], "bugbear": [0.97, 1.03], "ogre_chief": [1.10, 1.30]}   # 地精重锚 2026-10-28（触发条件批孤注守势入池稀释，无情境口径实测 0.9148；EV 锚注 enemy.tres）· 酋长重锚（震地怒击半血解锁入池，含闸长期速率上移：实测 1.1948；EV 锚注 enemy.tres）
 	var species := ["goblin", "bugbear", "ogre_chief"]
 	var rng = load("res://core/rng_service.gd").new()
@@ -836,7 +836,7 @@ func _smoke_skill_pool_ev_anchor() -> void:
 
 # ⑤ 死亡打断作废（摇定后、兑现前死亡 → 本拍技能作废、不动手、不进账）
 func _smoke_skill_pool_death_void() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	var void_seed := -1
 	for s in range(1, 400):
 		var rg = load("res://core/rng_service.gd").new()
@@ -876,7 +876,7 @@ func _smoke_skill_pool_death_void() -> void:
 
 # ⑥ 加载校验拒绝（单表域校验 + 跨表池构成纪律）
 func _smoke_skill_pool_validation_reject() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	var skill_table = load("res://data/schemas/skill_table.gd").new()
 	var enemy_table = load("res://data/schemas/enemy_table.gd").new()
 	enemy_table.rows.assign([{"enemy_id": "x", "display_name": "x", "pool": [{"skill_id": "ghost", "weight": 1}]}])
@@ -935,7 +935,7 @@ func _has_err_category(errs: Array, category: String) -> bool:
 # 停手轮驱动 (2,9)——零挖掘零封印 → 零池，伤害行可逐拍精确复算；种子 hunt 至少各命一粒毒爆伤害行
 # 与蛛网束缚施放行；毒分量随开战掷定的攻击基线缩放（atk 区间 2–4 → rider 1–3）。
 func _smoke_debuff_rider() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	var venom_seed := -1
 	var venom_check_ok := true
 	var venom_rows_seen := 0
@@ -1006,7 +1006,7 @@ func _smoke_debuff_rider() -> void:
 # ---- 天赋树六键行为冒烟（V10：开局姿态窗/危险直觉限次/财富之道聚散/守侧失误补偿；
 #      引擎直构 + 编排授予段直注（_grant_seg._judge_seal=结算授予段封印判定单口））----
 func _smoke_counter_buckets() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	print("--- 效果引擎无状态化四桶正向验收（卡② §9 V1/V6）---")
 	# V1——adventure 桶跨战持久：同一宿主字典下两战各真实 request_dig 一次，
 	# 断付费计数经 ctx 就地写入宿主字典并跨战累积（副本搬运态：读不到上一战值→第 2 战仍 1，此断言会红）。
@@ -1069,7 +1069,7 @@ func _smoke_counter_buckets() -> void:
 # V6 形态先例同源：直入真实管线缝（_judge_seal 直调同款口径）。
 
 func _smoke_extended_rows() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	print("--- 扩展行收敛：fx_reveal 兑付/落空 ---")
 	var RigS = load("res://core/battle_orchestrator.gd")   # 局部装配别名（_smoke_counter_buckets 同款——跨函数不共享局部量）
 	var enc_fx = {"level_index": 1, "node_depth": 0, "hero_hp": 40, "hero_atk": 8, "hero_max_hp": 40,
@@ -1115,7 +1115,7 @@ func _smoke_extended_rows() -> void:
 # 蓄力表值 2 拍衰减后剩 1 拍仍在池）→ 逐敌读敌方输出池。判据=施放者与被他敌的池读数差。
 
 func _smoke_enemy_buff_targets_self() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	var emp_mag: int = int(_db.combat.status_effects.row_by_id("empower").magnitude)
 	var sc_script = load("res://core/status_container.gd")
 	var found_seed := -1
diff --git a/game/tests/unit/battle_settlement/seal_polarity_test.gd b/game/tests/unit/battle_settlement/seal_polarity_test.gd
index 71d92b31..cc710205 100644
--- a/game/tests/unit/battle_settlement/seal_polarity_test.gd
+++ b/game/tests/unit/battle_settlement/seal_polarity_test.gd
@@ -22,7 +22,7 @@ var _db
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/排雷循环/排雷玩法.md:231 （封印与极性宿主——装载组）
+# 判据出处: design/gdd/systems/排雷循环/排雷玩法.md:231 （封印与极性宿主——装载组）
 	_db = ConfigDBScript.new()
 	# 表加载失败不中止（承 G2/G3/G4 同款：表损坏的红落在具体断言上——
 	# 诊断在此展开，后续断言按坏表实况逐条验红；collect_only=true 下成员照常赋值可评）
@@ -46,7 +46,7 @@ func _init() -> void:
 # ---- 末点 AP 封印轮末结算（playtest 缺陷②回归：末点 AP 花在封印必须终结轮次进入下一轮）----
 
 func _smoke_seal_ap_exhausted() -> void:
-# oracle: design/gdd/systems/排雷循环/行动经济.md:260 （末点 AP 耗尽即收轮组）
+# 判据出处: design/gdd/systems/排雷循环/行动经济.md:260 （末点 AP 耗尽即收轮组）
 	print("--- 排雷玩法·封印动作耗尽末点 AP 回归 ---")
 	var rng = load("res://core/rng_service.gd").new()
 	rng.set_master_seed(20260911)
@@ -324,8 +324,8 @@ func _rows_at(rows: Array, source_class: String, cell) -> Array:
 
 
 func _smoke_clear_reward_chain() -> void:
-# oracle: design/gdd/systems/战斗循环/地图战斗资源.md:235 （清图奖励链——清图槽对象身份组）
-# oracle: design/gdd/systems/战斗循环/地图战斗资源.md:235 （清图奖励链——清图槽对象身份组）
+# 判据出处: design/gdd/systems/战斗循环/地图战斗资源.md:235 （清图奖励链——清图槽对象身份组）
+# 判据出处: design/gdd/systems/战斗循环/地图战斗资源.md:235 （清图奖励链——清图槽对象身份组）
 	print("--- 清图奖励·双份兑付链（完美封印 / 零兑付 / 第二份被拒 / 高光记实）---")
 	# ① 真实流完美封印：标中一面真雷封印 + 零误标 + 清全图 → grant_clear 身份（clear_blast）双份真实兑付
 	var rows: Array = []
@@ -354,8 +354,8 @@ func _smoke_clear_reward_chain() -> void:
 # 弱形式登记：正常战斗流下"授段时刻无存活敌"不可达——敌全灭当轮判定段即判胜并终止战斗，而清图批在判定段之前，
 # 恒有存活敌；故本组直调编排私有面构造状态，只断言"路径存在 + 行为符合契约"（构造手法见各行注释）。
 func _smoke_clear_reward_zero_paths() -> void:
-# oracle: design/gdd/systems/战斗循环/地图战斗资源.md:240 （无存活敌群伤记「奖励未生效」组）
-# oracle: design/gdd/systems/战斗循环/地图战斗资源.md:240 （无存活敌群伤记「奖励未生效」组）
+# 判据出处: design/gdd/systems/战斗循环/地图战斗资源.md:240 （无存活敌群伤记「奖励未生效」组）
+# 判据出处: design/gdd/systems/战斗循环/地图战斗资源.md:240 （无存活敌群伤记「奖励未生效」组）
 	# ②-a 首份零兑付判定（无存活敌）→ first_ok=false + 未生效行
 	var rng = load("res://core/rng_service.gd").new()
 	rng.set_master_seed(20260915)
@@ -410,8 +410,8 @@ func _smoke_clear_reward_zero_paths() -> void:
 
 # 轮内刷新 provenance 守卫：刷新换来的图同轮清图不发清图奖励（_board_from_midround_refresh 守卫）
 func _smoke_refresh_provenance_guard() -> void:
-# oracle: design/gdd/systems/排雷循环/排雷玩法.md:237 （换图重置：旧封印印记先判定后消失组）
-# oracle: design/gdd/systems/排雷循环/排雷玩法.md:237 （换图重置：旧封印印记先判定后消失组）
+# 判据出处: design/gdd/systems/排雷循环/排雷玩法.md:237 （换图重置：旧封印印记先判定后消失组）
+# 判据出处: design/gdd/systems/排雷循环/排雷玩法.md:237 （换图重置：旧封印印记先判定后消失组）
 	print("--- 轮内刷新 provenance 守卫（刷新图清图不发清图奖励）---")
 	var rows: Array = []
 	var run := _run_full_clear(20260916, true, rows)
@@ -438,8 +438,8 @@ func _smoke_refresh_provenance_guard() -> void:
 
 
 func _smoke_polarity_routing() -> void:
-# oracle: design/gdd/systems/战斗循环/战斗结算.md:366 （极性路由：正向只兑正向、负向只兑负向组）
-# oracle: design/gdd/systems/战斗循环/战斗结算.md:366 （极性路由：正向只兑正向、负向只兑负向组）
+# 判据出处: design/gdd/systems/战斗循环/战斗结算.md:366 （极性路由：正向只兑正向、负向只兑负向组）
+# 判据出处: design/gdd/systems/战斗循环/战斗结算.md:366 （极性路由：正向只兑正向、负向只兑负向组）
 	print("--- 极性路由（挖安全格正向 / 挖危险格负向 / 标中正向 / 标空负向）---")
 	# 战斗随机值面随全局序漂移——构造种子按行为面扫描（谓词见 _polarity_probe_accepts）
 	var probe := {}
@@ -577,8 +577,8 @@ func _smoke_polarity_routing() -> void:
 # 场景 B（②）：标危险格 → 直接挖开 → 收轮。
 # 场景 C（①③）：标安全格 + 标危险格 → 不挖收轮 → 标空/标中判定照常。
 func _smoke_seal_irreversible_quadrants() -> void:
-# oracle: design/gdd/systems/排雷循环/排雷玩法.md:231 （封印不可逆四情况组）
-# oracle: design/gdd/systems/排雷循环/排雷玩法.md:231 （封印不可逆四情况组）
+# 判据出处: design/gdd/systems/排雷循环/排雷玩法.md:231 （封印不可逆四情况组）
+# 判据出处: design/gdd/systems/排雷循环/排雷玩法.md:231 （封印不可逆四情况组）
 	print("--- 封印不可逆四情况（禁撤封印 + 挖封印格兑付改判）---")
 	# 场景 A：安全格直挖（情况④）+ seal_pull/重复封印拒绝面
 	var rng_a = load("res://core/rng_service.gd").new()
@@ -687,8 +687,8 @@ func _smoke_seal_irreversible_quadrants() -> void:
 # 负向字典逐型直验（类型化兑付行协议）：找真实板上各型非封锁格，直调 grant_routed 负向路由（att 归因束形态），
 # 断言每型的兑付形态（enrage/off_guard/sapped 效果行、heal 直伤行、blast 警觉行、action 行动点排队）。
 func _smoke_negative_dictionary() -> void:
-# oracle: design/gdd/systems/排雷循环/行动经济.md:256 （下轮行动点修正排队与兑现组）
-# oracle: design/gdd/systems/排雷循环/行动经济.md:256 （下轮行动点修正排队与兑现组）
+# 判据出处: design/gdd/systems/排雷循环/行动经济.md:256 （下轮行动点修正排队与兑现组）
+# 判据出处: design/gdd/systems/排雷循环/行动经济.md:256 （下轮行动点修正排队与兑现组）
 	print("--- 负向字典逐型直验（sapped 在位 / heal 直伤 / blast 警觉 / action 行动点）---")
 	# 数据面：sapped 行在位（状态表七行 + effect_pool_map 映射在位）
 	var sapped: Dictionary = _db.combat.status_effects.row_by_id("sapped")
@@ -782,8 +782,8 @@ func _smoke_negative_dictionary() -> void:
 # 资源面断言：chain/dig 事件恒携带 resource=true（危险格同权）；initial 恒 false（封锁格）；
 # 封锁格查询 = null、危险格未开恒可查。
 func _smoke_resource_surface() -> void:
-# oracle: design/gdd/systems/战斗循环/地图战斗资源.md:235 （资源面只读查询组）
-# oracle: design/gdd/systems/战斗循环/地图战斗资源.md:235 （资源面只读查询组）
+# 判据出处: design/gdd/systems/战斗循环/地图战斗资源.md:235 （资源面只读查询组）
+# 判据出处: design/gdd/systems/战斗循环/地图战斗资源.md:235 （资源面只读查询组）
 	print("--- 格面资源资格面（危险格携带 / 封锁格无资源）---")
 	var run1 = _run_battle(1, 0)
 	var run2 = _run_battle(2, 0)
diff --git a/game/tests/unit/battle_settlement/settlement_wiring_snapshot_test.gd b/game/tests/unit/battle_settlement/settlement_wiring_snapshot_test.gd
index c3394f27..b9d81c91 100644
--- a/game/tests/unit/battle_settlement/settlement_wiring_snapshot_test.gd
+++ b/game/tests/unit/battle_settlement/settlement_wiring_snapshot_test.gd
@@ -419,7 +419,7 @@ var _db
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/战斗循环/战斗结算.md:362 （结算接线同种子逐项 golden 对拍组）
+# 判据出处: design/gdd/systems/战斗循环/战斗结算.md:362 （结算接线同种子逐项 golden 对拍组）
 	_db = ConfigDBScript.new()
 	var load_ok: bool = _db.load_tables("res://data/tables", true)
 	Kit.check("前置：表加载零 error", load_ok and _db.diagnostics_count("error") == 0)
diff --git a/game/tests/unit/battle_settlement/skill_unlock_test.gd b/game/tests/unit/battle_settlement/skill_unlock_test.gd
index c504f9bd..1257cc66 100644
--- a/game/tests/unit/battle_settlement/skill_unlock_test.gd
+++ b/game/tests/unit/battle_settlement/skill_unlock_test.gd
@@ -13,7 +13,7 @@ const Kit := preload("res://tests/unit/test_kit.gd")
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/战斗循环/敌人系统.md:293 Boss 半血解锁技宿主（装载组）
+# 判据出处: design/gdd/systems/战斗循环/敌人系统.md:293 Boss 半血解锁技宿主（装载组）
 	var db = ConfigDBScript.new()
 	var load_ok: bool = db.load_tables("res://data/tables", true)
 	Kit.check("前置：表加载零 error", load_ok and db.diagnostics_count("error") == 0)
@@ -26,7 +26,7 @@ func _init() -> void:
 
 # 门谓词：卓尔 (2,9) hp 130（×mult 1.0）→ venom_curb unlock 50 → 阈值 round(130×0.5)=65
 func _boss(db, L: int, D: int, kind := "boss"):
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	var ec = UnitContainerScript.new(db)
 	var ok: bool = ec.spawn({"level_index": L, "node_depth": D, "hero_hp": int(db.combat.hero.max_hp), "row_kind": kind})
 	Kit.check("前置：spawn (%d,%d) 受理" % [L, D], ok)
@@ -45,7 +45,7 @@ func _has_sid(arr: Array, sid: String) -> bool:
 
 
 func _test_gate_predicate(db) -> void:
-# oracle: design/gdd/systems/战斗循环/敌人系统.md:143 （门谓词：条件不满足不进可摇集合组）
+# 判据出处: design/gdd/systems/战斗循环/敌人系统.md:143 （门谓词：条件不满足不进可摇集合组）
 	var ec = _boss(db, 2, 9)
 	var u: Dictionary = _boss_u(ec)
 	var mhp: int = int(u.max_hp)
@@ -74,7 +74,7 @@ func _test_gate_predicate(db) -> void:
 
 # 闩不可逆：解锁后治疗抬回满血 → 复查零新解锁、可摇集合不回退
 func _test_latch_irreversible(db) -> void:
-# oracle: design/gdd/systems/战斗循环/敌人系统.md:143 （闩型条件首次为真整场保持组）
+# 判据出处: design/gdd/systems/战斗循环/敌人系统.md:143 （闩型条件首次为真整场保持组）
 	var ec = _boss(db, 2, 9)
 	var u: Dictionary = _boss_u(ec)
 	ec.apply_damage(u, int(u.max_hp) / 2)   # → 半血触发
@@ -86,7 +86,7 @@ func _test_latch_irreversible(db) -> void:
 
 # 普通行无字段逐位零扰动：地精 (1,0) 池快照零 unlock 键、过滤恒空转、可摇=全池
 func _test_plain_rows_zero_drift(db) -> void:
-# oracle: design/gdd/systems/战斗循环/敌人系统.md:301 （普攻倍率 1 特例——零漂移组）
+# 判据出处: design/gdd/systems/战斗循环/敌人系统.md:301 （普攻倍率 1 特例——零漂移组）
 	var ec = load("res://core/unit_container.gd").new(db)
 	Kit.check("零扰动前置：巨蜘蛛首遇带 spawn（池三行全无 trigger——快照键策略钉死载体）", ec.spawn({"level_index": 2, "node_depth": 1, "hero_hp": int(db.combat.hero.max_hp)}))
 	var u: Dictionary = ec.all_enemies()[0]
diff --git a/game/tests/unit/battle_settlement/trigger_cond_test.gd b/game/tests/unit/battle_settlement/trigger_cond_test.gd
index 154a8afa..440a3a26 100644
--- a/game/tests/unit/battle_settlement/trigger_cond_test.gd
+++ b/game/tests/unit/battle_settlement/trigger_cond_test.gd
@@ -9,7 +9,7 @@ const Kit := preload("res://tests/unit/test_kit.gd")
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/战斗循环/敌人系统.md:143 （触发条件机制 V1–V10 组）
+# 判据出处: design/gdd/systems/战斗循环/敌人系统.md:143 （触发条件机制 V1–V10 组）
 	var db = load("res://core/config_db.gd").new()
 	if not db.load_tables("res://data/tables", false):
 		print("[trigger_cond_test] FAIL — 数值表加载失败")
diff --git a/game/tests/unit/battle_settlement/variant_placement_test.gd b/game/tests/unit/battle_settlement/variant_placement_test.gd
index e900d82a..af3da1f9 100644
--- a/game/tests/unit/battle_settlement/variant_placement_test.gd
+++ b/game/tests/unit/battle_settlement/variant_placement_test.gd
@@ -15,7 +15,7 @@ var _db
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/排雷循环/地形变异.md:151 变异布置宿主（装载组）
+# 判据出处: design/gdd/systems/排雷循环/地形变异.md:151 变异布置宿主（装载组）
 	_db = ConfigDBScript.new()
 	# 表加载失败不中止（承 G2/G3/G4/G5 同款：表损坏的红落在具体断言上——
 	# 诊断在此展开，后续断言按坏表实况逐条验红；collect_only=true 下成员照常赋值可评）
@@ -54,7 +54,7 @@ class _CountVariantRng extends RngServiceCore:
 # 本段经 begin_battle 走完整初始化序后断言：门控一致性 / 布置域 / 数量公式 / 连通片上限 / 确定性。
 
 func _smoke_variant_placement(L: int) -> void:
-# oracle: design/gdd/systems/排雷循环/地形变异.md:63 （战内布置段门控组）
+# 判据出处: design/gdd/systems/排雷循环/地形变异.md:63 （战内布置段门控组）
 	print("--- 地形变异 布置段（L%d）---" % L)
 	var rng = load("res://core/rng_service.gd").new()
 	rng.set_master_seed(42)
@@ -148,7 +148,7 @@ func _variant_dump(b) -> String:
 
 
 func _smoke_global_variant() -> void:
-# oracle: design/gdd/systems/排雷循环/地形变异.md:74 （全局替换制与回落组）
+# 判据出处: design/gdd/systems/排雷循环/地形变异.md:74 （全局替换制与回落组）
 	print("--- 全局作用域变异（门控三维 + 全局池空兜底回落 + 资源面偏斜）---")
 	# ① 跨字段互锁负样本（resource_face ⟺ scope=global 三条 + effect_value 新域 [0,50]）
 	var vt = load("res://data/schemas/variation_table.gd").new()
@@ -343,7 +343,7 @@ func _errs_has_cross_field(errs: Array) -> bool:
 # 全称不可断）。可达判据=①静态（布置面零字面量下界）＋②同种子改值产物互异（真实入口=begin_battle 布置段）。
 
 func _test_pack_min_from_table() -> void:
-# oracle: design/gdd/systems/排雷循环/地形变异.md:63 （连通片格数 [pack_min,pack_max] 读表组）
+# 判据出处: design/gdd/systems/排雷循环/地形变异.md:63 （连通片格数 [pack_min,pack_max] 读表组）
 	# ① 静态：布置面零字面量下界（randi_range(2, 退役——下界读 pack_min 表头单点）
 	var src := FileAccess.get_file_as_string("res://core/board_installer.gd")
 	Kit.check("布置面零字面量下界（randi_range(2, 退役、下界读表单点在位）〔架构整改 V10·静态〕",
diff --git a/game/tests/unit/contracts/source_guard_test.gd b/game/tests/unit/contracts/source_guard_test.gd
index 4a386b4c..394ab682 100644
--- a/game/tests/unit/contracts/source_guard_test.gd
+++ b/game/tests/unit/contracts/source_guard_test.gd
@@ -21,7 +21,7 @@ func _init() -> void:
 # ---- 类型闸断言（V7——project.godot warning 配置在位〔源码断言〕+审计器脚本在位；
 # 审计器归零判定走 static_scan S9 闸机，此处兜配置面）----
 func _smoke_type_gate() -> void:
-# oracle: design/engineering/code-conventions.md:41 （封装边界——类型闸源码扫描组）
+# 判据出处: design/engineering/code-conventions.md:41 （封装边界——类型闸源码扫描组）
 	var pj: String = FileAccess.get_file_as_string("res://project.godot")
 	Kit.check("V7 类型闸 warning 配置在位（untyped_declaration=1 显形）〔迭代27 T5〕",
 		pj.contains("gdscript/warnings/untyped_declaration=1"))
@@ -32,7 +32,7 @@ func _smoke_type_gate() -> void:
 
 # ---- 卫生件 grep 闸（V8——死代码/字符串 Callable/影子账残留零命中；源码扫描面）----
 func _smoke_hygiene_gates() -> void:
-# oracle: design/engineering/code-conventions.md:54 （模态覆盖层层级与登记纪律——卫生闸组）
+# 判据出处: design/engineering/code-conventions.md:54 （模态覆盖层层级与登记纪律——卫生闸组）
 	var callables := 0
 	for d in ["res://core", "res://presentation", "res://data"]:
 		var dir := DirAccess.open(d)
diff --git a/game/tests/unit/contracts/system_contracts_test.gd b/game/tests/unit/contracts/system_contracts_test.gd
index 2a499efc..0f10190b 100644
--- a/game/tests/unit/contracts/system_contracts_test.gd
+++ b/game/tests/unit/contracts/system_contracts_test.gd
@@ -18,7 +18,7 @@ const Kit := preload("res://tests/unit/test_kit.gd")   # T6 收口：_check/汇
 
 
 func _init() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	var db = ConfigDBScript.new()
 	var load_ok: bool = db.load_tables("res://data/tables", true)
 	Kit.check("前置：表加载零 error", load_ok and db.diagnostics_count("error") == 0)
@@ -41,8 +41,8 @@ func _init() -> void:
 # ---- B1 兑付配方词表：五配方/三目标规则/双结账政策——常量非空且互异（封闭枚举负空间） ----
 
 func _test_damage_controller_vocabularies() -> void:
-# oracle: design/engineering/architecture/architecture.md:89 （事件/事实/效果类型/算子四词表封闭——契约词表组）
-# oracle: design/engineering/architecture/architecture.md:89 （事件/事实/效果类型/算子四词表封闭——契约词表组）
+# 判据出处: design/engineering/architecture/architecture.md:89 （事件/事实/效果类型/算子四词表封闭——契约词表组）
+# 判据出处: design/engineering/architecture/architecture.md:89 （事件/事实/效果类型/算子四词表封闭——契约词表组）
 	var kinds: Array = [
 		DamageControllerScript.KIND_HERO_ATTACK, DamageControllerScript.KIND_ENEMY_SKILL,
 		DamageControllerScript.KIND_BOARD_TYPED, DamageControllerScript.KIND_BOARD_BLAST,
@@ -72,8 +72,8 @@ func _test_damage_controller_vocabularies() -> void:
 # ---- D2↔B1：掷点用途标签 ∈ RngService 封闭词表（EC12——跨系统字面量契约的成员性断言） ----
 
 func _test_rng_tag_closure(db) -> void:
-# oracle: design/engineering/architecture/architecture.md:90 （流 scope 封闭词表组）
-# oracle: design/engineering/architecture/architecture.md:90 （流 scope 封闭词表组）
+# 判据出处: design/engineering/architecture/architecture.md:90 （流 scope 封闭词表组）
+# 判据出处: design/engineering/architecture/architecture.md:90 （流 scope 封闭词表组）
 	var stream_label: String = String(db.combat.settlement.damage_roll.armor_roll_stream)
 	Kit.check("settlement.armor_roll_stream ∈ RngService 封闭标签词表（EC12）",
 		RngServiceScript.PURPOSE_TAGS.has(stream_label))
@@ -87,8 +87,8 @@ func _test_rng_tag_closure(db) -> void:
 # ---- B1→D1 行协议：单据九栏缺省齐备 + 协议公共键形态 ----
 
 func _test_ticket_nine_columns() -> void:
-# oracle: design/gdd/systems/战斗循环/战斗结算.md:362 （单据九列协议组）
-# oracle: design/gdd/systems/战斗循环/战斗结算.md:362 （单据九列协议组）
+# 判据出处: design/gdd/systems/战斗循环/战斗结算.md:362 （单据九列协议组）
+# 判据出处: design/gdd/systems/战斗循环/战斗结算.md:362 （单据九列协议组）
 	var ctrl = _bare_controller()
 	var t: Dictionary = ctrl.open_ticket(DamageControllerScript.KIND_BOARD_FLAT_HERO, "mine_hit", "契约探针",
 		{"channel": "棋盘兑付", "base_value": 1, "target_rule": DamageControllerScript.TARGET_HERO, "ri": 0})
@@ -118,8 +118,8 @@ func _bare_controller():
 # ---- B4→B3：增益授予布尔受理口径（受理/拒绝二元面 + 投影一致性） ----
 
 func _test_status_boolean_acceptance(db) -> void:
-# oracle: design/gdd/systems/战斗循环/增益状态.md:250 （受理布尔面组）
-# oracle: design/gdd/systems/战斗循环/增益状态.md:250 （受理布尔面组）
+# 判据出处: design/gdd/systems/战斗循环/增益状态.md:250 （受理布尔面组）
+# 判据出处: design/gdd/systems/战斗循环/增益状态.md:250 （受理布尔面组）
 	var effects = StatusContainerScript.new(db)
 	# EC1 域闭：notify_battle_start 前授予 = false（受理面封闭）
 	var any_row: Dictionary = {}
@@ -146,8 +146,8 @@ func _test_status_boolean_acceptance(db) -> void:
 # 个体键直传字面量（"e1"/"e2"/"e3"——拼写约定单点在 StatusContainer.owner_key_for，测试面模拟授予路径逐只授）
 
 func _test_status_individual_isolation(db) -> void:
-# oracle: design/gdd/systems/战斗循环/增益状态.md:251 （按个体归属组）
-# oracle: design/gdd/systems/战斗循环/增益状态.md:251 （按个体归属组）
+# 判据出处: design/gdd/systems/战斗循环/增益状态.md:251 （按个体归属组）
+# 判据出处: design/gdd/systems/战斗循环/增益状态.md:251 （按个体归属组）
 	var effects = StatusContainerScript.new(db)
 	effects.notify_battle_start()
 	var src := {"source_class": "seal_hit", "origin_cell": Vector2i(-1, -1), "round_index": 0}
@@ -169,8 +169,8 @@ func _test_status_individual_isolation(db) -> void:
 
 
 func _test_status_grant_all_per_unit(db) -> void:
-# oracle: design/gdd/systems/战斗循环/增益状态.md:252 （授予即生效组）
-# oracle: design/gdd/systems/战斗循环/增益状态.md:252 （授予即生效组）
+# 判据出处: design/gdd/systems/战斗循环/增益状态.md:252 （授予即生效组）
+# 判据出处: design/gdd/systems/战斗循环/增益状态.md:252 （授予即生效组）
 	var effects = StatusContainerScript.new(db)
 	effects.notify_battle_start()
 	var src := {"source_class": "mine_hit", "origin_cell": Vector2i(-1, -1), "round_index": 0}
@@ -197,8 +197,8 @@ func _test_status_grant_all_per_unit(db) -> void:
 
 
 func _test_status_death_clears(db) -> void:
-# oracle: design/gdd/systems/战斗循环/增益状态.md:250 （战斗结束清空组）
-# oracle: design/gdd/systems/战斗循环/增益状态.md:250 （战斗结束清空组）
+# 判据出处: design/gdd/systems/战斗循环/增益状态.md:250 （战斗结束清空组）
+# 判据出处: design/gdd/systems/战斗循环/增益状态.md:250 （战斗结束清空组）
 	var effects = StatusContainerScript.new(db)
 	effects.notify_battle_start()
 	var src := {"source_class": "seal_hit", "origin_cell": Vector2i(-1, -1), "round_index": 0}
@@ -212,8 +212,8 @@ func _test_status_death_clears(db) -> void:
 
 
 func _test_status_merge_per_unit(db) -> void:
-# oracle: design/gdd/systems/战斗循环/增益状态.md:253 （只登记不去重组）
-# oracle: design/gdd/systems/战斗循环/增益状态.md:253 （只登记不去重组）
+# 判据出处: design/gdd/systems/战斗循环/增益状态.md:253 （只登记不去重组）
+# 判据出处: design/gdd/systems/战斗循环/增益状态.md:253 （只登记不去重组）
 	var effects = StatusContainerScript.new(db)
 	effects.notify_battle_start()
 	var src := {"source_class": "enemy_action", "origin_cell": Vector2i(-1, -1), "round_index": 0}
@@ -236,8 +236,8 @@ func _test_status_merge_per_unit(db) -> void:
 # ---- B4 结算链契约（断言补齐批——①增益状态结算链）：衰减逐值/战斗结束全清/满层拒绝/独立并存/首授快照 ----
 
 func _test_status_decay_and_clear(db) -> void:
-# oracle: design/gdd/systems/战斗循环/增益状态.md:21 （先兑付后衰减组）
-# oracle: design/gdd/systems/战斗循环/增益状态.md:21 （先兑付后衰减组）
+# 判据出处: design/gdd/systems/战斗循环/增益状态.md:21 （先兑付后衰减组）
+# 判据出处: design/gdd/systems/战斗循环/增益状态.md:21 （先兑付后衰减组）
 	var effects = StatusContainerScript.new(db)
 	effects.notify_battle_start()
 	var src := {"source_class": "seal_hit", "origin_cell": Vector2i(-1, -1), "round_index": 0}
@@ -258,8 +258,8 @@ func _test_status_decay_and_clear(db) -> void:
 
 
 func _test_status_stack_full_reject(db) -> void:
-# oracle: design/gdd/systems/战斗循环/增益状态.md:255 （满层拒绝原子且留痕组）
-# oracle: design/gdd/systems/战斗循环/增益状态.md:255 （满层拒绝原子且留痕组）
+# 判据出处: design/gdd/systems/战斗循环/增益状态.md:255 （满层拒绝原子且留痕组）
+# 判据出处: design/gdd/systems/战斗循环/增益状态.md:255 （满层拒绝原子且留痕组）
 	var effects = StatusContainerScript.new(db)
 	effects.notify_battle_start()
 	var src := {"source_class": "seal_hit", "origin_cell": Vector2i(-1, -1), "round_index": 0}
@@ -277,8 +277,8 @@ func _test_status_stack_full_reject(db) -> void:
 
 
 func _test_status_independent_branch(db) -> void:
-# oracle: design/gdd/systems/战斗循环/增益状态.md:257 （合成不设上下限组）
-# oracle: design/gdd/systems/战斗循环/增益状态.md:257 （合成不设上下限组）
+# 判据出处: design/gdd/systems/战斗循环/增益状态.md:257 （合成不设上下限组）
+# 判据出处: design/gdd/systems/战斗循环/增益状态.md:257 （合成不设上下限组）
 	var effects = StatusContainerScript.new(db)
 	effects.notify_battle_start()
 	var probe := {
@@ -303,8 +303,8 @@ func _test_status_independent_branch(db) -> void:
 
 
 func _test_status_snapshot_first_grant(db) -> void:
-# oracle: design/gdd/systems/战斗循环/增益状态.md:258 （快照抗重载组）
-# oracle: design/gdd/systems/战斗循环/增益状态.md:258 （快照抗重载组）
+# 判据出处: design/gdd/systems/战斗循环/增益状态.md:258 （快照抗重载组）
+# 判据出处: design/gdd/systems/战斗循环/增益状态.md:258 （快照抗重载组）
 	var effects = StatusContainerScript.new(db)
 	effects.notify_battle_start()
 	var src_first := {"source_class": "seal_hit", "origin_cell": Vector2i(3, 4), "round_index": 1}
diff --git a/game/tests/unit/core/adventure_feats_test.gd b/game/tests/unit/core/adventure_feats_test.gd
index a852361c..aeee46ba 100644
--- a/game/tests/unit/core/adventure_feats_test.gd
+++ b/game/tests/unit/core/adventure_feats_test.gd
@@ -17,7 +17,7 @@ var _db
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/冒险循环/冒险结构.md:281 冒险结构与专长宿主（装载组）
+# 判据出处: design/gdd/systems/冒险循环/冒险结构.md:281 冒险结构与专长宿主（装载组）
 	_db = ConfigDBScript.new()
 	# 表加载失败不中止（承 G2/G3/G4/G5 同款：表损坏的红落在具体断言上——
 	# 诊断在此展开，后续断言按坏表实况逐条验红；collect_only=true 下成员照常赋值可评）
@@ -59,7 +59,7 @@ func _hits_kind(hits: Array, kind: String) -> Array:
 
 # ② 冒险结构 API 闸（状态机受理面——重复开始拒绝 / 入口停点 / 放弃两态）
 func _smoke_adventure_api() -> void:
-# oracle: design/gdd/systems/冒险循环/冒险结构.md:283 （冒险 API 组：开始受理/序列/回调）
+# 判据出处: design/gdd/systems/冒险循环/冒险结构.md:283 （冒险 API 组：开始受理/序列/回调）
 	print("--- 冒险结构 API 闸（重复开始拒绝 · 入口停点 · 放弃两态受理）---")
 	var adr = load("res://core/adventure_runner.gd").new(_db, _fresh_rng(42))
 	adr.set_hero_override(900, 400)   # 首战速胜档（放弃的非战斗受理要走到选路态）
@@ -122,7 +122,7 @@ func _api_mark_node(_node: Dictionary, _info: Dictionary, seq: Array) -> void:
 # ③ 冒险验收断言（映射 冒险结构.md 验收标准——表覆盖/满配冒险成功/种子复现/大奖励/败北线/
 # 重复拒绝/GP 跨关延续/加算区同账/恢复数学/放弃）
 func _smoke_adventure() -> void:
-# oracle: design/gdd/systems/冒险循环/冒险结构.md:284 （冒险生命周期组：推进/末关/倒下/重开/生命账）
+# 判据出处: design/gdd/systems/冒险循环/冒险结构.md:284 （冒险生命周期组：推进/末关/倒下/重开/生命账）
 	print("--- 冒险结构验收（三关序列 · 大奖励 · 摘要五件事 · 账本封闭）---")
 	var autoplay = load("res://sim/level_autoplay.gd")
 	# ① 表与覆盖义务（序列关数 = 行集关数；节点源 = 参数档在固定种子下的生成图，
@@ -463,7 +463,7 @@ func _smoke_adventure() -> void:
 # ---- 专长冒烟（feats 四级 · 案D 池接线 · V3 订阅面逐件三列）----
 
 func _smoke_feats() -> void:
-# oracle: design/gdd/systems/冒险循环/奇物.md:465 （奇物授予与凭证保底组）
+# 判据出处: design/gdd/systems/冒险循环/奇物.md:465 （奇物授予与凭证保底组）
 	print("--- 专长重设计实装（feat_table 四级 · 专长带池接线 · 订阅面逐件）---")
 	# ① 现行表牌库构成：37 件全量入池——102 数值令牌+37 relic 令牌（四级 rarity 直映射）
 	Kit.check("feat_table 已加载（37 件=基础 27+迁入 2+完美保险 1+迭代 46 换图系七件——换代）", _db.crossrun.feats != null and (_db.crossrun.feats.rows as Array).size() == 37)
diff --git a/game/tests/unit/core/auto_player_deduce_test.gd b/game/tests/unit/core/auto_player_deduce_test.gd
index 47d1a6bf..013d58df 100644
--- a/game/tests/unit/core/auto_player_deduce_test.gd
+++ b/game/tests/unit/core/auto_player_deduce_test.gd
@@ -16,7 +16,7 @@ func _init() -> void:
 
 
 func _smoke_zero_chain_rule() -> void:
-# oracle: design/gdd/systems/排雷循环/排雷玩法.md:230 （0 格连锁传播闭包——模拟玩家算子组）
+# 判据出处: design/gdd/systems/排雷循环/排雷玩法.md:230 （0 格连锁传播闭包——模拟玩家算子组）
 	var db = load("res://core/config_db.gd").new()
 	var load_ok: bool = db.load_tables("res://data/tables", true) and db.diagnostics_count("error") == 0
 	Kit.check("前置：表加载零 error", load_ok)
diff --git a/game/tests/unit/core/battle_driver_drive_test.gd b/game/tests/unit/core/battle_driver_drive_test.gd
index 7df68bd3..3612341a 100644
--- a/game/tests/unit/core/battle_driver_drive_test.gd
+++ b/game/tests/unit/core/battle_driver_drive_test.gd
@@ -55,7 +55,7 @@ func _init() -> void:
 
 # ① 缺省两参（真编排器）：同种子两跑整轮驱动逐位（确定性自证——动作序列快照经 cell_revealed 事件流）
 func _smoke_drive_round_contract() -> void:
-# oracle: design/engineering/architecture/architecture.md:144 （效果端口件：收事件交结算取回命中批——驱动循环契约组）
+# 判据出处: design/engineering/architecture/architecture.md:144 （效果端口件：收事件交结算取回命中批——驱动循环契约组）
 	var db = load("res://core/config_db.gd").new()
 	var load_ok: bool = db.load_tables("res://data/tables", true) and db.diagnostics_count("error") == 0
 	Kit.check("前置：表加载零 error", load_ok)
@@ -81,7 +81,7 @@ func _smoke_drive_round_contract() -> void:
 
 # ② provider 形态：策略回调产出 dig/seal_place/refresh 各一——提交与日志回调四元组在案
 func _provider_shapes() -> void:
-# oracle: design/engineering/architecture/architecture.md:144 （端口应答束形状组）
+# 判据出处: design/engineering/architecture/architecture.md:144 （端口应答束形状组）
 	var st := _StubSettlement.new()
 	var script := [ {"kind": "dig", "cell": Vector2i(1, 1)}, {"kind": "seal", "cell": Vector2i(2, 2)}, {"kind": "refresh"}, {"kind": "stop"} ]
 	var logs: Array = []
@@ -102,7 +102,7 @@ func _provider_shapes() -> void:
 
 # ③ max_rejects：策略恒返被拒动作——第 3 拒后停手出环（循环次数=3）
 func _max_rejects() -> void:
-# oracle: design/engineering/architecture/architecture.md:144 （拒绝通道组）
+# 判据出处: design/engineering/architecture/architecture.md:144 （拒绝通道组）
 	var st := _StubSettlement.new()
 	st.minesweeper.accept = false
 	st.minesweeper.reject_cells = {Vector2i(9, 9): true}
@@ -122,7 +122,7 @@ func _max_rejects() -> void:
 
 # ④ 合步 next：move 后相位变更即断弃 dig（桩 on_submit 钩子把 phase 推离 Active）
 func _combined_step_next() -> void:
-# oracle: design/engineering/architecture/architecture.md:144 （合并步进组）
+# 判据出处: design/engineering/architecture/architecture.md:144 （合并步进组）
 	var st := _StubSettlement.new()
 	st.minesweeper.on_submit = func(action: String) -> void:
 		if action == "move":
diff --git a/game/tests/unit/core/board_gen_reward_test.gd b/game/tests/unit/core/board_gen_reward_test.gd
index 8e734dab..c1446a41 100644
--- a/game/tests/unit/core/board_gen_reward_test.gd
+++ b/game/tests/unit/core/board_gen_reward_test.gd
@@ -18,7 +18,7 @@ var _rng
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/排雷循环/棋盘生成.md:219 棋盘生成宿主（装载组）
+# 判据出处: design/gdd/systems/排雷循环/棋盘生成.md:219 棋盘生成宿主（装载组）
 	_db = ConfigDBScript.new()
 	# 表加载失败不中止（承 G2 同款：表损坏的红落在具体断言上——
 	# 诊断在此展开，后续断言按坏表实况逐条验红；collect_only=true 下成员照常赋值可评）
@@ -52,7 +52,7 @@ func _mk_stream(stream_name: String, scope: int) -> RandomNumberGenerator:
 # 公式 N×cell ≤ 可用高−12 必须计入 (N−1)×2px 网格间距，否则网格实高溢出被 clip_contents 裁掉；
 # 现公式 = 计入间距 + 垂直预留 24px〔上 12/下 12——底部不贴 D 区边框〕）----
 func _smoke_layout_cell_formula() -> void:
-# oracle: design/gdd/systems/排雷循环/棋盘生成.md:75 （出生区边长表单点——格边长公式组）
+# 判据出处: design/gdd/systems/排雷循环/棋盘生成.md:75 （出生区边长表单点——格边长公式组）
 	print("--- 棋盘布局格边长公式（底部预留回归·四档板型）---")
 	var board_generator = load("res://core/board_generator.gd").new()
 	var board_view = load("res://presentation/views/board_view.gd").new()
@@ -82,7 +82,7 @@ func _smoke_layout_cell_formula() -> void:
 # ---- 地图战斗资源·身份面单元冒烟（格面资源：roll 恰一次 / 雷安同池 / 幂等 / 清图批尾）----
 
 func _smoke_reward_identity_unit() -> void:
-# oracle: design/gdd/systems/战斗循环/地图战斗资源.md:233 （格面资源身份——三分出口与资源身份组）
+# 判据出处: design/gdd/systems/战斗循环/地图战斗资源.md:233 （格面资源身份——三分出口与资源身份组）
 	print("--- 地图战斗资源·格面资源身份面 ---")
 	var rng = load("res://core/rng_service.gd").new()
 	rng.set_master_seed(20260911)
@@ -144,7 +144,7 @@ class _BoardRowStub:
 
 
 func _smoke_board_generator() -> void:
-# oracle: design/gdd/systems/排雷循环/棋盘生成.md:221 （确定性复现＋布雷纪律组）
+# 判据出处: design/gdd/systems/排雷循环/棋盘生成.md:221 （确定性复现＋布雷纪律组）
 	print("--- 棋盘生成 ---")
 	var board_generator = load("res://core/board_generator.gd").new()
 	for L in [1, 2]:
@@ -239,7 +239,7 @@ func _board_dump(b) -> String:
 # ---- 地图战斗资源·伤害量值区间冒烟（roll 域内 + 中点锚 + 变异实际流动 + 定值行不受扰）----
 
 func _smoke_power_interval() -> void:
-# oracle: design/gdd/systems/战斗循环/地图战斗资源.md:233 （资源量值区间——伤害量值区间组）
+# 判据出处: design/gdd/systems/战斗循环/地图战斗资源.md:233 （资源量值区间——伤害量值区间组）
 	print("--- 地图战斗资源·伤害量值区间（上阶/下阶随机）---")
 	# ① 表侧静态锚（配置推导——改表不断锚）：凡带 power_min/power_max 的行 = 区间行，
 	#    校验配对齐全（lo ≤ hi）+ power = floor 中点（行动经济 条款①期望当量锚）；其余行必须零区间字段。
diff --git a/game/tests/unit/core/board_generator_test.gd b/game/tests/unit/core/board_generator_test.gd
index 698b5d52..af492d3d 100644
--- a/game/tests/unit/core/board_generator_test.gd
+++ b/game/tests/unit/core/board_generator_test.gd
@@ -13,7 +13,7 @@ var _db: ConfigDb
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/排雷循环/棋盘生成.md:219 棋盘生成（装载组）
+# 判据出处: design/gdd/systems/排雷循环/棋盘生成.md:219 棋盘生成（装载组）
 	_db = load("res://core/config_db.gd").new() as ConfigDb
 	if not _db.load_tables("res://data/tables", false):
 		Kit.check("数值表加载", false)
@@ -40,7 +40,7 @@ func _generate(L: int, D: int, seed0: int) -> BoardData:
 
 
 func _test_generate_shape_and_mines() -> void:
-# oracle: design/gdd/systems/排雷循环/棋盘生成.md:224 （布雷纪律组）
+# 判据出处: design/gdd/systems/排雷循环/棋盘生成.md:224 （布雷纪律组）
 	var b := _generate(1, 0, 71000)
 	if b == null:
 		Kit.check("生成返回棋盘", false)
@@ -61,7 +61,7 @@ func _test_generate_shape_and_mines() -> void:
 
 # 目标雷数公式单点（d14）：同参同值对拍原式 + 真实产图指标读数同源
 func _test_target_mine_count_single_source() -> void:
-# oracle: design/gdd/systems/排雷循环/棋盘生成.md:224 （雷数单源组）
+# 判据出处: design/gdd/systems/排雷循环/棋盘生成.md:224 （雷数单源组）
 	var bad := 0
 	var checked := 0
 	for L in [1, 2, 3]:
@@ -92,7 +92,7 @@ func _test_target_mine_count_single_source() -> void:
 
 
 func _test_digits_equal_neighbor_mine_count() -> void:
-# oracle: design/gdd/systems/排雷循环/棋盘生成.md:223 （数字恒真组）
+# 判据出处: design/gdd/systems/排雷循环/棋盘生成.md:223 （数字恒真组）
 	var b := _generate(1, 1, 72000)
 	if b == null:
 		Kit.check("生成返回棋盘（数字段）", false)
@@ -113,7 +113,7 @@ func _test_digits_equal_neighbor_mine_count() -> void:
 
 
 func _test_same_seed_bit_identical() -> void:
-# oracle: design/gdd/systems/排雷循环/棋盘生成.md:221 （同种子逐位复现组）
+# 判据出处: design/gdd/systems/排雷循环/棋盘生成.md:221 （同种子逐位复现组）
 	var a := _generate(2, 0, 73000)
 	var b := _generate(2, 0, 73000)
 	if a == null or b == null:
@@ -124,7 +124,7 @@ func _test_same_seed_bit_identical() -> void:
 
 
 func _test_clearable_and_inferability_selfconsistent() -> void:
-# oracle: design/gdd/systems/排雷循环/棋盘生成.md:226 （可清图与及格线自洽组）
+# 判据出处: design/gdd/systems/排雷循环/棋盘生成.md:226 （可清图与及格线自洽组）
 	var b := _generate(1, 0, 74000)
 	if b == null:
 		Kit.check("生成返回棋盘（可推理段）", false)
@@ -140,7 +140,7 @@ func _test_clearable_and_inferability_selfconsistent() -> void:
 # ---- V8 出生区边长表单点（架构整改——spawn_edge 表头驱动布雷域基/几何/护栏全导出）----
 
 func _test_spawn_edge_from_table() -> void:
-# oracle: design/gdd/systems/排雷循环/棋盘生成.md:75 （出生区边长读表组）
+# 判据出处: design/gdd/systems/排雷循环/棋盘生成.md:75 （出生区边长读表组）
 	# ① 纯函数对拍：edge=5 夹具 → target = round(d×(W×H−25))（25 格布雷域基可观测）
 	var p5 := {"w": 12, "h": 12, "density": 0.15, "spawn_edge": 5}
 	Kit.check("V8 纯函数：edge=5 布雷域基 25 格（target=round(d×(144−25))）〔架构整改 V8〕",
diff --git a/game/tests/unit/core/breakpoint_resume_test.gd b/game/tests/unit/core/breakpoint_resume_test.gd
index 24b28c4a..876ddb34 100644
--- a/game/tests/unit/core/breakpoint_resume_test.gd
+++ b/game/tests/unit/core/breakpoint_resume_test.gd
@@ -15,7 +15,7 @@ var _bp_path := "user://test_breakpoint_resume.json"
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/表现与支撑/存档序列化.md:180 （断点域契约：七字段往返/续玩确定性/幂等/三结局清除组）
+# 判据出处: design/gdd/systems/表现与支撑/存档序列化.md:180 （断点域契约：七字段往返/续玩确定性/幂等/三结局清除组）
 	var db = load("res://core/config_db.gd").new()
 	if not db.load_tables("res://data/tables", false):
 		print("[breakpoint_resume_test] FAIL — 数值表加载失败")
diff --git a/game/tests/unit/core/config_db_cross_validator_test.gd b/game/tests/unit/core/config_db_cross_validator_test.gd
index 8cb7ee18..6849e2de 100644
--- a/game/tests/unit/core/config_db_cross_validator_test.gd
+++ b/game/tests/unit/core/config_db_cross_validator_test.gd
@@ -13,7 +13,7 @@ const StatusTableScript := preload("res://data/schemas/status_effect_table.gd")
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:195 （跨表校验宿主——装载组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:195 （跨表校验宿主——装载组）
 	_test_all_links_valid()
 	_test_dangling_skill_id()
 	_test_cast_side_mismatch()
@@ -47,7 +47,7 @@ func _cats(errs: Array) -> Array[String]:
 
 # ---- 正向：技能池全对齿（普攻恰一行、buff 挂敌方侧）应零错，防校验误伤 ----
 func _test_all_links_valid() -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:195 （悬空引用类别：跨表链接全有效组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:195 （悬空引用类别：跨表链接全有效组）
 	var skills := _skill([
 		{"skill_id": "attack", "type": "basic"},
 		{"skill_id": "raise_morale", "type": "buff", "buff_ref": "st_strong"},
@@ -63,7 +63,7 @@ func _test_all_links_valid() -> void:
 
 # ---- 负向：技能池引用表里不存在的 skill_id 必须报 ----
 func _test_dangling_skill_id() -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:195 （悬空引用类别：skill_id 悬空组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:195 （悬空引用类别：skill_id 悬空组）
 	var skills := _skill([{"skill_id": "attack", "type": "basic"}])
 	var enemies := _enemy([
 		{"level_index": 1, "row_kind": "battle", "depth_band": 0, "enemy_id": "goblin", "pool": [
@@ -76,7 +76,7 @@ func _test_dangling_skill_id() -> void:
 
 # ---- 负向：buff 挂到主角侧状态（side 反向）必须报 ----
 func _test_cast_side_mismatch() -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:195 （side 反向校验组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:195 （side 反向校验组）
 	var skills := _skill([{"skill_id": "raise_morale", "type": "buff", "buff_ref": "st_hero_side"}])
 	var enemies := _enemy([
 		{"level_index": 1, "row_kind": "battle", "depth_band": 0, "enemy_id": "goblin", "pool": [
diff --git a/game/tests/unit/core/config_db_resolver_test.gd b/game/tests/unit/core/config_db_resolver_test.gd
index 9e5e4c53..8a890f69 100644
--- a/game/tests/unit/core/config_db_resolver_test.gd
+++ b/game/tests/unit/core/config_db_resolver_test.gd
@@ -12,7 +12,7 @@ var _resolver: ConfigDbResolver
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:202 （解析器宿主——装载组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:202 （解析器宿主——装载组）
 	_resolver = ResolverScript.new(
 		func(level, category, message) -> void:   # 诊断通道签名按调用实参收（首参为表 id 字符串）
 			_diags.append("%s/%s/%s" % [str(level), str(category), str(message)]),
@@ -55,7 +55,7 @@ func _difficulty_table():
 
 
 func _test_band_hit() -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:202 （精确命中零警告组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:202 （精确命中零警告组）
 	var hit: Array = _resolver.resolve_enemy_rowset(1, 4, "battle")
 	Kit.check("带命中取偏难一侧：请求深度 4 命中带 5（逐字不回带 0）〔fv1〕",
 		hit.size() == 1 and String((hit[0] as Dictionary).get("enemy_id", "")) == "giant_spider")
@@ -65,7 +65,7 @@ func _test_band_hit() -> void:
 
 
 func _test_rowset_order_preserved() -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:202 （行集寻址与行序保序组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:202 （行集寻址与行序保序组）
 	var rows: Array = _resolver.resolve_enemy_rowset(1, 0, "battle")
 	var ids: Array[String] = []
 	for r in rows:
@@ -75,7 +75,7 @@ func _test_rowset_order_preserved() -> void:
 
 
 func _test_top_band_clamp() -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:202 （超最大行走封顶取最大行组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:202 （超最大行走封顶取最大行组）
 	_diags.clear()
 	var rows: Array = _resolver.resolve_enemy_rowset(1, 99, "battle")
 	Kit.check("越顶带 clamp 取顶带行集（battle 顶带 5）〔fv3〕",
@@ -91,7 +91,7 @@ func _test_top_band_clamp() -> void:
 
 
 func _test_row_kind_routing() -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:202 （行类别路由组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:202 （行类别路由组）
 	var battle_rows: Array = _resolver.resolve_enemy_rowset(1, 0, "battle")
 	var boss_rows: Array = _resolver.resolve_enemy_rowset(1, 0, "boss")
 	Kit.check("行类路由：同请求深度 battle 与 boss 命中不同键域〔fv4〕",
@@ -100,7 +100,7 @@ func _test_row_kind_routing() -> void:
 
 
 func _test_request_oob() -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:203 （越域致命中止组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:203 （越域致命中止组）
 	_diags.clear()
 	_resolver.resolve_enemy_rowset(0, 0, "battle")
 	Kit.check("关卡序号 <1 → fatal request_oob〔fv5〕", _has_fatal_oob())
@@ -120,7 +120,7 @@ func _has_fatal_oob() -> bool:
 
 
 func _test_difficulty_clamp() -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:202 （难度 clamp 组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:202 （难度 clamp 组）
 	var m: Dictionary = _resolver.resolve_difficulty_modifiers(1, 0)
 	Kit.check("难度乘数越域被 clamp：hp 99 → 上限 10", absf(float(m.get("hp_mult", 0.0)) - 10.0) < 0.001)
 	Kit.check("难度乘数越域被 clamp：atk 0.01 → 下限 0.1", absf(float(m.get("atk_mult", 0.0)) - 0.1) < 0.001)
diff --git a/game/tests/unit/core/curio_refresh_paid_test.gd b/game/tests/unit/core/curio_refresh_paid_test.gd
index 6be57be7..3cb11177 100644
--- a/game/tests/unit/core/curio_refresh_paid_test.gd
+++ b/game/tests/unit/core/curio_refresh_paid_test.gd
@@ -8,7 +8,7 @@ const Kit := preload("res://tests/unit/test_kit.gd")
 
 
 func _init() -> void:
-# oracle: design/engineering/architecture/architecture.md:107 （CurioDeck：三选一/商店共享池、抽签、cap 库存——刷新付费组）
+# 判据出处: design/engineering/architecture/architecture.md:107 （CurioDeck：三选一/商店共享池、抽签、cap 库存——刷新付费组）
 	var db = load("res://core/config_db.gd").new()
 	if not db.load_tables("res://data/tables", false):
 		print("[curio_refresh_paid_test] FAIL — 数值表加载失败")
diff --git a/game/tests/unit/core/effect_words_t1_test.gd b/game/tests/unit/core/effect_words_t1_test.gd
index c9902171..df590855 100644
--- a/game/tests/unit/core/effect_words_t1_test.gd
+++ b/game/tests/unit/core/effect_words_t1_test.gd
@@ -11,7 +11,7 @@ const EffectEngineScript = preload("res://core/effect_engine.gd")
 
 
 func _init() -> void:
-# oracle: design/engineering/architecture/architecture.md:89 （效果词表封闭——扩签封闭性组）
+# 判据出处: design/engineering/architecture/architecture.md:89 （效果词表封闭——扩签封闭性组）
 	# ① 词表在册断言（扩签面：2 事件+8 事实+7 效果类型+1 算子）
 	Kit.check_quiet(EffectEngineScript.EVENTS.has("dig_stop") and EffectEngineScript.EVENTS.has("battle_won"),
 		"新事件在册：dig_stop/battle_won〔专长批 V1〕")
diff --git a/game/tests/unit/core/encapsulation_p2_sweep_test.gd b/game/tests/unit/core/encapsulation_p2_sweep_test.gd
index 08bd3e76..db885c9e 100644
--- a/game/tests/unit/core/encapsulation_p2_sweep_test.gd
+++ b/game/tests/unit/core/encapsulation_p2_sweep_test.gd
@@ -11,34 +11,34 @@ const Kit := preload("res://tests/unit/test_kit.gd")
 
 
 func _init() -> void:
-# oracle: design/engineering/code-conventions.md:41 （封装边界：跨对象往来只走公开方法与属性——P2 词表单点扫描组）
+# 判据出处: design/engineering/code-conventions.md:41 （封装边界：跨对象往来只走公开方法与属性——P2 词表单点扫描组）
 	_sweep_generator()
 	_sweep_production_face()
 	quit(Kit.finish("encapsulation_p2_sweep_test"))
 
 
 func _src(path: String) -> String:
-# oracle: design/engineering/code-conventions.md:41 （源码采样组）
+# 判据出处: design/engineering/code-conventions.md:41 （源码采样组）
 	var src := FileAccess.get_file_as_string(path)
 	Kit.check("扫描面非空前置：%s" % path, src.length() > 0)
 	return src
 
 
 func _zero(pattern: String, src: String, label: String) -> void:
-# oracle: design/engineering/code-conventions.md:41 （零命中扫描组）
+# 判据出处: design/engineering/code-conventions.md:41 （零命中扫描组）
 	var re := RegEx.create_from_string(pattern)
 	Kit.check("%s：%s 零命中〔架构P2〕" % [label, pattern], re.search(src) == null)
 
 
 func _anchor(pattern: String, src: String, label: String) -> void:
-# oracle: design/engineering/code-conventions.md:41 （正锚存在组）
+# 判据出处: design/engineering/code-conventions.md:41 （正锚存在组）
 	var re := RegEx.create_from_string(pattern)
 	Kit.check("%s：%s 正锚在案〔架构P2〕" % [label, pattern], re.search(src) != null)
 
 
 # ① V1 生成器词表定义删除与改指
 func _sweep_generator() -> void:
-# oracle: design/engineering/code-conventions.md:41 （生成器本地副本归零组）
+# 判据出处: design/engineering/code-conventions.md:41 （生成器本地副本归零组）
 	var src := _src("res://core/node_map_generator.gd")
 	if src.length() == 0:
 		return
@@ -48,7 +48,7 @@ func _sweep_generator() -> void:
 
 # ② V2 生产三目录定义唯一性（递归扫 .gd，恰好 1 处且落 level_table.gd）
 func _sweep_production_face() -> void:
-# oracle: design/engineering/code-conventions.md:41 （schema 唯一定点组）
+# 判据出处: design/engineering/code-conventions.md:41 （schema 唯一定点组）
 	var files: Array[String] = []
 	for dir_path in ["res://core", "res://data", "res://presentation"]:
 		_collect_gd(dir_path, files)
diff --git a/game/tests/unit/core/encapsulation_sweep_test.gd b/game/tests/unit/core/encapsulation_sweep_test.gd
index e1bbf105..c408f885 100644
--- a/game/tests/unit/core/encapsulation_sweep_test.gd
+++ b/game/tests/unit/core/encapsulation_sweep_test.gd
@@ -14,7 +14,7 @@ const Kit := preload("res://tests/unit/test_kit.gd")
 
 
 func _init() -> void:
-# oracle: design/engineering/code-conventions.md:41 （封装边界——五处结构性零命中扫描组）
+# 判据出处: design/engineering/code-conventions.md:41 （封装边界——五处结构性零命中扫描组）
 	_sweep_settlement_segments()
 	_sweep_orchestrator_methods()
 	_sweep_breakpoint_pair()
@@ -26,7 +26,7 @@ func _init() -> void:
 
 # 源文件读取＋非空前置（返 "" 即已判红——调用侧跳过后续正则断言）
 func _src(path: String) -> String:
-# oracle: design/engineering/code-conventions.md:41 （源码采样组）
+# 判据出处: design/engineering/code-conventions.md:41 （源码采样组）
 	var src := FileAccess.get_file_as_string(path)
 	Kit.check("扫描面非空前置：%s" % path, src.length() > 0)
 	return src
@@ -34,21 +34,21 @@ func _src(path: String) -> String:
 
 # 正则零命中断言（-pattern 意图写入断言文案——可 grep 定位）
 func _zero(pattern: String, src: String, label: String, path: String) -> void:
-# oracle: design/engineering/code-conventions.md:41 （零命中扫描组）
+# 判据出处: design/engineering/code-conventions.md:41 （零命中扫描组）
 	var re := RegEx.create_from_string(pattern)
 	Kit.check("%s：%s 零命中〔封装5.1〕" % [label, pattern], re.search(src) == null)
 
 
 # 正锚在案断言（正则命中 ≥1——新公开面/新形态在用）
 func _anchor(pattern: String, src: String, label: String, path: String) -> void:
-# oracle: design/engineering/code-conventions.md:41 （正锚存在组）
+# 判据出处: design/engineering/code-conventions.md:41 （正锚存在组）
 	var re := RegEx.create_from_string(pattern)
 	Kit.check("%s：%s 正锚在案〔封装5.1〕" % [label, pattern], re.search(src) != null)
 
 
 # ① V2 settlement 七文件（束注入换代——对编排器引用归零）
 func _sweep_settlement_segments() -> void:
-# oracle: design/engineering/code-conventions.md:41 （结算段封装扫描组）
+# 判据出处: design/engineering/code-conventions.md:41 （结算段封装扫描组）
 	var classes := {
 		"res://core/settlement/grant_segment.gd": "GrantSegment",
 		"res://core/settlement/combat_segment.gd": "CombatSegment",
@@ -68,7 +68,7 @@ func _sweep_settlement_segments() -> void:
 
 # ② V3 编排器搬家五方法零残留
 func _sweep_orchestrator_methods() -> void:
-# oracle: design/engineering/code-conventions.md:41 （编排器方法面扫描组）
+# 判据出处: design/engineering/code-conventions.md:41 （编排器方法面扫描组）
 	var src := _src("res://core/battle_orchestrator.gd")
 	if src.length() == 0:
 		return
@@ -78,7 +78,7 @@ func _sweep_orchestrator_methods() -> void:
 
 # ③ V4 断点域（adventure_runner → BreakpointStore 公开面）
 func _sweep_breakpoint_pair() -> void:
-# oracle: design/engineering/code-conventions.md:41 （断点对封装扫描组）
+# 判据出处: design/engineering/code-conventions.md:41 （断点对封装扫描组）
 	var src := _src("res://core/adventure_runner.gd")
 	if src.length() == 0:
 		return
@@ -88,7 +88,7 @@ func _sweep_breakpoint_pair() -> void:
 
 # ④ V5 存档双向公开面（save_manager↔slot_store）
 func _sweep_save_pair() -> void:
-# oracle: design/engineering/code-conventions.md:41 （存档对封装扫描组）
+# 判据出处: design/engineering/code-conventions.md:41 （存档对封装扫描组）
 	var src_m := _src("res://core/save_manager.gd")
 	if src_m.length() > 0:
 		_zero("slots\\._", src_m, "save_manager 对槽位件私取归零", "res://core/save_manager.gd")
@@ -102,7 +102,7 @@ func _sweep_save_pair() -> void:
 
 # ⑤ V6 效果宿主累积面（grant → BattleFxHost 公开累积方法）
 func _sweep_fx_host_accumulators() -> void:
-# oracle: design/engineering/code-conventions.md:41 （特效宿主累积面扫描组）
+# 判据出处: design/engineering/code-conventions.md:41 （特效宿主累积面扫描组）
 	var src := _src("res://core/settlement/grant_segment.gd")
 	if src.length() == 0:
 		return
@@ -112,7 +112,7 @@ func _sweep_fx_host_accumulators() -> void:
 
 # ⑥ V7 配置挂载面（config_db → 三 schema bind_resolver）
 func _sweep_config_resolver() -> void:
-# oracle: design/engineering/code-conventions.md:41 （配置挂载面扫描组）
+# 判据出处: design/engineering/code-conventions.md:41 （配置挂载面扫描组）
 	var src := _src("res://core/config_db.gd")
 	if src.length() == 0:
 		return
diff --git a/game/tests/unit/core/feat_vouchers_test.gd b/game/tests/unit/core/feat_vouchers_test.gd
index ad9b7b65..a312428b 100644
--- a/game/tests/unit/core/feat_vouchers_test.gd
+++ b/game/tests/unit/core/feat_vouchers_test.gd
@@ -16,7 +16,7 @@ func EffectEngineKindProbe(_db) -> bool:
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/冒险循环/奇物.md:465 （奇物凭证五件与留任二件组）
+# 判据出处: design/gdd/systems/冒险循环/奇物.md:465 （奇物凭证五件与留任二件组）
 	var db = load("res://core/config_db.gd").new()
 	if not db.load_tables("res://data/tables", false):
 		print("[feat_vouchers_test] FAIL — 数值表加载失败")
diff --git a/game/tests/unit/core/hero_ledger_test.gd b/game/tests/unit/core/hero_ledger_test.gd
index ad786cfa..8f1f6e86 100644
--- a/game/tests/unit/core/hero_ledger_test.gd
+++ b/game/tests/unit/core/hero_ledger_test.gd
@@ -14,7 +14,7 @@ const LevelRunnerScript := preload("res://core/level_runner.gd")
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/冒险循环/冒险结构.md:288 （生命一致性：三写入口封顶 [0,生效上限]——主角账组）
+# 判据出处: design/gdd/systems/冒险循环/冒险结构.md:288 （生命一致性：三写入口封顶 [0,生效上限]——主角账组）
 	var db = load("res://core/config_db.gd").new()
 	if not db.load_tables("res://data/tables", false):
 		print("[hero_ledger_test] FAIL — 数值表加载失败")
diff --git a/game/tests/unit/core/level_map_type_vis_test.gd b/game/tests/unit/core/level_map_type_vis_test.gd
index 9cb4d92d..01452aa5 100644
--- a/game/tests/unit/core/level_map_type_vis_test.gd
+++ b/game/tests/unit/core/level_map_type_vis_test.gd
@@ -10,7 +10,7 @@ const LevelTableScript := preload("res://data/schemas/level_table.gd")
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点地图.md:176 （信息迷雾类型可见性宿主——装载组）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点地图.md:176 （信息迷雾类型可见性宿主——装载组）
 	var db = load("res://core/config_db.gd").new()
 	var loaded: bool = db.load_tables("res://data/tables", false)
 	Kit.check_quiet(loaded, "可见性用例：数值表加载成功")
@@ -103,7 +103,7 @@ func _runner(db, nodes: Array, anchor_id: int, candidates: Array, n: int = 2):
 # ---- ⑥ N 进数据表（含越域校验）〔fv6〕----
 
 func _test_field_in_table(db) -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点地图.md:176 （迷雾参数读表——字段在表组）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点地图.md:176 （迷雾参数读表——字段在表组）
 	var n_in_table: int = int(db.run.level.info_visible_layers)
 	Kit.check("N 落表：level.tres 读数 2（实际 %d）〔fv6〕" % n_in_table, n_in_table == 2)
 	var t := LevelTableScript.new()
@@ -127,7 +127,7 @@ func _has_n_domain_err(errs: Array) -> bool:
 # ---- ① 邻近 N 层见类型（层距边界）〔fv1〕----
 
 func _test_layer_distance(db) -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点地图.md:176 （层距 N 可见性组）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点地图.md:176 （层距 N 可见性组）
 	var nodes := _graph_nodes()
 	var r = _runner(db, nodes, 1, [nodes[2]])   # 锚 = 节点 1（层 1），候选 = 节点 2
 	var vis: Array = r.type_visible_ids()
@@ -139,7 +139,7 @@ func _test_layer_distance(db) -> void:
 # ---- ② 下一跳恒可见（跨层跳边候选）〔fv4〕----
 
 func _test_candidate_exempt(db) -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点地图.md:176 （候选豁免组）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点地图.md:176 （候选豁免组）
 	var nodes := _graph_nodes()
 	var r = _runner(db, nodes, 6, [nodes[3]])   # 锚 = 节点 6（层 5），候选 = 节点 3（层 2，层距 3）
 	var vis: Array = r.type_visible_ids()
@@ -150,7 +150,7 @@ func _test_candidate_exempt(db) -> void:
 # ---- ③ Boss/终点不入雾＋⑤ 入口停点锚层 0〔fv3〕〔fv1〕----
 
 func _test_boss_exempt(db) -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点地图.md:176 （Boss 豁免组）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点地图.md:176 （Boss 豁免组）
 	var nodes := _graph_nodes()
 	var r = _runner(db, nodes, -1, [nodes[0]])   # 入口停点（无当前节点，锚层 0）
 	var vis: Array = r.type_visible_ids()
@@ -163,7 +163,7 @@ func _test_boss_exempt(db) -> void:
 # ---- ④ 单圈回雾（visited 不豁免）〔fv7〕----
 
 func _test_single_circle(db) -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点地图.md:176 （单圈可见组）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点地图.md:176 （单圈可见组）
 	var nodes := _graph_nodes()
 	var r = _runner(db, nodes, 6, [nodes[7], nodes[3]])
 	r.visited.assign([nodes[0], nodes[1], nodes[2], nodes[3], nodes[4], nodes[5], nodes[6]])
@@ -176,7 +176,7 @@ func _test_single_circle(db) -> void:
 # ---- ⑤ 单链退化形态（出度 ≤1 图，编号 = id 句柄）〔fv1〕----
 
 func _test_single_chain_entry(db) -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点地图.md:176 （单链入口组）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点地图.md:176 （单链入口组）
 	var nodes := _chain_nodes()
 	var r = _runner(db, nodes, -1, [nodes[0]])
 	var vis: Array = r.type_visible_ids()
@@ -189,7 +189,7 @@ func _test_single_chain_entry(db) -> void:
 # ---- ⑥ N 读表：可见窗随表值随动〔fv6〕----
 
 func _test_n_from_table(db) -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点地图.md:176 （N 读表组）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点地图.md:176 （N 读表组）
 	var nodes := _graph_nodes()
 	var r = _runner(db, nodes, 1, [nodes[2]])   # 锚层 1
 	db.run.level.info_visible_layers = 1
@@ -207,7 +207,7 @@ func _test_n_from_table(db) -> void:
 # ---- ⑦ 续玩重建同值〔fv7〕----
 
 func _test_resume_rebuild(db) -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	var t := LevelTableScript.new()
 	t.info_visible_layers = 2
 	t.rows = [{"level_index": 1, "display_name": "夹具关", "rest_heal_pct": 30}]
diff --git a/game/tests/unit/core/level_shop_economy_test.gd b/game/tests/unit/core/level_shop_economy_test.gd
index ca61382d..1d099eda 100644
--- a/game/tests/unit/core/level_shop_economy_test.gd
+++ b/game/tests/unit/core/level_shop_economy_test.gd
@@ -232,7 +232,7 @@ func _board_row_exact(level_index: int, depth: int) -> bool:
 
 
 func _init() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	_db = ConfigDBScript.new()
 	# 表加载失败不中止（承 G2/G3/G4/G5 同款：表损坏的红落在具体断言上——
 	# 诊断在此展开，后续断言按坏表实况逐条验红；collect_only=true 下成员照常赋值可评）
@@ -262,7 +262,7 @@ func _init() -> void:
 # ---- 数值入表等价证明（d11/d16a——原字面量迁移：表值 == 迁移前字面量，消费端读表）----
 
 func _smoke_table_migration() -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:195 （行集纪律——表迁移组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:195 （行集纪律——表迁移组）
 	print("--- 数值入表（shop 两 knob + hero 显示名 · 原值迁移）---")
 	Kit.check("shop.relic_base_price 表值 == 迁移前字面量（15.0）〔wd11〕", _db.run.shop.relic_base_price == 15.0)
 	Kit.check("hero.display_name 表值 == 迁移前字面量（探险者）〔wd16〕", _db.combat.hero.display_name == "探险者")
@@ -277,7 +277,7 @@ func _smoke_table_migration() -> void:
 # 敌侧/板侧解析一律走 ConfigDB 真实消费链，禁直读行集自算）----
 
 func _smoke_generated_coverage() -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点地图.md:184 （每终点前恰一店——生成覆盖扫描组）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点地图.md:184 （每终点前恰一店——生成覆盖扫描组）
 	var enemy_ok := true
 	var board_ok := true
 	var boss_band_ok := true
@@ -328,7 +328,7 @@ func _smoke_generated_coverage() -> void:
 # ---- 关卡节点图·生成图推进冒烟（图 = 该关参数档 × 种子）----
 
 func _smoke_level() -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点地图.md:178 （关卡图校验推进组）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点地图.md:178 （关卡图校验推进组）
 	print("--- 关卡节点图·生成图推进（参数档×种子产图·满配冒险成功/恢复公式/败北线/回放确定性）---")
 	var autoplay = load("res://sim/level_autoplay.gd")
 	var hero_base := {"atk": int(_db.combat.hero.atk), "hp": int(_db.combat.hero.max_hp), "ac": int(_db.combat.hero.armor_class)}   # 配置基线快照——⑤ 回基线对比用（改表自动跟随，不再硬编码）
@@ -442,7 +442,7 @@ func _drive_to_rest(level_index: int, seed_val: int, gap: int) -> Dictionary:
 # ---- 分支节点图冒烟：图合法性校验 + L2 幽暗地域生成图行进（图 = 参数档 × 种子）----
 
 func _smoke_level_graph() -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点地图.md:178 （图结构与行进纪律组）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点地图.md:178 （图结构与行进纪律组）
 	print("--- 关卡节点图·分支节点图（L2 幽暗地域·生成图）---")
 	var autoplay = load("res://sim/level_autoplay.gd")
 	# ① 关卡表行级校验零错误（关卡表只承载序号/显示名/恢复比例——图合法性由 validate_graph 在起关时承担）
@@ -801,7 +801,7 @@ func _fresh_rng(seed_val: int):
 # ---- ① GP 冒险钱包·到账 ----
 
 func _smoke_gp_wallet() -> void:
-# oracle: design/gdd/systems/战斗循环/地图战斗资源.md:233 （GP 钱包入账组）
+# 判据出处: design/gdd/systems/战斗循环/地图战斗资源.md:233 （GP 钱包入账组）
 	print("--- GP 冒险钱包·到账（战斗完成入账恰一次 + Boss 加值）---")
 	var autoplay = load("res://sim/level_autoplay.gd")
 	# ① L1 首战（普通战档——掷定 [2,4] + 关级加值 0）：runner 驱动，收集 battle_finished 与钱包事件
@@ -867,7 +867,7 @@ func _escrow_sum_of(rows: Array) -> int:
 # ---- ② escrow 隔离（GP安全格兑付 / 破财直验 / 钱包 clamp）----
 
 func _smoke_gp_escrow() -> void:
-# oracle: design/gdd/systems/战斗循环/地图战斗资源.md:233 （GP escrow 组）
+# 判据出处: design/gdd/systems/战斗循环/地图战斗资源.md:233 （GP escrow 组）
 	print("--- GP escrow 隔离（GP安全格兑付入缓冲 · 破财不透支）---")
 	# ① 种子扫描：找GP 袋（gp 型安全格）可挖掘局——挖开兑付 +3 入 escrow，战斗末随 gp_dropped 一次上抛
 	var scan := {}
@@ -981,7 +981,7 @@ func _find_gp_dig(minesweeper, settlement) -> Dictionary:
 # ---- ③ 商店房三收口 ----
 
 func _smoke_shop_room() -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点地图.md:184 （商店房呈现组）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点地图.md:184 （商店房呈现组）
 	print("--- 商店房三收口（现价/加算区/余额不足拒/离开回选路/收束清零）---")
 	var autoplay = load("res://sim/level_autoplay.gd")
 	# 行进到商店房（按图型别定位商店节点——候选取最小句柄行进，到达即停）：
@@ -1115,7 +1115,7 @@ func _shop_products_by_id(prods: Array) -> Dictionary:
 # ---- ④ 商店编排性质（生成图扫描面——三条性质 + 终点跨表解析）----
 
 func _smoke_shop_graph() -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点地图.md:184 （必经恰一店图纪律组）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点地图.md:184 （必经恰一店图纪律组）
 	print("--- 商店编排性质（每终点前一位恰一店 · 店数＝终点数 · 全路径恰穿一店）---")
 	var pred_bad := 0
 	var term_total := 0
@@ -1186,7 +1186,7 @@ func _smoke_shop_graph() -> void:
 
 # ---- ⑥ 大岔口分区域兑付（V3——多终点图走哪条路决定打谁，任一 Boss 胜即收束恰一次）----
 func _smoke_multi_terminal_settlement() -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点地图.md:185 （多终局收束组）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点地图.md:185 （多终局收束组）
 	print("--- 大岔口分区域兑付（L2 两轴各打各的终点）---")
 	var autoplay = load("res://sim/level_autoplay.gd")
 	var nodes: Array = _generated_graph(2, 42).get("nodes", [])
@@ -1254,7 +1254,7 @@ func _paths_all_one_shop(nodes: Array) -> bool:
 # ---- ⑤ 商店共享池（三选一同构/乘法价/跨渠道共账/切边/断点扩键）----
 
 func _smoke_shop_pool() -> void:
-# oracle: design/engineering/architecture/architecture.md:107 （商店共享池组）
+# 判据出处: design/engineering/architecture/architecture.md:107 （商店共享池组）
 	print("--- 商店共享池（抽3买1全重抽 · 乘法定价 ceil · 池空硬闸 · 切边零入店）---")
 	var autoplay = load("res://sim/level_autoplay.gd")
 	var shelf_kinds: Array = []
@@ -1417,7 +1417,7 @@ func _smoke_shop_pool() -> void:
 # ---- 商店房 node_entered 载荷（尾波 V1——_enter_node pool/legacy 双发射路径归一后的行为保持断言）----
 
 func _test_shop_node_entered_payload() -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点地图.md:184 （行进至此打开商店覆盖层——载荷组）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点地图.md:184 （行进至此打开商店覆盖层——载荷组）
 	print("--- 商店房 node_entered 载荷（pool 含 shelf:true＋gp 现值／legacy 无 shelf 键）---")
 	var autoplay = load("res://sim/level_autoplay.gd")
 	# pool 态：载荷字典经信号闭包当场取样（字典为引用累积器——lambda 按值捕获标量的绕行惯例）
@@ -1576,7 +1576,7 @@ func _has_err_category(errs: Array, category: String) -> bool:
 # ---- 货架位数读表（架构整改——shelf_size 表头单点：进店与重抽同源）----
 
 func _test_shelf_size_from_table() -> void:
-# oracle: design/ux/shop.md:13 （货架位数读表组）
+# 判据出处: design/ux/shop.md:13 （货架位数读表组）
 	var autoplay = load("res://sim/level_autoplay.gd")
 	var st = _db.run.shop
 	var saved: int = int(st.shelf_size)
@@ -1598,7 +1598,7 @@ func _test_shelf_size_from_table() -> void:
 # ---- 散折价收回规则键（架构整改 R2——shop.spend_discount 表字段退役，折价读 economy_spend.discount_pct）----
 
 func _test_spend_discount_from_rule_key() -> void:
-# oracle: design/gdd/systems/排雷循环/行动经济.md:256 （换图基座：挖格产 RAP 与刷新折扣组）
+# 判据出处: design/gdd/systems/排雷循环/行动经济.md:256 （换图基座：挖格产 RAP 与刷新折扣组）
 	# 字段真删：shop.tres 加载零诊断 + spend_discount 属性不在位
 	Kit.check("shop.tres 加载零诊断（spend_discount 字段真删——schema 与表行同卸）〔架构整改 V2〕",
 		_db.diagnostics_count("error") == 0 and _db.run.shop.get("spend_discount") == null)
diff --git a/game/tests/unit/core/level_table_validate_test.gd b/game/tests/unit/core/level_table_validate_test.gd
index 14201d91..ca050b6a 100644
--- a/game/tests/unit/core/level_table_validate_test.gd
+++ b/game/tests/unit/core/level_table_validate_test.gd
@@ -11,7 +11,7 @@ const LevelTableScript := preload("res://data/schemas/level_table.gd")
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点地图.md:178 （关卡表消费侧校验宿主）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点地图.md:178 （关卡表消费侧校验宿主）
 	_test_positive()
 	_test_negative()
 	_test_scope_not_extended()
@@ -38,7 +38,7 @@ func _has(errs: Array, cat: String, needle: String = "") -> bool:
 # ---- 正例（四检全过）----
 
 func _test_positive() -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点地图.md:178 （良构基底正向组）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点地图.md:178 （良构基底正向组）
 	# 多入口多终点：两入口共汇入一岔口，两终点各在互异深度
 	var multi := [
 		_n(0, "battle", 0, [2]), _n(1, "battle", 0, [2]),
@@ -61,7 +61,7 @@ func _test_positive() -> void:
 # ---- 负例九类（各报对应类别与判据消息）----
 
 func _test_negative() -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点地图.md:178 （违规配置加载期致命——负向组）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点地图.md:178 （违规配置加载期致命——负向组）
 	var non_boss_end := [_n(0, "battle", 0, [1]), _n(1, "battle", 1, [])]
 	Kit.check("负例：终点非 Boss 命中「终点恒为 Boss」〔v1〕",
 		_has(_errs(non_boss_end), "structural", "终点 1 非 Boss"))
@@ -95,7 +95,7 @@ func _test_negative() -> void:
 # ---- 「勿扩勿缩」反证：本检不含商店位与个数对参数档的核对 ----
 
 func _test_scope_not_extended() -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点地图.md:178 （校验范围不外扩组）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点地图.md:178 （校验范围不外扩组）
 	# 合法形状但全程无商店／三个终点同入口图——四检不该因此报错（商店位归冒烟断言、个数归产出侧）
 	var no_shop := [_n(0, "battle", 0, [1, 2]), _n(1, "battle", 1, [3]), _n(2, "rest", 1, [3]), _n(3, "boss", 2, [])]
 	Kit.check("范围反证：无商店图不在加载校验内报错（商店位由冒烟断言把关）〔v1〕", _errs(no_shop).is_empty())
diff --git a/game/tests/unit/core/meta_progression_forge_test.gd b/game/tests/unit/core/meta_progression_forge_test.gd
index 35c769f6..cfd4efba 100644
--- a/game/tests/unit/core/meta_progression_forge_test.gd
+++ b/game/tests/unit/core/meta_progression_forge_test.gd
@@ -21,7 +21,7 @@ var _db
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/跨局循环/元进度.md:148 元进度与锻造宿主（装载组）
+# 判据出处: design/gdd/systems/跨局循环/元进度.md:148 元进度与锻造宿主（装载组）
 	_db = ConfigDBScript.new()
 	# 表加载失败不中止（承 G2/G3/G4/G5 同款：表损坏的红落在具体断言上——
 	# 诊断在此展开，后续断言按坏表实况逐条验红；collect_only=true 下成员照常赋值可评）
@@ -133,7 +133,7 @@ func _auto_play_round(settlement, out: Dictionary) -> void:
 # ---- 元进度 ②树购买面（购买受理/持久/余额不足拒绝/未知节点拒绝；
 #      行价=表值 flat 单价）----
 func _meta_pricing_and_buy() -> void:
-# oracle: design/gdd/systems/跨局循环/天赋树.md:198 （单币可判：购买只扣钥石、余额不足拒绝零变化组）
+# 判据出处: design/gdd/systems/跨局循环/天赋树.md:198 （单币可判：购买只扣钥石、余额不足拒绝零变化组）
 	print("--- 元进度·树购买面（隔离档 smoke_meta_buy/dry）---")
 	_meta_smoke_cleanup()
 	var sv = _meta_new_save(_META_SMOKE_PATHS[0])
@@ -160,7 +160,7 @@ func _meta_pricing_and_buy() -> void:
 
 # ---- 元进度 ⑥Boss 两档 ⑦钥石不丢 ⑧工坊解锁 ⑩摘要副本与 cap（合成摘要驱动——settle 纯账面零跑局）----
 func _meta_settle_and_workshop() -> void:
-# oracle: design/gdd/systems/跨局循环/元进度.md:150 （钥石收束入账不丢组）
+# 判据出处: design/gdd/systems/跨局循环/元进度.md:150 （钥石收束入账不丢组）
 	print("--- 元进度·收束入账与工坊（隔离档 smoke_meta_settle/workshop/cap）---")
 	var sv = _meta_new_save(_META_SMOKE_PATHS[2])
 	var mp = load("res://core/meta_progression.gd").new(_db, sv)
@@ -353,7 +353,7 @@ func _meta_settle_and_workshop() -> void:
 
 # ---- 元进度 ④注入可见 + 白板成立（验收 4/2/3——程序面；MC 逐位回归归 T7 全量验证）----
 func _meta_injection() -> void:
-# oracle: design/gdd/systems/跨局循环/天赋树.md:201 （注入可判：开局覆盖值分层可加组）
+# 判据出处: design/gdd/systems/跨局循环/天赋树.md:201 （注入可判：开局覆盖值分层可加组）
 	print("--- 元进度·注入可见与白板（隔离档 smoke_meta_white/dry）---")
 	var sv = _meta_new_save(_META_SMOKE_PATHS[1])
 	var mp = load("res://core/meta_progression.gd").new(_db, sv)
@@ -397,7 +397,7 @@ func _meta_injection() -> void:
 # ---- 锻造工坊·两根类型轴所有权移交（V5 前半：hero.tres 两轴删除+锻造配置默认值）----
 # 后半（build_adventure_params 注入默认值/选中覆盖）随 T4 注入接线同批断言；写口/解锁面归 T3。
 func _smoke_forge_axes() -> void:
-# oracle: design/gdd/systems/跨局循环/锻造工坊.md:220 （锻造两轴单选注入与树零攻防组）
+# 判据出处: design/gdd/systems/跨局循环/锻造工坊.md:220 （锻造两轴单选注入与树零攻防组）
 	print("--- 锻造工坊·类型轴所有权移交（T2）---")
 	# V5：hero.tres 静态表两轴已删（全表加载零违例——config_db_test 同款闸；此处钉字段不在位）
 	Kit.check("hero.tres 无 attack_type/armor_type 字段（契约 2——静态表两轴删除）〔锻造工坊批 V5〕",
@@ -560,7 +560,7 @@ func _smoke_forge_axes() -> void:
 # ---- 天赋树冒烟（v0.8 12 节点：schema/购买面/Fork 一节点双态/彩蛋特化）----
 
 func _smoke_tree() -> void:
-# oracle: design/gdd/systems/跨局循环/天赋树.md:194 （天赋树购买与六键合成组）
+# 判据出处: design/gdd/systems/跨局循环/天赋树.md:194 （天赋树购买与六键合成组）
 	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〕",
@@ -643,7 +643,7 @@ func _smoke_tree() -> void:
 # ---- 天赋树六键行为冒烟（V10：开局姿态窗/危险直觉限次/财富之道聚散/守侧失误补偿；
 #      引擎直构 + 编排授予段直注（_grant_seg._judge_seal=结算授予段封印判定单口））----
 func _smoke_tree_rules() -> void:
-# oracle: design/gdd/systems/跨局循环/天赋树.md:194 （规则键参数读表组）
+# 判据出处: design/gdd/systems/跨局循环/天赋树.md:194 （规则键参数读表组）
 	print("--- 天赋树六键行为（V10：窗/限次/聚散/守侧）---")
 	# 开局姿态组：每关首轮窗（battle_index 事实——引擎直构 + 自建 ctx）
 	var fx = load("res://core/effect_engine.gd").new(null)
@@ -784,7 +784,7 @@ func _smoke_tree_rules() -> void:
 # ---- 锻造契约补齐（断言补齐批——⑥锻造工坊）：拒购零副作用/祝福件零泄漏/默认值解耦/甲型双轴 ----
 
 func _test_forge_buy_reject() -> void:
-# oracle: design/gdd/systems/跨局循环/锻造工坊.md:222 （钥石不足购买被拒、余额与等级零变化组）
+# 判据出处: design/gdd/systems/跨局循环/锻造工坊.md:222 （钥石不足购买被拒、余额与等级零变化组）
 	var sv = _meta_new_save("user://smoke_meta_reject.json")
 	var mp = load("res://core/meta_progression.gd").new(_db, sv)
 	sv.meta_state._add_keystone(10)   # 低于首购价 20——余额不足面
@@ -799,7 +799,7 @@ func _test_forge_buy_reject() -> void:
 
 
 func _test_blessing_no_forge_leak() -> void:
-# oracle: design/gdd/systems/跨局循环/锻造工坊.md:220 （树淬炼对攻击与 AC 零贡献组）
+# 判据出处: design/gdd/systems/跨局循环/锻造工坊.md:220 （树淬炼对攻击与 AC 零贡献组）
 	var sv = _meta_new_save("user://smoke_meta_blessing.json")
 	var mp = load("res://core/meta_progression.gd").new(_db, sv)
 	var fs0: Dictionary = sv.meta_state.forge_state().duplicate(true)
@@ -818,7 +818,7 @@ func _test_blessing_no_forge_leak() -> void:
 
 
 func _test_default_axes_pre_key() -> void:
-# oracle: design/gdd/systems/跨局循环/锻造工坊.md:217 （未点亮期间默认值照常注入组）
+# 判据出处: design/gdd/systems/跨局循环/锻造工坊.md:217 （未点亮期间默认值照常注入组）
 	var sv = _meta_new_save("user://smoke_meta_axesw.json")
 	var mp = load("res://core/meta_progression.gd").new(_db, sv)
 	var ax: Dictionary = mp.hero_type_axes()
@@ -827,7 +827,7 @@ func _test_default_axes_pre_key() -> void:
 
 
 func _test_armor_switch_dual_axes() -> void:
-# oracle: design/gdd/systems/跨局循环/锻造工坊.md:221 （换装不丢级不生效——双轴组）
+# 判据出处: design/gdd/systems/跨局循环/锻造工坊.md:221 （换装不丢级不生效——双轴组）
 	var sv = _meta_new_save("user://smoke_meta_axesw.json")
 	sv.meta_state._add_keystone(1000)
 	var mp = load("res://core/meta_progression.gd").new(_db, sv)
diff --git a/game/tests/unit/core/minesweeper_rules_test.gd b/game/tests/unit/core/minesweeper_rules_test.gd
index c6d52fd4..1797b128 100644
--- a/game/tests/unit/core/minesweeper_rules_test.gd
+++ b/game/tests/unit/core/minesweeper_rules_test.gd
@@ -17,7 +17,7 @@ var _ae: ActionEconomy
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/排雷循环/排雷玩法.md:224 （排雷规则宿主——装载组）
+# 判据出处: design/gdd/systems/排雷循环/排雷玩法.md:224 （排雷规则宿主——装载组）
 	_db = load("res://core/config_db.gd").new() as ConfigDb
 	if not _db.load_tables("res://data/tables", false):
 		Kit.check("数值表加载", false)
@@ -46,7 +46,7 @@ func _init() -> void:
 
 
 func _test_install_invariants() -> void:
-# oracle: design/gdd/systems/排雷循环/排雷玩法.md:228 （装板四不变式组）
+# 判据出处: design/gdd/systems/排雷循环/排雷玩法.md:228 （装板四不变式组）
 	_rules.install_board(_board)
 	Kit.check("装板后 current_board 即所装棋盘", _rules.current_board() == _board)
 	var opened: int = _rules.revealed_cells().size()
@@ -70,7 +70,7 @@ func _unrevealed_safe() -> Vector2i:
 
 
 func _test_dig_face_rules() -> void:
-# oracle: design/gdd/systems/排雷循环/排雷玩法.md:231 （挖/封印合法性与可辨拒绝组）
+# 判据出处: design/gdd/systems/排雷循环/排雷玩法.md:231 （挖/封印合法性与可辨拒绝组）
 	var revealed_first = _rules.revealed_cells()[0] as Vector2i
 	var out: Array = _rules.settle_batch([{"action": "dig", "cell": revealed_first}])
 	var o: Dictionary = (out[0] as Dictionary) if not out.is_empty() else {}
@@ -85,7 +85,7 @@ func _test_dig_face_rules() -> void:
 
 
 func _test_reveal_advances() -> void:
-# oracle: design/gdd/systems/排雷循环/排雷玩法.md:230 （揭示推进与连锁组）
+# 判据出处: design/gdd/systems/排雷循环/排雷玩法.md:230 （揭示推进与连锁组）
 	var c := _unrevealed_safe()
 	if c == Vector2i(-1, -1):
 		Kit.check("存在未揭示安全格（揭示推进前置）", false)
@@ -99,7 +99,7 @@ func _test_reveal_advances() -> void:
 
 
 func _test_seal_place() -> void:
-# oracle: design/gdd/systems/排雷循环/排雷玩法.md:231 （重复封印拒绝组）
+# 判据出处: design/gdd/systems/排雷循环/排雷玩法.md:231 （重复封印拒绝组）
 	var c := _unrevealed_safe()
 	if c == Vector2i(-1, -1):
 		Kit.check("存在未揭示安全格（封印前置）", false)
@@ -112,7 +112,7 @@ func _test_seal_place() -> void:
 
 
 func _test_reject_out_of_catalog() -> void:
-# oracle: design/gdd/systems/排雷循环/排雷玩法.md:236 （目录外拒绝组）
+# 判据出处: design/gdd/systems/排雷循环/排雷玩法.md:236 （目录外拒绝组）
 	var out: Array = _rules.settle_batch([{"action": "not_a_real_action", "cell": Vector2i(0, 0)}])
 	var o: Dictionary = (out[0] as Dictionary) if not out.is_empty() else {}
 	Kit.check("目录外意图被拒（不静默吞掉）——实际载荷 %s" % str(o).substr(0, 80),
@@ -122,7 +122,7 @@ func _test_reject_out_of_catalog() -> void:
 # ---- V14 棋盘揭示预览只读口（架构整改——preview_reveal 与实挖揭示集同口径、零状态写入零事件）----
 
 func _test_preview_reveal_readonly() -> void:
-# oracle: design/engineering/architecture/architecture.md:103 （preview_reveal 只读预览口——零写入零事件组）
+# 判据出处: design/engineering/architecture/architecture.md:103 （preview_reveal 只读预览口——零写入零事件组）
 	var events := 0
 	_rules.cell_revealed.connect(func(_evt): events += 1)   # 零发射哨兵（preview 全程不触发揭示事件）
 	# 形态 A：封印在场——preview(未开格) 不越封印且零状态写入
diff --git a/game/tests/unit/core/node_map_generator_test.gd b/game/tests/unit/core/node_map_generator_test.gd
index 403bdc3a..358e6ec1 100644
--- a/game/tests/unit/core/node_map_generator_test.gd
+++ b/game/tests/unit/core/node_map_generator_test.gd
@@ -16,7 +16,7 @@ var _gen
 
 
 func _init() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	_db = ConfigDBScript.new()
 	var load_ok: bool = _db.load_tables("res://data/tables", true)
 	if not load_ok:
@@ -78,7 +78,7 @@ func _max_depth(g: Dictionary) -> int:
 # ---- V1 产出合格：三档×种子扫描，自证零错误 ----
 
 func _test_output_ok() -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点图生成.md:129 （产出约束六条＋结构铁律组）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点图生成.md:129 （产出约束六条＋结构铁律组）
 	var all_ok := true
 	var entry_exit_ok := true
 	for L in [1, 2, 3]:
@@ -96,7 +96,7 @@ func _test_output_ok() -> void:
 # ---- V3 可复现：纯函数＋counter 无关 ----
 
 func _test_reproducible() -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点图生成.md:134 （同种子同参数同图组）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点图生成.md:134 （同种子同参数同图组）
 	var same := true
 	for L in [1, 2, 3]:
 		if _sig(_graph(L, 42)) != _sig(_graph(L, 42)):
@@ -127,7 +127,7 @@ func _test_reproducible() -> void:
 # ---- V5 岔路取舍两条 ----
 
 func _test_fork_rules() -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点图生成.md:88 （岔路取舍组）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点图生成.md:88 （岔路取舍组）
 	var next_hop_ok := true
 	var comp_ok := true
 	for L in [1, 2, 3]:
@@ -203,7 +203,7 @@ func _branch_types(g: Dictionary, head_id: int, sibling_outs: Array) -> Array:
 # ---- V6 必经恰一店＋归属锁定＋多终点深度互异 ----
 
 func _test_shop_and_attribution() -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点图生成.md:48 （必经恰一店与归属锁定组）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点图生成.md:48 （必经恰一店与归属锁定组）
 	var paths_ok := true
 	var lock_ok := true
 	var depth_ok := true
@@ -256,7 +256,7 @@ func _all_paths(g: Dictionary) -> Array:
 # ---- V7 战斗保底 ----
 
 func _test_battle_floor() -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点图生成.md:129 （战斗保底组）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点图生成.md:129 （战斗保底组）
 	var ok := true
 	for L in [1, 2, 3]:
 		for s in range(42, 52):
@@ -268,7 +268,7 @@ func _test_battle_floor() -> void:
 # ---- V9 含岔口与出口结构 ----
 
 func _test_exit_structure() -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点图生成.md:48 （出口结构与分支互斥组）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点图生成.md:48 （出口结构与分支互斥组）
 	var fork_all := true
 	var l1_single := true
 	var big_fork_ok := true
@@ -315,7 +315,7 @@ func _terminals_reachable(g: Dictionary, id: int) -> int:
 # ---- V9 Boss 出场门控（难度曲线与Boss——每区域恰一 Boss 终点）----
 
 func _test_boss_exit_per_region() -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点图生成.md:48 （每区域 Boss 出口组）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点图生成.md:48 （每区域 Boss 出口组）
 	# 真实生成多区域图：全部终点 type=="boss"、boss 终点数==exit_count、深度=L−r（r∈[0,exit_count)
 	# ——每区域恰一 boss、深度互异即分属不同区域）
 	# 节点 depth 字段=入口起最长路径深（生成器校验轴）；区域序号 r 的可观测形态=最深 boss（r=0）
@@ -351,7 +351,7 @@ func _test_boss_exit_per_region() -> void:
 # ---- V10 RNG 单点（纯流面 counter 不变）----
 
 func _test_rng_single_point() -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点图生成.md:134 （RNG 单点流组）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点图生成.md:134 （RNG 单点流组）
 	var svc = RngScript.new()
 	svc.new_adventure(4242)
 	var before: int = svc.counter()
@@ -366,7 +366,7 @@ func _test_rng_single_point() -> void:
 # ---- V1 违规夹具：各报对应错误类别 ----
 
 func _test_negative_fixtures() -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:198 （无解 fail-fast 夹具组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:198 （无解 fail-fast 夹具组）
 	# 夹具构造器：手写 nodes/entries/terminals
 	var dup := _fx([
 		{"id": 0, "type": "battle", "depth": 0, "next": [1]},
@@ -493,7 +493,7 @@ func _has_msg(errs: Array, needle: String) -> bool:
 # ---- V6 节点图三参数表值驱动（架构整改——fork_third_way_pct/fill_rest_first_pct/width_max 入 level_gen_params）----
 
 func _test_gen_params_table_driven() -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点图生成.md:129 （参数档读表驱动组）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点图生成.md:129 （参数档读表驱动组）
 	# ① 同种子真实表行产图逐位（表值驱动回归锚）
 	var g1 := _graph(2, 42)
 	var g2 := _graph(2, 42)
diff --git a/game/tests/unit/core/node_map_growth_test.gd b/game/tests/unit/core/node_map_growth_test.gd
index 570ebce6..1f40c974 100644
--- a/game/tests/unit/core/node_map_growth_test.gd
+++ b/game/tests/unit/core/node_map_growth_test.gd
@@ -12,7 +12,7 @@ const Kit := preload("res://tests/unit/test_kit.gd")
 
 
 func _init() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	if OS.get_cmdline_user_args().has("fatal-fixture"):
 		_trigger_fatal()
 		return
@@ -39,7 +39,7 @@ func _reading(gen, db, L: int) -> Dictionary:
 # ---- V8 生长递增（三档×多种子逐档读数）----
 
 func _test_growth(gen, db) -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点图生成.md:130 （生长递增组）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点图生成.md:130 （生长递增组）
 	var steps_ok := true
 	var count_ok := true
 	for s in [42, 43, 44, 45, 46]:
@@ -63,7 +63,7 @@ func _test_growth(gen, db) -> void:
 # ---- V4 参数无解判定（静态面：域/预算无解夹具必须被 check_params 拦下）----
 
 func _test_fail_fast_static(gen, db) -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:198 （参数无解静态拒绝组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:198 （参数无解静态拒绝组）
 	Kit.check("生产三档参数档可行性判定零错误〔fv4〕",
 		NodeMapGenerator.check_params(db.run.level_gen_params.row_by_level_index(1)).is_empty()
 		and NodeMapGenerator.check_params(db.run.level_gen_params.row_by_level_index(3)).is_empty())
@@ -82,7 +82,7 @@ func _test_fail_fast_static(gen, db) -> void:
 # ---- V4 致命中止真实通道（子进程退出码非零；零回退分支＝件核）----
 
 func _test_fatal_subprocess() -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:199 （无解致命子进程组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:199 （无解致命子进程组）
 	var bin := _engine_bin()
 	if bin == "":
 		Kit.check("未找到引擎二进制，致命子进程通道未跑（如实标注）〔fv4〕", false)
@@ -98,7 +98,7 @@ func _test_fatal_subprocess() -> void:
 
 
 func _trigger_fatal() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	var gen = GenScript.new(RngScript.new())
 	# 域内合法但深度预算无解：层深 6 放三出口（check_params 拦下 → 致命中止）
 	var unsolvable := {"layers": 6, "branch_density": 0.0, "battle_ratio": 0.5, "reward_ratio": 0.2,
diff --git a/game/tests/unit/core/playtest_logger_guard_test.gd b/game/tests/unit/core/playtest_logger_guard_test.gd
index 41c5bdfc..ff80fde5 100644
--- a/game/tests/unit/core/playtest_logger_guard_test.gd
+++ b/game/tests/unit/core/playtest_logger_guard_test.gd
@@ -13,7 +13,7 @@ func _init() -> void:
 
 
 func _smoke_required_injection() -> void:
-# oracle: design/engineering/code-conventions.md:40 （拆分交接：依赖构造期一次交付——日志器必填注入守卫组）
+# 判据出处: design/engineering/code-conventions.md:40 （拆分交接：依赖构造期一次交付——日志器必填注入守卫组）
 	# 未注入（缺省 0）：start_session 返回空串、零文件产出
 	var lg0 = load("res://presentation/playtest_logger.gd").new()
 	var p0: String = lg0.start_session(42)
diff --git a/game/tests/unit/core/pool_case_d_test.gd b/game/tests/unit/core/pool_case_d_test.gd
index 96002e48..7d1b75da 100644
--- a/game/tests/unit/core/pool_case_d_test.gd
+++ b/game/tests/unit/core/pool_case_d_test.gd
@@ -9,7 +9,7 @@ const Kit := preload("res://tests/unit/test_kit.gd")
 
 
 func _init() -> void:
-# oracle: design/engineering/architecture/architecture.md:107 （池结构案 D：候选抽取与池纪律组）
+# 判据出处: design/engineering/architecture/architecture.md:107 （池结构案 D：候选抽取与池纪律组）
 	var db = load("res://core/config_db.gd").new()
 	if not db.load_tables("res://data/tables", false):
 		print("[pool_case_d_test] FAIL — 数值表加载失败")
@@ -66,7 +66,7 @@ func _tiers_of(cands: Array) -> Array:
 
 
 func check_v7(a, db) -> void:
-# oracle: design/engineering/architecture/architecture.md:107 （池案 D V7 组）
+# 判据出处: design/engineering/architecture/architecture.md:107 （池案 D V7 组）
 	if not a.start_adventure(201):
 		Kit.check_quiet(false, "V7 前置：冒险启动")
 		return
@@ -112,7 +112,7 @@ func check_v7(a, db) -> void:
 
 
 func check_v6(b, db) -> void:
-# oracle: design/engineering/architecture/architecture.md:107 （池案 D V6 组）
+# 判据出处: design/engineering/architecture/architecture.md:107 （池案 D V6 组）
 	if not b.start_adventure(202):
 		Kit.check_quiet(false, "V6 前置：冒险启动")
 		return
@@ -142,7 +142,7 @@ func check_v6(b, db) -> void:
 
 
 func check_v12(m, db) -> void:
-# oracle: design/engineering/architecture/architecture.md:107 （池案 D V12 组）
+# 判据出处: design/engineering/architecture/architecture.md:107 （池案 D V12 组）
 	if not m.start_adventure(401):
 		Kit.check_quiet(false, "V12 前置：冒险启动")
 		return
@@ -161,7 +161,7 @@ func check_v12(m, db) -> void:
 
 
 func check_v8(c, db) -> void:
-# oracle: design/engineering/architecture/architecture.md:107 （池案 D V8 组）
+# 判据出处: design/engineering/architecture/architecture.md:107 （池案 D V8 组）
 	if not c.start_adventure(203):
 		Kit.check_quiet(false, "V8 前置：冒险启动")
 		return
diff --git a/game/tests/unit/core/run_time_fatal_test.gd b/game/tests/unit/core/run_time_fatal_test.gd
index 4df2ce6a..597e81fa 100644
--- a/game/tests/unit/core/run_time_fatal_test.gd
+++ b/game/tests/unit/core/run_time_fatal_test.gd
@@ -20,7 +20,7 @@ const TAG_OK := "board_gen"   # 在册合法标签（PURPOSE_TAGS 含；wr7 必
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:199 （运行期违约通道——致命真的会死组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:199 （运行期违约通道——致命真的会死组）
 	var db = ConfigDBScript.new()
 	if not db.load_tables("res://data/tables", true):
 		push_error("[run_time_fatal_test] 表加载失败——夹具不可用（回归）")
@@ -45,7 +45,7 @@ func _init() -> void:
 
 # 缺省形态（契约 2）：不接组装点的协作件违约只落自身 push_error+assert，不外溢封印
 func _default_form(db) -> bool:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	var rng = RngScript.new()
 	rng.set_master_seed(3)
 	var oc = OrchestratorScript.new(db, rng)
@@ -70,7 +70,7 @@ func _default_form(db) -> bool:
 # （棋盘生成半边：装板域拆件后生成器随 BoardInstaller 件内自建——组装点＝引用束 fatal_cb 接线，
 #   经新组装点构建后触发生成器违约，封印传导断言不变）
 func _seal_propagation(db) -> bool:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	var rng_a = RngScript.new()
 	rng_a.set_master_seed(5)
 	var oc_bg = OrchestratorScript.new(db, rng_a)
@@ -92,7 +92,7 @@ func _seal_propagation(db) -> bool:
 
 # ②wr6（p6）：未知用途标签 → handler 记录位为真（判据主体）＋拿不到可用 RNG；合法标签对照另行验过
 func _unknown_tag_channel() -> bool:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	var rng_bad = RngScript.new()
 	rng_bad.set_master_seed(7)
 	if not _inject_handler(rng_bad, "wr6"):
@@ -111,7 +111,7 @@ func _unknown_tag_channel() -> bool:
 
 # ③wr7（p7）：未播种取数 → handler 记录位为真＋拿不到可用 RNG；同标签播种对照另行验过
 func _unseeded_channel() -> bool:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	var rng_bad = RngScript.new()   # 不播种（_master_seed 缺省 -1）
 	if not _inject_handler(rng_bad, "wr7"):
 		return false
@@ -129,7 +129,7 @@ func _unseeded_channel() -> bool:
 
 # 成员在位前提检查（成员被移除时走干净退出 2，不落「赋值不存在的属性」式中途中断）
 func _inject_handler(rng, label: String) -> bool:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	if not (rng.get("violation_handler") is Callable):
 		push_error("[run_time_fatal_test/%s] violation_handler 成员缺失（p6/p7 形态未实装——回归）" % label)
 		return false
diff --git a/game/tests/unit/core/save_boot_no_activate_test.gd b/game/tests/unit/core/save_boot_no_activate_test.gd
index 87aced80..09ddf19a 100644
--- a/game/tests/unit/core/save_boot_no_activate_test.gd
+++ b/game/tests/unit/core/save_boot_no_activate_test.gd
@@ -22,7 +22,7 @@ func _init() -> void:
 
 # ① 无参实例（autoload 实例化形态）＝无激活态＋默认合法空态（sv2 类级）
 func _test_no_arg_instance_has_no_activation() -> void:
-# oracle: design/gdd/systems/表现与支撑/存档序列化.md:61 （启动态无激活不读写组）
+# 判据出处: design/gdd/systems/表现与支撑/存档序列化.md:61 （启动态无激活不读写组）
 	var sm := SaveManagerScript.new()
 	Kit.check_quiet(sm.slots.active_slot() == 0 and not sm.slots.has_write_target(),
 		"sv2 无参实例无激活态（路径空/激活号 0/写盘目标空）〔卡① sv2〕")
@@ -41,7 +41,7 @@ func _test_no_arg_instance_has_no_activation() -> void:
 # 判别锚：空 _path 的退化写目标=裸 ".tmp"（落 res://，拆闸实验实测杂散落点）——
 # 断言先清退化目标再核零新增，闸短路缺陷（拒绝口旁路、写盘真实发生）必红。
 func _test_write_rejected_without_target() -> void:
-# oracle: design/gdd/systems/表现与支撑/存档序列化.md:61 （无激活态写盘拒绝组）
+# 判据出处: design/gdd/systems/表现与支撑/存档序列化.md:61 （无激活态写盘拒绝组）
 	var sm := SaveManagerScript.new()
 	var before := {}
 	for i in range(1, 4):
@@ -81,7 +81,7 @@ func _test_write_rejected_without_target() -> void:
 # （生产结算链全段在位：mark_first_adventure_done→apply_adventure_summary→refresh_treasure_unlocks
 #   →write_to_disk；无激活态下落账内存、写盘拒绝、盘面零触碰——已知中间态的机检面）
 func _test_settle_chain_write_rejected() -> void:
-# oracle: design/gdd/systems/表现与支撑/存档序列化.md:61 （结算链写盘拒绝组）
+# 判据出处: design/gdd/systems/表现与支撑/存档序列化.md:61 （结算链写盘拒绝组）
 	var db = load("res://core/config_db.gd").new()
 	if not db.load_tables("res://data/tables", false):
 		Kit.check_quiet(false, "sv3 链测试前置：数值表加载失败〔卡① sv3〕")
@@ -104,7 +104,7 @@ func _test_settle_chain_write_rejected() -> void:
 
 # ③ 越界槽号三原语拒绝＋窥视越界返回不可读（原语边界 fail-safe）
 func _test_out_of_range_slots_rejected() -> void:
-# oracle: design/gdd/systems/表现与支撑/存档序列化.md:61 （三存档位域界——越域槽拒绝组）
+# 判据出处: design/gdd/systems/表现与支撑/存档序列化.md:61 （三存档位域界——越域槽拒绝组）
 	var sm := SaveManagerScript.new()
 	sm.slots.attach_slot_template("user://smoke_boot_noact_%d.json")
 	Kit.check_quiet(not sm.slots.activate_slot(0) and not sm.slots.activate_slot(4)
diff --git a/game/tests/unit/core/save_manager_domain_test.gd b/game/tests/unit/core/save_manager_domain_test.gd
index c2c1a639..1d9a7386 100644
--- a/game/tests/unit/core/save_manager_domain_test.gd
+++ b/game/tests/unit/core/save_manager_domain_test.gd
@@ -19,7 +19,7 @@ var _db
 
 
 func _init() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	_db = ConfigDBScript.new()
 	# 表加载失败不中止（承 G2–G5 同款：表损坏的红落在具体断言上）
 	var load_ok: bool = _db.load_tables("res://data/tables", true)
@@ -47,7 +47,7 @@ func _fresh_rng(seed_val: int):
 # 损坏兜底/迁移链/域界干净/摘要 cap/摘要跨系统块/生涯终身计数域 v6）。测试文件统一 user://smoke_save_*.json 隔离，
 # 段首清场+段尾清理——绝不碰 user://save.json（红线）。
 func _smoke_save() -> void:
-# oracle: design/gdd/systems/表现与支撑/存档序列化.md:176 （存档域读写往返/迁移链/损坏兜底/域界组）
+# 判据出处: design/gdd/systems/表现与支撑/存档序列化.md:176 （存档域读写往返/迁移链/损坏兜底/域界组）
 	print("--- SaveManager 存档读写/迁移/兜底 ---")
 	var sm_script = load("res://core/save_manager.gd")
 	var paths := ["user://smoke_save_roundtrip.json", "user://smoke_save_fresh.json",
@@ -340,7 +340,7 @@ func _smoke_save() -> void:
 # 测试文件统一 user://smoke_save_slot_%d.json 模板隔离（attach_slot_template 注入口——禁各自拼槽名），
 # 段首清场+段尾清理——绝不碰 user://save.json 与真实槽 user://save_slot_N.json（红线）。
 func _smoke_save_slots() -> void:
-# oracle: design/gdd/systems/表现与支撑/存档序列化.md:61 （三槽位与摘要 cap——槽位域组）
+# 判据出处: design/gdd/systems/表现与支撑/存档序列化.md:61 （三槽位与摘要 cap——槽位域组）
 	print("--- SaveManager 三存档位承载（迭代 33 卡①）---")
 	var sm_script = load("res://core/save_manager.gd")
 	var slot_tpl := "user://smoke_save_slot_%d.json"
diff --git a/game/tests/unit/core/save_slot_isolation_test.gd b/game/tests/unit/core/save_slot_isolation_test.gd
index 743d77c1..2920be7f 100644
--- a/game/tests/unit/core/save_slot_isolation_test.gd
+++ b/game/tests/unit/core/save_slot_isolation_test.gd
@@ -38,7 +38,7 @@ func _write_v7_keystone(path: String, keystone: int) -> void:
 
 # ① 三槽往返：各槽写异值 → 写盘 → 新实例按位读回逐域相等；改槽 1 槽 2 字节不动（sv1）
 func _test_three_slot_roundtrip_and_isolation() -> void:
-# oracle: design/gdd/systems/表现与支撑/存档序列化.md:61 （三槽位独立文件隔离组）
+# 判据出处: design/gdd/systems/表现与支撑/存档序列化.md:61 （三槽位独立文件隔离组）
 	var t := SaveManagerScript.new()
 	t.slots.attach_slot_template(TPL)
 	for i in range(1, 4):
@@ -66,7 +66,7 @@ func _test_three_slot_roundtrip_and_isolation() -> void:
 
 # ② 高版本槽进档失败：拒绝＋恢复切换前三态（路径/激活号/数据）＋拒读槽零误写（sv9/sv10）
 func _test_activate_failure_restores_previous_slot() -> void:
-# oracle: design/gdd/systems/表现与支撑/存档序列化.md:61 （激活失败回滚组）
+# 判据出处: design/gdd/systems/表现与支撑/存档序列化.md:61 （激活失败回滚组）
 	var t := SaveManagerScript.new()
 	t.slots.attach_slot_template(TPL)
 	_write_v7_keystone(TPL % 1, 311)
@@ -88,7 +88,7 @@ func _test_activate_failure_restores_previous_slot() -> void:
 
 # ③ MetaProgression 宿主链切槽：引用同一性保持＋写盘落当前槽（sv10——禁换实例先例）
 func _test_metaprogression_reference_identity() -> void:
-# oracle: design/gdd/systems/表现与支撑/存档序列化.md:176 （元进度引用同一性——往返一致组）
+# 判据出处: design/gdd/systems/表现与支撑/存档序列化.md:176 （元进度引用同一性——往返一致组）
 	var t := SaveManagerScript.new()
 	t.slots.attach_slot_template(TPL)
 	_write_v7_keystone(TPL % 1, 533)
diff --git a/game/tests/unit/core/save_slot_summary_test.gd b/game/tests/unit/core/save_slot_summary_test.gd
index 47094660..6cbc987f 100644
--- a/game/tests/unit/core/save_slot_summary_test.gd
+++ b/game/tests/unit/core/save_slot_summary_test.gd
@@ -36,7 +36,7 @@ func _write_slot_json(path: String, content: String) -> void:
 
 # ① 三槽异值逐槽三项正确＋不激活不写内存（sv7）
 func _test_peek_three_slots_distinct_values() -> void:
-# oracle: design/gdd/systems/表现与支撑/存档序列化.md:174 （槽位摘要按槽窥视组）
+# 判据出处: design/gdd/systems/表现与支撑/存档序列化.md:174 （槽位摘要按槽窥视组）
 	var t := SaveManagerScript.new()
 	t.slots.attach_slot_template(TPL)
 	for i in range(1, 4):
@@ -58,7 +58,7 @@ func _test_peek_three_slots_distinct_values() -> void:
 
 # ② 空槽零值合法态＋不可读三态显式标记（sv7/契约 9）
 func _test_peek_empty_and_unreadable_states() -> void:
-# oracle: design/gdd/systems/表现与支撑/存档序列化.md:174 （坏槽三态组）
+# 判据出处: design/gdd/systems/表现与支撑/存档序列化.md:174 （坏槽三态组）
 	var t := SaveManagerScript.new()
 	t.slots.attach_slot_template(TPL)
 	DirAccess.remove_absolute(TPL % 3)   # 清①段残留——空槽夹具
@@ -79,7 +79,7 @@ func _test_peek_empty_and_unreadable_states() -> void:
 
 # ③ 窥视零副作用：字节+mtime 双比对不变＋零 .corrupt.bak 改名（sv8——真实入口冒烟段同判据）
 func _test_peek_zero_side_effect() -> void:
-# oracle: design/gdd/systems/表现与支撑/存档序列化.md:174 （窥视零副作用组）
+# 判据出处: design/gdd/systems/表现与支撑/存档序列化.md:174 （窥视零副作用组）
 	var t := SaveManagerScript.new()
 	t.slots.attach_slot_template(TPL)
 	_write_slot_json(TPL % 1, "corrupt bytes {{{{")
diff --git a/game/tests/unit/core/settle_segments_test.gd b/game/tests/unit/core/settle_segments_test.gd
index d209504c..0eaa756e 100644
--- a/game/tests/unit/core/settle_segments_test.gd
+++ b/game/tests/unit/core/settle_segments_test.gd
@@ -9,7 +9,7 @@ const Kit := preload("res://tests/unit/test_kit.gd")
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/战斗循环/战斗结算.md:362 （结算五段 Segment——五段全序组）
+# 判据出处: design/gdd/systems/战斗循环/战斗结算.md:362 （结算五段 Segment——五段全序组）
 	var db = load("res://core/config_db.gd").new()
 	if not db.load_tables("res://data/tables", false):
 		print("[settle_segments_test] FAIL — 数值表加载失败")
diff --git a/game/tests/unit/core/treasure_effects_test.gd b/game/tests/unit/core/treasure_effects_test.gd
index 3a989daa..a23cdcd7 100644
--- a/game/tests/unit/core/treasure_effects_test.gd
+++ b/game/tests/unit/core/treasure_effects_test.gd
@@ -10,7 +10,7 @@ const Kit := preload("res://tests/unit/test_kit.gd")
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/跨局循环/秘宝.md:246 （秘宝 12 件逐件行为——效果行为组）
+# 判据出处: design/gdd/systems/跨局循环/秘宝.md:246 （秘宝 12 件逐件行为——效果行为组）
 	var db = load("res://core/config_db.gd").new()
 	if not db.load_tables("res://data/tables", false):
 		Kit.check_quiet(false, "数值表加载")
diff --git a/game/tests/unit/core/treasure_items_test.gd b/game/tests/unit/core/treasure_items_test.gd
index f998c777..748e3022 100644
--- a/game/tests/unit/core/treasure_items_test.gd
+++ b/game/tests/unit/core/treasure_items_test.gd
@@ -53,7 +53,7 @@ func _all_revealed(_c: Vector2i) -> bool:
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/跨局循环/秘宝.md:246 （秘宝结构冻结与护栏校验——结构组）
+# 判据出处: design/gdd/systems/跨局循环/秘宝.md:246 （秘宝结构冻结与护栏校验——结构组）
 	# ① 授予归因+受理序+Used 不可逆
 	var inv = _new_inv()
 	var r1: Dictionary = inv.add_item("sapper_order", "safe_cell", Vector2i(3, 4), 2)
diff --git a/game/tests/unit/core/tree_requires_level_test.gd b/game/tests/unit/core/tree_requires_level_test.gd
index e3b1a907..5c35eced 100644
--- a/game/tests/unit/core/tree_requires_level_test.gd
+++ b/game/tests/unit/core/tree_requires_level_test.gd
@@ -7,7 +7,7 @@ extends SceneTree
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/跨局循环/天赋树.md:195 （等级阈值前置：schema 四拒一过＋判定三态＋投影两态组）
+# 判据出处: design/gdd/systems/跨局循环/天赋树.md:195 （等级阈值前置：schema 四拒一过＋判定三态＋投影两态组）
 	var failures := 0
 	var db = load("res://core/config_db.gd").new()
 	var mt = load("res://data/schemas/meta_tree_table.gd").new()
diff --git a/game/tests/unit/core/tree_rules_v11_test.gd b/game/tests/unit/core/tree_rules_v11_test.gd
index f737a0d9..dbb464e0 100644
--- a/game/tests/unit/core/tree_rules_v11_test.gd
+++ b/game/tests/unit/core/tree_rules_v11_test.gd
@@ -12,7 +12,7 @@ extends SceneTree
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/跨局循环/天赋树.md:194 （结构封闭：六键合成行闭集校验组）
+# 判据出处: design/gdd/systems/跨局循环/天赋树.md:194 （结构封闭：六键合成行闭集校验组）
 	var eng = load("res://core/effect_engine.gd")
 	var tree_tbl = load("res://data/schemas/meta_tree_table.gd")
 	var db = load("res://core/config_db.gd").new()
@@ -89,7 +89,7 @@ func _init() -> void:
 # ---- 规则键参数域校验（架构整改批 R1——六键参数字典）：正例全过/缺参数拒/多参数拒/越域拒/非字典拒 ----
 
 func _test_rule_key_params(eng, tree_tbl, db) -> Array:
-# oracle: design/gdd/systems/跨局循环/天赋树.md:194 （规则键参数字典——参数名/取值域合规组）
+# 判据出处: design/gdd/systems/跨局循环/天赋树.md:194 （规则键参数字典——参数名/取值域合规组）
 	var errs: Array = []
 	var params_tbl: Dictionary = tree_tbl.RULE_KEY_PARAMS
 	# 正例：meta_tree.tres 现行 Fork 行逐键过 validate（加载期已验——此处显式复核）
diff --git a/game/tests/unit/cross_system_flow_test.gd b/game/tests/unit/cross_system_flow_test.gd
index 5c0e8610..86a0e484 100644
--- a/game/tests/unit/cross_system_flow_test.gd
+++ b/game/tests/unit/cross_system_flow_test.gd
@@ -20,7 +20,7 @@ var _db
 
 
 func _init() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	_db = ConfigDBScript.new()
 	# 表加载失败不中止（承 G2–G5 同款：表损坏的红落在具体断言上）
 	var load_ok: bool = _db.load_tables("res://data/tables", true)
@@ -47,7 +47,7 @@ func _fresh_rng(seed_val: int):
 # ---- ① RNG 事件日志会话落盘（源 `_initialize` :70，主会话裁决一改判跨系统闭环承载——
 # 驱动沿源 :60–70 取号序列自持：master 种子 42 → 前置取号 → new_adventure 开日志会话 → 会话内取号）----
 func _rng_event_log_session() -> void:
-# oracle: design/engineering/architecture/architecture.md:90 （事件日志落盘会话组）
+# 判据出处: design/engineering/architecture/architecture.md:90 （事件日志落盘会话组）
 	var rng = load("res://core/rng_service.gd").new()
 	rng.set_master_seed(42)
 	rng.open_stream("board_gen")
@@ -62,7 +62,7 @@ func _rng_event_log_session() -> void:
 # _on_level_finished(victory)＋breakpoint_snapshot 取读＋clear_breakpoint；
 # 起局与兑付两步的受理断言留单元宿主（adventure_feats_test），此处纯驱动——前置失败自然落红）----
 func _feats_breakpoint_roundtrip() -> void:
-# oracle: design/gdd/systems/表现与支撑/存档序列化.md:180 （专长断点附随件往返组）
+# 判据出处: design/gdd/systems/表现与支撑/存档序列化.md:180 （专长断点附随件往返组）
 	var rt := FeatTable.new()
 	rt.rows = [
 		{"feat_id": "x1", "display_name": "试一", "rarity": "common", "desc": "测试揭示", "cap": 1,
@@ -108,7 +108,7 @@ func _feats_breakpoint_roundtrip() -> void:
 # level_autoplay 真局摘要 → apply 原语 → 域读数 → 写盘读回保持；临时档 user://smoke_save_integration.json
 # 段首清场+段尾清理（源 _smoke_save 隔离纪律），绝不碰 user://save.json（红线））----
 func _save_summary_integration() -> void:
-# oracle: design/gdd/systems/跨局循环/元进度.md:150 （摘要跨系统块与钥石只增不减组）
+# 判据出处: design/gdd/systems/跨局循环/元进度.md:150 （摘要跨系统块与钥石只增不减组）
 	var sm_script = load("res://core/save_manager.gd")
 	var path9 := "user://smoke_save_integration.json"   # 源 paths[8]
 	if FileAccess.file_exists(path9):
@@ -141,7 +141,7 @@ func _save_summary_integration() -> void:
 # ---- ④ 试玩记录仪（源 `_smoke_playtest_logger` 整套八条，主会话裁决七改判跨系统闭环承载——
 # PlaytestLogger 挂真实结算流：会话文件/逐结算快照/字段齐备/spawn_count 回归/诊断转储/JSONL 回读）----
 func _smoke_playtest_logger() -> void:
-# oracle: design/engineering/code-conventions.md:40 （试玩日志器跨系统接线组）
+# 判据出处: design/engineering/code-conventions.md:40 （试玩日志器跨系统接线组）
 	print("--- PlaytestLogger（结算快照 JSONL + 诊断转储）---")
 	var rng = load("res://core/rng_service.gd").new()
 	rng.set_master_seed(20260912)
diff --git a/game/tests/unit/data_config/config_db_fatal_oob_test.gd b/game/tests/unit/data_config/config_db_fatal_oob_test.gd
index b67e2f72..f7f5664d 100644
--- a/game/tests/unit/data_config/config_db_fatal_oob_test.gd
+++ b/game/tests/unit/data_config/config_db_fatal_oob_test.gd
@@ -12,7 +12,7 @@ var _db
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:200 致命真的会死：正式通道加载进程非 0 退出（装载前提组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:200 致命真的会死：正式通道加载进程非 0 退出（装载前提组）
 	_db = ConfigDBScript.new()
 	var load_ok: bool = _db.load_tables("res://data/tables", true)
 	if not load_ok:
@@ -24,7 +24,7 @@ func _init() -> void:
 
 
 func _trigger_oob() -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:204 越域请求在进入解析前致命中止（Fatal 级诊断＋进程非 0，无兜底）（越域组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:204 越域请求在进入解析前致命中止（Fatal 级诊断＋进程非 0，无兜底）（越域组）
 	# 共享 .tres 上的 resolver 归最后装载的实例——autoload ConfigDB 的 _ready 在测试 _init 之后
 	# 二次注入覆盖私有实例，故触发前把解析通道归还被测实例（诊断落 _db，退出码判据才成立）
 	_db.combat.board_gen._resolver = _db._resolver
diff --git a/game/tests/unit/data_config/config_db_test.gd b/game/tests/unit/data_config/config_db_test.gd
index 058bbc43..39646e80 100644
--- a/game/tests/unit/data_config/config_db_test.gd
+++ b/game/tests/unit/data_config/config_db_test.gd
@@ -9,7 +9,7 @@ const Kit := preload("res://tests/unit/test_kit.gd")   # T6 收口：_check/汇
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:198 干净检出：表清单内全部表加载成功、就绪态断言（装载组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:198 干净检出：表清单内全部表加载成功、就绪态断言（装载组）
 	var db = ConfigDBScript.new()
 	var load_ok: bool = db.load_tables("res://data/tables", true)
 	Kit.check("全部表加载 + 校验通过（含跨表护栏零 error 诊断）〔fv6〕", load_ok and db.diagnostics_count("error") == 0)
@@ -31,7 +31,7 @@ func _init() -> void:
 # ---- 进度坐标 ceil 解析（R1：向上下取整保证偏难；越最大行 clamp 取最大值 + 警告去重）----
 
 func _test_progress_resolution(db) -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:203 向上取整解析：请求无精确行返回不低于请求坐标的最近行（进度查行组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:203 向上取整解析：请求无精确行返回不低于请求坐标的最近行（进度查行组）
 	var bg_rows: Array = db.combat.board_gen.rows
 	# 行键全集自表推导（禁写死关卡/深度数值）
 	var level_keys: Array = []
@@ -88,7 +88,7 @@ func _test_progress_resolution(db) -> void:
 # ---- 变异池门控（unlock_level 闸 + ∅ board_types 通配 + 节点身份第三维）----
 
 func _test_variant_pool_gate(db) -> void:
-# oracle: design/gdd/systems/排雷循环/地形变异.md:153 候选池空合法：门控筛空时静默零布置（变异门控组）
+# 判据出处: design/gdd/systems/排雷循环/地形变异.md:153 候选池空合法：门控筛空时静默零布置（变异门控组）
 	var rows: Array = db.combat.variation.rows
 	var gated_row := {}
 	var wildcard_row := {}
@@ -131,7 +131,7 @@ func _rows_contain(pool: Array, row: Dictionary) -> bool:
 # ---- ShopTable 消费面（行集解析单点——runner/编排禁自扫表的契约消费侧验证）----
 
 func _test_shop_accessors(db) -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:199 校验类别全覆盖：行结构与引用闭合（商店访问器行结构组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:199 校验类别全覆盖：行结构与引用闭合（商店访问器行结构组）
 	var products: Array = db.run.shop.product_rows()
 	if products.is_empty():
 		Kit.check("ShopTable products 行族非空（表已已入库前提）", false)
@@ -159,7 +159,7 @@ func _test_shop_accessors(db) -> void:
 # ---- MetaTable 消费面 ----
 
 func _test_meta_accessors(db) -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:199 校验类别全覆盖：行结构与引用闭合（元进度访问器行结构组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:199 校验类别全覆盖：行结构与引用闭合（元进度访问器行结构组）
 	# 无 forge_products 行族断言（行族/访问器不在表，V20 清单）
 	var key_rows: Array = db.crossrun.meta.boss_keystone
 	if not key_rows.is_empty():
@@ -179,7 +179,7 @@ func _test_meta_accessors(db) -> void:
 # ---- TABLE_MANIFEST ↔ data/tables 目录同步（各系统→D2 单点契约的登记面）----
 
 func _test_manifest_dir_sync(db) -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:198 表目录无清单外文件（清单对账组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:198 表目录无清单外文件（清单对账组）
 	var manifest: Dictionary = db.TABLE_MANIFEST
 	var dir := DirAccess.open("res://data/tables")
 	var disk_files: Array = []
@@ -204,7 +204,7 @@ func _test_manifest_dir_sync(db) -> void:
 # （rowset_rule——行序即契约，R6 加载期兜底）③行集实例总数 ≤4（骰后值运行面，spawn 守卫——冒烟侧验证）。
 
 func _test_rowset_discipline() -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:199 校验类别：重复键与缺锚行逐类断言（行集纪律组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:199 校验类别：重复键与缺锚行逐类断言（行集纪律组）
 	# 行集用 rows.assign([...]) 而非直接赋值：rows 是 Array[Dictionary] 定型属性，直接赋 untyped
 	# 数组字面量会触发「Invalid assignment」脚本错误——该错误不改退出码，却会**中断本函数剩余断言**
 	#（本函数五条纪律断言曾因此全部静默不跑，套件仍报 all green，是零覆盖假象）。
diff --git a/game/tests/unit/data_config/counter_prefix_fatal_test.gd b/game/tests/unit/data_config/counter_prefix_fatal_test.gd
index 6b09280e..49fff507 100644
--- a/game/tests/unit/data_config/counter_prefix_fatal_test.gd
+++ b/game/tests/unit/data_config/counter_prefix_fatal_test.gd
@@ -20,7 +20,7 @@ const PROBE_REF := ' {\n  "feat_id": "ref_probe",\n  "display_name": "引用探
 
 
 func _inject(dir: String, probe: String) -> bool:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:199 校验类别全覆盖：前缀违规夹具注入（前缀夹具组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:199 校验类别全覆盖：前缀违规夹具注入（前缀夹具组）
 	var path := dir + "/feats.tres"
 	var f := FileAccess.open(path, FileAccess.READ)
 	if f == null:
@@ -45,7 +45,7 @@ func _inject(dir: String, probe: String) -> bool:
 
 
 func _assert_rejected(bad_dir: String, probe: String, label: String) -> bool:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:200 致命真的会死：违规表拒绝且进程非 0（拒绝判定组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:200 致命真的会死：违规表拒绝且进程非 0（拒绝判定组）
 	# 返回 true=正确拒绝；false=放行或夹具失败（调用方据此退出 2）
 	if not Kit.copy_tables(SRC_DIR, bad_dir) or not _inject(bad_dir, probe):
 		push_error("[%s] 夹具目录准备失败" % label)
diff --git a/game/tests/unit/data_config/effect_kind_retired_test.gd b/game/tests/unit/data_config/effect_kind_retired_test.gd
index b3476417..3f20ece2 100644
--- a/game/tests/unit/data_config/effect_kind_retired_test.gd
+++ b/game/tests/unit/data_config/effect_kind_retired_test.gd
@@ -39,7 +39,7 @@ const PROBE_TRADE_KEY := ' {
 
 
 func _inject(dir: String, probe: String) -> bool:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:199 校验类别全覆盖：退役词夹具注入（退役词夹具组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:199 校验类别全覆盖：退役词夹具注入（退役词夹具组）
 	var path := dir + "/feats.tres"
 	var f := FileAccess.open(path, FileAccess.READ)
 	if f == null:
@@ -64,7 +64,7 @@ func _inject(dir: String, probe: String) -> bool:
 
 
 func _assert_rejected(bad_dir: String, probe: String, label: String) -> bool:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:200 致命真的会死：退役词加载致命中止（拒绝判定组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:200 致命真的会死：退役词加载致命中止（拒绝判定组）
 	# 返回 true=正确拒绝；false=放行或夹具失败（调用方据此退出 2）
 	if not Kit.copy_tables(SRC_DIR, bad_dir) or not _inject(bad_dir, probe):
 		push_error("[%s] 夹具目录准备失败" % label)
diff --git a/game/tests/unit/data_config/elite_row_test.gd b/game/tests/unit/data_config/elite_row_test.gd
index b915df38..fd7d2be3 100644
--- a/game/tests/unit/data_config/elite_row_test.gd
+++ b/game/tests/unit/data_config/elite_row_test.gd
@@ -58,7 +58,7 @@ func _count_cat(errs: Array, cat: String) -> int:
 
 # ---- R1：elite 行类合法与字段互锁、引用校验（合法零错＋十一违例各自「含」预期类别）----
 func _test_elite_validation_rejects() -> void:
-# oracle: design/gdd/systems/战斗循环/敌人系统.md:325 elite 行字段互锁与基础引用违例加载期返回错误
+# 判据出处: design/gdd/systems/战斗循环/敌人系统.md:325 elite 行字段互锁与基础引用违例加载期返回错误
 	var t_ok = EnemyTableScript.new()
 	t_ok.rows.assign(_legal_rows())
 	var errs: Array = t_ok.validate()
@@ -130,7 +130,7 @@ func _validate_rows(rows: Array) -> Array:
 
 # ---- R2：有效池＝基础池＋附加技，基础池取深度带最小行（深带行在前防取首行假绿）----
 func _test_effective_pool_merge() -> void:
-# oracle: design/gdd/systems/战斗循环/敌人系统.md:149 精英有效池＝同关战斗行类基础敌种深度带最小行的池＋附加技
+# 判据出处: design/gdd/systems/战斗循环/敌人系统.md:149 精英有效池＝同关战斗行类基础敌种深度带最小行的池＋附加技
 	var rows := [
 		_mk_row(1, "battle", 3, "goblin"),   # 深带行在前（取首行的错误实现必红）
 		_mk_row(1, "battle", 0, "goblin"),
@@ -155,7 +155,7 @@ func _test_effective_pool_merge() -> void:
 
 # ---- R3：继承不复制——基础池改表传到精英、改写返回数组不回灌 ----
 func _test_base_pool_change_propagates() -> void:
-# oracle: design/gdd/systems/战斗循环/敌人系统.md:149 继承不复制——基础池调参自动传到精英
+# 判据出处: design/gdd/systems/战斗循环/敌人系统.md:149 继承不复制——基础池调参自动传到精英
 	var rows := [
 		_mk_row(1, "battle", 3, "goblin"),
 		_mk_row(1, "battle", 0, "goblin"),
@@ -181,7 +181,7 @@ func _test_base_pool_change_propagates() -> void:
 
 # ---- R4：合并池过池构成纪律（跨表件校验对象=合并后的池）----
 func _test_merged_pool_composition() -> void:
-# oracle: design/gdd/systems/战斗循环/敌人系统.md:150 池构成纪律校验对象是合并后的池
+# 判据出处: design/gdd/systems/战斗循环/敌人系统.md:150 池构成纪律校验对象是合并后的池
 	var skills := SkillTableScript.new()
 	skills.rows.assign([
 		{"skill_id": "attack", "type": "basic"},
@@ -239,7 +239,7 @@ func _msgs(errs: Array) -> Array[String]:
 
 # ---- R5：暂不接线——表里有 elite 行时寻址拿不到它（行类门改动特有判据）----
 func _test_elite_unreachable_by_encounter() -> void:
-# oracle: design/gdd/systems/战斗循环/敌人系统.md:151 精英行接线前不会被任何节点读到
+# 判据出处: design/gdd/systems/战斗循环/敌人系统.md:151 精英行接线前不会被任何节点读到
 	_diags.clear()
 	var resolver = ResolverScript.new(
 		func(level, category, message) -> void:
@@ -272,7 +272,7 @@ func _test_elite_unreachable_by_encounter() -> void:
 
 # ---- R6：生产表地精精英落表（真实加载零错＋行值逐位＋有效池字典）----
 func _test_production_goblin_elite() -> void:
-# oracle: design/gdd/systems/战斗循环/敌人系统.md:147 精英＝敌人表行类为 elite 的独立一行
+# 判据出处: design/gdd/systems/战斗循环/敌人系统.md:147 精英＝敌人表行类为 elite 的独立一行
 	var db = load("res://core/config_db.gd").new()
 	var ok: bool = db.load_tables("res://data/tables", true)
 	Kit.check("生产表 ConfigDB.load_tables 装载（is_ready=%s）〔精英批 V6〕" % str(db.is_ready), ok and db.is_ready)
diff --git a/game/tests/unit/data_config/forge_table_test.gd b/game/tests/unit/data_config/forge_table_test.gd
index f4d4bc34..fc459ec0 100644
--- a/game/tests/unit/data_config/forge_table_test.gd
+++ b/game/tests/unit/data_config/forge_table_test.gd
@@ -12,7 +12,7 @@ const Kit := preload("res://tests/unit/test_kit.gd")
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:198 锻造表装载与就绪态（装载组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:198 锻造表装载与就绪态（装载组）
 	var db = ConfigDBScript.new()
 	var load_ok: bool = db.load_tables("res://data/tables", true)
 	Kit.check("生产 forge.tres 随全表加载 + validate 零违例〔锻造工坊批 V1〕", load_ok and db.diagnostics_count("error") == 0)
@@ -27,7 +27,7 @@ func _init() -> void:
 # ---- 生产表六行正向（V1 生产面 + V11 行字段闭集）----
 
 func _test_production_rows(db) -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:199 校验类别全覆盖：行 schema 正反逐类断言（生产行结构组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:199 校验类别全覆盖：行 schema 正反逐类断言（生产行结构组）
 	var rows: Array = db.crossrun.forge.route_rows()
 	Kit.check("六路线行族规模恰 6（三武器+三甲）〔锻造工坊批 V1〕", rows.size() == 6)
 	var ids := []
@@ -91,7 +91,7 @@ func _test_production_rows(db) -> void:
 # ---- 几何价格梯（V2 价格面单测半边——购买写在 T3 冒烟）----
 
 func _test_price_ladder(db) -> void:
-# oracle: design/gdd/systems/跨局循环/锻造工坊.md:220 定价结构：每级价格随已购级数几何递增、基价与公比读表单点（价格梯组）
+# 判据出处: design/gdd/systems/跨局循环/锻造工坊.md:220 定价结构：每级价格随已购级数几何递增、基价与公比读表单点（价格梯组）
 	var row: Dictionary = db.crossrun.forge.route("sword")
 	var prices := []
 	for owned in range(5):
@@ -150,7 +150,7 @@ func _mut_spear_initial(t) -> void:
 
 
 func _test_negative_cases() -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:199 校验类别全覆盖（负向 schema 组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:199 校验类别全覆盖（负向 schema 组）
 	# 夹具本身须零违例（否则负向判读失效）
 	var t_ok = ForgeTableScript.new()
 	t_ok.routes = _base_rows()
@@ -219,7 +219,7 @@ func _test_negative_cases() -> void:
 # 32→31：改写族清退批摘 spike（CI run 87 追绿——词表合法收窄的断言随动）。
 
 func _test_effect_kinds_closed() -> void:
-# oracle: design/engineering/architecture/architecture.md:89 事件/事实/效果类型/算子四词表封闭（特效闭集组）
+# 判据出处: design/engineering/architecture/architecture.md:89 事件/事实/效果类型/算子四词表封闭（特效闭集组）
 	Kit.check("效果引擎效果类型闭集 31 种（甲案词表退役 overflow/attack_segments＋改写族清退摘 spike）〔锻造工坊批 V11〕",
 		EffectEngineScript.EFFECT_KINDS.size() == 31)
 	Kit.check("效果引擎事件词表在册 21 种（charge_full 位摘名——蓄力层删键批）〔锻造工坊批 V11〕",
diff --git a/game/tests/unit/data_config/level_gen_params_test.gd b/game/tests/unit/data_config/level_gen_params_test.gd
index cd87446a..a7a82c4c 100644
--- a/game/tests/unit/data_config/level_gen_params_test.gd
+++ b/game/tests/unit/data_config/level_gen_params_test.gd
@@ -11,7 +11,7 @@ const Kit := preload("res://tests/unit/test_kit.gd")
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:198 参数档表装载与就绪态（装载组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:198 参数档表装载与就绪态（装载组）
 	var db = ConfigDBScript.new()
 	var load_ok: bool = db.load_tables("res://data/tables", true)
 	Kit.check("生产 level_gen_params.tres 随全表加载 + validate 零违例〔fv2〕",
@@ -43,7 +43,7 @@ func _table(rows: Array) -> Variant:
 # ---- 生产三行正向（V2）----
 
 func _test_production(db) -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点图生成.md:127 产出合格：任意参数档产出的图必过产出约束（生产档组）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点图生成.md:127 产出合格：任意参数档产出的图必过产出约束（生产档组）
 	var r1: Dictionary = db.run.level_gen_params.row_by_level_index(1)
 	var r2: Dictionary = db.run.level_gen_params.row_by_level_index(2)
 	var r3: Dictionary = db.run.level_gen_params.row_by_level_index(3)
@@ -61,7 +61,7 @@ func _test_production(db) -> void:
 # ---- 访问器缺行防御 ----
 
 func _test_accessor() -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点图生成.md:127 参数档访问器读回与产出约束（访问器组）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点图生成.md:127 参数档访问器读回与产出约束（访问器组）
 	var t = _table([_row(1, 6, 0.3, [0.5, 0.2, 0.2, 0.1], 1, 1, 4)])
 	Kit.check("row_by_level_index 缺行返回空字典〔fv2〕", t.row_by_level_index(9).is_empty())
 
@@ -69,7 +69,7 @@ func _test_accessor() -> void:
 # ---- 域校验逐类负向（V2）----
 
 func _test_negative() -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:199 校验类别全覆盖：参数档 schema 拒绝（负向组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:199 校验类别全覆盖：参数档 schema 拒绝（负向组）
 	# 合法基线三行
 	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),
diff --git a/game/tests/unit/data_config/reward_dangling_treasure_test.gd b/game/tests/unit/data_config/reward_dangling_treasure_test.gd
index 5f7d785a..98a54738 100644
--- a/game/tests/unit/data_config/reward_dangling_treasure_test.gd
+++ b/game/tests/unit/data_config/reward_dangling_treasure_test.gd
@@ -14,7 +14,7 @@ const BAD_DIR := "user://treasure_fixture_dangling"
 
 
 func _inject_violation() -> bool:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:199 校验类别：悬空引用夹具（悬空引用组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:199 校验类别：悬空引用夹具（悬空引用组）
 	var path := BAD_DIR + "/reward.tres"
 	var f := FileAccess.open(path, FileAccess.READ)
 	if f == null:
@@ -37,7 +37,7 @@ func _inject_violation() -> bool:
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:200 致命真的会死：悬空引用被拒绝、进程非 0（拒绝组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:200 致命真的会死：悬空引用被拒绝、进程非 0（拒绝组）
 	if not Kit.copy_tables(SRC_DIR, BAD_DIR) or not _inject_violation():
 		push_error("[reward_dangling_treasure_test] 夹具目录准备失败")
 		quit(2)
diff --git a/game/tests/unit/data_config/rng_service_test.gd b/game/tests/unit/data_config/rng_service_test.gd
index b2c31fd6..46283b93 100644
--- a/game/tests/unit/data_config/rng_service_test.gd
+++ b/game/tests/unit/data_config/rng_service_test.gd
@@ -12,7 +12,7 @@ const TEST_SEED := 20260928   # 夹具种子（任意固定值；语义 = 可复
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:201 黄金向量：登记向量逐个复算（装载组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:201 黄金向量：登记向量逐个复算（装载组）
 	_test_derive_determinism()
 	_test_counter_ledger()
 	_test_stream_draw_determinism()
@@ -28,7 +28,7 @@ func _fresh_service():
 
 # 单盐派生纯函数：两全新实例同种子逐位一致（derive_at 不推计数器——纯函数契约）
 func _test_derive_determinism() -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:201 黄金向量：随机派生纯函数对登记向量逐个复算相等、同输入恒同输出（派生确定性组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:201 黄金向量：随机派生纯函数对登记向量逐个复算相等、同输入恒同输出（派生确定性组）
 	var a = _fresh_service()
 	var b = _fresh_service()
 	var same := true
@@ -44,7 +44,7 @@ func _test_derive_determinism() -> void:
 
 # 全局取数计数器：唯一账本——open_stream 逐次 +1（scope 单调）
 func _test_counter_ledger() -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:202 计数器纪律：连续取号跨模拟关卡切换单调不重置（计数账本组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:202 计数器纪律：连续取号跨模拟关卡切换单调不重置（计数账本组）
 	var rng = _fresh_service()
 	var c0: int = rng.counter()
 	rng.open_stream("armor_roll")
@@ -62,7 +62,7 @@ func _test_counter_ledger() -> void:
 
 # 同种子两实例同标签流的实际取数序列逐位一致（回放确定性契约——存档快照=主种子+计数器的前提）
 func _test_stream_draw_determinism() -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:201 同输入恒同输出：流取号确定性（流取号组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:201 同输入恒同输出：流取号确定性（流取号组）
 	var faces := 20   # d20 探针面数（夹具值，非玩法表值——只用于产生可比较序列）
 	var a = _fresh_service()
 	var b = _fresh_service()
@@ -77,7 +77,7 @@ func _test_stream_draw_determinism() -> void:
 
 # 负输入 abs 归一化（警告通道）——|−s| 与 s 同派生
 func _test_negative_seed_normalization() -> void:
-# oracle: design/engineering/architecture/architecture.md:90 RngService：master_seed 与各流 scope 计数器单点（种子规约组）
+# 判据出处: design/engineering/architecture/architecture.md:90 RngService：master_seed 与各流 scope 计数器单点（种子规约组）
 	var pos = _fresh_service()
 	var neg = RngServiceScript.new()
 	neg.set_master_seed(-TEST_SEED)
diff --git a/game/tests/unit/data_config/rng_stream_boot_test.gd b/game/tests/unit/data_config/rng_stream_boot_test.gd
index 179d5591..eaea9c40 100644
--- a/game/tests/unit/data_config/rng_stream_boot_test.gd
+++ b/game/tests/unit/data_config/rng_stream_boot_test.gd
@@ -22,7 +22,7 @@ func _init() -> void:
 # 单元宿主改由 `_init` 显式调用，断言逐字未动；源 :70 事件日志落盘条经主会话裁决一
 # 改判跨系统闭环套件——不随本宿主，见迁移账本转办清单）----
 func _smoke_initialize() -> void:
-# oracle: design/engineering/architecture/architecture.md:90 RngService autoload：open_stream 有状态门面与启动初始化（启动流组）
+# 判据出处: design/engineering/architecture/architecture.md:90 RngService autoload：open_stream 有状态门面与启动初始化（启动流组）
 	print("=== Dungeon Sweeper 垂直切片冒烟 ===")
 	var db = ConfigDBScript.new()
 	var load_ok: bool = db.load_tables("res://data/tables", true)
diff --git a/game/tests/unit/data_config/table_structure_guard_test.gd b/game/tests/unit/data_config/table_structure_guard_test.gd
index f7247ec6..b43e7463 100644
--- a/game/tests/unit/data_config/table_structure_guard_test.gd
+++ b/game/tests/unit/data_config/table_structure_guard_test.gd
@@ -29,7 +29,7 @@ var _db
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:198 表结构守卫装载与就绪态（装载组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:198 表结构守卫装载与就绪态（装载组）
 	_db = ConfigDBScript.new()
 	# 表加载失败不中止（沿被迁断言面的源语义：表损坏的红落在具体断言上——
 	# 诊断在此展开，后续断言按坏表实况逐条验红；collect_only=true 下成员照常赋值可评）
@@ -92,7 +92,7 @@ func _first_encounter_band(level_index: int, enemy_id: String) -> int:
 
 # ① 冒险表（单行全局 Rule 4 豁免——建表与接线闸；TP0 令牌池：配额结构/件值对/池总量域检）
 func _smoke_adventure_table() -> void:
-# oracle: design/gdd/systems/冒险循环/冒险结构.md:281 冒险结构表校验（冒险表组）
+# 判据出处: design/gdd/systems/冒险循环/冒险结构.md:281 冒险结构表校验（冒险表组）
 	print("--- 冒险表（AdventureTable——令牌池行值单点：回血/配额/件值对/同调位）---")
 	Kit.check("db.adventure 已加载（adventure.tres 入 manifest）", _db.run.adventure != null)
 	if _db.run.adventure == null:
@@ -211,7 +211,7 @@ func _smoke_adventure_table() -> void:
 # ---- 敌人表深度带键结构（迭代 34 建·L1 混编批换代：30 行键序=覆盖表序·(1,3) 混编行集·Boss 行集带键清单·精英行）----
 
 func _smoke_enemy_bands() -> void:
-# oracle: design/gdd/systems/冒险循环/难度曲线与Boss.md:316 难度与敌人带校验（敌人带组）
+# 判据出处: design/gdd/systems/冒险循环/难度曲线与Boss.md:316 难度与敌人带校验（敌人带组）
 	print("--- 敌人表深度带键结构（30 行键序 · (1,3) 混编 · Boss 带键覆盖表 · 精英行）---")
 	# ① 30 行计数 + 键序 = 覆盖表序（文件行序不变——行序即契约；(1,3) 两行相邻、熊地精在前；精英行随精英专属池批）
 	#    迭代 35 生成图深度扩面覆盖批随动：战斗带顶扩到各关最大生成深度（L1→6／L2→9／L3→13）、
@@ -300,7 +300,7 @@ func _smoke_enemy_bands() -> void:
 # ④ 掷点参数域：档位边界升序/档位值降序无零档/骰面与暴击参数在域（加载校验双保险）。
 
 func _smoke_ac_swap_guard() -> void:
-# oracle: design/gdd/systems/跨局循环/锻造工坊.md:219 切换语义：一次冒险＝一个武器类型＋一个甲型，冒险开始后锁死（AC 换装守卫组）
+# 判据出处: design/gdd/systems/跨局循环/锻造工坊.md:219 切换语义：一次冒险＝一个武器类型＋一个甲型，冒险开始后锁死（AC 换装守卫组）
 	print("--- 护甲等级掷点批·换装护栏 ---")
 	# ① 三处无双轨
 	Kit.check("状态表 defense_up 行已退役（无双轨）", _db.combat.status_effects.row_by_id("defense_up").is_empty())
@@ -421,7 +421,7 @@ func _smoke_ac_swap_guard() -> void:
 # ---- 地形变异 框架面（四行两轴×两关 + 门控 + 跨字段互锁）----
 
 func _smoke_variation_framework() -> void:
-# oracle: design/gdd/systems/排雷循环/地形变异.md:153 候选池门控与静默零布置（变异框架组）
+# 判据出处: design/gdd/systems/排雷循环/地形变异.md:153 候选池门控与静默零布置（变异框架组）
 	print("--- 地形变异 框架面（首批四类型 + 候选池门控 + 跨字段互锁）---")
 	Kit.check("变异清单 6 行（荆棘丛/藤蔓缠绕/岩浆/烬覆 + 落石/矿尘——首批类型定稿批 + 第三关内容批；贫矿脉 2026-10-16 用户令屏蔽删行）",
 		_db.combat.variation.rows.size() == 6)
@@ -457,7 +457,7 @@ func _smoke_variation_framework() -> void:
 # ---- 难度曲线与Boss DifficultyTable 结构位冒烟（AC-10：空表零行为 + 套乘点 = 行值快照前）----
 
 func _smoke_difficulty_table() -> void:
-# oracle: design/gdd/systems/冒险循环/难度曲线与Boss.md:316 难度修饰套乘（难度表组）
+# 判据出处: design/gdd/systems/冒险循环/难度曲线与Boss.md:316 难度修饰套乘（难度表组）
 	print("--- 难度曲线与Boss·DifficultyTable 结构位 ---")
 	Kit.check("DifficultyTable MVP 空表加载（结构位）", _db.run.difficulty != null and _db.run.difficulty.rows.is_empty())
 	# ① 空表零行为：敌人系统.spawn 敌值 = EnemyTable 行值原样
@@ -488,7 +488,7 @@ func _smoke_difficulty_table() -> void:
 # ---- ⑤ 格面资源九型 + gp_drop 流（黄金向量）----
 
 func _smoke_nine_types_gp_stream() -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:199 校验类别全覆盖：九型 GP 流校验（九型流组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:199 校验类别全覆盖：九型 GP 流校验（九型流组）
 	print("--- 格面资源九型 + gp_drop 流（奖励字典 18 格 + 黄金向量）---")
 	Kit.check("格面资源十型封闭（第九型 gp 九型批 2026-09-20 / 第十型 treasure_item 秘宝内容批 2026-09-29——词表 v1.2）",
 		RewardTable.CELL_TYPES.size() == 10 and RewardTable.CELL_TYPES.has("gp") and RewardTable.CELL_TYPES.has("treasure_item"))
@@ -538,7 +538,7 @@ func _smoke_nine_types_gp_stream() -> void:
 # ---- 元进度·MetaTable 表结构（行值全 provisional 归元进度设计文档配读数；
 # conversion 覆盖恰三，Boss 两档 first ≥ repeat）----
 func _smoke_meta() -> void:
-# oracle: design/gdd/systems/跨局循环/元进度.md:148 元进度行族校验（meta 行族组）
+# 判据出处: design/gdd/systems/跨局循环/元进度.md:148 元进度行族校验（meta 行族组）
 	print("--- 元进度·MetaTable 表结构 ---")
 	var meta_tbl = _db.crossrun.meta
 	Kit.check("MetaTable 非空 + validate 零错（三行族词表封闭/唯一/连续/域界/first≥repeat/ratio 全过）",
@@ -578,7 +578,7 @@ func _conversion_row_of(rows: Array, attr: String) -> Dictionary:
 # ---- V7 节点图三新键域校验（架构整改——缺新键行拒/width_max 越域拒/两 pct 越域拒/表值全过）----
 
 func _test_level_gen_new_fields() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	var tbl = _db.run.level_gen_params
 	var mk := func(mod: Dictionary) -> Dictionary:
 		var row := {"level_index": 1, "layers": 6, "branch_density": 0.3, "battle_ratio": 0.5, "reward_ratio": 0.2,
@@ -615,7 +615,7 @@ func _test_level_gen_new_fields() -> void:
 # ---- 变异表头域校验 / feat cap 必填（架构整改——丁案三件的数据面守卫）----
 
 func _test_variation_header_domains() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	var inst = load("res://data/schemas/variation_table.gd").new()
 	inst.percent_of_cells = 5
 	inst.per_level_bonus = 0
@@ -633,7 +633,7 @@ func _test_variation_header_domains() -> void:
 
 
 func _test_feat_cap_required() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	var inst = load("res://data/schemas/feat_table.gd").new()
 	# 生产表全行 cap 在场（加载期已验——此处显式复核 37 行）
 	var all_cap := true
diff --git a/game/tests/unit/data_config/treasure_target_violation_test.gd b/game/tests/unit/data_config/treasure_target_violation_test.gd
index 99ba2573..da5ff235 100644
--- a/game/tests/unit/data_config/treasure_target_violation_test.gd
+++ b/game/tests/unit/data_config/treasure_target_violation_test.gd
@@ -15,7 +15,7 @@ const BAD_DIR := "user://treasure_fixture_target_violation"
 
 
 func _inject_violation() -> bool:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:199 校验类别全覆盖：违规夹具逐类注入（真视窄域夹具组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:199 校验类别全覆盖：违规夹具逐类注入（真视窄域夹具组）
 	var path := BAD_DIR + "/treasure_items.tres"
 	var f := FileAccess.open(path, FileAccess.READ)
 	if f == null:
@@ -40,7 +40,7 @@ func _inject_violation() -> bool:
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/表现与支撑/数据配置.md:200 致命真的会死：违规表被拒绝、进程非 0（违规拒绝组）
+# 判据出处: design/gdd/systems/表现与支撑/数据配置.md:200 致命真的会死：违规表被拒绝、进程非 0（违规拒绝组）
 	if not Kit.copy_tables(SRC_DIR, BAD_DIR) or not _inject_violation():
 		push_error("[treasure_target_violation_test] 夹具目录准备失败")
 		quit(2)
diff --git a/game/tests/unit/example_test.gd b/game/tests/unit/example_test.gd
index 0dd7c944..1cf8d1a5 100644
--- a/game/tests/unit/example_test.gd
+++ b/game/tests/unit/example_test.gd
@@ -10,7 +10,7 @@ extends SceneTree
 const Kit := preload("res://tests/unit/test_kit.gd")   # T6 收口：check/汇总退出样板单点
 
 func _init() -> void:
-# oracle: design/engineering/test-conventions.md:37 （套件协议模板——执行载体与退出码范例组）
+# 判据出处: design/engineering/test-conventions.md:37 （套件协议模板——执行载体与退出码范例组）
 	Kit.check("headless SceneTree 协议可用（quit(code) 通道）", _test_headless_protocol())
 	Kit.check("命名规范可执行：test_[scenario]_[expected]", _test_naming_convention_followed())
 	quit(Kit.finish("example_test"))
diff --git a/game/tests/unit/node_map_determinism_test.gd b/game/tests/unit/node_map_determinism_test.gd
index 80961da3..22bf0b66 100644
--- a/game/tests/unit/node_map_determinism_test.gd
+++ b/game/tests/unit/node_map_determinism_test.gd
@@ -19,7 +19,7 @@ var _bp_path := "user://smoke_node_map_save.json"
 
 
 func _init() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	_db = load("res://core/config_db.gd").new()
 	# 表加载失败不中止（承 G2/G3/G4/G5 同款：表损坏的红落在具体断言上）
 	var load_ok: bool = _db.load_tables("res://data/tables", true)
@@ -34,7 +34,7 @@ func _init() -> void:
 
 # ---- 关卡节点图生成·确定性承载断言面 ----
 func _smoke_generated_map_determinism() -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点图生成.md:134 （起关/选路/断点重生成同图组）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点图生成.md:134 （起关/选路/断点重生成同图组）
 	# ① 纯函数复现：图 = f(参数档, 种子)——同档同种子两次产图逐位同图，换种子必变图
 	var gen = NodeMapGenerator.new(_fresh_rng(910001))
 	var params2: Dictionary = _db.run.level_gen_params.row_by_level_index(2)
diff --git a/game/tests/unit/presentation/animation_frame_spec_test.gd b/game/tests/unit/presentation/animation_frame_spec_test.gd
index ad4fd0a4..294b08e8 100644
--- a/game/tests/unit/presentation/animation_frame_spec_test.gd
+++ b/game/tests/unit/presentation/animation_frame_spec_test.gd
@@ -20,7 +20,7 @@ const CURRENT_FORM := {
 
 
 func _init() -> void:
-# oracle: design/art/art-bible.md:539 （帧数规格条——样张冻结定值组）
+# 判据出处: design/art/art-bible.md:539 （帧数规格条——样张冻结定值组）
 	_test_spec_table()
 	_test_current_form()
 	quit(Kit.finish("animation_frame_spec_test"))
@@ -28,7 +28,7 @@ func _init() -> void:
 
 # ① 规格表冻结面（帧数档定值单点=本表）
 func _test_spec_table() -> void:
-# oracle: design/art/art-bible.md:539 （帧数规格表冻结组）
+# 判据出处: design/art/art-bible.md:539 （帧数规格表冻结组）
 	Kit.check("待机循环 4 帧在表〔帧规格 V1〕", SPEC.get("idle", 0) == 4)
 	Kit.check("攻击准备 6 帧单次在表〔帧规格 V2〕", SPEC.get("attack", 0) == 6)
 	Kit.check("受击 2 帧在表〔帧规格 V3〕", SPEC.get("hit", 0) == 2)
@@ -36,7 +36,7 @@ func _test_spec_table() -> void:
 
 # ② 现役单帧形制锚定（真实加载链——资产被换形制而未走规格表时此处红）
 func _test_current_form() -> void:
-# oracle: design/art/art-bible.md:539 （现役单帧形制组）
+# 判据出处: design/art/art-bible.md:539 （现役单帧形制组）
 	for fn: String in CURRENT_FORM:
 		var tex: Texture2D = load("res://assets/art/character/" + fn)
 		var want := Vector2(CURRENT_FORM[fn])
diff --git a/game/tests/unit/presentation/battle_narrator_test.gd b/game/tests/unit/presentation/battle_narrator_test.gd
index 322a9908..e123aa7b 100644
--- a/game/tests/unit/presentation/battle_narrator_test.gd
+++ b/game/tests/unit/presentation/battle_narrator_test.gd
@@ -18,7 +18,7 @@ class _BossRunner:
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:260 （战斗叙述宿主——装载组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:260 （战斗叙述宿主——装载组）
 	_test_numeric_lines_carry_values()
 	_test_end_text_differs_by_result()
 	_test_phase_text_nonempty()
@@ -29,7 +29,7 @@ func _init() -> void:
 
 
 func _test_numeric_lines_carry_values() -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:272 （结算行数值带入组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:272 （结算行数值带入组）
 	var rest: String = NarratorScript.rest_line(12, 30, 40)
 	Kit.check("休整叙述带入回复量与当前血量（实际「%s」）" % rest,
 		rest.contains("12") and rest.contains("30") and rest.contains("40"))
@@ -40,7 +40,7 @@ func _test_numeric_lines_carry_values() -> void:
 
 
 func _test_end_text_differs_by_result() -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:272 （胜负互异文案组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:272 （胜负互异文案组）
 	# 关卡收束（level_end=true）恒为「关卡完成！」——单场胜负文案只在非收束态出现
 	var level: String = NarratorScript.battle_end_text("lose", true)
 	Kit.check("关卡收束态恒为「关卡完成！」（实际「%s」）" % level, level == "关卡完成！")
@@ -53,7 +53,7 @@ func _test_end_text_differs_by_result() -> void:
 
 
 func _test_phase_text_nonempty() -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:272 （阶段行非空组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:272 （阶段行非空组）
 	var t: String = NarratorScript.phase_text(1, "", false, false, "")
 	Kit.check("相位叙述非空（实际「%s」）" % t, t != "")
 	var boss: String = NarratorScript.phase_text(2, "", false, true, "灰矮人石君王")
@@ -63,7 +63,7 @@ func _test_phase_text_nonempty() -> void:
 # 叙述寻址按行类取 Boss 行集（S 清单 S15 换代）：Boss 节点名必须来自 (关卡, boss, 带) 行集，
 # 不能落到同深度的战斗行集——期望名由表行集首行读出，不写死字面量。
 func _test_boss_name_uses_boss_rowset() -> void:
-# oracle: design/gdd/systems/战斗循环/敌人系统.md:295 （Boss 名读行集组）
+# 判据出处: design/gdd/systems/战斗循环/敌人系统.md:295 （Boss 名读行集组）
 	var db = load("res://core/config_db.gd").new()
 	var loaded: bool = db.load_tables("res://data/tables", false)
 	Kit.check_quiet(loaded, "叙述寻址用例：数值表加载成功")
@@ -92,7 +92,7 @@ func _test_boss_name_uses_boss_rowset() -> void:
 # 关卡完成停点文案族措辞钉子（口径换代批）：回血行/满血合法态/渠道句/摘要关数行——
 # 旧措辞退役后玩家可见面由本组断言钉在新措辞上（撤销证明：回退 battle_narrator 对应行→断言红→复原复绿）
 func _test_level_clear_wording() -> void:
-# oracle: design/ux/level-clear.md:11 （关卡结算屏文案组）
+# 判据出处: design/ux/level-clear.md:11 （关卡结算屏文案组）
 	var healed: String = NarratorScript.curio_pick_header({"level_index": 1, "heal_gained": 5, "hp_before": 10, "hp_after": 15})
 	Kit.check("关卡完成回血行带入回血量与生命区间（实际「%s」）〔口径换代 V1〕" % healed,
 		healed.contains("关卡完成回血 +5（生命 10 → 15）"))
@@ -112,7 +112,7 @@ func _test_level_clear_wording() -> void:
 # 真实入口=呈现状态快照函数 presentation_snapshot：A 有削弱 B 无 → 两卡投影各现各的（零共享引用）
 
 func _test_snapshot_effects_per_unit() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	var db = load("res://core/config_db.gd").new()
 	Kit.check("V8 前置：表加载零 error", db.load_tables("res://data/tables", true) and db.diagnostics_count("error") == 0)
 	var rng = load("res://core/rng_service.gd").new()
diff --git a/game/tests/unit/presentation/camp_scene_layout_test.gd b/game/tests/unit/presentation/camp_scene_layout_test.gd
index dbca0cfa..f4cfdbcd 100644
--- a/game/tests/unit/presentation/camp_scene_layout_test.gd
+++ b/game/tests/unit/presentation/camp_scene_layout_test.gd
@@ -10,19 +10,19 @@ const _EXPECTED_KEYS: Array[StringName] = [&"gate", &"forge", &"dummy", &"chest"
 
 
 func _initialize() -> void:
-# oracle: design/ux/camp.md:29 （营地场景布局数据件——纵深与地平线组）
+# 判据出处: design/ux/camp.md:29 （营地场景布局数据件——纵深与地平线组）
 	call_deferred("_run_all")
 
 
 func _run_all() -> void:
-# oracle: design/ux/camp.md:29 （套件统一收尾——双测试函数单进程单 quit）
+# 判据出处: design/ux/camp.md:29 （套件统一收尾——双测试函数单进程单 quit）
 	await _test_layout_hotspot_geometry()
 	await _test_hud_band_contrast_over_bg()
 	quit(Kit.finish("camp_scene_layout_test", "PASS — 布局几何＋顶栏栏体对比 全过"))
 
 
 func _test_layout_hotspot_geometry() -> void:
-# oracle: design/ux/camp.md:16 （七物件命中区几何红线组）
+# 判据出处: design/ux/camp.md:16 （七物件命中区几何红线组）
 	var table: CampSceneLayoutTable = load("res://data/tables/camp_scene_layout.tres")
 	Kit.check("V14 布局表加载且 schema 类在位〔营地图批 V14〕", table is CampSceneLayoutTable and table != null)
 	if table == null:
@@ -98,9 +98,9 @@ func _test_layout_hotspot_geometry() -> void:
 
 # 顶栏栏体规格侧对比核验（R6——与 R5 分工：R5 核实装等值，本行核规格值本身达标）：
 # 按规格句在测试内写死 #6E4526 与 α0.80，与背景贴图顶带实测均色做 α 合成后算 WCAG 对比 ≥3.0。
-# 禁把视图件的 color 直接当预期值喂进算式（oracle 镜像——test-conventions §8.7 判红）。
+# 禁把视图件的 color 直接当预期值喂进算式（判据镜像——test-conventions §8.7 判红）。
 func _test_hud_band_contrast_over_bg() -> void:
-# oracle: design/ux/camp.md:41 （顶栏栏体定值——对落位带底色对比 ≥3:1 组）
+# 判据出处: design/ux/camp.md:41 （顶栏栏体定值——对落位带底色对比 ≥3:1 组）
 	var table: CampSceneLayoutTable = load("res://data/tables/camp_scene_layout.tres")
 	var band_h := 48
 	if table != null:
diff --git a/game/tests/unit/presentation/confirm_dialog_test.gd b/game/tests/unit/presentation/confirm_dialog_test.gd
index ff7bbbfc..50058b36 100644
--- a/game/tests/unit/presentation/confirm_dialog_test.gd
+++ b/game/tests/unit/presentation/confirm_dialog_test.gd
@@ -10,7 +10,7 @@ const ConfirmDialogScript := preload("res://presentation/views/confirm_dialog.gd
 
 
 func _initialize() -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:90 （确认弹窗按钮位次定值——位次与语义同钉组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:90 （确认弹窗按钮位次定值——位次与语义同钉组）
 	call_deferred("_run")
 
 
@@ -27,7 +27,7 @@ func _find_btn_row(node: Node) -> HBoxContainer:
 
 
 func _test_two_button_row_order() -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:90 双钮形态位次=推进在左、维持在右（两钮同钉组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:90 双钮形态位次=推进在左、维持在右（两钮同钉组）
 	var ov: Control = ConfirmDialogScript.new()
 	root.add_child(ov)
 	ov.open("t", "推进", "维持")
@@ -40,7 +40,7 @@ func _test_two_button_row_order() -> void:
 
 
 func _test_three_button_row_order() -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:90 三钮形态位次=推进/次推/维持（三钮同钉组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:90 三钮形态位次=推进/次推/维持（三钮同钉组）
 	var ov: Control = ConfirmDialogScript.new()
 	root.add_child(ov)
 	ov.open_three("t", "推进", "次推", "维持")
diff --git a/game/tests/unit/presentation/forge_workbench_test.gd b/game/tests/unit/presentation/forge_workbench_test.gd
index 907ec41b..aa9e7711 100644
--- a/game/tests/unit/presentation/forge_workbench_test.gd
+++ b/game/tests/unit/presentation/forge_workbench_test.gd
@@ -10,7 +10,7 @@ const _TEST_SAVE := "user://test_forge_workbench.json"
 
 
 func _initialize() -> void:
-# oracle: design/gdd/systems/跨局循环/锻造工坊.md:219 （工作间两区六路线——装载组）
+# 判据出处: design/gdd/systems/跨局循环/锻造工坊.md:219 （工作间两区六路线——装载组）
 	call_deferred("_run")
 
 
@@ -22,7 +22,7 @@ func _row_by_id(ov) -> Dictionary:
 
 
 func _run() -> void:
-# oracle: design/gdd/systems/跨局循环/锻造工坊.md:219 （六路线 UI 直验组）
+# 判据出处: design/gdd/systems/跨局循环/锻造工坊.md:219 （六路线 UI 直验组）
 	var db = load("res://core/config_db.gd").new()
 	var load_ok: bool = db.load_tables("res://data/tables", true)
 	if not load_ok:
diff --git a/game/tests/unit/presentation/hud_presenter_test.gd b/game/tests/unit/presentation/hud_presenter_test.gd
index 2c85c0d1..6c779854 100644
--- a/game/tests/unit/presentation/hud_presenter_test.gd
+++ b/game/tests/unit/presentation/hud_presenter_test.gd
@@ -9,7 +9,7 @@ const HudScript := preload("res://presentation/hud_presenter.gd")
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:260 （HUD 投影宿主——装载组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:260 （HUD 投影宿主——装载组）
 	_test_accepted_text()
 	_test_reject_text_by_reason()
 	_test_unknown_reason_fallback()
@@ -17,13 +17,13 @@ func _init() -> void:
 
 
 func _test_accepted_text() -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:212 （受理反馈呈现组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:212 （受理反馈呈现组）
 	var t: String = HudScript.outcome_text({"accepted": true})
 	Kit.check("受理态文案固定为「执行完成。」（实际「%s」）" % t, t == "执行完成。")
 
 
 func _test_reject_text_by_reason() -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:212 （拒绝三源可辨文案组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:212 （拒绝三源可辨文案组）
 	var cases := {
 		"not_adjacent": "不能执行：目标与小人不相邻",
 		"target_revealed": "不能执行：目标已开",
@@ -42,7 +42,7 @@ func _test_reject_text_by_reason() -> void:
 
 
 func _test_unknown_reason_fallback() -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:212 （未知兜底文案组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:212 （未知兜底文案组）
 	var t: String = HudScript.outcome_text({"accepted": false, "reject_reason": "brand_new_reason"})
 	Kit.check("未知拒绝原因兜底为「动作被拒。」而非空串（实际「%s」）" % t, t == "动作被拒。")
 	var sub: String = HudScript.outcome_text({
diff --git a/game/tests/unit/presentation/level_map_info_fog_test.gd b/game/tests/unit/presentation/level_map_info_fog_test.gd
index d103f20b..ff663ae7 100644
--- a/game/tests/unit/presentation/level_map_info_fog_test.gd
+++ b/game/tests/unit/presentation/level_map_info_fog_test.gd
@@ -11,12 +11,12 @@ const ScreenScript := preload("res://presentation/views/level_map_screen.gd")
 
 
 func _initialize() -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点地图.md:178 （信息迷雾呈现宿主——装载组）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点地图.md:178 （信息迷雾呈现宿主——装载组）
 	call_deferred("_run")
 
 
 func _run() -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点地图.md:178 （迷雾显隐宿主组）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点地图.md:178 （迷雾显隐宿主组）
 	var db = load("res://core/config_db.gd").new()
 	var loaded: bool = db.load_tables("res://data/tables", false)
 	Kit.check_quiet(loaded, "迷雾呈现用例：数值表加载成功")
@@ -48,7 +48,7 @@ func _runner(db, nodes: Array, candidates: Array, n: int = 2):
 # ---- ① 范围外只见结构：雾下节点类型图标与文字均不绘制〔fv2〕----
 
 func _test_fog_hides_type() -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点地图.md:178 （雾下类型隐藏组）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点地图.md:178 （雾下类型隐藏组）
 	var node := {"id": 3, "type": "battle", "depth": 3, "next": []}
 	var shown: Dictionary = ScreenScript.node_display(node, 2, [2], false, false)
 	Kit.check("可见集内节点：图标/类型文字均绘制〔fv2〕",
@@ -62,7 +62,7 @@ func _test_fog_hides_type() -> void:
 # ---- ② Boss/终点不入雾＋多终点标记〔fv3〕----
 
 func _test_boss_exempt_and_multi_boss() -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点地图.md:178 （Boss 描边豁免与多 Boss 组）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点地图.md:178 （Boss 描边豁免与多 Boss 组）
 	var type_vis: Array = [1, 7, 9]   # 双 Boss 图：7/9 均在可见集
 	var boss_a: Dictionary = ScreenScript.node_display({"id": 7, "type": "boss", "depth": 7, "next": []}, 7, type_vis, false, false)
 	var boss_b: Dictionary = ScreenScript.node_display({"id": 9, "type": "boss", "depth": 9, "next": []}, 9, type_vis, false, false)
@@ -80,7 +80,7 @@ func _test_boss_exempt_and_multi_boss() -> void:
 # ---- ③ 节点内详情图上从不显示〔fv5〕----
 
 func _test_details_never_shown() -> void:
-# oracle: design/gdd/systems/冒险循环/关卡节点地图.md:178 （详情零显示组）
+# 判据出处: design/gdd/systems/冒险循环/关卡节点地图.md:178 （详情零显示组）
 	var plain := {"id": 3, "type": "battle", "depth": 3, "next": [4]}
 	var loaded := {"id": 3, "type": "battle", "depth": 3, "next": [4], "enemy_id": "goblin_secret", "reward_id": "reward_secret"}
 	var a: Dictionary = ScreenScript.node_display(plain, 3, [3], false, true)
@@ -97,7 +97,7 @@ func _test_details_never_shown() -> void:
 # ---- ④ label_text 三态文案〔fv2〕----
 
 func _test_label_three_states() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	var node := {"id": 3, "type": "battle", "depth": 3, "next": [4]}
 	Kit.check("当前位文案＝「当前位置」〔fv2〕",
 		String(ScreenScript.node_display(node, 3, [3], true, false)["label_text"]) == "当前位置")
@@ -150,7 +150,7 @@ func _big_graph_nodes() -> Array:
 
 
 func _test_big_graph_fit(db) -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	var nodes := _big_graph_nodes()
 	var entry: Dictionary = nodes[0]
 	var runner = _runner(db, nodes, [nodes[1]])
@@ -204,7 +204,7 @@ func _test_big_graph_fit(db) -> void:
 # 命中读数 = is_same 同实例判别（重算必产新字典、命中返回缓存原实例）——零生产计数器。
 
 func _test_layout_cache(db) -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	var nodes := _big_graph_nodes()
 	var runner = _runner(db, nodes, [nodes[1]])
 	var screen = ScreenScript.new()
diff --git a/game/tests/unit/presentation/modal_flow_test.gd b/game/tests/unit/presentation/modal_flow_test.gd
index 6e2db94e..cd6588a8 100644
--- a/game/tests/unit/presentation/modal_flow_test.gd
+++ b/game/tests/unit/presentation/modal_flow_test.gd
@@ -11,7 +11,7 @@ const ModalStackScript := preload("res://presentation/modal_stack.gd")
 
 
 func _init() -> void:
-# oracle: design/engineering/code-conventions.md:54 （模态编排纯逻辑——层级与输入锁组）
+# 判据出处: design/engineering/code-conventions.md:54 （模态编排纯逻辑——层级与输入锁组）
 	# 哑层与桩 Callable（纯逻辑类零场景前提的证明面）
 	var start := Control.new()
 	var inter := Control.new()
diff --git a/game/tests/unit/presentation/pacing_queue_test.gd b/game/tests/unit/presentation/pacing_queue_test.gd
index 0e16413e..5b093080 100644
--- a/game/tests/unit/presentation/pacing_queue_test.gd
+++ b/game/tests/unit/presentation/pacing_queue_test.gd
@@ -37,13 +37,13 @@ class FakeFx extends SettlementFxView:
 
 
 func check(cond: bool, msg: String) -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	if not cond:
 		_problems.append(msg)
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:272 （排播节奏——排空零分叉/零丢行/延迟双态组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:272 （排播节奏——排空零分叉/零丢行/延迟双态组）
 	var main: Node = load("res://presentation/main.tscn").instantiate()
 	root.add_child(main)
 	await process_frame
@@ -157,7 +157,7 @@ func _count_row(row: Dictionary, arr: Array) -> void:
 
 
 func _finish() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	for p in ["user://test_pacing_queue_save.json", "user://test_pacing_queue_save.json.tmp"]:
 		if FileAccess.file_exists(p):
 			DirAccess.remove_absolute(p)
diff --git a/game/tests/unit/presentation/palette_token_pairwise_test.gd b/game/tests/unit/presentation/palette_token_pairwise_test.gd
index 6b28e016..53787fbe 100644
--- a/game/tests/unit/presentation/palette_token_pairwise_test.gd
+++ b/game/tests/unit/presentation/palette_token_pairwise_test.gd
@@ -57,7 +57,7 @@ const EXEMPT_LEDGER := {
 
 
 func _init() -> void:
-# oracle: design/art/art-bible.md:220 （色板增量纪律条——存量两两互查组）
+# 判据出处: design/art/art-bible.md:220 （色板增量纪律条——存量两两互查组）
 	_test_pairwise()
 	quit(Kit.finish("palette_token_pairwise_test"))
 
@@ -78,7 +78,7 @@ func _hex(c: Color) -> String:
 
 # 存量两两互查：豁免账外零近色对（扫描面>0 前置防静默绿）
 func _test_pairwise() -> void:
-# oracle: design/art/art-bible.md:220 （色板增量纪律条——存量两两互查组）
+# 判据出处: design/art/art-bible.md:220 （色板增量纪律条——存量两两互查组）
 	var tokens := _token_colors()
 	Kit.check("token 面非空（扫描面>0）〔token互查 V1〕", tokens.size() >= 40)
 	var names: Array = tokens.keys()
diff --git a/game/tests/unit/presentation/player_copy_sweep_test.gd b/game/tests/unit/presentation/player_copy_sweep_test.gd
index de41e562..9cbb480c 100644
--- a/game/tests/unit/presentation/player_copy_sweep_test.gd
+++ b/game/tests/unit/presentation/player_copy_sweep_test.gd
@@ -23,7 +23,7 @@ var _db
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:281 （玩家面文案清扫宿主——装载组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:281 （玩家面文案清扫宿主——装载组）
 	_db = ConfigDBScript.new()
 	var load_ok: bool = _db.load_tables("res://data/tables", true)
 	if not load_ok:
@@ -43,7 +43,7 @@ func _init() -> void:
 
 # ① C 区两段头（u1/u2——直建 hero 面板，adventure_feats_test ⑦c 族同构）
 func _sweep_hero_panel() -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:274 （英雄面板文案组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:274 （英雄面板文案组）
 	var panel = load("res://presentation/views/hero_info_panel_view.gd").new(_db.presentation.battle_layout)
 	var feat_head := _first_label(panel._feat_section)
 	var curio_head := _first_label(panel._curio_section)
@@ -55,7 +55,7 @@ func _sweep_hero_panel() -> void:
 
 # ②③ 奖励节点头部＋专长卡兜底（u3/u11——静态直调）
 func _sweep_narrator() -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:272 （叙述文案组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:272 （叙述文案组）
 	var narrator = load("res://presentation/battle_narrator.gd")
 	var head := String(narrator.node_curio_header())
 	Kit.check("奖励点头部含「冒险牌库」（u3 机制事实①同库）〔wa4〕", head.contains("冒险牌库"))
@@ -68,7 +68,7 @@ func _sweep_narrator() -> void:
 
 # ④ 图例封印行（u4——直建 LegendOverlay 读 ENTRIES 常量）
 func _sweep_legend() -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:267 （图例文案组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:267 （图例文案组）
 	load("res://presentation/views/legend_overlay.gd").new()   # 直建（_init(rap_cost) 现签名）
 	var seal_row: Array = []
 	for e in load("res://presentation/views/legend_overlay.gd").ENTRIES:
@@ -84,7 +84,7 @@ func _sweep_legend() -> void:
 
 # ⑤⑥ 来源名双源（u5/u6——状态槽消费半＋表值 ConfigDB 真装载＋battle_log 行消费半）
 func _sweep_source_names() -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:274 （来源名读表组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:274 （来源名读表组）
 	var row_view = load("res://presentation/views/status_slot_row.gd").new()
 	row_view.set_effects([{"effect_id": "alert", "source_class": "mine_hit",
 		"display_name": "危险格受击", "remaining_settlements": 2, "round_index": 1}])
@@ -110,7 +110,7 @@ func _sweep_source_names() -> void:
 
 # ⑦⑧ 已开危险格字形族（u7/u8/u9——BoardView rebuild 真实刷新路径＋源 token 扫描）
 func _sweep_board_glyph() -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:264 （危险格字形组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:264 （危险格字形组）
 	var board_generator = load("res://core/board_generator.gd").new()
 	var b = board_generator.generate(1, 0, _mk_stream("board_gen", 4242), _db)
 	var ae = load("res://core/action_economy.gd").new(_db)
@@ -149,7 +149,7 @@ func _sweep_board_glyph() -> void:
 
 # ⑧⑩ 源 token 扫描（注释剥离=行首 # 判——契约 2 保留面不入域）
 func _sweep_token_scans() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	var board_src := FileAccess.get_file_as_string("res://presentation/views/board_view.gd")
 	Kit.check("board_view.gd 源零 \"雷\" 字面量（u7/u8/u9 哨兵族统一钉住）〔wa8〕",
 		board_src.count("\"雷\"") == 0)
@@ -167,7 +167,7 @@ func _sweep_token_scans() -> void:
 # 刷新两 toast 文案零数字字面量（架构整改 R4——格式串零数字、插值位与表字段一一对应；
 # 静态判据＋评审注记观测面局限：真机文案随表值由实机目检兜——T10 清单两项）
 func _sweep_refresh_toast_no_literals() -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:260 （刷新提示读表拼接——零字面量组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:260 （刷新提示读表拼接——零字面量组）
 	var main_src := FileAccess.get_file_as_string("res://presentation/main.gd")
 	var rap_toast := ""
 	var cap_toast := ""
diff --git a/game/tests/unit/presentation/presentation_encapsulation_sweep_test.gd b/game/tests/unit/presentation/presentation_encapsulation_sweep_test.gd
index caee31ea..5d56614d 100644
--- a/game/tests/unit/presentation/presentation_encapsulation_sweep_test.gd
+++ b/game/tests/unit/presentation/presentation_encapsulation_sweep_test.gd
@@ -33,7 +33,7 @@ const A1_FILES := {
 
 
 func _init() -> void:
-# oracle: design/engineering/code-conventions.md:41 （presentation 封装——四族零命中扫描组）
+# 判据出处: design/engineering/code-conventions.md:41 （presentation 封装——四族零命中扫描组）
 	_sweep_a1_data_classes()
 	_sweep_a2_subparts()
 	_sweep_b_combo_root()
@@ -43,7 +43,7 @@ func _init() -> void:
 
 # 源文件读取＋非空前置（返 "" 即已判红——调用侧跳过后续正则断言）
 func _src(path: String) -> String:
-# oracle: design/engineering/code-conventions.md:41 （源码采样组）
+# 判据出处: design/engineering/code-conventions.md:41 （源码采样组）
 	var src := FileAccess.get_file_as_string(path)
 	Kit.check("扫描面非空前置：%s" % path, src.length() > 0)
 	return src
@@ -51,21 +51,21 @@ func _src(path: String) -> String:
 
 # 正则零命中断言（-pattern 意图写入断言文案——可 grep 定位；suffix 区分族组）
 func _zero(pattern: String, src: String, label: String, suffix: String = "pres封装 V1") -> void:
-# oracle: design/engineering/code-conventions.md:41 （零命中扫描组）
+# 判据出处: design/engineering/code-conventions.md:41 （零命中扫描组）
 	var re := RegEx.create_from_string(pattern)
 	Kit.check("%s：%s 零命中〔%s〕" % [label, pattern, suffix], re.search(src) == null)
 
 
 # 正锚在案断言（正则命中 ≥1——新公开面/新形态在用；suffix 区分族组）
 func _anchor(pattern: String, src: String, label: String, suffix: String = "pres封装 V1") -> void:
-# oracle: design/engineering/code-conventions.md:41 （正锚存在组）
+# 判据出处: design/engineering/code-conventions.md:41 （正锚存在组）
 	var re := RegEx.create_from_string(pattern)
 	Kit.check("%s：%s 正锚在案〔%s〕" % [label, pattern, suffix], re.search(src) != null)
 
 
 # ② V2 A2 拆件子件（行为归位子件公开方法、读走公开读法、身份构造交付）
 func _sweep_a2_subparts() -> void:
-# oracle: design/engineering/code-conventions.md:41 （A2 子件封装扫描组）
+# 判据出处: design/engineering/code-conventions.md:41 （A2 子件封装扫描组）
 	var body := _src("res://presentation/views/standee_body.gd")
 	if body.length() > 0:
 		_zero("\\bst\\._|\\bmo\\._", body, "子件私取模式零命中（standee_body）", "pres封装 V2")
@@ -82,7 +82,7 @@ func _sweep_a2_subparts() -> void:
 
 # ③ V3 B 组合根交接面（main＋五分文件——成对单行转发梯换代为公开入口＋Callable 束）
 func _sweep_b_combo_root() -> void:
-# oracle: design/engineering/code-conventions.md:41 （组合根束封装扫描组）
+# 判据出处: design/engineering/code-conventions.md:41 （组合根束封装扫描组）
 	var b_files := {
 		"res://presentation/main.gd": false,
 		"res://presentation/main_ui_build.gd": true,
@@ -117,7 +117,7 @@ func _sweep_b_combo_root() -> void:
 
 # ④ V4 C 杂项（UiKit 私有工厂公开化＋cell_mark 构造交付）
 func _sweep_c_misc() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	var offenders: PackedStringArray = []
 	var scanned := 0
 	_walk_gd_for("res://", "UiKit\\._[a-zA-Z]", "res://presentation/views/ui_kit.gd", offenders)
@@ -155,7 +155,7 @@ func _walk_gd_for(dir_path: String, pattern: String, exclude: String, offenders:
 
 # ① V1 A1 三内部数据类（字段公开化——宿主直读写内类私有字段清零）
 func _sweep_a1_data_classes() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	for path in A1_FILES:
 		var spec: Dictionary = A1_FILES[path]
 		var src := _src(path)
diff --git a/game/tests/unit/presentation/reward_overlay_test.gd b/game/tests/unit/presentation/reward_overlay_test.gd
index bd30a41a..4f6e2faf 100644
--- a/game/tests/unit/presentation/reward_overlay_test.gd
+++ b/game/tests/unit/presentation/reward_overlay_test.gd
@@ -10,7 +10,7 @@ const ProbeUiUtil := preload("res://probe/probe_ui_util.gd")   # 真输入合成
 
 # 断言 + 失败即停（原直写 print FAIL + quit(1) + return 样板单点化——早退语义逐位保持）
 func _req(desc: String, ok: bool) -> bool:
-# oracle: design/ux/node-reward.md:9 （奖励覆盖层直验——需求包装组）
+# 判据出处: design/ux/node-reward.md:9 （奖励覆盖层直验——需求包装组）
 	Kit.check(desc, ok)
 	if not ok:
 		quit(1)
@@ -18,11 +18,11 @@ func _req(desc: String, ok: bool) -> bool:
 	return true
 
 func _initialize() -> void:
-# oracle: design/ux/node-reward.md:9 （奖励节点装载组）
+# 判据出处: design/ux/node-reward.md:9 （奖励节点装载组）
 	call_deferred("_run")
 
 func _run() -> void:
-# oracle: design/ux/node-reward.md:9 （奖励三选一呈现组）
+# 判据出处: design/ux/node-reward.md:9 （奖励三选一呈现组）
 	var ov = load("res://presentation/views/curio_pick_overlay.gd").new()
 	root.add_child(ov)
 	var picked := []
diff --git a/game/tests/unit/presentation/seal_mark_params_test.gd b/game/tests/unit/presentation/seal_mark_params_test.gd
index f13ea2be..8000c9c4 100644
--- a/game/tests/unit/presentation/seal_mark_params_test.gd
+++ b/game/tests/unit/presentation/seal_mark_params_test.gd
@@ -10,7 +10,7 @@ const CELL_UNIT := preload("res://presentation/views/board_cell_unit.gd")
 
 
 func _init() -> void:
-# oracle: design/ux/battle.md:128 （封印印记参数宿主——装载组）
+# 判据出处: design/ux/battle.md:128 （封印印记参数宿主——装载组）
 	_test_param_values()
 	_test_shader_uniforms()
 	_test_fog_gate()
@@ -19,7 +19,7 @@ func _init() -> void:
 
 # R1–R3/R7 前置：五常量取值逐项相等（art-bible §8.2 定值）
 func _test_param_values() -> void:
-# oracle: design/ux/battle.md:128 （环径与法阵定值组）
+# 判据出处: design/ux/battle.md:128 （环径与法阵定值组）
 	Kit.check("SEAL_RING_FRAC = 0.82〔seal批 V1〕", UiKit.SEAL_RING_FRAC == 0.82)
 	Kit.check("SEAL_WALL_FRAC = 0.11〔seal批 V2〕", UiKit.SEAL_WALL_FRAC == 0.11)
 	Kit.check("SEAL_ARM_FRAC = 0.156〔seal批 V2〕", UiKit.SEAL_ARM_FRAC == 0.156)
@@ -29,7 +29,7 @@ func _test_param_values() -> void:
 
 # R1–R3/R7：着色器存在＋七个 uniform 名在文（参数注入面契约）
 func _test_shader_uniforms() -> void:
-# oracle: design/ux/battle.md:128 （着色器参数化绘制组）
+# 判据出处: design/ux/battle.md:128 （着色器参数化绘制组）
 	var src := FileAccess.get_file_as_string(SEAL_SHADER)
 	Kit.check("着色器文件存在且非空：%s〔seal批 V1〕" % SEAL_SHADER, src.length() > 0)
 	if src.length() == 0:
@@ -43,7 +43,7 @@ func _test_shader_uniforms() -> void:
 # R4 迷雾门控：seal_on × fog_state → 封印子件可见性（内部字段直查=受控例外——子件可见性无公开可观测面，
 # 卡面 R4 断言即 prescribe 子件 visible 直查；对照表该行注记理由）
 func _test_fog_gate() -> void:
-# oracle: design/ux/battle.md:128 （迷雾联动门控组）
+# 判据出处: design/ux/battle.md:128 （迷雾联动门控组）
 	var u: Node2D = CELL_UNIT.new()
 	u.seal_on = true
 	Kit.check("seal_on 即挂封印子件〔seal批 V4〕", u._seal_layer != null)
diff --git a/game/tests/unit/presentation/settings_store_test.gd b/game/tests/unit/presentation/settings_store_test.gd
index 67aa6df4..f6e8f7c7 100644
--- a/game/tests/unit/presentation/settings_store_test.gd
+++ b/game/tests/unit/presentation/settings_store_test.gd
@@ -12,7 +12,7 @@ const ISO_PATH := "user://settings_store_unit_test.cfg"   # 隔离注路径（
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/表现与支撑/设置与本地化.md:4 （设置存储宿主——装载组）
+# 判据出处: design/gdd/systems/表现与支撑/设置与本地化.md:4 （设置存储宿主——装载组）
 	_test_settings_roundtrip()
 	_test_settings_default()
 	_test_settings_apply_chain()
@@ -27,7 +27,7 @@ func _cleanup() -> void:
 # ---- 持久化回读（写 true→存→新实例回读 true；节/键 motion/reduced）----
 
 func _test_settings_roundtrip() -> void:
-# oracle: design/gdd/systems/表现与支撑/设置与本地化.md:4 （设置写读往返组）
+# 判据出处: design/gdd/systems/表现与支撑/设置与本地化.md:4 （设置写读往返组）
 	var w = StoreScript.new(ISO_PATH)
 	w.reduced_motion = true
 	Kit.check("前置：save_settings 落盘成功", w.save_settings())
@@ -44,7 +44,7 @@ func _test_settings_roundtrip() -> void:
 # ---- 缺省值（无文件缺省 false）----
 
 func _test_settings_default() -> void:
-# oracle: design/gdd/systems/表现与支撑/设置与本地化.md:4 （出厂默认组）
+# 判据出处: design/gdd/systems/表现与支撑/设置与本地化.md:4 （出厂默认组）
 	var absent_path := "user://settings_store_unit_absent_%d.cfg" % (Time.get_ticks_msec())
 	DirAccess.remove_absolute(ProjectSettings.globalize_path(absent_path))   # 确保无文件
 	var d = StoreScript.new(absent_path)
@@ -55,7 +55,7 @@ func _test_settings_default() -> void:
 # ---- 引擎档应用链（reduced→apply()→UiKit.motion_scale==0.5，false→1.0；测毕还原静态初值）----
 
 func _test_settings_apply_chain() -> void:
-# oracle: design/gdd/systems/表现与支撑/设置与本地化.md:4 （应用链组）
+# 判据出处: design/gdd/systems/表现与支撑/设置与本地化.md:4 （应用链组）
 	var saved_scale: float = UiKit.motion_scale   # 静态初值留底——测毕还原
 	var a = StoreScript.new(ISO_PATH)
 	a.reduced_motion = true
diff --git a/game/tests/unit/presentation/stage_background_test.gd b/game/tests/unit/presentation/stage_background_test.gd
index e7a402ec..3886c8db 100644
--- a/game/tests/unit/presentation/stage_background_test.gd
+++ b/game/tests/unit/presentation/stage_background_test.gd
@@ -26,12 +26,12 @@ class AllMissingStage extends BattleStageView:
 
 
 func _initialize() -> void:
-# oracle: design/ux/battle.md:122 （舞台背景宿主——装载组）
+# 判据出处: design/ux/battle.md:122 （舞台背景宿主——装载组）
 	call_deferred("_run")
 
 
 func _run() -> void:
-# oracle: design/ux/battle.md:122 （B 区背景宿主组）
+# 判据出处: design/ux/battle.md:122 （B 区背景宿主组）
 	_test_layout_ground_field()
 	await _test_background_selection()
 	await _test_background_fallback()
@@ -42,7 +42,7 @@ func _run() -> void:
 
 # ---- V1 ground_h 字段与校验（表值/默认表 validate 空/三态拒绝族） ----
 func _test_layout_ground_field() -> void:
-# oracle: design/ux/battle.md:122 （连续地面层组）
+# 判据出处: design/ux/battle.md:122 （连续地面层组）
 	var layout = load("res://data/tables/battle_layout.tres")
 	Kit.check("布局表 ground_h = 100 且默认表 validate 为空〔舞台背景 V1〕",
 		int(layout.ground_h) == 100 and layout.validate().is_empty())
@@ -75,7 +75,7 @@ func _make_stage() -> Node:
 
 # ---- V2 背景按 board_type 选图（直建默认 dungeon + 三值路径逐值对应 + 层序在世界之下） ----
 func _test_background_selection() -> void:
-# oracle: design/ux/battle.md:122 （三关变体选图组）
+# 判据出处: design/ux/battle.md:122 （三关变体选图组）
 	var layout = load("res://data/tables/battle_layout.tres")
 	var stage: Node = _make_stage()
 	await process_frame
@@ -104,7 +104,7 @@ func _test_background_selection() -> void:
 
 # ---- V3 缺图回退（目标缺→dungeon；全缺→平色兜底不崩不刷产品日志） ----
 func _test_background_fallback() -> void:
-# oracle: design/ux/battle.md:122 （缺位回退组）
+# 判据出处: design/ux/battle.md:122 （缺位回退组）
 	var s1: Node = MissingUnderdarkStage.new(null, load("res://data/tables/battle_layout.tres"))
 	root.add_child(s1)
 	await process_frame
@@ -128,7 +128,7 @@ func _test_background_fallback() -> void:
 
 # ---- V4 连续地面层几何（底贴 B 区底、高读表、全宽、位于背景与世界之间） ----
 func _test_ground_layer_geometry() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	var layout = load("res://data/tables/battle_layout.tres")
 	var stage: Node = _make_stage()
 	await process_frame
@@ -155,7 +155,7 @@ func _test_ground_layer_geometry() -> void:
 
 # ---- V5 光柱层与舞台底源常量退役（源码锚 + 常量表 + 菜单斜光带在位） ----
 func _test_beams_retired() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	var f := FileAccess.open("res://presentation/views/battle_stage_view.gd", FileAccess.READ)
 	var src := f.get_as_text() if f != null else ""
 	Kit.check("舞台源码零光柱残留且平色回退含合并目标 SLOT_BACKDROP〔舞台背景 V5〕",
diff --git a/game/tests/unit/presentation/standee_fx_sweep_test.gd b/game/tests/unit/presentation/standee_fx_sweep_test.gd
index f7f7b49d..47615389 100644
--- a/game/tests/unit/presentation/standee_fx_sweep_test.gd
+++ b/game/tests/unit/presentation/standee_fx_sweep_test.gd
@@ -69,7 +69,7 @@ class FakeDB:
 
 
 func _init() -> void:
-# oracle: design/ux/battle.md:154 （站桩呈现域缺陷扫掠组）
+# 判据出处: design/ux/battle.md:154 （站桩呈现域缺陷扫掠组）
 	UiKit.motion_scale = 1.0
 
 	# ---- ⑤ 站桩按 id 解析（两口共用同名字敌载体）----
diff --git a/game/tests/unit/presentation/standee_present_values_test.gd b/game/tests/unit/presentation/standee_present_values_test.gd
index e4ce0ab9..7d82f696 100644
--- a/game/tests/unit/presentation/standee_present_values_test.gd
+++ b/game/tests/unit/presentation/standee_present_values_test.gd
@@ -31,7 +31,7 @@ func _read_source(rel_path: String) -> String:
 
 
 func _init() -> void:
-# oracle: design/ux/battle.md:154 （站桩呈现定值与素材绑定组）
+# 判据出处: design/ux/battle.md:154 （站桩呈现定值与素材绑定组）
 	# ---- V5 血条填充 = 危险红 #A8321F(§4.2 语义物件显式落法) ----
 	Kit.check("血条填充常量 = 危险红 #A8321F〔样张批 V5〕",
 		UiKit.HP_BAR_FILL.to_html(false) == "a8321f")
@@ -137,7 +137,7 @@ func _enemy_tex_path(key: String) -> String:
 
 
 func _check_display_tier() -> void:
-# oracle: design/ux/battle.md:154 （显示档与分辨率绑定组）
+# 判据出处: design/ux/battle.md:154 （显示档与分辨率绑定组）
 	# V13/V15 九键逐一:真实入口 StandeeBody → set_data(enemy_id) → set_portrait_texture(真纹理) → portrait_probe
 	for key: String in _DISPLAY_SPEC:
 		var spec: Array = _DISPLAY_SPEC[key]
diff --git a/game/tests/unit/presentation/terrain_tile_sets_test.gd b/game/tests/unit/presentation/terrain_tile_sets_test.gd
index 71519fde..8bddcca1 100644
--- a/game/tests/unit/presentation/terrain_tile_sets_test.gd
+++ b/game/tests/unit/presentation/terrain_tile_sets_test.gd
@@ -13,7 +13,7 @@ const Kit := preload("res://tests/unit/test_kit.gd")   # T6 收口：_check/汇
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:260 （地形瓦片套宿主——装载组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:260 （地形瓦片套宿主——装载组）
 	var board_dir := ProjectSettings.globalize_path("res://assets/art/board/")
 	var probe_path := board_dir.path_join("terrain_wall_center_dungeon.png")
 	if not FileAccess.file_exists(probe_path):
@@ -42,7 +42,7 @@ func _init() -> void:
 # 套完整性：词表每个 board_type 的 16 墙 + 5 地面变体全部在盘（缺位 → BoardView 整批回落 dungeon 的
 # 缺位回退断言由 ui_input_probe 覆盖；本断言管「入包完整」面）
 func _test_set_completeness(board_dir: String, types: Array) -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:260 （瓦片套完整性组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:260 （瓦片套完整性组）
 	var wall_names: Array = TilePaletteScript.TILE_WALL_NAMES
 	var variants: int = int(TilePaletteScript.TILE_FLOOR_VARIANTS)
 	for bt in types:
@@ -60,7 +60,7 @@ func _test_set_completeness(board_dir: String, types: Array) -> void:
 
 # 色相域抽检：wall_center 上半幅（墙顶面）与 floor_1 全幅的均值色相/明度
 func _test_hue_domains(board_dir: String) -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:260 地形瓦片色相域（色相域组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:260 地形瓦片色相域（色相域组）
 	var bands := {
 		"dungeon": [0.02, 0.16],        # 暖石棕 ≈15°–58°
 		"underdark": [0.50, 0.72],      # 灰白蓝紫 ≈180°–260°
@@ -124,7 +124,7 @@ func _load_stats(board_dir: String, fname: String, top_half: bool) -> Dictionary
 #   （双峰纹理直画不可救——渲染帧取证深墨隐形实证，牌上深墨 12:1）；③直画模式的双门槛值照抄
 #   TilePalette 判据常量（防判据漂移）
 func _test_digit_ink_modes(board_dir: String, types: Array) -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:260 （数字墨色模式组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:260 （数字墨色模式组）
 	var expect_plate := {"dungeon": false, "underdark": true, "deep_underdark": true}
 	var variants: int = int(TilePaletteScript.TILE_FLOOR_VARIANTS)
 	for bt in types:
diff --git a/game/tests/unit/presentation/theme_projection_test.gd b/game/tests/unit/presentation/theme_projection_test.gd
index 5c26d6fa..0e0093ef 100644
--- a/game/tests/unit/presentation/theme_projection_test.gd
+++ b/game/tests/unit/presentation/theme_projection_test.gd
@@ -30,7 +30,7 @@ var _rng
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:260 （呈现投影与主题宿主——装载组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:260 （呈现投影与主题宿主——装载组）
 	_db = ConfigDBScript.new()
 	# 表加载失败不中止（承 G2–G5 同款：表损坏的红落在具体断言上）
 	var load_ok: bool = _db.load_tables("res://data/tables", true)
@@ -181,7 +181,7 @@ func _meta_new_save(path: String):
 
 # ---- 未开格类型微光（作用集恒等／九型归组封闭／零玩法写入）----
 func _smoke_type_glow() -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:267 （未开格类型微光数据面组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:267 （未开格类型微光数据面组）
 	print("--- 未开格类型微光（作用集恒等／九型归组封闭／零玩法写入）---")
 	var board_generator = load("res://core/board_generator.gd").new()
 	var b = board_generator.generate(1, 0, _mk_stream("board_gen", 4242), _db)
@@ -383,7 +383,7 @@ func _smoke_type_glow() -> void:
 # _format_row Invalid access 使结算段中途夭折、界面卡死。行协议变更必须同步呈现层〔战斗结算 §行协议〕，
 # 本段把现行行形态逐型喂进真实视图：拆行残留与行字段错位在此转红）----
 func _smoke_battle_log_view() -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:272 （明细带行协议组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:272 （明细带行协议组）
 	print("--- 战斗日志视图行格式化（行协议 9 类呈现层同步闸）---")
 	var view = load("res://presentation/views/battle_log_view.gd").new(_db, _db.presentation.battle_layout)
 	# 敌方行动伤害行（现行形态：baseline 在场、attach 已出协议——修复前此行即 Invalid access）
@@ -428,7 +428,7 @@ func _smoke_battle_log_view() -> void:
 # ---- 开场行后缀尾接协议（迭代36 wc1 静态半——level_open_line 第五参布尔直控尾接，签名零变；
 # 该函数此前零既有断言，尾接行为由此钉住）----
 func _smoke_level_open_line() -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:272 （关卡开启行组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:272 （关卡开启行组）
 	var NarratorScript := load("res://presentation/battle_narrator.gd")
 	Kit.check("开场行 boosted=true 尾接「（含面板加成）」〔wc1〕",
 		String(NarratorScript.level_open_line("第一层", 42, 5, 30, true)).contains("（含面板加成）"))
@@ -443,7 +443,7 @@ func _smoke_level_open_line() -> void:
 # V1 挂载覆盖 / V2 滑轨两段 / V3 预盖件运行时证词 / V4 旧形态零残留 /
 # V5 回归（本冒烟全绿即回归网）/ V6 中文字体防御（挂主题后 default_font 顶掉 custom_font 也不丢字形）
 func _smoke_global_theme() -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:260 （全局主题组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:260 （全局主题组）
 	print("--- UI 全局主题（main_theme.tres 挂载与词条断言）---")
 	var th := ThemeDB.get_project_theme()
 	Kit.check("V1 项目主题挂载（project.godot gui/theme/custom → main_theme.tres）", th != null)
@@ -548,7 +548,7 @@ func _smoke_global_theme() -> void:
 
 # ---- 按钮五态矩阵冒烟（四工厂产物逐实例 override 断言；V1/V2）----
 func _smoke_button_five_states() -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:260 （按钮五态组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:260 （按钮五态组）
 	print("--- UI 按钮五态矩阵（四工厂五态样式盒）---")
 	var uikit_s = load("res://presentation/views/ui_kit.gd")
 	var states := ["normal", "hover", "pressed", "disabled", "focus"]
@@ -620,7 +620,7 @@ func _smoke_button_five_states() -> void:
 
 # ---- 全局纹理过滤冒烟（工程设置 Nearest＋平滑渐变件 LINEAR 白名单；V3）----
 func _smoke_texture_filter() -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:260 （纹理过滤白名单组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:260 （纹理过滤白名单组）
 	print("--- UI 全局纹理过滤（Nearest+白名单三件）---")
 	var v = ProjectSettings.get_setting("rendering/textures/canvas_textures/default_texture_filter")
 	Kit.check("V3 工程设置 default_texture_filter=0（Nearest，翻转面=立绘/瓦片/九宫格 crisp）",
@@ -670,7 +670,7 @@ func _smoke_texture_filter() -> void:
 
 # ---- <4.5:1 文字位换墨冒烟（站桩徽标两族亮档+RAP 行深石墨；V4）----
 func _smoke_contrast_inks() -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:281 （对比度墨色锚组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:281 （对比度墨色锚组）
 	print("--- UI 残余 <4.5:1 文字位换墨（V4 对比度锚定）---")
 	var uikit_s = load("res://presentation/views/ui_kit.gd")
 	var stage: Color = uikit_s.SLOT_BACKDROP   # 舞台底对比锚改读合并目标（art-bible §4.1 换色合并③——阈值与判据不变）
@@ -697,7 +697,7 @@ func _smoke_contrast_inks() -> void:
 
 # ---- 元素细节余②③冒烟（BCard 图标槽明度差降档+商店居中+营地四栏等高）----
 func _smoke_element_details() -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:274 （元素细节源码锚组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:274 （元素细节源码锚组）
 	print("--- UI 元素细节余②③（图标槽降档+布局修）---")
 	var uikit_s = load("res://presentation/views/ui_kit.gd")
 	# ②白图标 ≥3:1 图形对比硬约束＋降档方向锚定
@@ -720,7 +720,7 @@ func _smoke_element_details() -> void:
 
 # ---- 诊断转储钮冒烟（角落钮不在玩家画面+转储入口在调试浮窗；V6）----
 func _smoke_diag_button_retired() -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:260 （诊断钮退役契约组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:260 （诊断钮退役契约组）
 	print("--- UI 诊断转储钮退役（V6：玩家画面清零+浮窗可达）---")
 	var main_src: String = FileAccess.get_file_as_string("res://presentation/main.gd")
 	Kit.check("V6 主区无 build_diag_button 调用残留（旧实现同批清理）",
@@ -744,7 +744,7 @@ func _smoke_diag_button_retired() -> void:
 #      断言归 ui_struct_probe 呈现侧，本段只管数据面；跨关解锁概览断言族随面板换代退役——
 #      替换判据=sv5 零旧段＋八键投影断言（实现报告 §8.3 申报））----
 func _status_panel_projection() -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:274 （状态面板只读投影组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:274 （状态面板只读投影组）
 	print("--- 状态面板·本局信息面板投影一致性（迭代36 卡③——八键快照手拼夹具，同构口径不依赖 runner）---")
 	_meta_smoke_cleanup()   # 套件级夹具清场（生涯页 fixture 依赖此前置——旧状态段同款保留）
 	# 夹具（代拍板 4——任意非零可辨值，禁读 data/tables 现值、禁与属性行断言共值致误判掩盖）
@@ -805,7 +805,7 @@ func _all_labels(root: Node) -> Array:
 #      只读性连接巡检与零动效断言归 ui_struct_probe 呈现侧，本段只管数据面+旧档载入显示
 #      （v5 样档升 v6——完成定义 6「计数域缺省补零、页正常显示」））----
 func _career_overlay_projection() -> void:
-# oracle: design/ux/camp.md:45 （生涯页只读投影组）
+# 判据出处: design/ux/camp.md:45 （生涯页只读投影组）
 	print("--- 生涯页·只读投影一致性（隔离档 smoke_meta_career/career_v5）---")
 	var sv = _meta_new_save(_META_SMOKE_PATHS[9])
 	var mp = load("res://core/meta_progression.gd").new(_db, sv)
diff --git a/game/tests/unit/presentation/tune_sim_batch_parity_test.gd b/game/tests/unit/presentation/tune_sim_batch_parity_test.gd
index 5fff1de1..bb68381e 100644
--- a/game/tests/unit/presentation/tune_sim_batch_parity_test.gd
+++ b/game/tests/unit/presentation/tune_sim_batch_parity_test.gd
@@ -163,7 +163,7 @@ func _run_pair(n: int, frame_idx: Dictionary) -> Dictionary:
 
 
 func _check_n3(r: Dictionary) -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	var pa: FakePanel = r["pa"]
 	var pb: FakePanel = r["pb"]
 	var da: FakeDriver = r["da"]
@@ -196,7 +196,7 @@ func _check_n3(r: Dictionary) -> void:
 
 
 func _check_n0(r: Dictionary) -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	var pa: FakePanel = r["pa"]
 	var pb: FakePanel = r["pb"]
 	var da: FakeDriver = r["da"]
diff --git a/game/tests/unit/presentation/type_glow_test.gd b/game/tests/unit/presentation/type_glow_test.gd
index 7a0e9dd5..71029b99 100644
--- a/game/tests/unit/presentation/type_glow_test.gd
+++ b/game/tests/unit/presentation/type_glow_test.gd
@@ -46,7 +46,7 @@ const CONST_NAME := {
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:267 （微光数据面宿主——装载组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:267 （微光数据面宿主——装载组）
 	_test_grouping_closed()
 	_test_frozen_hue_face()
 	_test_render_params()
@@ -57,7 +57,7 @@ func _init() -> void:
 
 # ① 归组封闭：九值全域映射＋清单外显式失败＋禁子串＋两带差异锚定
 func _test_grouping_closed() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	for t in TYPE_EXPECT:
 		var got: int = UiKitScript.glow_group_for_cell_type(t)
 		Kit.check("九型封闭：%s → 组%d（期望组%d）" % [t, got, int(TYPE_EXPECT[t])], got == int(TYPE_EXPECT[t]))
@@ -81,7 +81,7 @@ func _test_grouping_closed() -> void:
 
 # ② 冻结色相面：逐组 HSV 对照 art-bible §4.2 冻结值——只准动明度（ΔH≤0.2°／ΔS≤0.01）
 func _test_frozen_hue_face() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	for g in FROZEN:
 		var f: Color = FROZEN[g]
 		var m: Color = IMPL[g]
@@ -100,7 +100,7 @@ func _test_frozen_hue_face() -> void:
 
 # ③ 呈现参数锚定（art-bible §4.2 v2 冻结参数）
 func _test_render_params() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	Kit.check("泛光强度 α = 170/255（v2 呈现参数冻结）",
 		is_equal_approx(UiKitScript.TYPE_GLOW_ALPHA, 170.0 / 255.0))
 	Kit.check("带宽 = cell÷8（TYPE_GLOW_BAND_FRAC=0.125）",
@@ -112,7 +112,7 @@ func _test_render_params() -> void:
 
 # ④ 合成空间阶梯：模型域单调 + 相邻组 CR ≥1.20（色弱互辨数据面预判；终审=探针实测）
 func _test_gamma_ladder() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	# 合成模型（ui_kit 头注登记口径）：带内均值 ≈ 0.49×色值 + 0.51×瓦片（BRICK 未开掩尘地砖）
 	var k := 0.49
 	var tile: Color = UiKitScript.BRICK
@@ -139,7 +139,7 @@ func _test_gamma_ladder() -> void:
 
 # ⑤ probe API 形状：默认开＋空态键集（无板直取——不依赖棋盘装配）
 func _test_probe_api_shape() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	var view = BoardViewScript.new()
 	var snap: Dictionary = view.type_glow_probe()
 	Kit.check("probe 键集 = {enabled, cells, errors}",
diff --git a/game/tests/unit/presentation/ui_font_asset_test.gd b/game/tests/unit/presentation/ui_font_asset_test.gd
index d263f554..eb120344 100644
--- a/game/tests/unit/presentation/ui_font_asset_test.gd
+++ b/game/tests/unit/presentation/ui_font_asset_test.gd
@@ -11,7 +11,7 @@ const Kit := preload("res://tests/unit/test_kit.gd")   # T6 收口：_check/汇
 
 
 func _init() -> void:
-# oracle: design/gdd/systems/表现与支撑/HUD框架.md:281 （中文字体随包与字形覆盖组）
+# 判据出处: design/gdd/systems/表现与支撑/HUD框架.md:281 （中文字体随包与字形覆盖组）
 	var path: String = UiKitScript.FONT_UI
 	var f: Font = UiKitScript.load_font(path)
 	Kit.check("随包字体守卫装载非空（res://assets/fonts/ui_font_fusion_pixel_zh_hans.ttf）", f != null)
diff --git a/game/tests/unit/save_rng_roundtrip_test.gd b/game/tests/unit/save_rng_roundtrip_test.gd
index 756d4d64..01382d0b 100644
--- a/game/tests/unit/save_rng_roundtrip_test.gd
+++ b/game/tests/unit/save_rng_roundtrip_test.gd
@@ -20,7 +20,7 @@ var _disk: String
 
 
 func _init() -> void:
-# oracle: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
 	_disk = ProjectSettings.globalize_path(SAVE_PATH)
 	_clear_disk()
 	_db = load("res://core/config_db.gd").new() as ConfigDb
@@ -36,7 +36,7 @@ func _init() -> void:
 
 # ---- 用例一：盘上往返保真——写档再读回，断点逐键零漂移 ----
 func _test_disk_roundtrip_preserves_breakpoint() -> void:
-# oracle: design/gdd/systems/表现与支撑/存档序列化.md:180 （存档⇄RNG 快照往返——断点域逐位组）
+# 判据出处: design/gdd/systems/表现与支撑/存档序列化.md:180 （存档⇄RNG 快照往返——断点域逐位组）
 	var rng := RngServiceScript.new()
 	var sm := SaveManagerScript.new(SAVE_PATH)
 	var adr := AdventureRunnerScript.new(_db, rng)
@@ -67,7 +67,7 @@ func _test_disk_roundtrip_preserves_breakpoint() -> void:
 
 # ---- 用例二：旧版本档经迁移链后仍可续玩（单测不覆盖的跨系统闭环面）----
 func _test_old_version_save_migrates_and_resumes() -> void:
-# oracle: design/gdd/systems/表现与支撑/存档序列化.md:179 （旧档迁移链读回续玩组）
+# 判据出处: design/gdd/systems/表现与支撑/存档序列化.md:179 （旧档迁移链读回续玩组）
 	var rng := RngServiceScript.new()
 	var sm := SaveManagerScript.new(SAVE_PATH)
 	var adr := AdventureRunnerScript.new(_db, rng)
diff --git a/reports/需求卡片-QA覆盖余量收口批-2026-11-07.md b/reports/需求卡片-QA覆盖余量收口批-2026-11-07.md
index f3745988..8cace893 100644
--- a/reports/需求卡片-QA覆盖余量收口批-2026-11-07.md
+++ b/reports/需求卡片-QA覆盖余量收口批-2026-11-07.md
@@ -99,7 +99,7 @@
 ### T1 G1 schema 违约词负面断言（1.0 日）
 - [ ] 新增 `game/tests/unit/schema_vocab_violation_test.gd`：七个检查函数——`_check_empty_tables`（八表空行集注入→errs 含 empty_table）、`_check_settlement_vocab`（missing_segment／pperfect_oob／segorder_violation 三注入）、`_check_zero_flat_guard`（feat＋treasure 两表 zero_flat 白名单违约注入）、`_check_keystone_cost_domain`（meta attune 行 keystone_cost 域外注入）、`_check_use_phase_domain`（treasure use_phase 出域注入，覆盖 active_dig 枚值面）、`_check_solver_frozen`（board_gen solver_rules="single" 注入→frozen 拒，同钉 single_subset 冻结语义）、`_check_meta_tree_load_bearing`（meta_tree 彩蛋 cap>3 违约注入→category=load_bearing）
 - [ ] 注入形态沿在役先例 `load(schema).new()` 新实例＋行注入（`meta_progression_forge_test.gd:581` 同款）——禁改共享 Resource（避引擎 Gotcha：共享 Resource 池污染）
-- [ ] 每检查函数带 `# oracle:` 注记锚 `design/engineering/test-conventions.md:67`
+- [ ] 每检查函数带 `# 判据出处:` 注记锚 `design/engineering/test-conventions.md:67`
 - [ ] `game/tests/run_all.gd` `_suites()` manifest 登记新套件（缺登记则全套件不含本件）
 - [ ] 验证：单件直跑绿（读数入提交信息）
 
diff --git a/tools/capability_audit.py b/tools/capability_audit.py
index be4df145..6ff74464 100644
--- a/tools/capability_audit.py
+++ b/tools/capability_audit.py
@@ -16,7 +16,7 @@ r"""capability_audit.py — 能力清单、覆盖域表与 GDD 纯度机检（
     对上能力表里的行名；部分／未覆盖行的缺口非空且指待办清单。
   G 判据出处随测注记（test-conventions §8.3）：game/tests/** 与 game/probe/** 内每个验证函数
     （函数体含 check(/check_quiet(/_problems.append(/push_error( 判定调用，定义行与 _check( 前缀除外）
-    须带 ≥1 条 `# oracle: <design/相对路径>:<行号> <判据一句>` 注记；指针指向存在的设计文档行且不出
+    须带 ≥1 条 `# 判据出处: <design/相对路径>:<行号> <判据一句>` 注记；指针指向存在的设计文档行且不出
     design/ 全域。扫描面＝game/tests/**＋game/probe/**（sim/ 不进——测量面直构惯例）。
   条件闸行豁免（代表用例含「条件闸」字样）不参与 D/E。
 
@@ -337,13 +337,13 @@ def check_coverage(cov_tables, names):
         red(README.relative_to(REPO), 1, "覆盖域表", "%s 未在覆盖域表登记" % doc)
 
 
-ORACLE_RE = re.compile(r"^#\s*oracle:\s*(\S+\.md):(\d+)\s+\S")
+CRITERION_RE = re.compile(r"^#\s*判据出处:\s*(\S+\.md):(\d+)\s+\S")
 VERDICT_RE = re.compile(r"(?<![_\w])check(?:_quiet)?\(|_problems\.append\(|push_error\(")
-ORACLE_FUNC_RE = re.compile(r"^(?:static\s+)?func\s+([A-Za-z_]\w*)")
+CRITERION_FUNC_RE = re.compile(r"^(?:static\s+)?func\s+([A-Za-z_]\w*)")
 
 
-def check_oracle_markers():
-    """判据出处随测注记机检（G 道）：验证函数须带 # oracle 注记，指针可核。"""
+def check_criterion_markers():
+    """判据出处随测注记机检（G 道）：验证函数须带 # 判据出处: 注记，指针可核。"""
     files = sorted((REPO / "game" / "tests").rglob("*.gd")) + sorted((REPO / "game" / "probe").glob("*.gd"))
     files = [p for p in files if p.name != "test_kit.gd" and p.name != "run_all.gd"]
     if not files:
@@ -355,7 +355,7 @@ def check_oracle_markers():
         lines = read(p).splitlines()
         starts = []
         for i, ln in enumerate(lines):
-            m = ORACLE_FUNC_RE.match(ln)
+            m = CRITERION_FUNC_RE.match(ln)
             if m:
                 starts.append((m.group(1), i))
         ranges = []
@@ -379,11 +379,11 @@ def check_oracle_markers():
             for ln in body:
                 st = ln.strip()
                 if st.startswith("#"):
-                    m = ORACLE_RE.match(st)
+                    m = CRITERION_RE.match(st)
                     if m:
                         oks.append(m)
             if not oks:
-                red(rel, s0 + 1, "判据出处注记", "验证函数 %s 缺 # oracle 注记" % name)
+                red(rel, s0 + 1, "判据出处注记", "验证函数 %s 缺 # 判据出处: 注记" % name)
                 flagged += 1
                 continue
             marked += 1
@@ -421,16 +421,16 @@ def main():
     names, referenced = check_capability_rows(cap_tables, suites, funcs, cards_corpus())
     missing_suites = check_suite_coverage(suites, referenced)
     check_coverage(cov_tables, names)
-    oracle_marked, oracle_flagged = check_oracle_markers()
+    criterion_marked, criterion_flagged = check_criterion_markers()
 
     if selfcheck:
         print("capability_audit 扫描面异常：")
         for s in selfcheck:
             print("  ! " + s)
 
-    print("| ── 能力审计：系统文档 %d 篇 · 能力行 %d · 套件 %d · 覆盖域表 %d 行 · 链断套件 %d · oracle 注记函数 %d · 红项 %d"
+    print("| ── 能力审计：系统文档 %d 篇 · 能力行 %d · 套件 %d · 覆盖域表 %d 行 · 链断套件 %d · 判据出处注记函数 %d · 红项 %d"
           % (len(system_docs()), len(names), len(suites),
-             sum(len(r) for _, r in cov_tables), len(missing_suites), oracle_marked, len(reds)))
+             sum(len(r) for _, r in cov_tables), len(missing_suites), criterion_marked, len(reds)))
     for path, line, check, msg in reds:
         print("  ✗ [%s] %s:%d %s" % (check, path, line, msg))
     if selfcheck:
diff --git a/tools/coverage_enum.py b/tools/coverage_enum.py
index bb8d1e87..54b51084 100644
--- a/tools/coverage_enum.py
+++ b/tools/coverage_enum.py
@@ -18,7 +18,7 @@ r"""coverage_enum.py — 本体枚举器（游戏内容↔测试验证对账，B
   比对＝差集：本体存在、验证零关联＝缺口清单，按类别分组、标首见批次（本工具生成时间）。
 
 诚实边界（契约 §7 在案）：grep 关联有假阳假阴——断言测了实体但文本没带 id＝假缺口（人工核销
-兜）；文本带 id 但断言弱＝假覆盖（oracle 改造堵）。推荐约定「断言文本含被测实体 id」提高精度，
+兜）；文本带 id 但断言弱＝假覆盖（判据改造堵）。推荐约定「断言文本含被测实体 id」提高精度，
 不立规约。交互点（按钮/物件被点过没有）不在本工具判据内——那归探针真输入覆盖登记。
 
 用法:  python tools/coverage_enum.py [--out <路径>]
diff --git a/待办清单.md b/待办清单.md
index 14003875..3eca9ddc 100644
--- a/待办清单.md
+++ b/待办清单.md
@@ -299,7 +299,7 @@
 
 #### 测试面真输入化分期与存量断言逐条精锚（2026-11-05 登记，来源=批次移交）
 
-**实况**：证据＝test-conventions §8.3「判据出处行锚」「真实入口判定口径」两条文＋§2「UI 驱动断言须走真输入管线」条文（批1补，qa-harness 分支 2cbd2ca9）＋「测试函数的判据出处注记」条款与机检 G 道（2026-11-06 批，capability_audit --strict 绿 402 函数）。已承接＝探针 emit 站点两批合计（QA 批两探针 51+1 与真输入化批七探针 63 处，8 处在案保留带注记）＋判据出处注记全库铺开（402 验证函数挂 `# oracle:` 指针）。剩余面＝视图层测试方法面（press_candidate／press_continue／press_card／press_confirm／press_refresh_for_probe 等探针消费口，非 emit 站点）。
+**实况**：证据＝test-conventions §8.3「判据出处行锚」「真实入口判定口径」两条文＋§2「UI 驱动断言须走真输入管线」条文（批1补，qa-harness 分支 2cbd2ca9）＋「测试函数的判据出处注记」条款与机检 G 道（2026-11-06 批，capability_audit --strict 绿 402 函数）。已承接＝探针 emit 站点两批合计（QA 批两探针 51+1 与真输入化批七探针 63 处，8 处在案保留带注记）＋判据出处注记全库铺开（402 验证函数挂 `# 判据出处:` 指针）。剩余面＝视图层测试方法面（press_candidate／press_continue／press_card／press_confirm／press_refresh_for_probe 等探针消费口，非 emit 站点）。
 
 **改动面**：游戏代码
 

From 76b86dc44d9c5285180b3405b5977c230aa33e59 Mon Sep 17 00:00:00 2001
From: DKChan <524912269@qq.com>
Date: Sat, 7 Nov 2026 07:13:50 +0800
Subject: [PATCH 3/5] =?UTF-8?q?docs(08):=20=E5=88=A0=E3=80=8C=E9=80=90?=
 =?UTF-8?q?=E8=A1=8C=E7=BB=93=E7=AE=97=E6=8E=92=E6=92=AD=E3=80=8D=E8=A1=8C?=
 =?UTF-8?q?=EF=BC=882026-11-07=20=E7=94=A8=E6=88=B7=E4=BB=A4=EF=BC=89?=
 =?UTF-8?q?=EF=BC=8B=E6=96=87=E9=A6=96=E7=89=88=E6=9C=AC=E5=8F=B7=20v1.28?=
 =?UTF-8?q?=E2=86=92v1.29?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

用户裁定该表现不是想要的，Alpha 表现清单删除此行；同表「战斗演出链（弹道/受击/血条/灰化）在役」行保留，覆盖伤害飘字与攻击特效。待办清单第一条缺口同步去掉已完成的删行项，余项＝文字列表退役范围、日志两处中文字段清理、battle 不可整体跳过承诺与战斗表现因果可读判据改写。凭据：开工现查 166114e0 远端 CI conclusion=success（exit=0）；文档域闸 --docs【验收通过】无新增红 exit=0。
---
 design/gdd/08-Alpha版本标准.md | 3 +--
 待办清单.md                    | 2 +-
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/design/gdd/08-Alpha版本标准.md b/design/gdd/08-Alpha版本标准.md
index 144eff1c..ef64060f 100644
--- a/design/gdd/08-Alpha版本标准.md
+++ b/design/gdd/08-Alpha版本标准.md
@@ -2,7 +2,7 @@
 
 > **一句话定位**：本文定义这个项目的 **Alpha 版本包含哪些东西**——它是里程碑 M3 的完成标准，也是判断"还差什么"的对照表。
 > **本文只列条目，不写内容**：每样东西是什么、规则怎么走，一律归各自的权威文档，本文只给指路链接。想知道某样东西的定义，请点链接，不要在本文里找解释。
-> **状态**：**已定稿（v1.28）**——2026-10-13 用户令定稿，历次升版明细见 git 提交史。Alpha 的内容范围自此冻结：增删条目一律须经用户裁决。
+> **状态**：**已定稿（v1.29）**——2026-10-13 用户令定稿，历次升版明细见 git 提交史。Alpha 的内容范围自此冻结：增删条目一律须经用户裁决。
 > **成文**：2026-10-13。
 
 ## 本文怎么用
@@ -152,7 +152,6 @@ Alpha 内以玩法循环本身的内容与表现为主（棋盘、关卡、战
 | 主角立绘三态 | [角色设计](../art/character-design.md) | 在役 |
 | 状态图标 | [美术圣经](../art/art-bible.md) | 在役 |
 | 战斗演出链（弹道 / 受击 / 血条 / 灰化） | [战斗表现](systems/战斗循环/战斗表现.md) | 在役 |
-| 逐行结算排播 | [settlement-summary](../ux/settlement-summary.md) | 在役 |
 | 减动效开关 | [设置与本地化](systems/表现与支撑/设置与本地化.md) | 在役 |
 | 全局纹理过滤设为邻近采样 | [待办清单](../../待办清单.md) | 在役（default_texture_filter=0＋平滑渐变件三处显式 LINEAR 白名单，翻转面全枚举闭合） |
 | UI 字体（全局像素字，Fusion Pixel 单套单字重） | [美术圣经](../art/art-bible.md) §7.4 | 在役（现状即终稿——拉丁沿用自带字形不另接专件、不上第二字重；信息层级手段＝字号档差＋墨色深浅） |
diff --git a/待办清单.md b/待办清单.md
index 14003875..f1e322b7 100644
--- a/待办清单.md
+++ b/待办清单.md
@@ -57,7 +57,7 @@
 
 **实况**：用户裁定撤掉战斗屏结算期逐行滚动的文字列表，保留伤害飘字与攻击特效；日志零文案只存字段。现行日志已逐行全字段落盘（game/presentation/playtest_logger.gd:130-143；开新／续玩均开会话，game/presentation/main.gd:247/:295）——零缺漏、无需补采，与裁定不符处是日志多带中文文案两处（text 与平铺的 display_name）。文字列表消费面＝game/presentation/views/battle_log_view.gd:173-260 与 game/presentation/row_pacer.gd:100；动画特效走 target／target_id，不依赖行文案（game/presentation/views/battle_stage_view.gd:328-341）。[战斗结算](design/gdd/systems/战斗循环/战斗结算.md) v1.8 明细流水节规范句仍写「文案入表、代码读表拼行」，与本裁定相反。
 
-**缺口**：还差设计讨论——文字列表退役范围（飘字与特效保留面）、日志两处中文字段清理、[08-Alpha版本标准](design/gdd/08-Alpha版本标准.md)「逐行结算排播」行删行（同表「战斗演出链」行已覆盖保留面）、[battle](design/ux/battle.md) 不可整体跳过承诺与[战斗表现](design/gdd/systems/战斗循环/战斗表现.md) 因果可读验收判据改写。
+**缺口**：还差设计讨论——文字列表退役范围（飘字与特效保留面）、日志两处中文字段清理、[battle](design/ux/battle.md) 不可整体跳过承诺与[战斗表现](design/gdd/systems/战斗循环/战斗表现.md) 因果可读验收判据改写。
 
 **改动面**：文档＋游戏代码
 

From b03e4eeee83fb4d0ee7a6e03f577610f2d705fa8 Mon Sep 17 00:00:00 2001
From: DKChan <524912269@qq.com>
Date: Sat, 7 Nov 2026 07:24:35 +0800
Subject: [PATCH 4/5] =?UTF-8?q?docs(=E5=BE=85=E5=8A=9E=E9=80=80=E5=BD=B9+0?=
 =?UTF-8?q?8=E5=88=A0=E8=A1=8C):=20=E3=80=8CUI=20=E6=B0=9B=E5=9B=B4?=
 =?UTF-8?q?=E5=B1=82=E4=B8=8E=E4=B9=9D=E5=AE=AB=E6=A0=BC=E5=88=87=E7=89=87?=
 =?UTF-8?q?=E8=A7=82=E6=84=9F=E4=BF=AE=E3=80=8D=E6=8C=89=202026-11-07=20?=
 =?UTF-8?q?=E7=94=A8=E6=88=B7=E8=A3=81=E3=80=8C=E5=B7=B2=E8=A7=A3=E5=86=B3?=
 =?UTF-8?q?=E3=80=8D=E7=BB=93=E6=A1=88=E2=80=94=E2=80=94=E5=BE=85=E5=8A=9E?=
 =?UTF-8?q?=E6=B8=85=E5=8D=95=E6=9D=A1=E7=9B=AE=E6=95=B4=E6=9D=A1=E5=88=A0?=
 =?UTF-8?q?=E9=99=A4+UI=20=E8=B4=B4=E5=9B=BE=E9=87=8D=E6=9E=84=E6=89=B9?=
 =?UTF-8?q?=E5=AE=9E=E5=86=B5=E5=86=85=E6=8C=87=E6=B6=89=E5=8F=A5=E6=B8=85?=
 =?UTF-8?q?=E7=90=86+08=20=E8=A1=A8=E7=8E=B0=E6=B8=85=E5=8D=95=E5=90=8C?=
 =?UTF-8?q?=E5=90=8D=E8=A1=8C=E6=95=B4=E8=A1=8C=E7=A7=BB=E5=87=BA=E3=80=81?=
 =?UTF-8?q?=E6=96=87=E9=A6=96=20v1.29=E2=86=92v1.30;=20=E5=87=AD=E6=8D=AE:?=
 =?UTF-8?q?=20--docs=E3=80=90=E9=AA=8C=E6=94=B6=E9=80=9A=E8=BF=87=E3=80=91?=
 =?UTF-8?q?exit=3D0=20=E6=97=A0=E6=96=B0=E5=A2=9E=E7=BA=A2(=E5=9B=9E?=
 =?UTF-8?q?=E6=89=A7=20game/tests/.gates/receipt.json)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 design/gdd/08-Alpha版本标准.md |  3 +--
 待办清单.md                    | 12 +-----------
 2 files changed, 2 insertions(+), 13 deletions(-)

diff --git a/design/gdd/08-Alpha版本标准.md b/design/gdd/08-Alpha版本标准.md
index ef64060f..3e335e3c 100644
--- a/design/gdd/08-Alpha版本标准.md
+++ b/design/gdd/08-Alpha版本标准.md
@@ -2,7 +2,7 @@
 
 > **一句话定位**：本文定义这个项目的 **Alpha 版本包含哪些东西**——它是里程碑 M3 的完成标准，也是判断"还差什么"的对照表。
 > **本文只列条目，不写内容**：每样东西是什么、规则怎么走，一律归各自的权威文档，本文只给指路链接。想知道某样东西的定义，请点链接，不要在本文里找解释。
-> **状态**：**已定稿（v1.29）**——2026-10-13 用户令定稿，历次升版明细见 git 提交史。Alpha 的内容范围自此冻结：增删条目一律须经用户裁决。
+> **状态**：**已定稿（v1.30）**——2026-10-13 用户令定稿，历次升版明细见 git 提交史。Alpha 的内容范围自此冻结：增删条目一律须经用户裁决。
 > **成文**：2026-10-13。
 
 ## 本文怎么用
@@ -156,7 +156,6 @@ Alpha 内以玩法循环本身的内容与表现为主（棋盘、关卡、战
 | 全局纹理过滤设为邻近采样 | [待办清单](../../待办清单.md) | 在役（default_texture_filter=0＋平滑渐变件三处显式 LINEAR 白名单，翻转面全枚举闭合） |
 | UI 字体（全局像素字，Fusion Pixel 单套单字重） | [美术圣经](../art/art-bible.md) §7.4 | 在役（现状即终稿——拉丁沿用自带字形不另接专件、不上第二字重；信息层级手段＝字号档差＋墨色深浅） |
 | 战斗一屏样张（界面美术的终稿闸） | [美术圣经](../art/art-bible.md) §1.4 | 在役（样张整体过闸——用户实机目检核销，沿革查 git 提交史；目标规格与五项实装定值单点=art-bible 五张规格表。主角＋三 Boss 重产依赖照旧；站桩帧动画已改排 Beta，见「六 · Alpha 不含」） |
-| UI 氛围层与九宫格切片观感修 | [待办清单](../../待办清单.md) | 部分在役（光柱硬边已修＝连续 alpha 渐变；未结半＝九宫格切片错位——Alpha 内做最小修复：核对素材尺寸，必要时重出九宫格素材，全套素材重出排 Beta；出口＝结算屏与图例屏错位消失，渲染闸＋用户目检通过） |
 | UI 元素细节修（滑轨填充 / 图标垫块 / 留白 / 开发件外泄） | [待办清单](../../待办清单.md) | 在役（四子项中滑轨填充注销，余三件——图标垫块明度差降档/商店+营地布局修/诊断钮迁调试浮窗——全落地） |
 
 ---
diff --git a/待办清单.md b/待办清单.md
index f1e322b7..1ca8b2fd 100644
--- a/待办清单.md
+++ b/待办清单.md
@@ -75,7 +75,7 @@
 
 #### UI 贴图重构批——元进度件仍是程序化占位（2026-10-13 登记，来源=审计发现）
 
-**实况**：元进度图标目前仍是程序化画出来的占位形态，没有上贴图（原登记见 [美术资产清单](design/art/art-assets-checklist.md)）。规格已定——烛光黄 `#F6C667` 配木色 `#8A5A34`（见 [美术圣经](design/art/art-bible.md) §4.4），素材来源允许走"通用图标改色复用"低成本渠道。营地柜台贴图义务已随营地场景图形态终结（见 [camp](design/ux/camp.md)）；九宫格切片错位归「UI 氛围层与九宫格切片观感修」条。本条余元进度件贴图终稿，排 Beta。
+**实况**：元进度图标目前仍是程序化画出来的占位形态，没有上贴图（原登记见 [美术资产清单](design/art/art-assets-checklist.md)）。规格已定——烛光黄 `#F6C667` 配木色 `#8A5A34`（见 [美术圣经](design/art/art-bible.md) §4.4），素材来源允许走"通用图标改色复用"低成本渠道。营地柜台贴图义务已随营地场景图形态终结（见 [camp](design/ux/camp.md)）。本条余元进度件贴图终稿，排 Beta。
 
 **缺口**：还差一次「自己画 vs 找 CC0 素材改色」的美术裁决（见 [美术资产清单](design/art/art-assets-checklist.md) §0 的复用渠道闸），裁决后才能定素材工单写卡。
 
@@ -83,16 +83,6 @@
 
 **状态**：待美术设计（备选）
 
-#### UI 氛围层与九宫格切片观感修——光柱硬边与面板切片错位（2026-10-13 登记，来源=审计发现）
-
-**实况**：原两处，一处已修一处存续。①光柱硬边**已修**（`ui_kit.gd` 光柱贴片改带内 alpha 0→0.05→0 三角过渡＋纵向衰减上亮下暗的连续渐变方案）。②九宫格切片错位**存续**——结算屏与图例屏的面板边缘可见错位小方块，成因是九宫格切片参数与素材尺寸不匹配（仪式石框 258 字节小图按 12 像素切片、石板亮面板 314 字节按 16 像素切片，铺到四百多像素宽面板中段拉出错位），须先核素材尺寸能否撑住新切片值（border_stone/panel_stone 均 48×48），可能要重出素材，归「UI 贴图重构批」后续贴图批次。
-
-**缺口**：还差「UI 贴图重构批」里的素材尺寸核对与「是否重出素材」裁决，才能定切片修法。
-
-**改动面**：美术素材＋游戏代码
-
-**状态**：待美术设计
-
 #### 扩展节点类型——危险/精英节点与特殊地形节点（2026-10-21 登记，来源=会话提及）
 
 **实况**：用户定方向：Alpha 版只留现行四类（战斗/奖励/恢复/商店），以下两类留到以后再做——①危险/精英节点（怪物与普通战斗不同、奖励肥）；②特殊地形节点（效果修饰：地图战斗资源、敌我伤害、金币比例等）。内容未设计。

From 7618ee44c6e851d4e7701526ac0e71e8b23c0b10 Mon Sep 17 00:00:00 2001
From: DKChan <524912269@qq.com>
Date: Sat, 7 Nov 2026 07:34:17 +0800
Subject: [PATCH 5/5] =?UTF-8?q?docs(=E5=86=99=E5=8D=A1=E6=AE=B5):=20?=
 =?UTF-8?q?=E7=BB=93=E7=AE=97=E6=9C=9F=E6=96=87=E5=AD=97=E5=88=97=E8=A1=A8?=
 =?UTF-8?q?=E9=80=80=E5=BD=B9=E4=B8=8E=E6=97=A5=E5=BF=97=E9=9B=B6=E6=96=87?=
 =?UTF-8?q?=E6=A1=88=E9=9C=80=E6=B1=82=E5=8D=A1=E7=89=87=EF=BC=882026-11-0?=
 =?UTF-8?q?7=20=E7=94=A8=E6=88=B7=E4=BB=A4=EF=BC=89?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

设计前置按用户明示「设完了就写卡」认定会话设计讨论闭合（待裁点清零＋用户点头），待办条目状态推进「文档设计已闭合＋已写卡」。卡片按 req-card 十四节成文；同步 game/tests/README.md 能力行换代与覆盖域表（§8.3 写卡段当场入表）。卡内如实补正上一轮核查漏项：tools/analyze_playtest.py 四处读 text 判读，须补 reason 结构化字段并改读结构化字段。凭据：流水线闸 PASS（34 条目·总表 55 行·交叉核 1 链·卡片口径 3 张全过）；能力审计 --strict 红项 0；文档域闸 --docs【验收通过】无新增红 exit=0。
---
 game/tests/README.md                          |   5 +-
 ...��求卡片-结算期文字列表退役批-2026-11-07.md | 183 ++++++++++++++++++
 待办清单.md                                   |   6 +-
 3 files changed, 188 insertions(+), 6 deletions(-)
 create mode 100644 reports/需求卡片-结算期文字列表退役批-2026-11-07.md

diff --git a/game/tests/README.md b/game/tests/README.md
index f8e9c51d..a32e04e8 100644
--- a/game/tests/README.md
+++ b/game/tests/README.md
@@ -132,7 +132,8 @@ tests/
 | 能力 | 系统 | 真实入口 | 代表用例（文件:函数） |
 |---|---|---|---|
 | 拒绝反馈分面可辨与未知兜底文案 | HUD框架 | `HudPresenter.outcome_text()` | `hud_presenter_test.gd:_test_reject_text_by_reason`；`hud_presenter_test.gd:_test_unknown_reason_fallback`；`hud_presenter_test.gd:_test_accepted_text` |
-| 结算明细带逐行呈现与排播节奏 | HUD框架 | `BattleLogView.append_row()`／`RowPacer.pace_delay_for()` | `theme_projection_test.gd:_smoke_battle_log_view`；`player_copy_sweep_test.gd:_sweep_source_names`；`pacing_queue_test.gd:_init` |
+| 结算期零逐行文字与 FX 排播链保持 | HUD框架 | `RowPacer._consume_row()`／`BattleStageView.on_step_row_fx()`（真实停手→轮末结算→B 区场景树与 FX 调用面） | `battle_log_zero_text_test.gd:_smoke_settle_zero_rows`；`pacing_queue_test.gd:_assert_fx_chain`；`standee_fx_sweep_test.gd:_init` |
+| 日志 step 行零文案与结构化判读等价 | 表现与支撑 | `PlaytestLogger._on_step_row()`→`PlaytestLogger._append()`（真实结算→落盘 JSONL 读回） | `playtest_logger_step_fields_test.gd:_assert_no_text_and_full_payload`；`reward_ineffective_reason_test.gd:_assert_four_reasons` |
 | 模态覆盖层编排与输入锁 | HUD框架 | `ModalFlow.locks_input()`／`ModalFlow.open_after_playback()` | `modal_flow_test.gd:_init`；`reward_overlay_test.gd:_run` |
 | 模态句柄分域寻址面 | HUD框架 | 局内／菜单／营地三子容器句柄经注册面合同寻址（`UiRegistry.node()` 逐键取层）＋模态编排口开合（`ModalFlow.open()`／`ModalFlow.close()`） | `ui_struct_probe.gd:_modal_registry_contract`（registry 合同序段＋分域句柄段） |
 | 未开格类型微光（8 邻作用集／五组色相／零玩法写入） | HUD框架 | `BoardView.type_glow_probe()`／`UiKit.glow_group_for_cell_type()` | `theme_projection_test.gd:_smoke_type_glow`；`type_glow_test.gd:_test_grouping_closed`；`type_glow_test.gd:_test_frozen_hue_face` |
@@ -215,7 +216,7 @@ tests/
 | 排雷循环 | 排雷玩法.md | 装板与开局免费展开（封锁格无资源、计入清图）；挖／封印合法性与可辨拒绝（拒绝零副作用）；封印不可逆与挖开封印格放行（兑付改判四情况） | 已覆盖 | — |
 | 排雷循环 | 棋盘生成.md | 棋盘按参数行出图、数字恒真；同参数同种子逐位复现、异种子不退化；可推理率与清图可达（合法性先于质量分）、重试有界、降级诚实 | 已覆盖 | — |
 | 排雷循环 | 行动经济.md | AP 扣费、末点耗尽即收轮与战斗收束清零；停手转存储备与轮内刷新（上限／AP 不重置／刷新图零清图奖励）；下轮行动点修正排队与兑现 | 已覆盖 | — |
-| 表现与支撑 | HUD框架.md | 拒绝反馈分面可辨与未知兜底文案；结算明细带逐行呈现与排播节奏；模态覆盖层编排与输入锁；未开格类型微光（8 邻作用集／五组色相／零玩法写入）；UI 全局主题与按钮五态（含对比度锚）；中文字体随包与字形覆盖；地形瓦片套与格面数字可读；战斗叙述与终局文案（数值带入／胜负互异）；玩家面文案与危险格格面字形；战斗屏三区几何与棋盘格边长（分辨率两档×四档板型）；B 区舞台背景三关变体与连续地面层（按 board_type 选图／地面层高度读布局表／四柱光柱退役）；模态句柄分域寻址面 | 已覆盖 | — |
+| 表现与支撑 | HUD框架.md | 拒绝反馈分面可辨与未知兜底文案；结算期零逐行文字与 FX 排播链保持；模态覆盖层编排与输入锁；未开格类型微光（8 邻作用集／五组色相／零玩法写入）；UI 全局主题与按钮五态（含对比度锚）；中文字体随包与字形覆盖；地形瓦片套与格面数字可读；战斗叙述与终局文案（数值带入／胜负互异）；玩家面文案与危险格格面字形；战斗屏三区几何与棋盘格边长（分辨率两档×四档板型）；B 区舞台背景三关变体与连续地面层（按 board_type 选图／地面层高度读布局表／四柱光柱退役）；模态句柄分域寻址面 | 已覆盖 | — |
 | 表现与支撑 | 存档序列化.md | 存档写盘⇄读回往返保真；三槽位隔离与激活失败回滚；槽位摘要窥视与坏槽三态；启动态无激活不写盘；旧档迁移链与断点续玩零跳号；存档⇄RNG 快照往返保真 | 已覆盖 | — |
 | 表现与支撑 | 教学引导.md | — | 未覆盖 | 教学形态与首遇时机待设计；见待办清单「教学形态未定」条 |
 | 表现与支撑 | 数据配置.md | 全表装载、就绪态与表清单目录对账；进度坐标查行：精确命中／向上取整／封顶／警告去重；运行期越域致命与进程非 0 退出；加载期违规表拒绝：跨表悬空／计数器前缀／真视窄域；表结构守卫：域校验／行序键／跨字段互锁／配额锚 | 已覆盖 | — |
diff --git a/reports/需求卡片-结算期文字列表退役批-2026-11-07.md b/reports/需求卡片-结算期文字列表退役批-2026-11-07.md
new file mode 100644
index 00000000..e3b524a2
--- /dev/null
+++ b/reports/需求卡片-结算期文字列表退役批-2026-11-07.md
@@ -0,0 +1,183 @@
+# 需求卡片：结算期文字列表退役与日志零文案批
+
+> 状态：待用户裁决（写完呈用户，开工令归 /iter 或用户另行发令）
+> 验收档：中（依据 test-conventions §8.3：后果玩家可见但不损持久状态，本批不动存档写读、RNG 流、结算公式与数值表结构；用户批卡 U0 时可改判）
+> 来源：`待办清单.md`「结算期逐行文字列表退役与日志零文案」条（2026-11-07 登记，来源=会话提及）
+> **唯一事实源**＝2026-11-07 用户裁定（会话设计讨论闭合、待裁点清零）＋ `design/gdd/08-Alpha版本标准.md` v1.29（「逐行结算排播」行已删）＋ `待办清单.md` 该条实况。三处 GDD 条款改写属实现批禁写面，列在第 6 节由文档批落文。
+
+## 1 目标与完成定义
+
+撤掉战斗屏结算期一行行滚动的文字列表；保留伤害飘字、攻击特效与站桩动画；日志侧零中文文案、只存结构化字段，并保证数值分析判读结论与改前逐位一致。
+
+完成定义：①结算期 B 区不产任何逐行文字；②FX 排播链与两类 toast 仍在；③新日志 `step` 行零中文字段、原有全字段与全部 payload 仍在；④`tools/analyze_playtest.py` 对同一份历史锚与一份新日志的判读结论与改前一致；⑤每个需求点有从真实入口进入的正向验收断言并跑绿，读数写进该步提交信息。
+
+## 2 设计事实源
+
+- 用户裁定（2026-11-07 会话，待裁点清零、用户点头）：撤掉结算期逐行滚动文字列表；保留伤害飘字与攻击特效；日志零文案只存字段；战斗画面优化另立待办。
+- `design/gdd/08-Alpha版本标准.md` v1.29：「五、表现」表已删「逐行结算排播」行，「战斗演出链（弹道／受击／血条／灰化）在役」行保留。
+- `待办清单.md` 该条实况与状态（写卡时推进为「文档设计已闭合＋已写卡」）。
+- 设计闭合凭据说明：req-card 第〇步要求的闭合凭据＝用户裁定已落 `08-Alpha版本标准.md` v1.29；`battle.md`／`战斗结算.md`／`战斗表现.md` 三处条款改写不是设计待裁点，是按裁定的文档同步义务，按「实现批禁写 `design/`」纪律列进第 6 节与反哺点清单，由文档批落文。
+
+## 3 现状事实（代码级考证）
+
+| 事实 | 位置 |
+|---|---|
+| 结算行协议：`_emit_row()` 发 `step_row`，公共字段 type／source_class／origin_cell／round_index／display_name／value／highlight＋extra 全平铺 | `game/core/battle_orchestrator.gd:710-735` |
+| 玩家侧逐行文字渲染（7 处读 display_name、BBCode 行模板、上轮摘要、聚合计数） | `game/presentation/views/battle_log_view.gd:87-103`、`:146-264` |
+| 排播泵：文字入带是 `log_view.append_row/append_bb/finish_settlement_round`；FX 链是 `stage.on_step_row_fx`／`_play_cross_zone_fx`／`_play_settlement_mark`／`refresh_request`／`pump_ended` | `game/presentation/row_pacer.gd:83-101`、`:106-152` |
+| 动画定位走 target／target_id，不读行文案 | `game/presentation/views/battle_stage_view.gd:327-344` |
+| 两类 toast 仍读 display_name／display：清图奖励、Boss 半血解锁技名 | `game/presentation/main.gd:417-425`；`row_pacer.gd:97-100`；规格 `design/gdd/systems/战斗循环/敌人系统.md:207` |
+| 日志逐行全字段落盘；中文字段两处＝`text`（:138）与平铺进去的 `display_name`（:140-142） | `game/presentation/playtest_logger.gd:130-143` |
+| 开新／续玩均开日志会话并挂接战斗 | `game/presentation/main.gd:247-253`、`:295-302`；`game/presentation/main_adventure_flow.gd:62` |
+| 分析工具依赖 `text` 做四类判读：effect_id 反查、群伤奖励判定（两处）、未生效原因分类 | `tools/analyze_playtest.py:83-88`、`:189`、`:434`、`:471-478` |
+| 群伤行已有结构化 `target: "all_enemies"`；未生效行散有 `batch_key`／`forfeit`／`deferred`，无统一「原因」字段 | `game/core/damage_controller.gd:515-516`、`:623-624`；`game/core/reward_grant.gd:269-271`、`:362-369`；`game/core/settlement/combat_segment.gd:123-124`；`game/core/settlement/grant_segment.gd:103`、`:321` |
+| 玩家可见文案的现役测试／探针面 | `game/tests/README.md:135`；`game/tests/unit/presentation/theme_projection_test.gd:385`；`player_copy_sweep_test.gd:86-108`；`pacing_queue_test.gd:165`；`game/probe/ui_probe.gd:133-135`；`game/probe/ui_click_probe.gd:423`、`:473`、`:616`、`:798-844` |
+
+## 4 设计契约（🔴 触碰＝L3 停机呈报）
+
+1. 🔴 保留伤害飘字、攻击特效、站桩闪白／弹道／灰化；`row_pacer.gd:89-101` 的 FX 调用链与 `pump_ended`／`refresh_request` 零删改。文字列表退役不等于取消结算演出。
+2. 🔴 核心层 `step_row` 公共字段集不变：`display_name` 保留（清图奖励 toast、Boss 解锁技名 toast、历史日志兼容都读它）；本批只改日志消费端与补 `reason` 这类结构化 extra，不动 `_emit_row()` 签名与载荷键集。
+3. 🔴 日志逐行全字段落盘义务不变（kind／type／source／cell／round／value／highlight＋全部 payload）；只去掉 `text` 与 `display_name` 两份中文文案。
+4. 🔴 数值与随机零改动；玩法数值只经 ConfigDB 单点，随机只经 RngService；Core 零 UI。
+5. 🔴 实现批禁写 `design/` 整个目录、根规则文件与 `game/tests/README.md`（能力清单归写卡段维护）；文档义务只进 `reports/` 反哺点清单。
+6. 🔴 按 2026-10-24／2026-10-28 用户裁：禁变异类测试与撤销类取证，禁删断言／放宽阈值换绿；验收主力＝从真实入口进入的正向断言，同种子复放对拍只作兜底。
+
+## 5 范围边界
+
+- 做：撤 B 区逐行文字（含上轮摘要、轮首分隔行、聚合计数行的文字呈现）；日志零中文文案；补未生效原因的结构化字段；分析工具改读结构化字段；相关测试／探针改写成退役后的正向断言；能力行换代。
+- 不做：战斗画面优化（另立待办，等用户发令）、美术资产、`design/` 三处条款改写（文档批）、日志采集面扩充（除 `reason` 外零新增）、`step_row` 行协议重构、`08-Alpha版本标准.md`（已落地 v1.29）。
+- 不收件去向：动画密度与素材范围 →「战斗画面优化」待办；三处设计条款 → 反哺点清单；历史锚里的旧 `text` 字段 → 不改历史数据，分析工具保留旧日志兼容分支。
+
+## 6 关联文档同步面
+
+| 文档 | 关联点（本批实现会改变它的哪条陈述） | 同步义务 |
+|---|---|---|
+| `design/ux/battle.md:157`／`:230`／`:304` | 结算期明细带逐行滚动；「结算逐行兑现不可整体跳过、只给减动效」 | 实现批禁写 `design/`；逐条列进 `reports/iter<N>-反哺点-<日期>.md`，用户裁决后由文档批落文 |
+| `design/gdd/systems/战斗循环/战斗结算.md:73`／`:87` | 明细流水是结算明细屏的数据源；「显示名等玩家可见文案是数据面字段、代码读表拼行」 | 同上 |
+| `design/gdd/systems/战斗循环/战斗表现.md:53`／`:99`／`:149` | 结算逐行兑现是信息载体；因果可读验收「能说出这一行来自哪步操作」 | 同上 |
+| `design/gdd/08-Alpha版本标准.md` v1.29 | 「逐行结算排播」行已删（合并 `f7d7761e`） | 已落地，本批零动作 |
+| `game/tests/README.md:135` | 能力行「结算明细带逐行呈现与排播节奏」 | 实现批禁写；归写卡段维护，换代项写在 T3，本卡登记 |
+| `体验验证清单.md:86`／`:206`／`:220`／`:314`／`:315`／`:326`／`:442`／`:519` | 逐行结算、明细带来源／行序／文案可读性、减半标签等目检项 | 实现批禁写根规则文件；列进反哺点清单，由文档批落文；真人目检登记不阻塞 |
+
+## 7 文件结构图
+
+| 路径 | 职责 | 行为／非行为 | 对照表行 | 复用／新增 |
+|---|---|---|---|---|
+| `game/presentation/views/battle_log_view.gd` | B 区文字列表渲染面退役（保留视图壳供挖掘期摘要位或整体退役，二选一定在 T1） | 行为改动 | R1 | 复用既有件，不新增 |
+| `game/presentation/row_pacer.gd` | 移除文字入带调用，保留 FX 排播链 | 行为改动 | R1／R2 | 复用既有件 |
+| `game/presentation/main.gd` | 组合根 `log_view` 接线与 `clear()` 调用面同步 | 行为改动 | R1 | 复用既有件 |
+| `game/presentation/playtest_logger.gd` | 日志 `step` 行去掉两份中文文案 | 行为改动 | R3 | 复用既有件 |
+| `game/core/damage_controller.gd`／`reward_grant.gd`／`settlement/combat_segment.gd`／`settlement/grant_segment.gd` | `reward_ineffective` 行补 `reason` 枚举 extra | 行为改动 | R5 | 复用既有 `_emit_row` 出口 |
+| `tools/analyze_playtest.py` | 四处 `text` 判读改读结构化字段，保留历史锚兼容分支 | 行为改动 | R4 | 复用既有解析入口 |
+| `game/tests/unit/presentation/*`／`game/probe/*` | 旧断言改写成退役后正向断言 | 行为改动 | R1／R2／R3 | 复用既有套件 |
+| `game/tests/README.md` | 能力行换代 | 非行为改动 | — | 复用既有表行 |
+| `reports/需求卡片-…`／实现报告／代拍板追认单／反哺点清单／验收审计 | 过程件 | 非行为改动 | — | 复用既有模板 |
+
+## 8 落位与可复用性预检
+
+- **复用面**：本批零新增视图、服务、工具脚本。`grep` 现成实现结果＝文字渲染唯一在 `battle_log_view.gd`，排播唯一在 `row_pacer.gd`，日志落盘唯一在 `playtest_logger.gd:130-143`，分析判读唯一在 `tools/analyze_playtest.py`；同名同义标识符无第二处。新增文件只有 `reports/` 过程件与新增测试函数（落在既有套件内）。
+- **唯一面**：`step` 行字段定义只在 `battle_orchestrator.gd:723-735`；`reason` 枚举取值只在第 9 节 T2 定义一次，四个发射点只引用不各自定义；日志行字段组装只在 `playtest_logger.gd:136-143`；分析工具的「旧日志兼容分支」只在 `effect_id_of()` 一处。
+- **分层与交互面**：core 发 `step_row` → 呈现层 `row_pacer`／`playtest_logger` 并列订阅（删文字只动呈现层那条）；`row_pacer` → `stage.on_step_row_fx`／`settlement_fx`／`board_zone` 的调用链不变；core 零 UI、数值经 ConfigDB、随机经 RngService 三条红线不因补 `reason` 而绕。
+
+## 9 任务卡
+
+估时合计 3.5–4.75 个工作日（软盒 5 日）；T2 若 `reason` 枚举落点超 4 处，按「先 damage_controller＋reward_grant 两处、再 combat/grant 两处」切成 T2a／T2b，不扩 T 卡验收面。
+
+### T0 开工核对与改前基线（0.25 日）
+
+取用：本卡第 3 节全部 file:line。产出：`sim-data/` 下改前判读基线读数一份（不入库）、T1..T4 共用的 `REASON_ENUM` 取值表。
+
+- [ ] 逐条复核第 3 节 file:line 与现役代码一致，不一致处回呈写卡段，不改卡硬做。
+- [ ] 跑 `python tools/analyze_playtest.py` 对现行历史锚出一份判读基线，落 `sim-data/` 并在实现报告登记路径。
+- [ ] 跑 `python tools/run_all_gates.sh --docs` 确认写卡段文档域闸绿，回执记入实现报告。
+
+### T1 撤玩家侧逐行文字（1–1.5 日）
+
+取用：T0 复核结果、`battle_log_view.gd`／`row_pacer.gd`／`main.gd` 现役签名。产出：`row_pacer.log_view` 句柄与文字入带调用清零、FX 调用链原样。
+
+- [ ] 在 `row_pacer.gd:83-101` 移除 `log_view.append_row(row)`、`log_view.append_bb(...)`、`log_view.finish_settlement_round()` 三处调用，保留 `:89-101` 其余 FX 调用与 `refresh_request.call()`。
+- [ ] 在 `row_pacer.gd` 移除 `log_view: BattleLogView` 句柄声明与组合根注入面，保留 `stage`／`board_zone`／`settlement_fx`／`board_view` 四个句柄。
+- [ ] 在 `main.gd` 移除 `_start_adventure`／`_resume_from_menu` 的 `ui.battle.log_view.clear()` 与 `wire_battle` 相关文字接线，`_on_step_row` 的清图奖励 toast 保留。
+- [ ] 定 `battle_log_view.gd` 去留并落实现：视图壳整体退役或只保留挖掘期摘要位，二选一以「B 区结算期零文字节点」为准，改动写进实现报告。
+- [ ] 从真实入口（停手→结算）跑 `battle_log_zero_text_test.gd:_smoke_settle_zero_rows`，断言结算期 B 区 `RichTextLabel` 行文本为空且无逐行追加，读数写进本步提交信息。
+
+### T2 日志零文案与结构化字段补齐（1–1.5 日）
+
+取用：`step_row` 行协议（公共字段＋extra 全平铺）、`REASON_ENUM`。产出：新日志 `step` 行零中文字段、`reward_ineffective` 行带 `reason`。
+
+- [ ] 在 `playtest_logger.gd:136-143` 从 `line` 去掉 `"text"`，并在 `:140-142` 平铺循环里跳过 `display_name`，其余字段与 payload 一行不减。
+- [ ] 定义 `REASON_ENUM` 四个取值：`full_layers`／`full_hp`／`no_enemy_alive`／`hero_down`，只在本卡定义一次。
+- [ ] 在 `damage_controller.gd:623-624`／`reward_grant.gd:269-271`、`:362-369`／`combat_segment.gd:123-124`／`grant_segment.gd:103`、`:321` 的 `reward_ineffective` 行 extra 各补一个 `reason` 键，取值按现文案对号入座。
+- [ ] 从真实入口（开新局→真实结算→落盘 JSONL 读回）跑 `playtest_logger_step_fields_test.gd:_assert_no_text_and_full_payload`，断言 `step` 行无 `text`／`display_name`、且 `type`／`source`／`cell`／`round`／`value`／`highlight` 与全部 payload 键集与改前逐位一致。
+
+### T3 分析工具、测试与探针正面化（0.75–1 日）
+
+取用：T0 判读基线、T2 的 `REASON_ENUM`。产出：分析判读结论与改前一致、旧断言全部改写而非删除。
+
+- [ ] 在 `tools/analyze_playtest.py:83-88` 的 `effect_id_of()` 保留旧日志 `text` 兼容分支，新日志分支改读 `effect_id`。
+- [ ] 在 `:189`／`:434` 把 `"全体敌人" in r.get("text","")` 改读 `r.get("target") == "all_enemies"`。
+- [ ] 在 `:471-478` 把未生效原因分类由 `text` 子串改读 `s.get("reason")`，四类取值与 `REASON_ENUM` 一一对应。
+- [ ] 把 `theme_projection_test.gd:_smoke_battle_log_view`／`player_copy_sweep_test.gd:_sweep_source_names`／`ui_probe.gd:133-135`／`ui_click_probe.gd:423`、`:473`、`:616`、`:798-844` 的旧文字断言改写为退役后的正向断言（例：结算期零行文本、来源标签从数据表读而非从行文本读），逐条登记进测试削弱申报表。
+- [ ] 同步 `game/tests/README.md:135` 能力行为退役后口径。
+- [ ] 对同一份历史锚与一份新日志各跑一次 `tools/analyze_playtest.py`，判读结论与 T0 基线逐位一致，读数写进本步提交信息。
+
+### T4 批末验收与产出物落位（0.5 日）
+
+取用：T1..T3 各步读数、第 10 节对照表。产出：`reports/` 四份过程件。
+
+- [ ] 按本批改动域跑重闸选档全绿，回执记入实现报告。
+- [ ] 跑独立验收审计（入口 `reports/iter<N>-验收审计-<日期>.md`，由未参与实现的会话或子代理执行），未过不合并。
+- [ ] 在轻闸全绿后、合并前写齐 `reports/` 三份：实现报告（各卡状态＋实机目检总清单＋遗留读数义务）、代拍板追认单、反哺点清单（第 6 节每条都有落点）。
+- [ ] 用户目检项只登记不阻塞，登记完成即本卡义务了结。
+
+## 10 验证闸（改动—验收对照表）
+
+| 需求点 | 改动（文件:行／行为） | 验收测试（名称＋落点＋尾缀） | 层级 | 真实入口 | 判据绑定面 | 能力行 |
+|---|---|---|---|---|---|---|
+| R1 结算期零逐行文字（design/ux/battle.md:157） | `battle_log_view.gd:87-103`／`row_pacer.gd:83-101`／`main.gd:417-425` | `battle_log_zero_text_test.gd:_smoke_settle_zero_rows`（新增，落在表现层单元套件） | 单元＋探针 | 真实停手→轮末结算→读 B 区场景树与 `RichTextLabel` 行文本 | `step_row` 消费后 `RichTextLabel.append_text` 调用计数＝0、parsed_text 空；不绑终屏态 | 新增：结算期零逐行文字与 FX 排播链保持 |
+| R2 FX 与 toast 链不断（design/ux/battle.md:297） | `row_pacer.gd:89-101` 保留 | `pacing_queue_test.gd:_assert_fx_chain`（既有套件扩断言）＋`standee_fx_sweep_test.gd:_init` | 单元＋集成 | `step_row`→`row_pacer`→`stage.on_step_row_fx`／`settlement_fx` | `on_step_row_fx`／`play_damage_number`／`play_projectile` 调用计数与改前逐位一致 | 新增：结算期零逐行文字与 FX 排播链保持 |
+| R3 日志零文案、字段不缺（design/gdd/systems/战斗循环/战斗结算.md:73） | `playtest_logger.gd:136-143` | `playtest_logger_step_fields_test.gd:_assert_no_text_and_full_payload`（新增） | 单元＋集成 | `start_session`→真实结算→落盘 JSONL 读回 | 落盘 `step` 行键集：`type`／`source`／`cell`／`round`／`value`／`highlight`＋全部 payload 与改前一致，且无 `text`／`display_name` | 新增：日志 step 行零文案与结构化判读等价 |
+| R4 分析判读等价（design/engineering/test-conventions.md:133） | `tools/analyze_playtest.py:83-88`／`:189`／`:434`／`:471-478` | `analyze_parity_check.py`（新增，落在 `tools/`） | 工具／集成 | 同一份 `sim-data/` 历史锚＋一份新日志各跑一次判读 | `eff_counts`／`reward_dmg`／未生效分类计数字典与 T0 基线逐位一致 | 新增：日志 step 行零文案与结构化判读等价 |
+| R5 未生效原因结构化（design/gdd/systems/战斗循环/战斗结算.md:80） | 四处 `reward_ineffective` 发射点 extra 补 `reason` | `reward_ineffective_reason_test.gd:_assert_four_reasons`（新增，落在结算域单元套件） | 单元 | 真实结算产生满层／满血／无存活敌人／主角已倒下四类未生效行→`step_row` 载荷 | `step_row` 载荷 `reason` 键取值四类逐一命中，不绑终态结算结果 | 新增：日志 step 行零文案与结构化判读等价 |
+
+**测试削弱申报**：随文字列表退役需改写的旧断言＝`theme_projection_test.gd:_smoke_battle_log_view`、`player_copy_sweep_test.gd:_sweep_source_names`、`ui_probe.gd:133-135`、`ui_click_probe.gd:423`／`:473`／`:616`／`:798-844`、`pacing_queue_test.gd:165` 的文字呈现部分。一律改写为退役后的正向断言，**不删除、不放宽阈值、不缩小扫描面**；实现期出现未申报的删除断言由独立验收审计判红。
+
+**独立验收审计**：`reports/iter<N>-验收审计-<日期>.md`，由未参与实现的会话或子代理执行，未过不得合并。
+
+## 11 异常分级
+
+- L1 自救：单件直跑出红，只重跑该红件最小单元（一次重试）。
+- L2 记录继续：连续三次同红灯，记录进实现报告并继续本卡其余步骤。
+- L3 停机写报告等用户：触碰第 4 节任一 🔴、分析判读结论与改前不一致且定位不到字段来源、独立验收审计未过。
+
+## 12 代拍板白名单
+
+1. 新增测试函数命名与落点（须落在第 7 节列出的既有套件／工具目录）。
+2. `battle_log_view.gd` 视图壳整体退役 vs 只留挖掘期摘要位，以「结算期 B 区零文字节点」为判据自判，结论写进实现报告。
+3. `reason` 四个枚举键在四个发射点的写法（照现役 `_emit_row` extra 模式，不新增helper）。
+
+超出以上三项一律呈报。
+
+## 13 待裁点
+
+零待裁点。用户裁定已覆盖方向、保留面、日志口径与 08 清单行处置；开工门＝U0（用户发令 /iter）。卡片写完呈用户裁决后才可开工。
+
+## 14 复核记录
+
+复核发现按四类去向逐条登记（自判／补写／待裁／退回上游）；本节即复核凭据，不另设报告文件（2026-11-06 用户裁）。
+
+| 发现 | 去向 | 处置结果 |
+|---|---|---|
+| 视图壳整体退役 vs 只留挖掘期摘要位 | 自判 | 以「结算期 B 区零文字节点」为判据自判，写进第 12 节白名单第 2 项 |
+| 新增测试函数命名与落点 | 自判 | 写进第 12 节白名单第 1 项，落在第 7 节列出的既有套件 |
+| `reason` 枚举键在四个发射点的写法 | 自判 | 写进第 12 节白名单第 3 项，照现役 `_emit_row` extra 模式 |
+| 上一轮核查漏项：`tools/analyze_playtest.py` 四处读 `text` | 补写 | 补进 T2／T3／R4，并保留旧日志 `text` 兼容分支 |
+| 未生效原因缺统一结构化字段 | 补写 | 补进 T2／R5，定义 `REASON_ENUM` 四个取值 |
+| 验收对照表列名与 2026-10-24／10-28 两裁冲突 | 补写 | 第六列改「判据绑定面」，内容全改正向断言与改前改后对照 |
+| req-card 第〇步「标题带设计面=标记」与现行 §12.1 模板冲突 | 补写 | 按现行规约，闭合凭据以用户裁定＋`08-Alpha版本标准.md` v1.29 为准，第 2 节写明 |
+
+零待裁点、零退回上游。
+
+**自审六查**：①规格覆盖——第 1 节五条完成定义逐条指到 T1..T4 与 R1..R5，无悬空；②步骤扫描——每步一个动作＋一个可核查结果，无「TBD／酌情／适当优化」；③类型一致性——`REASON_ENUM` 四个取值在 T2 定义、T3 与 R5 逐字引用；④审查焦点＋改动覆盖——最可能坑到玩家的失败模式＝FX 链被误删（R2 兜）、分析判读静默失真（R4 兜）、日志丢 payload（R3 兜），文件结构图每个行为改动都有对照表行；⑤篇幅比例——本卡以签名、取值、断言名为主，未抄函数体；⑥落位与复用——第 8 节三问逐条答完，零新增视图／服务／工具，与第 7 节「复用既有」标注一致。
+
+**上一轮核查漏项补正详情**：此前报「日志零缺漏」时未查到 `tools/analyze_playtest.py:83-88`／`:189`／`:434`／`:471-478` 对 `text` 的四处判读依赖；本卡已列为 R4 并补 `reason` 字段（R5），不属新增需求，属用户令「缺什么补什么」的同批处理。
diff --git a/待办清单.md b/待办清单.md
index f1e322b7..dacc0f25 100644
--- a/待办清单.md
+++ b/待办清单.md
@@ -55,13 +55,11 @@
 
 #### 结算期逐行文字列表退役与日志零文案（2026-11-07 登记，来源=会话提及）
 
-**实况**：用户裁定撤掉战斗屏结算期逐行滚动的文字列表，保留伤害飘字与攻击特效；日志零文案只存字段。现行日志已逐行全字段落盘（game/presentation/playtest_logger.gd:130-143；开新／续玩均开会话，game/presentation/main.gd:247/:295）——零缺漏、无需补采，与裁定不符处是日志多带中文文案两处（text 与平铺的 display_name）。文字列表消费面＝game/presentation/views/battle_log_view.gd:173-260 与 game/presentation/row_pacer.gd:100；动画特效走 target／target_id，不依赖行文案（game/presentation/views/battle_stage_view.gd:328-341）。[战斗结算](design/gdd/systems/战斗循环/战斗结算.md) v1.8 明细流水节规范句仍写「文案入表、代码读表拼行」，与本裁定相反。
-
-**缺口**：还差设计讨论——文字列表退役范围（飘字与特效保留面）、日志两处中文字段清理、[battle](design/ux/battle.md) 不可整体跳过承诺与[战斗表现](design/gdd/systems/战斗循环/战斗表现.md) 因果可读验收判据改写。
+**实况**：设计讨论 2026-11-07 会话闭合（用户裁定、待裁点零）：撤掉结算期逐行滚动文字列表、保留伤害飘字与攻击特效、日志零文案只存字段。落点 [08-Alpha版本标准](design/gdd/08-Alpha版本标准.md) v1.29（现行不含「逐行结算排播」行）与 [需求卡片](reports/需求卡片-结算期文字列表退役批-2026-11-07.md)。日志逐行全字段落盘（game/presentation/playtest_logger.gd:130-143；开新／续玩均开会话，game/presentation/main.gd:247/:295），采集面零缺漏；多带 text 与平铺 display_name 两处中文文案，tools/analyze_playtest.py:83-88/:189/:434/:471-478 四处读 text 判读，须补 reason 字段并改读结构化字段。文字列表消费面＝battle_log_view.gd:173-260／row_pacer.gd:100；动画特效走 target／target_id 不依赖行文案（battle_stage_view.gd:328-341）。[战斗结算](design/gdd/systems/战斗循环/战斗结算.md) v1.8 明细流水节规范句仍与本裁定相反（同步义务列卡片第 6 节）。
 
 **改动面**：文档＋游戏代码
 
-**状态**：待文档设计
+**状态**：文档设计已闭合＋已写卡
 
 #### 战斗画面优化——动画演出与美术表现（2026-11-07 登记，来源=会话提及）