iter45-卡②T2: 断点域拆件 breakpoint_store(R2整族归件v1.1)——六成员(save_manager/resume_bp/pending_next_level/last_level_payload/last_treasure_cleared/loadout_seeded)+BREAKPOINT_FIELDS 27键冻结+函数族九个归件:纯读侧三函数与_bp_parts/snapshot body逐字(宿主输入state/level_index/master_seed/runner/counters逐调传参——件禁反向持宿主),四_resume_*按所有权缝语句分家:件侧(主角账三件restore_fragment/curio池与特性还原/stop与bank片段回填/数值账规范化钳制)迁store五个回填函数,宿主侧(八项重绑定与_reset_curio_state/_attune_refresh_x_total调用)按原语句序吸收进resume_adventure壳,引用束九引用解包为原名成员保body逐字(6+9=15贴顶);宿主留_snapshot_breakpoint一行委托壳(CurioStop的Callable目标零改)与set_save_manager转发件,断点键面零变化,语句序逐步保形;测试:185改址BreakpointStoreScript.BREAKPOINT_FIELDS(判据零变化——第14节申报)〔补件 V2〕;验证:run_all三套件全绿+run_smoke 15项0失败

AGENTS.md

@@ -16,7 +16,7 @@
 
 ## 运行与验证（工作目录 = 含 project.godot 的切片目录）
 
-- **交付前验收 = 跑 `tools/run_all_gates.sh`，按本批改动域选档（`--code` 只跑代码域／`--docs` 只跑文档域／不带参数＝两域全量），所选域全绿才合回 master**——它是全部验证闸的唯一入口与唯一清单，**域划分与选闸算法也只写在它这一个地方**，闸件增减与分域调整都只改它，文档禁另列清单。域按**文件性质**判：代码域＝`game/` 下非 `.md` 的行为载体（代码/测试脚本/探针/场景/数据表/素材），`game/` 内 `.md` 与 `game/` 外一切路径＝文档域；同批两类都有时跑全量档。代码域按**关联档选测**（2026-10-29 用户裁）：02 单元与集成只跑「需求卡片申报 ∪ diff 推导」并集的套件（关联档＝只跑与本批改动关联的那部分测试），00 冒烟／01 系统测试／09 静态扫描三件保险恒跑不降，横切面改动（公共件/数据表/autoload/数值·存档·RNG·结算触面）回落全部套件；算法与套件族映射表只在闸脚本内定义。所选域全绿即可合回；全量回归由用户自发发起，合入后无自动兜底。跑完写回执 `game/tests/.gates/receipt.json`（含 `domain` 与 `scope` 字段），合回时由 worktree-guard 按 diff 文件性质推出该验哪个域再校验回执（六况拦截细则见 process-conventions §3.9）；非代码面的直改批验收＝commit 点 git 钩子自动跑 `--docs`，无 worktree 与回执流程
+- **合回验证 = 本地 CI（2026-10-30 用户裁）**：git merge 合回 master 落地后，post-merge 钩子（`tools/hooks/post-merge`）后台触发 `tools/ci_runner.sh` 跑一次全量域闸（调 `tools/run_all_gates.sh` 不带参数档，02 全套件），结果落 `game/tests/.gates/ci-status.json`（commit／绿红／红闸名单＋关键日志行／耗时）＋`ci-history.jsonl` 流水账；CI 红态下每个修复提交经 post-commit 钩子（`tools/hooks/post-commit`）自动追绿复验，绿态与无状态零触发——主区小批直提不重复跑全量，同一份字节禁止第二次人手跑。CI 红不回滚合并，红项在案、修复提交追绿；开工先读 CI 状态，红未修不开新批。跑批起手自动 `--editor --quit` 刷类名缓存（.godot 缓存不入 git，防合并后失配假红）。`tools/run_all_gates.sh` 仍是全部验证闸的**唯一入口与唯一清单，域划分与选闸算法只写在它这一个地方**，闸件增减与分域调整都只改它，文档禁另列清单；`--code`／`--docs`／`--quick` 手动档只服务开发期按域跑批（开发期窄测纪律见 process-conventions §6），不构成验收；全量回归由用户自发发起
 - 单件直跑（调试期最窄确认用，**不构成验收**）：冒烟测试 `python tools/run_smoke.py`（`game/tests/smoke_boot.tscn` 极小启动场景）· 系统测试 `python tools/run_system_test.py`（宿主 `game/tests/system_test.gd`）· 场景探针 `…console.exe --headless --path . res://probe/ui_probe.tscn` · 单元与集成 `… --script res://tests/run_all.gd`
 - 调参批量：`--script res://sim/adventure_monte_carlo.gd`（全冒险期望）· `res://sim/reward_expectation.gd`（奖励期望）；关卡完成率/难度类测量一律走全冒险
 - 数值验证：`python tools/balance_verifier.py`（采集端 `res://sim/verifier_batch.gd`，报告与原始数据落 `sim-data/`）
@@ -40,7 +40,7 @@
 
 | 时机 | 权威文档 |
 |---|---|
-| 批次开工 / 流程纪律 | `design/engineering/process-conventions.md`——车道铁律（代码面 worktree 批／其余主区直改）、五段流水线、批次清单、测试两入口与 MC/闸机细则、像素纪律 |
+| 批次开工 / 流程纪律 | `design/engineering/process-conventions.md`——车道铁律（主区直改＋直提；大批约定走 worktree）、合回后本地 CI、五段流水线、批次清单、测试两入口与 MC/闸机细则、像素纪律 |
 | 流水线段入口 | 技能对照——doc-design=文档设计（兼任反哺点落文）／asset-ingest=美术录入／req-card=写卡／iter-plan=迭代编排／iter=实现（五者均装于项目 `.zcode/skills/`）；登记不立技能；批后收尾与中间文档退役=batch-closure（同一目录）；格式与状态机权威=`design/engineering/doc-conventions.md` §12 |
 | 定代码方案 / 写代码 / 改代码前 | `design/engineering/code-conventions.md`——结构/契约/语言/数值/流程五类硬纪律（反例库 = 同目录 code-conventions-cases.md） |
 | 定测试方案 / 写测试 / 改测试前 | `design/engineering/test-conventions.md`——探针标配 / 回归断言 / 提交前验证 / 验收清单落码 |
@@ -85,11 +85,11 @@
 
 ## 硬性红线（勿违反；操作细则在 process-conventions.md 与各规约）
 
-- 车道铁律（判据与改动域划分同一，按文件性质切）——代码面（`game/` 下非 `.md` 的行为载体）唯一强制独立 worktree（迭代批全套仪式不变）；其余一切面（含 `game/` 内 `.md` 与 `.zcode/`、`.qoder/` 等不入 git 面）主工作区直改＋直提，commit 点由 git pre-commit 钩子（`tools/hooks/pre-commit`，`core.hooksPath` 挂载）现场跑文档域闸，绿落地红拦；主区直提代码面被该钩子拦；`--no-verify` 仅属用户，agent 禁用（细则见 process-conventions §1）
+- 车道铁律（判据与改动域划分同一，按文件性质切；2026-10-30 用户裁本地 CI 化）——一切面（含代码面 `game/` 下非 `.md` 的行为载体与 `.zcode/`、`.qoder/` 等不入 git 面）主工作区直改＋直提；commit 点由 git pre-commit 钩子（`tools/hooks/pre-commit`，`core.hooksPath` 挂载）现场跑文档域闸，绿落地红拦，合并收尾提交跳过（归合回后 CI）；代码面全量验证归合回后本地 CI（`tools/hooks/post-merge` 触发，见「运行与验证」首条）；大批次（迭代实现批等）按约定仍走独立 worktree（冻结→件核→并 master→重塑→主区合回→CI 验证），约定非强制；`--no-verify` 仅属用户，agent 禁用（细则见 process-conventions §1）
 - **仓库根禁止设会话状态文件**（`active.md` 已废除）——现状看 roadmap「当前位」，待办看待办清单，过程看 git 提交信息，产出物看 `reports/`；任何文档禁止另设「当前状态快照」节，两处记同一件事必然漂移（细则见 doc-conventions 第 10 节）
 - 测试执行两入口铁规——只有迭代 loop 开发与用户点名两个触发入口；其余会话零测试，需测试支撑先请示并注明未跑测
-- 交付前验收 = 跑 `tools/run_all_gates.sh` **按改动域**全绿（唯一入口、唯一闸清单、唯一域划分与选闸算法，禁在文档另列）；代码域按**关联档选测**——02 单元与集成跑「卡片申报 ∪ diff 推导」并集套件、三件保险（冒烟/系统测试/静态扫描）恒跑、横切面回落全量，所选域绿即可合回，全量回归由用户自发（2026-10-29 用户裁，合入后无自动兜底）（算法见闸脚本）；合回 master 由 worktree-guard 按 diff 文件性质推域校验回执强制（process-conventions §3）；非代码面直改批的验收＝commit 点 git 钩子自动跑 `--docs`（process-conventions §1）
-- **改动四类**——**需求改动**（游戏代码，含随逻辑写/改的测试代码）：唯一走「写需求卡片＋编入迭代批次」通道；迭代实现批禁写 `design/` 整个目录、两份根流程清单（`待办清单.md`/`体验验证清单.md`）与 `game/tests/README.md`（能力清单，归写卡段维护）（含新增/修改/删除），设计文档对它只读、是写测试与实现代码的输入依据；两份流程清单的条目状态只由流水线各段推进，实现批禁止顺手改；产出物只准写 `reports/`；批末只跑代码域闸。**工程改动**（tools/、闸件、模拟测量工具、纯测试维护——不改变游戏行为的配套代码）、**文档设计改动**、**美术素材改动**：不写需求卡片、不编迭代批次，登记在案后由用户发令在主工作区直改＋直提（commit 点 git 钩子自动跑文档域闸），完成即删条目；触及代码面的工程改动（如纯测试维护）仍走 worktree 批；文档设计类写入走 doc-design 技能（登记条目格式由流水线闸强制）
+- 合回后验证 = 本地 CI 全量域闸全绿（唯一强制验证点；唯一入口、唯一闸清单、唯一域划分与选闸算法仍只在 `tools/run_all_gates.sh`，禁在文档另列；触发与追绿语义见「运行与验证」首条与 process-conventions §1）。开发期手动跑批按需选档（`--code` 关联档选测——02 跑「卡片申报 ∪ diff 推导」并集套件、三件保险恒跑、横切面回落全量——算法只在闸脚本内定义），手动跑不构成验收；全量回归由用户自发发起。文档面直改批验收＝commit 点 git 钩子自动跑 `--docs`（process-conventions §1）
+- **改动四类**——**需求改动**（游戏代码，含随逻辑写/改的测试代码）：唯一走「写需求卡片＋编入迭代批次」通道；迭代实现批禁写 `design/` 整个目录、两份根流程清单（`待办清单.md`/`体验验证清单.md`）与 `game/tests/README.md`（能力清单，归写卡段维护）（含新增/修改/删除），设计文档对它只读、是写测试与实现代码的输入依据；两份流程清单的条目状态只由流水线各段推进，实现批禁止顺手改；产出物只准写 `reports/`；合回后由本地 CI 全量验证（红项修复提交追绿，process-conventions §1）。**工程改动**（tools/、闸件、模拟测量工具、纯测试维护——不改变游戏行为的配套代码）、**文档设计改动**、**美术素材改动**：不写需求卡片、不编迭代批次，登记在案后由用户发令在主工作区直改＋直提（commit 点 git 钩子自动跑文档域闸），完成即删条目；大体量改动（含触及代码面的工程改动如纯测试维护）按约定走 worktree 批（非强制）；文档设计类写入走 doc-design 技能（登记条目格式由流水线闸强制）
 - 五段流水线铁律——**需求改动**（游戏代码）按「登记 → 文档设计／美术设计 → 写需求卡片 → 迭代编排 → 实现」五段推进，段间不自动流转、每段转进由用户发令；编入迭代的卡片必须设计闭合＋零待裁点——需求卡片任何工作量皆可写、皆可编入迭代，工作量限制只属迭代层（迭代估时总量 <5 个工作日＝「冻结待凑批」、不可开工）；流水线闸 `tools/pipeline_gate.py` 强制（已注册进 run_all_gates.sh 文档域）；实现段零裁断——卡片没写清=上游缺陷，停该卡退回上游，禁内联求裁（process-conventions §2，格式与状态机=doc-conventions §12）。工程／文档设计／美术素材三类改动不走写卡与编排段：登记 →（如需设计讨论）→ 用户发令直改 → 主区直改＋commit 点闸 → 完成删条目（车道细则=process-conventions §1）
 - MC/模拟：无数值改动零跑；档位硬闸见 `sim-data/README.md`「MC 采集档位表」，一档只能由用户发起
 - 闸机轮次纪律：新码先孤立验证 → 出红只跑红件最小单元 → 长批先最小参数试车 → 开工扫坑册（process-conventions §6）

design/engineering/process-conventions.md

@@ -7,12 +7,12 @@
 
 ## 1. 分支纪律（车道铁律）
 
-改动按文件性质分两车道（2026-10-26 用户裁，取代 2026-09-19 立的「一切改动走 worktree」铁律；判据与 §3 第 8 条改动域划分同一）：
+一切面主工作区直改＋直提（2026-10-30 用户裁本地 CI 化：验证挪到合回后，主区直提不再拦任何面；判据与 §3 第 8 条改动域划分同一）：
 
-1. **worktree 批车道（唯一强制面＝代码面）**：一切触及代码面（`game/` 下非 `.md` 的行为载体：代码、测试脚本、探针、场景、数据表、素材）的改动——迭代实现批与触及代码面的工程改动（如纯测试维护）——先建独立 worktree：`git worktree add ../g-plan2-<任务名> -b <任务分支>`；所有改动与验证都在 worktree 内进行（未跟踪文件不会出现在新 worktree，需手工搬运）；建区后立刻跑 `tools/setup_worktree_userdir.sh`——给该区独立 Godot user 目录（测试夹具、试玩日志、截图产物不与其他区共用；主区不生成，真实档保持原位）。迭代批开工细则见 §3 与 iter 技能
-2. **worktree 批收尾**：批次收口顺序固定为**冻结 → 件核 → 并 master → 重塑 → 跑一次域闸 → 合回**——代码与断言改完即冻结，全仓件核 grep 查残留；master 已被别的批次推进时先 `git merge master` 解冲突（必须在跑闸之前，闸跑完再并＝那次闸白跑）；**重塑**＝迭代分支（iter<N> 形）在跑闸前执行 `python tools/reshape_cards.py`，把分支线性史按卡末态快照压成一卡一笔（可选追加一笔纯文档收尾），master 台账由此每卡一行——工具自带「重塑前后树逐字节一致」断言与 backup 分支，不改任何文件内容；非迭代工程小批免重塑；然后按本批改动域跑**一次** `tools/run_all_gates.sh`（见 §3.9），全绿后在主工作区 `git merge --no-ff <任务分支>`（合回闸对迭代分支数卡校验，未归卡提交拦下），再 `git worktree remove`+删分支。闸后代码面不得再改一个字节（回执作废须重跑），只允许追加 `reports/`、`design/` 等文档件提交。游戏类测试（冒烟/单测/MC/探针）批内默认零执行（两入口铁规，见 §4），用户点名或当场问才跑
-3. **直改车道（代码面之外的一切面）**：`design/`、`reports/`、`tools/`、根规则与清单文件、`game/` 内 `.md`、`.zcode/`、`.qoder/`——主工作区直接改、直接提交，无 worktree、无冻结/件核/合并仪式。验收＝commit 点 git pre-commit 钩子（`tools/hooks/pre-commit`，经 `core.hooksPath` 挂载，在位性由 run_all_gates.sh 跑批自检）现场跑 `tools/run_all_gates.sh --docs`（秒级文本扫描）：绿即落地，红即拦下，修红后重新 commit 钩子自动重跑；跑完把闸输出呈报对话即完成义务。预期大体量改动（跨文档结构重构等）时由用户开工点名自愿开 worktree，非规则强制
-4. **执法分层（全机械，零自觉依赖）**：①git pre-commit 钩子——直改车道的闸机检，并对主工作区直提代码面的提交一律拦（代码面唯一合法路径＝worktree 批合回）；任务 worktree 内的代码面提交跳过（归批末闸＋合回闸管，不打扰迭代批中间提交）。②`.zcode/hooks/worktree-guard.sh`（PreToolUse，本机件不入 git）——agent 侧：主工作区代码面的 Edit/Write 与 staged 含代码面的 commit 拦截、`git commit --no-verify` 拦截（该旗标仅属用户）、合回闸回执六况校验（§3.9）。git 层钩子对一切提交者生效（含用户手工提交，紧急出口 `--no-verify`）；ZCode 层只约束 agent
+1. **主区直改车道（一切面）**：`game/`（含代码面＝`game/` 下非 `.md` 的行为载体）、`design/`、`reports/`、`tools/`、根规则与清单文件、`.zcode/`、`.qoder/`——直接改、直接提交。验收分两层：commit 点 git pre-commit 钩子（`tools/hooks/pre-commit`，经 `core.hooksPath` 挂载，在位性由 run_all_gates.sh 跑批自检）现场跑 `tools/run_all_gates.sh --docs`（秒级文本扫描）绿即落地红即拦，合并收尾提交跳过（MERGE_HEAD 在，内容归合回后 CI）；代码面的全量验证归合回后本地 CI（下条）。开发期纪律不变：卡内只测自己改的东西、出红只跑红件最小单元（§6）
+2. **合回后验证（本地 CI，2026-10-30 用户裁）**：git merge 合回 master 落地后 post-merge 钩子（`tools/hooks/post-merge`）后台触发 `tools/ci_runner.sh merge` 对 master 尖跑一次全量域闸——唯一强制全量验证点；CI 红态下每个修复提交经 post-commit 钩子（`tools/hooks/post-commit`）自动追绿复验，绿态与无状态零触发。重跑判据：同一份字节禁止第二次人手跑；有意义的重跑只剩「验证修复」一类。CI 红不回滚合并——红项记 `game/tests/.gates/ci-status.json`，修复提交追绿；开工先读 CI 状态，红未修不开新批。跑批起手 `--editor --quit` 刷类名缓存（在册坑：.godot 缓存不入 git，合并后失配假红假绿）——原「合并后零复跑」的秒级动作由跑批件接管。并跑语义＝跑完补跑（coalesce）：跑批期间新触发不中断当前轮，轮尾对最新尖端补跑，绝不逐笔各跑一轮
+3. **worktree 批车道（大批约定，非强制）**：迭代实现批与大体量改动按约定仍走独立 worktree：`git worktree add ../g-plan2-<任务名> -b <任务分支>`；建区后立刻跑 `tools/setup_worktree_userdir.sh`——给该区独立 Godot user 目录（测试夹具、试玩日志、截图产物不与其他区共用；主区不生成，真实档保持原位）。收口顺序固定为**冻结 → 件核 → 并 master → 重塑 → 主区合回 → CI 验证**——代码与断言改完即冻结，全仓件核 grep 查残留；master 已被别的批次推进时先 `git merge master` 解冲突；**重塑**＝迭代分支（iter<N> 形）合回前执行 `python tools/reshape_cards.py`，把分支线性史按卡末态快照压成一卡一笔（可选追加一笔纯文档收尾），master 台账由此每卡一行——工具自带「重塑前后树逐字节一致」断言与 backup 分支，不改任何文件内容；非迭代工程小批免重塑；然后主工作区 `git merge --no-ff <任务分支>`（合回守卫对迭代分支数卡校验，未归卡提交拦下），合并落地 post-merge 钩子触发 CI，红则修复提交（主区直提）追绿，全绿后 `git worktree remove`+删分支。游戏类测试（冒烟/单测/MC/探针）批内默认零执行（两入口铁规，见 §4），用户点名或当场问才跑
+4. **执法分层（全机械，零自觉依赖）**：①git pre-commit 钩子——一切提交的文档域闸机检（合并收尾提交豁免）。②post-merge／post-commit 钩子——本地 CI 触发（仅主工作区；任务 worktree 内的合并不触发）。③`.zcode/hooks/worktree-guard.sh`（PreToolUse，本机件不入 git）——agent 侧：`git commit --no-verify` 拦截（该旗标仅属用户）、iter<N> 分支合回的一卡一提交数卡校验、规则闸（写 design/／game/ 前核对会话规约读取记录）。git 层钩子对一切提交者生效（含用户手工提交，紧急出口 `--no-verify`）；ZCode 层只约束 agent
 
 ## 2. 五段流水线
 
@@ -48,8 +48,8 @@
 7. **验收改动先行声明**——验收变化（基线换代/探针增改/旧断言改判）预先写进需求卡片，禁事后补
 
 **完成**
-8. **批末按域验收才合并（worktree 批；直改车道无批末动作，验收在 commit 点由 git 钩子执行，见 §1 第 3 条）**——在任务 worktree 内跑 `tools/run_all_gates.sh`，**按本批改动域选档**：按文件性质判——代码面＝`game/` 下非 `.md` 的行为载体（代码、测试脚本、探针、场景、数据表、素材）→ `--code`；文档件＝`game/` 内 `.md`（README、生成清单）与 `game/` 外一切路径（`design/`、根规则文件、`tools/` 工具脚本、`.zcode/` 配置等）→ `--docs`；两类同批都有 → 全量档不带参数。代码域按**关联档选测**（2026-10-29 用户裁）：02 单元与集成只跑「需求卡片申报 ∪ diff 推导」并集的套件——申报＝在册需求卡片对照表「验收测试」列提到的测试文件名，推导＝闸脚本内套件族映射表按改动文件归族；改动命中公共件/数据表/autoload/数值·存档·RNG·结算触面或映射不到 → 横切回落全部套件；00 冒烟／01 系统测试／09 静态扫描三件保险恒跑不降；03 场景探针与 05 渲染闸维持影响面口径（本批 game/ 改动全在测量面 game/tests、game/sim 时记 SKIP）。所选域全绿即可合回 master，全量回归由用户自发发起（合入后无自动兜底）。合回前独立验收审计通过（iter 技能第 5 步），未过不合回。该脚本是全部验证闸的**唯一入口、唯一清单与唯一域划分（含选闸算法与套件族映射表）**，闸件增减、分域调整都只改它；**本文与其他文档禁另列闸件清单**（清单散落多处正是 iter27 漏跑 `probe_gate --full` 的成因）。跑完写回执 `game/tests/.gates/receipt.json`（含 `domain`、`scope`（full｜related，02 跑子集＝related）与 `dirty_game` 字段），合回时由 worktree-guard 按 diff 文件性质推域强制校验（六况拦截：缺回执／quick 模式／回执未覆盖分支尖＝回执 commit 之后代码面又有改动、或跑闸时代码面带着未提交改动（`dirty_game`）／域不覆盖本次改动／含新增红／master HEAD 非回执 commit 祖先＝合并将产出未测内容；guard 只验域覆盖与全绿，不复核选套件清单）。回执与分支尖的对齐判据是**代码面**不是 commit 号：回执之后只追加文档件（`game/` 内 `.md`、`reports/`、`design/` 等）提交，回执照样有效，不构成复跑理由。闸件（`tools/` 下机检脚本与闸壳）自身的改动不占合回全量——其质量义务＝落批时人工确认闸可跑通且判据口径未变，闸真崩溃时合回闸 fail-closed（跑不出回执即拦），不以合回全量为兜底
-9. **合并后主区零复跑**（2026-10-24 用户裁：合回重跑验的是与回执同一份字节，零信息）——合回落地后 code 批只做两件秒级事：`--editor --quit` 重刷类名缓存（在册坑：.godot 缓存不入 git，与合并后代码失配会假红假绿）＋冒烟启动确认可开机（合计约 1 分钟）；docs 批零动作。全量验证**每批跑一次**＝worktree 批末按域闸，顺序是「先并入 master、再跑闸」（§1 第 2 条）；只有两种情形允许把这次跑作废重来——① 闸红且修法动了 `game/`，② 闸已开跑后 master 又被推进（合并将产出未测内容，由合回闸祖先判定拦下，§3.9 第六况）。「跑都跑了再跑一遍保险」「闸后顺手改点 `game/` 再补一跑」都不构成复跑理由；master 上永不跑全量
+8. **合回后 CI 验证（worktree 批；主区直改小批的验收在 commit 点由 git 钩子执行，见 §1 第 1 条）**——主工作区 `git merge --no-ff <任务分支>` 落地后 post-merge 钩子自动跑全量域闸（不带参数档，02 全套件），判定与红项落 `game/tests/.gates/ci-status.json`。全量是唯一强制档：跨卡触面、探针与未申报套件的消费漏网只有全量闸能抓（迭代 44 实证），关联档选测的盲区由它兜底。合回前独立验收审计通过（iter 技能第 5 步），未过不合回。该脚本是全部验证闸的**唯一入口、唯一清单与唯一域划分（含选闸算法与套件族映射表）**，闸件增减、分域调整都只改它；**本文与其他文档禁另列闸件清单**（清单散落多处正是 iter27 漏跑 `probe_gate --full` 的成因）。开发期手动跑批按需选档（按文件性质判域：代码面→`--code`，文档件→`--docs`，两类都有→全量；`--code` 关联档选测——02 只跑「需求卡片申报 ∪ diff 推导」并集套件、00 冒烟／01 系统测试／09 静态扫描三件保险恒跑、横切面回落全量——算法见闸脚本），手动跑不构成验收。闸件（`tools/` 下机检脚本与闸壳）自身的改动不占 CI 全量——其质量义务＝落批时人工确认闸可跑通且判据口径未变；闸真崩溃时 CI 判红在案（跑不出回执＝verdict 红，fail-closed 语义保留）
+9. **重跑语义（2026-10-30 用户裁，取代原「每批一次／合并后零复跑」口径）**——同一份字节禁止第二次人手跑；允许的重跑只剩两类：① CI 红后的修复提交（post-commit 钩子自动追绿复验，每笔修复至多触发一轮）；② 用户自发发起的全量回归。「跑都跑了再跑一遍保险」「顺手改点再补一跑」都不构成重跑理由。类名缓存刷新与开机确认由 CI 跑批起手接管（§1 第 2 条），合并后无手工动作
 10. **批次完成后的登记义务**——合回 master 后按 doc-conventions §12.1 推进待办清单条目状态（做完整条删除），涉及迭代编排的在 roadmap 迭代总表与顶部「当前位」节换代——执行入口=项目技能 batch-closure（批后收尾与中间文档退役），跨会话教训写记忆库。批次过程与结论由 git 提交信息承载，禁止再写会话状态文件（见 doc-conventions 第 10 节）。`design/` 与根规则文件（`AGENTS.md`/`roadmap.md`/`待办清单.md`/`体验验证清单.md`）实现批禁写，见 §12
 11. **文档同步闸（实现批禁写文档）**——实现批**禁写 `design/` 整个目录与根规则文件**，**另禁写 `game/tests/README.md`（能力清单，归写卡段维护，test-conventions §8.9）**，要往外交代的东西一律落 `reports/`：实现报告 `reports/iter<N>-实现报告-<日期>.md`（各卡状态+实机目检总清单+遗留读数义务+实现决定记录——超白名单／超卡片明列范围事项逐条记「决了什么／为什么／代价／撤销方式」，全部按卡执行时只写一行「零拍板」）、GDD 反哺点清单 `reports/iter<N>-反哺点-<日期>.md`（每条写清哪个文件哪一节、改成什么、依据是什么）。设计权威文档（GDD/art-bible）**任何批都不直改**：用户在会话中逐点裁决后，由工程/文档设计改动批（直改类）写入 `design/`（执行入口=doc-design 技能），并把反哺条目从 `reports/` 清掉（吸收即死；退役执行=batch-closure 技能）。机械面文档（roadmap 行/术语表/README 工具注）同样归工程/文档设计改动批在合并前更新。反哺点未落地期间相关 GDD 节视为待反哺，读前先查 `reports/` 与待办清单；需求卡片必列「关联文档同步面」按两层标注
 12. **实机目检归用户，只登记不阻塞**——真人检测项登记进实现报告目检总清单与体验验证清单即完成批内义务；禁把等目检当停工理由或完成前置
@@ -62,7 +62,7 @@
 
 **MC/verifier 触发细则**：仅在数值验证场景触发（改数值前后取证）；normal 档为主、perfect 按需；**无数值改动的会话禁跑 MC**；结构位移类「存档锚」须先向用户请示定性再跑；需求卡片预设步骤的前提消失时（如「带值裁定后重锚」实际未投值）停问勿照字面执行。
 
-**分级周期口径**：全部验证闸收编在 `tools/run_all_gates.sh` 一个入口下（**脚本即清单，且即域划分的唯一出处**），分三档——`--code`／`--docs` 按本批改动域只跑该域闸（闸件清单与域划分只写在脚本头部注释，本文不重列）；`--quick` 是全量档的中段自检形态（跳过渲染闸与静态扫描）；**不带参数＝两域全量**，用于同一批既有代码面又有文档件改动。完成出库按所选域全绿，回执由合回闸按 diff 文件性质推域强制校验。真人实机目检归用户不进自动闸。
+**分级周期口径**：全部验证闸收编在 `tools/run_all_gates.sh` 一个入口下（**脚本即清单，且即域划分的唯一出处**），分三档——`--code`／`--docs` 按本批改动域只跑该域闸（闸件清单与域划分只写在脚本头部注释，本文不重列）；`--quick` 是全量档的中段自检形态（跳过渲染闸与静态扫描）；**不带参数＝两域全量**。强制验证点＝合回后本地 CI 的全量档（§1 第 2 条）；分档只服务开发期手动跑批。真人实机目检归用户不进自动闸。
 
 ## 5. MC 采集档位细则
 

design/engineering/test-conventions.md

@@ -25,9 +25,9 @@
 每个缺陷修复必须在探针或冒烟中留下能抓住该缺陷的断言（例：封印动作耗尽 AP → 必须进入第 2 轮；
 选用道具 → 库存态必须变 Used）。没有回归断言的修复视为未完成。
 
-## 4. 提交前验证
+## 4. 验证时机（合回后本地 CI 制，2026-10-30 换代）
 
-交付前跑 `tools/run_all_gates.sh`（不带 `--quick`），按改动域选档、所选域全绿——该脚本是全部验证闸的唯一入口与唯一清单，域划分与选闸算法只写在脚本里，本文禁另列闸件清单。闸件增减只改脚本。代码域按**关联档选测**（2026-10-29 用户裁）：02 单元与集成只跑「需求卡片申报 ∪ diff 推导」并集的套件，00 冒烟／01 系统测试／09 静态扫描三件保险恒跑不降，横切面改动（公共件/数据表/autoload/数值·存档·RNG·结算触面）回落全部套件；所选域全绿即可合回，全量回归由用户自发发起（合入后无自动兜底）。
+开发期窄测义务不变：每批开发中，本批新增/改动的验收测试自己跑绿即收口（卡内只测自己改的东西，process-conventions §6）；主区小改孤跑验证后直提。全量验证归合回后的本地 CI：git merge 合回 master 触发 post-merge 钩子跑 `tools/run_all_gates.sh` 不带参数档（两域全量，02 全套件——跨卡触面与关联档选测的盲区由全量兜底），结果落 `game/tests/.gates/ci-status.json`；CI 红态下修复提交经 post-commit 钩子自动追绿。同一份字节禁止第二次人手跑。该脚本是全部验证闸的唯一入口与唯一清单，域划分与选闸算法只写在脚本里，本文禁另列闸件清单。
 行为探针使用随机化玩家行为（封印/停手/刷新/无效点击）——自动玩家不做的动作就是测试盲区。
 
 ## 5. 测试函数怎么写——验收清单条目的落码规范

game/core/adventure_runner.gd

@@ -27,19 +27,14 @@ var levels_total := 0                     # 序列总关数（读 level 表行
 var master_seed := 0                      # 本局主种子（摘要第五件事）
 var summary := {}                         # 最近一次结算的冒险摘要（idle 后保留——重开才新生成）
 var _runner: LevelRunner                  # 当前关卡行进器（每关新建——关卡域状态天然隔离）
-var _pending_next_level := false          # 大奖励已兑付、等 continue_to_next_level 确认
-var _last_level_payload := {}             # 最近一次关卡结束载荷（失败结算的败退节点明细来源——数值验证取数面）
-var _last_treasure_cleared := 0                 # additive（最近一次关卡末清空计数，summary 取数面）
 var _treasure_unlocked := {}                   # aux 解锁门控集（params.treasure_unlocked 接收面）
 var _attunement: Array[Variant] = []               # 同调装配集（params.attunement 接收面，start_level 外下传 LevelRunner）
-var _save_manager = null                  # 断点承载注入（null = 不写断点；模拟/冒烟缺省）
-var _resume_bp := {}                      # 续玩快照暂存（resume_adventure → _start_current_level 单跳传递）
-var _loadout_seeded := false              # 同调行已种标记（每冒险一次——首关 bind 时点投行；行跨关存活后续关零动作）
 # ---- 三选一停点（编排迁 CurioStop 件——停点三态/刷新三源/凭证出箱/信号面）----
 var _curio: CurioDeck = null              # 令牌池件（_init 建；纯池——多重集/抽签/cap/凭证判定唯一宿主）
 var _stop: CurioStop = null               # 停点件（_init 建；每冒险一次——关卡换实例不换件）
 var _refresh_bank: RefreshBank = null     # 刷新账件（_init 建——三源账与付费报价；宿主预算注入与断点片段直收）
 var _loadout: AttuneLoadout = null        # 同调配装件（_init 建；充能单源化——物化行唯一事实源）
+var _bp_store: BreakpointStore            # 断点组装与回放件（_init 建；六成员+27 键登记单源+读写侧机组随件——宿主读写经件）
 var adventure_inventory: TreasureItems    # 冒险级秘宝库存（单源化——同调未用行跨关存活的承载面；关卡域语义归 level 使用面）
 var _tree_rules: Array[Variant] = []               # 树 rule 键集（Fork 激活侧 effects 透传；下传 enc.tree_rules 消费面）
 var _shop_mode := "legacy"                # 商店模式（"legacy"=固定三件加定价〔off 对照承载，缺省零扰动〕/"pool"=共享池抽 3 买 1 重抽；真实入口 main.gd 显式投 pool）
@@ -57,6 +52,8 @@ func _init(db_ref: ConfigDb, rng_ref: RngServiceCore) -> void:
 		_snapshot_breakpoint)
 	_loadout = AttuneLoadout.new(db, _attunement)
 	adventure_inventory = TreasureItems.new(db)
+	_bp_store = BreakpointStore.new({"db": db, "rng": rng, "stats": _stats, "wallet": _wallet,
+		"journal": _journal, "curio": _curio, "stop": _stop, "bank": _refresh_bank, "loadout": _loadout})
 
 
 # 件出口（组件交出非委托壳——呈现/测量面取主角账三件与令牌池单点；领域拆分批接口块）
@@ -107,7 +104,7 @@ func start_adventure(seed_val: int, params: Dictionary = {}) -> bool:
 	_reset_curio_state()
 	levels_total = db.run.level.level_count()   # 表访问收口（关数读 level 表行数）
 	level_index = 1
-	_pending_next_level = false
+	_bp_store._pending_next_level = false
 	_shop_mode = "pool" if String(params.get("shop_mode", "legacy")) == "pool" else "legacy"   # 缺省 legacy（off 对照零扰动）
 	_treasure_unlocked = params.get("treasure_unlocked", {}) if params.get("treasure_unlocked", {}) is Dictionary else {}
 	_attunement = params.get("attunement", []) if params.get("attunement", []) is Array else []   # additive
@@ -115,7 +112,7 @@ func start_adventure(seed_val: int, params: Dictionary = {}) -> bool:
 	_refresh_bank.set_refresh_y(maxi(0, int(params.get("attune_refresh_y", 0))))   # additive（Y 冒险周期池）
 	_loadout.set_attunement(_attunement)   # 装配集注入（活引用——种行面）
 	adventure_inventory.reset()   # 冒险级库存重置（新局空库存）
-	_loadout_seeded = false   # 同调行投行延至首关 bind 时点（库存就位后）
+	_bp_store._loadout_seeded = false   # 同调行投行延至首关 bind 时点（库存就位后）
 	adventure_counters = {}   # 冒险桶清零（效果引擎 adv_ 计数器宿主——冒险开始归零）
 	# 刷新练习开局注入（refresh_stock_grant 装配即得一次性加仓：
 	# 装配集 kind 分发扫描；只入存量账、临时账不动=V8 契约；resume 不重注入〔存量随断点已在〕）
@@ -152,99 +149,50 @@ func resume_adventure(bp: Dictionary, params: Dictionary = {}) -> bool:
 		return false
 	master_seed = int(bp.get("master_seed", 0))
 	rng.restore_adventure(master_seed, int(bp.get("rng_counter", 0)))
-	_resume_ledger(bp, params)
-	_resume_curio_state(bp)
-	_resume_params(bp, params)
-	_resume_counters(bp)
+	# ---- 断点回放（R2 整族归件——件侧语句入 _bp_store、宿主侧语句按原语句序留本壳，序逐步保形）----
+	_bp_store.restore_ledger(bp, params)   # 续玩账面回填——主角账三件片段各还原各键（件侧；clamp 类夹 ≥0；日记在档=推导比对载入、缺键=旧档汇总直载）
+	summary = {}
+	levels_total = db.run.level.level_count()   # 表访问收口（关数读 level 表行数）
+	level_index = int(bp.get("level_index", 1))
+	_bp_store._pending_next_level = false
+	_reset_curio_state()   # 续玩三选一态回填前置清理（池与件计数归件、停点态归本类；桶归宿主字典）
+	_bp_store.restore_curio_state(bp)   # 续玩三选一态回填（池余库/获取计数/特性持有集——件侧；dual_merge/keep_on_null 策略见 BREAKPOINT_FIELDS）
+	_bp_store.apply_resume_params(params)   # 续玩参数面——数值账规范化与越界钳制（件侧）
+	_shop_mode = "pool" if String(params.get("shop_mode", "legacy")) == "pool" else "legacy"   # 续玩参数面同 start_adventure（缺省 legacy）
+	_treasure_unlocked = params.get("treasure_unlocked", {}) if params.get("treasure_unlocked", {}) is Dictionary else {}
+	_attunement = params.get("attunement", []) if params.get("attunement", []) is Array else []   # additive
+	_refresh_bank.set_refresh_x_cap(_attune_refresh_x_total())   # 刷新账 X 基数预算注入（续玩参数面同 start）
+	_bp_store.restore_stop_bank_fragments(bp, params)   # 停点件/刷新账片段回填（件侧——凭证计数；刷新存量/Y 池缺键回退参数面）
+	_tree_rules = params.get("tree_rules", []) if params.get("tree_rules", []) is Array else []   # A/B 面 rule 键集（续玩参数面同 start_adventure 同式，消费面 set_tree_rules 下传）
+	# 续玩计数器回填（adventure 域计数——缺键 = 旧版断点防御空集；_reset_curio_state 已清零在先——桶归宿主字典）
+	var bp_counters = _bp_store._bp_read("adventure_counters", bp)
+	if bp_counters is Dictionary:
+		adventure_counters = (bp_counters as Dictionary).duplicate(true)
 	var bp_pending: Dictionary[Variant, Variant] = bp.get("bonus_pending", {}) as Dictionary
 	var bp_result: Dictionary[Variant, Variant] = bp.get("bonus_result", {}) as Dictionary
 	if not bp_pending.is_empty():
-		_pending_next_level = true
+		_bp_store._pending_next_level = true
 		_state = State.RUNNING
 		_stop.restore_pending(bp_pending)   # 选择停点直回（续玩不重跑关卡——信号经停点件中继）
 		return true
 	if not bp_result.is_empty():
-		_pending_next_level = true
+		_bp_store._pending_next_level = true
 		_stop.restore_resolved(bp_result)   # 已兑付不重兑付只重发（置态＋重发收编一步——信号面归停点件）
 		_state = State.RUNNING
 		return true
-	_resume_bp = bp.duplicate(true)
+	_bp_store._resume_bp = bp.duplicate(true)
 	# 充能读侧以行集为源（键值仅校验读数——回填时点在首关 bind 行集就位后，经 _loadout_on_level_inventory）
-	_loadout_seeded = false
+	_bp_store._loadout_seeded = false
 	_loadout.set_attunement(_attunement)
 	adventure_inventory.reset()
 	_state = State.RUNNING
 	return _start_current_level()
 
 
-# 续玩账面回填（生命/特性/钱包/加算区/已购档/钥石/逐杀明细/真视——主角账三件片段各还原各键；
-# bonus 子键 clamp 类夹 ≥0；日记在档=推导比对载入、缺键=旧档汇总直载）
-func _resume_ledger(bp: Dictionary, params: Dictionary) -> void:
-	_stats.restore_fragment(bp, params)
-	_wallet.restore_fragment(bp, params)
-	_journal.restore_fragment(bp, params)
-	summary = {}
-	levels_total = db.run.level.level_count()   # 表访问收口（关数读 level 表行数）
-	level_index = int(bp.get("level_index", 1))
-	_pending_next_level = false
-
-
-# 续玩三选一态回填（池与件计数归件、停点态归本类；dual_merge/keep_on_null 策略见 BREAKPOINT_FIELDS）
-func _resume_curio_state(bp: Dictionary) -> void:
-	_reset_curio_state()
-	var bp_taken: Dictionary[Variant, Variant] = bp.get("bonus_taken", {}) as Dictionary
-	for id in _curio.taken.keys():
-		_curio.taken[id] = maxi(0, int(bp_taken.get(id, 0)))
-	for id in bp_taken.keys():
-		_curio.taken[String(id)] = maxi(0, int(bp_taken.get(id, 0)))   # 身份维键（relic:<feat_id>）随快照还原
-	# 令牌池余库还原（TP0 v2.2——快照缺键 = 旧版断点，保持满库重建态：旧档只读一版周期的防御口径；
-	# relic 令牌 feat_id 随还原）
-	var bp_deck = _bp_read("bonus_deck", bp)
-	if bp_deck is Array:
-		var restored: Array[Variant] = []
-		for t in (bp_deck as Array):
-			var tok: Dictionary[Variant, Variant] = t as Dictionary
-			var rtok := {"kind": String(tok.get("kind", "")), "tier": String(tok.get("tier", ""))}
-			if String(rtok["kind"]) == "relic":
-				rtok["feat_id"] = String(tok.get("feat_id", ""))   # relic 令牌 feat_id 随还原
-			restored.append(rtok)
-		_curio.deck = restored
-	# 特性持有集还原（缺键 = 旧版断点防御空集——主角数值账字段单点）
-	_stats.feats = []
-	for r in (bp.get("relics", []) as Array):
-		_stats.feats.append(String(r))
-
-# 续玩参数面回填（同 start_adventure 参数面；生命账本越界钳制在此落——clamp 类）
-func _resume_params(bp: Dictionary, params: Dictionary) -> void:
-	_stats.rebase_override(params.get("hero_override", {}))   # 续玩参数面同 start_adventure（规范化归数值账）
-	_stats.attack_type = String(params.get("attack_type", ""))   # 续玩参数面同 start_adventure（账号层选中态随 resume 重注入）
-	_stats.armor_type = String(params.get("armor_type", ""))
-	# 生命账本越界钳制（T17——spawn 守卫 EC16 免疫）：断点可能带出高于生效上限的账本值
-	#（如调试浮窗调高期写出的值，实例：hero_hp=28 > 基础 26）——恢复后钳到生效上限，
-	# 否则首战 spawn「hero_hp 入参越界」拒收 → 「敌人系统 spawn 被拒」fatal。钳制式单点归
-	# 数值账 clamp_hp_to_resume_cap（保守口径不含加算区——与原钳制式逐字同）。
-	_stats.clamp_hp_to_resume_cap(int(db.combat.hero.max_hp))
-	_shop_mode = "pool" if String(params.get("shop_mode", "legacy")) == "pool" else "legacy"   # 续玩参数面同 start_adventure（缺省 legacy）
-	_treasure_unlocked = params.get("treasure_unlocked", {}) if params.get("treasure_unlocked", {}) is Dictionary else {}
-	_attunement = params.get("attunement", []) if params.get("attunement", []) is Array else []   # additive
-	_refresh_bank.set_refresh_x_cap(_attune_refresh_x_total())   # 刷新账 X 基数预算注入（续玩参数面同 start）
-	_stop.restore_fragment(bp, params)   # 停点件片段回填（凭证计数）
-	_refresh_bank.restore_fragment(bp, params)   # 刷新账片段回填（刷新存量/Y 池——Y 缺键回退参数面 params_fallback 类）
-	_tree_rules = params.get("tree_rules", []) if params.get("tree_rules", []) is Array else []   # A/B 面 rule 键集（续玩参数面同 start_adventure 同式，消费面 set_tree_rules 下传）
-
-
-# 续玩计数器回填（冒险域计数——凭证计数/刷新存量/Y 池随停点件片段回填）
-func _resume_counters(bp: Dictionary) -> void:
-	# adventure 域计数器回填（缺键 = 旧版断点防御空集；_reset_curio_state 已清零在先——桶归宿主字典）
-	var bp_counters = _bp_read("adventure_counters", bp)
-	if bp_counters is Dictionary:
-		adventure_counters = (bp_counters as Dictionary).duplicate(true)
-
-
 func _reset_curio_state() -> void:
 	_curio.reset()   # 池与件获取计数（池半归件；停点态归停点件下行清理）
 	_stop.reset_adventure_state()
-	_loadout_seeded = false
+	_bp_store._loadout_seeded = false
 	_stats.feats = []
 	adventure_counters = {}
 
@@ -263,7 +211,7 @@ func effective_max_hp() -> int:
 
 # 断点承载注入（组合根冒险开始时调用；模拟/冒烟不注入 = 断点面整体静默）
 func set_save_manager(sm: SaveManagerCore) -> void:
-	_save_manager = sm
+	_bp_store._save_manager = sm
 
 
 # 当前关卡行进器读面（呈现层/冒烟用——每关新建实例，调用方须在 level_started 后重取）
@@ -278,13 +226,13 @@ func apply_rest(pct: int, hp: int, max_hp: int) -> int:
 
 # 大奖励确认 → 进下一关（仅兑付后受理——零自动推进的冒险级停点；三选一未兑付拒绝推进）
 func continue_to_next_level() -> bool:
-	if not _pending_next_level:
+	if not _bp_store._pending_next_level:
 		push_error("[冒险结构] continue_to_next_level 拒绝——无待确认的关卡推进")
 		return false
 	if _stop.curio_stop_pending():
 		push_error("[冒险结构] continue_to_next_level 拒绝——三选一停点未兑付（零自动推进契约）")
 		return false
-	_pending_next_level = false
+	_bp_store._pending_next_level = false
 	_stop.clear_resolved()
 	level_index += 1
 	return _start_current_level()
@@ -343,9 +291,9 @@ func _loadout_on_level_inventory() -> void:
 	var inv = _runner.treasure_inventory
 	if inv == null:
 		return
-	if not _loadout_seeded:
-		_loadout_seeded = true
-		var bp_charges: Variant = _bp_read("attunement_charges", _resume_bp, null) if not _resume_bp.is_empty() else null
+	if not _bp_store._loadout_seeded:
+		_bp_store._loadout_seeded = true
+		var bp_charges: Variant = _bp_store._bp_read("attunement_charges", _bp_store._resume_bp, null) if not _bp_store._resume_bp.is_empty() else null
 		if bp_charges is Dictionary:
 			_loadout.restore_fragment({"attunement_charges": bp_charges}, inv)   # 旧档读侧：行集为源＋键值校验读数
 		else:
@@ -368,8 +316,8 @@ func _loadout_on_level_inventory() -> void:
 # apply_adventure_summary 逐关卡完成关次置位〕；末关 Boss 照常入账；明细随摘要 additive 键供结算面归因）
 func _boss_keystone_drop(li: int) -> void:
 	var first := true
-	if _save_manager != null:
-		first = not _save_manager.meta_state.career_state().boss_first_kill.has(str(li))
+	if _bp_store._save_manager != null:
+		first = not _bp_store._save_manager.meta_state.career_state().boss_first_kill.has(str(li))
 	var row: Dictionary[Variant, Variant] = db.crossrun.meta.boss_keystone_row(li)
 	var amount: int = int(row.get("first_kill", 0)) if first else int(row.get("repeat_kill", 0))
 	_journal.record_keystone_drop({"level": li, "first": first, "amount": amount})   # 逐杀明细+累计单写原语
@@ -419,9 +367,9 @@ func _start_current_level() -> bool:
 	# 断点续玩分支：图由主种子＋参数档重生成同图（产图与计数器号位无关，停点零重抽语义随之消解），
 	# resume_state 带停点句柄与已到序——重建到停点后经 present_resumed_choice 呈现（信号顺序契约同入口）。
 	var resume_state: Dictionary[Variant, Variant] = {}
-	if not _resume_bp.is_empty():
-		resume_state = {"node_id": int(_bp_read("node_id", _resume_bp, -1)),
-			"visited_ids": _bp_read("visited_ids", _resume_bp, []) as Array}
+	if not _bp_store._resume_bp.is_empty():
+		resume_state = {"node_id": int(_bp_store._bp_read("node_id", _bp_store._resume_bp, -1)),
+			"visited_ids": _bp_store._bp_read("visited_ids", _bp_store._resume_bp, []) as Array}
 	# 接口①开始关卡：生命经主角账共享交接（账面当前值即开局生命——冒险开始置满 / 大奖励回满已写好）；
 	# 主角账三件与冒险桶注入（构造注入 ctx——拆件批 T3 收口形态）。
 	# defer_entry=true 起每关（含首关）——先 emit level_started（呈现层在
@@ -431,7 +379,7 @@ func _start_current_level() -> bool:
 	if ok:
 		_emit_level_started()
 		_present_level_entry(resume_state)
-	_resume_bp = {}
+	_bp_store._resume_bp = {}
 	return ok
 
 
@@ -455,7 +403,7 @@ func _present_level_entry(resume_state: Dictionary) -> void:
 	if resume_state.is_empty() or int(resume_state.get("node_id", -1)) < 0:
 		_runner.present_entry_choice()
 	else:
-		_runner.restore_treasure_items(_bp_read("aux_items", _resume_bp, []) as Array)
+		_runner.restore_treasure_items(_bp_store._bp_read("aux_items", _bp_store._resume_bp, []) as Array)
 		_runner.present_resumed_choice()
 
 
@@ -464,7 +412,7 @@ func _on_level_finished(payload: Dictionary) -> void:
 	if state != "running":
 		push_error("[冒险结构] 重复关卡结束宣布拒绝——state=%s（账本与摘要零变化）" % state)
 		return
-	_last_level_payload = payload.duplicate(true)
+	_bp_store._last_level_payload = payload.duplicate(true)
 	var result := String(payload.get("result", ""))
 	if result == "defeat":
 		_stats.hero_hp = 0   # 倒下记 0（生命账本战后回写口径）
@@ -473,7 +421,7 @@ func _on_level_finished(payload: Dictionary) -> void:
 	if result != "victory":
 		push_error("[冒险结构] 关卡结束结果出域: %s" % result)
 		return
-	_last_treasure_cleared = int(payload.get("aux_cleared", 0))   # additive（末关 summary 取数面）
+	_bp_store._last_treasure_cleared = int(payload.get("aux_cleared", 0))   # additive（末关 summary 取数面）
 	# Boss 钥石逐杀掉落（击杀掉落渠道，末关照常入账；首杀/复杀读 meta.tres boss_keystone）
 	_boss_keystone_drop(level_index)
 	if level_index < levels_total:
@@ -481,7 +429,7 @@ func _on_level_finished(payload: Dictionary) -> void:
 		#（信号同步派发——处理器内立即确认时 _pending_next_level 必须已就位）；
 		# 停点件内部分回血先行 → 加权洗牌掷 3 → 三选一停点（顺序即契约——回血按当刻账本与上限结算，
 		# 选择停点零自动推进）。载荷_base 随附钱包读数（停点件零钱包依赖——GP 件入账回调仍走 grant_curio_gp）
-		_pending_next_level = true
+		_bp_store._pending_next_level = true
 		var stop_base: Dictionary[Variant, Variant] = payload.duplicate(true)
 		stop_base["gp"] = _wallet.gp
 		_stop.open_level_clear(stop_base)
@@ -499,7 +447,7 @@ func _settle(result: String) -> void:
 		"stopped_at": 0 if result == "completed" else level_index,
 		"keystone_total": _journal.keystone_gained(),
 		"master_seed": master_seed,
-		"aux_cleared_last": _last_treasure_cleared,   # additive 扩签（末关清空反馈；非末关走 bonus 载荷）
+		"aux_cleared_last": _bp_store._last_treasure_cleared,   # additive 扩签（末关清空反馈；非末关走 bonus 载荷）
 		"keystone_drops": _journal.keystone_drop_log(),   # additive 扩签（逐杀掉落明细；settle 入账明细/复盘归因数据源）
 		"vision_used_delta": _journal.vision_used(),   # additive 扩签（真视使用本局计数；settle 聚合入档）
 		"pool_stock": _pool_stock_snapshot(),   # additive 扩签（终局池读数：清账前快照，商店买走 vs 奖励领走 vs 枯竭的终局面）
@@ -507,19 +455,19 @@ func _settle(result: String) -> void:
 	}
 	# 败退明细（数值验证工具取数面——tools/balance_verifier.py 止步节点分布数据源；
 	# 仅失败局附加，键缺省 = 未败退，既有五件事消费方零感知）
-	if result == "failed" and not _last_level_payload.is_empty():
+	if result == "failed" and not _bp_store._last_level_payload.is_empty():
 		summary["defeat"] = {
 			"level_index": level_index,
-			"node_id": int(_last_level_payload.get("node_id", -1)),
-			"node_type": String(_last_level_payload.get("node_type", "")),
+			"node_id": int(_bp_store._last_level_payload.get("node_id", -1)),
+			"node_type": String(_bp_store._last_level_payload.get("node_type", "")),
 		}
 	if _runner != null:
 		summary["gp_final"] = int(_runner.gp)   # gp_final 清账前快照（终局面板取数源=runner 钱包单点）
 		_runner.close_wallet()   # GP 冒险收束清零（三结局都清——经转发发 wallet_changed "clear" 供日志/呈现）
 	_reset_curio_state()   # 三选一停点态收束清零（结算受理只算一次语义——重复宣布零变化）
-	if _save_manager != null:
-		_save_manager.clear_breakpoint()   # 三结局清断点（退出冒险=放弃流程+清除断点）
-		_save_manager.write_to_disk()
+	if _bp_store._save_manager != null:
+		_bp_store._save_manager.clear_breakpoint()   # 三结局清断点（退出冒险=放弃流程+清除断点）
+		_bp_store._save_manager.write_to_disk()
 	_state = State.SETTLING
 	adventure_finished.emit(summary)
 	_state = State.IDLE
@@ -530,131 +478,7 @@ func _on_level_choices_presented(_candidates: Array) -> void:
 	_snapshot_breakpoint()
 
 
-# ---- 断点快照（字段登记单源：写侧拼装与读侧回退策略同登记一表）----
-# 键序即快照键序（27 顶层键——写侧/读侧/键集断言三面同源）。读侧回退策略词表：
-#   plain 无特殊回退面（缺键取代码内缺省）／clamp 数值夹 ≥0／keep_on_null 缺键或类型不符保持既有态
-#   dual_merge 双向合并（bonus_taken）／params_fallback 缺键回退参数面（attune_refresh_y）
-#   token_migration 旧版候选形态迁移（bonus_pending.candidates）
-# 注入缺省 null = 整面静默（模拟/冒烟零扰动）。
-const BREAKPOINT_FIELDS := {
-	"level_index": {"strategy": "plain"},
-	"node_id": {"strategy": "plain"},
-	"hero_hp": {"strategy": "clamp"},
-	"bonus": {"strategy": "clamp"},
-	"gp": {"strategy": "plain"},
-	"shop_purchased": {"strategy": "plain"},
-	"shop_shelf": {"strategy": "plain"},
-	"shop_visit_buys": {"strategy": "plain"},
-	"attunement_charges": {"strategy": "keep_on_null"},
-	"graph_gen_v2": {"strategy": "plain"},
-	"master_seed": {"strategy": "plain"},
-	"rng_counter": {"strategy": "plain"},
-	"keystone": {"strategy": "plain"},
-	"visited_ids": {"strategy": "plain"},
-	"aux_items": {"strategy": "plain"},
-	"bonus_taken": {"strategy": "dual_merge"},
-	"bonus_deck": {"strategy": "keep_on_null"},
-	"relics": {"strategy": "plain"},
-	"bonus_pending": {"strategy": "token_migration"},
-	"feat_ticket_pity": {"strategy": "plain"},
-	"feat_ticket_sold": {"strategy": "plain"},
-	"adventure_counters": {"strategy": "keep_on_null"},
-	"vision_counter_used": {"strategy": "clamp"},
-	"refresh_stock": {"strategy": "clamp"},
-	"attune_refresh_y": {"strategy": "params_fallback"},
-	"bonus_result": {"strategy": "plain"},
-	"keystone_drops": {"strategy": "plain"},
-	"gain_journal": {"strategy": "plain"},   # 获得日记（拆件批 T4 扩列——唯一声明的断点扩展；旧档缺键=汇总直载跳过比对）
-}
-
-
+# ---- 断点快照委托（组装与读侧策略机组归 breakpoint_store 件——六成员+27 键登记单源随件；
+# 本壳一行转发：CurioStop 构造注入的 Callable 目标与本类 _on_level_choices_presented 调用点零改）----
 func _snapshot_breakpoint() -> void:
-	if _save_manager == null or state != "running":
-		return
-	var parts: Dictionary[Variant, Variant] = _bp_parts()
-	var bp: Dictionary[Variant, Variant] = {}
-	for key in BREAKPOINT_FIELDS.keys():
-		bp[key] = parts[key]
-	_save_manager.set_breakpoint(bp)
-	_save_manager.write_to_disk()
-
-
-# 断点写侧取值（键集以 BREAKPOINT_FIELDS 为准——未登记键即取值越界，fail-fast）
-func _bp_parts() -> Dictionary[Variant, Variant]:
-	var stats_frag: Dictionary[Variant, Variant] = _stats.breakpoint_fragment()
-	var wallet_frag: Dictionary[Variant, Variant] = _wallet.breakpoint_fragment()
-	var journal_frag: Dictionary[Variant, Variant] = _journal.breakpoint_fragment()
-	var bank_frag: Dictionary[Variant, Variant] = _refresh_bank.breakpoint_fragment()
-	var stop_frag: Dictionary[Variant, Variant] = _stop.breakpoint_fragment()
-	var level_frag: Dictionary[Variant, Variant] = _runner.breakpoint_fragment() if _runner != null else {
-		"node_id": -1, "visited_ids": [] as Array, "aux_items": [] as Array,
-		"shop_shelf": [] as Array, "shop_visit_buys": 0}   # 三选一停点续玩分支 _runner 为 null——节点域按缺省落档
-	# 该两态的续玩只消费 bonus_* 附随件（选择停点/已兑付停点快照）
-	var parts: Dictionary[Variant, Variant] = {
-		"level_index": level_index,
-		"node_id": int(level_frag.get("node_id", -1)),
-		"hero_hp": int(stats_frag.get("hero_hp", 0)),
-		"bonus": journal_frag.get("bonus", {}),
-		"gp": int(wallet_frag.get("gp", 0)),
-		"shop_purchased": journal_frag.get("shop_purchased", {}),
-		"shop_shelf": level_frag.get("shop_shelf", []),            # 货架入断点（离开店/非店停点 = 空架合法态）
-		"shop_visit_buys": int(level_frag.get("shop_visit_buys", 0)),   # 本次进店已购次数（A 链定价输入）
-		"attunement_charges": (_loadout.breakpoint_fragment(_runner.treasure_inventory) if _runner != null and _runner.treasure_inventory != null else {"attunement_charges": {}}).get("attunement_charges", {}),   # 同调主动件充能余量随断点（行派生——save v4 域键名策略不变）
-		"graph_gen_v2": 1,   # 生成图换代代差标记（缺键 = 换代前旧断点 → resume 显式拒绝）
-		"master_seed": master_seed,
-		"rng_counter": rng.counter(),
-		"keystone": int(journal_frag.get("keystone", 0)),
-		"visited_ids": level_frag.get("visited_ids", []),
-		"aux_items": level_frag.get("aux_items", []),
-		"bonus_taken": _curio.taken.duplicate(true),            # 三选一件获取次数（kind 维度派生账本——断点附随件与读数承载）
-		"bonus_deck": _curio.deck.duplicate(true),              # 令牌池余库（TP0 v2.2——池消耗即上限，续玩余库逐枚还原）
-		"relics": stats_frag.get("relics", []),                 # 特性持有集（局内随机渠道获得态续玩防丢失）
-		"bonus_pending": stop_frag.get("bonus_pending", {}),    # 三选一停点态（空 = 无停点——选择停点可中断契约）
-		"feat_ticket_pity": int(stop_frag.get("feat_ticket_pity", 0)),   # T5 专长凭证保底计数（扩列向后兼容——旧档缺键缺省 0）
-		"feat_ticket_sold": int(stop_frag.get("feat_ticket_sold", 0)),   # T5 专长凭证限购计数（同上）
-		"adventure_counters": adventure_counters.duplicate(true),   # adventure 域计数器随断点（续玩跨战账不丢——桶归宿主字典）
-		"vision_counter_used": int(journal_frag.get("vision_counter_used", 0)),   # 真视使用计数随断点（续玩跨战账不丢）
-		"refresh_stock": int(bank_frag.get("refresh_stock", 0)),   # 刷新存量账随断点
-		"attune_refresh_y": int(bank_frag.get("attune_refresh_y", 0)),   # Y 冒险周期池余量随断点（扩列向后兼容——旧档缺键回退参数面）
-		"bonus_result": stop_frag.get("bonus_result", {}),      # 已兑付待推进态（空 = 无——中断续玩不重兑付）
-		"keystone_drops": journal_frag.get("keystone_drops", []),  # 逐杀掉落明细（摘要归因续接）
-		"gain_journal": journal_frag.get("gain_journal", {}),      # 获得日记（唯一声明的断点扩列——日记为现行事实源）
-	}
-	# 拼盘完整性自断言（fail-fast——片段并集与登记键集不符即中止落盘）
-	var stray: Array[Variant] = []
-	for key in parts.keys():
-		if not BREAKPOINT_FIELDS.has(key):
-			stray.append(key)
-	if not stray.is_empty():
-		push_error("[冒险结构] 断点拼盘含未登记键: %s（fail-fast——片段与登记单源失同步）" % str(stray))
-	return parts
-
-
-
-# 读侧单点（BREAKPOINT_FIELDS 策略标签分发；未登记键 fail-fast 不静默按 plain 兜）。
-# 二次消费面（_start_current_level 经 _resume_bp 取 node_id/visited_ids/aux_items）同走此口。
-func _bp_read(key: String, bp: Dictionary, fallback: Variant = null) -> Variant:
-	if not BREAKPOINT_FIELDS.has(key):
-		push_error("[冒险结构] 断点字段未登记（读侧）: %s" % key)
-	var v: Variant = bp.get(key, fallback)
-	if _bp_strategy(key) == "keep_on_null" and v != null and not (v is Dictionary or v is Array):
-		return null   # 类型不符——保持既有态（调用方跳过覆盖）
-	return v
-
-
-# 读侧策略标签（BREAKPOINT_FIELDS 读侧消费面单点）
-func _bp_strategy(key: String) -> String:
-	return String((BREAKPOINT_FIELDS.get(key, {}) as Dictionary).get("strategy", "plain"))
-
-
-# 数值类读侧（clamp 夹 ≥0 / params_fallback 断点缺键回退参数面整额注入 / plain 直取）
-func _bp_read_int(key: String, bp: Dictionary, fallback: int, params: Dictionary = {}) -> int:
-	match _bp_strategy(key):
-		"clamp":
-			return maxi(0, int(bp.get(key, fallback)))
-		"params_fallback":
-			return maxi(0, int(bp.get(key, int(params.get(key, fallback)))))
-		_:
-			return int(bp.get(key, fallback))
-
-
+	_bp_store.snapshot(state, level_index, master_seed, _runner, adventure_counters)

game/core/breakpoint_store.gd

@@ -0,0 +1,218 @@
+## VERTICAL SLICE - NOT FOR PRODUCTION
+## 存档断点组装与回放唯一承载（AdventureRunner 拆件——单一变化原因=断点快照键面与回放策略）：
+## 断点快照拼盘、回放回填、读侧策略分发；BREAKPOINT_FIELDS 27 键登记单源随件（键名/策略标签/键序冻结）。
+## 构造＝引用束字典注入（db/rng/主角账三件/curio/stop/bank/loadout——件禁反向持宿主）；
+## 快照宿主输入（state/level_index/master_seed/runner/adventure_counters）逐调传参；
+## resume_adventure 留宿主（壳＋宿主侧回填语句——所有权缝分家，语句序逐步保形）。
+class_name BreakpointStore
+extends RefCounted
+
+# ---- 断点快照（字段登记单源：写侧拼装与读侧回退策略同登记一表）----
+# 键序即快照键序（27 顶层键——写侧/读侧/键集断言三面同源）。读侧回退策略词表：
+#   plain 无特殊回退面（缺键取代码内缺省）／clamp 数值夹 ≥0／keep_on_null 缺键或类型不符保持既有态
+#   dual_merge 双向合并（bonus_taken）／params_fallback 缺键回退参数面（attune_refresh_y）
+#   token_migration 旧版候选形态迁移（bonus_pending.candidates）
+# 注入缺省 null = 整面静默（模拟/冒烟零扰动）。
+const BREAKPOINT_FIELDS := {
+	"level_index": {"strategy": "plain"},
+	"node_id": {"strategy": "plain"},
+	"hero_hp": {"strategy": "clamp"},
+	"bonus": {"strategy": "clamp"},
+	"gp": {"strategy": "plain"},
+	"shop_purchased": {"strategy": "plain"},
+	"shop_shelf": {"strategy": "plain"},
+	"shop_visit_buys": {"strategy": "plain"},
+	"attunement_charges": {"strategy": "keep_on_null"},
+	"graph_gen_v2": {"strategy": "plain"},
+	"master_seed": {"strategy": "plain"},
+	"rng_counter": {"strategy": "plain"},
+	"keystone": {"strategy": "plain"},
+	"visited_ids": {"strategy": "plain"},
+	"aux_items": {"strategy": "plain"},
+	"bonus_taken": {"strategy": "dual_merge"},
+	"bonus_deck": {"strategy": "keep_on_null"},
+	"relics": {"strategy": "plain"},
+	"bonus_pending": {"strategy": "token_migration"},
+	"feat_ticket_pity": {"strategy": "plain"},
+	"feat_ticket_sold": {"strategy": "plain"},
+	"adventure_counters": {"strategy": "keep_on_null"},
+	"vision_counter_used": {"strategy": "clamp"},
+	"refresh_stock": {"strategy": "clamp"},
+	"attune_refresh_y": {"strategy": "params_fallback"},
+	"bonus_result": {"strategy": "plain"},
+	"keystone_drops": {"strategy": "plain"},
+	"gain_journal": {"strategy": "plain"},   # 获得日记（拆件批 T4 扩列——唯一声明的断点扩展；旧档缺键=汇总直载跳过比对）
+}
+
+# 引用束（宿主构造注入——成员名与宿主侧原名一致，迁移函数体逐字）
+var db: ConfigDb
+var rng: RngServiceCore
+var _stats: HeroStats
+var _wallet: GpWallet
+var _journal: GainJournal
+var _curio: CurioDeck = null              # 令牌池件（池余库/获取计数随断点）
+var _stop: CurioStop = null               # 停点件（停点态/凭证计数片段）
+var _refresh_bank: RefreshBank = null     # 刷新账件（刷新存量/Y 池片段）
+var _loadout: AttuneLoadout = null        # 同调配装件（充能行集读侧）
+# 断点域六成员（自宿主收编——宿主其余读写点经本件）
+var _save_manager = null                  # 断点承载注入（null = 不写断点；模拟/冒烟缺省）
+var _resume_bp := {}                      # 续玩快照暂存（resume_adventure → _start_current_level 单跳传递）
+var _pending_next_level := false          # 大奖励已兑付、等 continue_to_next_level 确认
+var _last_level_payload := {}             # 最近一次关卡结束载荷（失败结算的败退节点明细来源——数值验证取数面）
+var _last_treasure_cleared := 0                 # additive（最近一次关卡末清空计数，summary 取数面）
+var _loadout_seeded := false              # 同调行已种标记（每冒险一次——首关 bind 时点投行；行跨关存活后续关零动作）
+
+
+func _init(refs: Dictionary) -> void:
+	db = refs["db"]
+	rng = refs["rng"]
+	_stats = refs["stats"]
+	_wallet = refs["wallet"]
+	_journal = refs["journal"]
+	_curio = refs["curio"]
+	_stop = refs["stop"]
+	_refresh_bank = refs["bank"]
+	_loadout = refs["loadout"]
+
+
+# 断点快照拼盘落盘（宿主 _snapshot_breakpoint 委托目标——宿主输入逐调传参）
+func snapshot(state: String, level_index: int, master_seed: int, runner: LevelRunner, counters: Dictionary[Variant, Variant]) -> void:
+	if _save_manager == null or state != "running":
+		return
+	var parts: Dictionary[Variant, Variant] = _bp_parts(level_index, master_seed, runner, counters)
+	var bp: Dictionary[Variant, Variant] = {}
+	for key in BREAKPOINT_FIELDS.keys():
+		bp[key] = parts[key]
+	_save_manager.set_breakpoint(bp)
+	_save_manager.write_to_disk()
+
+
+# 断点写侧取值（键集以 BREAKPOINT_FIELDS 为准——未登记键即取值越界，fail-fast）
+func _bp_parts(level_index: int, master_seed: int, runner: LevelRunner, counters: Dictionary[Variant, Variant]) -> Dictionary[Variant, Variant]:
+	var stats_frag: Dictionary[Variant, Variant] = _stats.breakpoint_fragment()
+	var wallet_frag: Dictionary[Variant, Variant] = _wallet.breakpoint_fragment()
+	var journal_frag: Dictionary[Variant, Variant] = _journal.breakpoint_fragment()
+	var bank_frag: Dictionary[Variant, Variant] = _refresh_bank.breakpoint_fragment()
+	var stop_frag: Dictionary[Variant, Variant] = _stop.breakpoint_fragment()
+	var level_frag: Dictionary[Variant, Variant] = runner.breakpoint_fragment() if runner != null else {
+		"node_id": -1, "visited_ids": [] as Array, "aux_items": [] as Array,
+		"shop_shelf": [] as Array, "shop_visit_buys": 0}   # 三选一停点续玩分支 runner 为 null——节点域按缺省落档
+	# 该两态的续玩只消费 bonus_* 附随件（选择停点/已兑付停点快照）
+	var parts: Dictionary[Variant, Variant] = {
+		"level_index": level_index,
+		"node_id": int(level_frag.get("node_id", -1)),
+		"hero_hp": int(stats_frag.get("hero_hp", 0)),
+		"bonus": journal_frag.get("bonus", {}),
+		"gp": int(wallet_frag.get("gp", 0)),
+		"shop_purchased": journal_frag.get("shop_purchased", {}),
+		"shop_shelf": level_frag.get("shop_shelf", []),            # 货架入断点（离开店/非店停点 = 空架合法态）
+		"shop_visit_buys": int(level_frag.get("shop_visit_buys", 0)),   # 本次进店已购次数（A 链定价输入）
+		"attunement_charges": (_loadout.breakpoint_fragment(runner.treasure_inventory) if runner != null and runner.treasure_inventory != null else {"attunement_charges": {}}).get("attunement_charges", {}),   # 同调主动件充能余量随断点（行派生——save v4 域键名策略不变）
+		"graph_gen_v2": 1,   # 生成图换代代差标记（缺键 = 换代前旧断点 → resume 显式拒绝）
+		"master_seed": master_seed,
+		"rng_counter": rng.counter(),
+		"keystone": int(journal_frag.get("keystone", 0)),
+		"visited_ids": level_frag.get("visited_ids", []),
+		"aux_items": level_frag.get("aux_items", []),
+		"bonus_taken": _curio.taken.duplicate(true),            # 三选一件获取次数（kind 维度派生账本——断点附随件与读数承载）
+		"bonus_deck": _curio.deck.duplicate(true),              # 令牌池余库（TP0 v2.2——池消耗即上限，续玩余库逐枚还原）
+		"relics": stats_frag.get("relics", []),                 # 特性持有集（局内随机渠道获得态续玩防丢失）
+		"bonus_pending": stop_frag.get("bonus_pending", {}),    # 三选一停点态（空 = 无停点——选择停点可中断契约）
+		"feat_ticket_pity": int(stop_frag.get("feat_ticket_pity", 0)),   # T5 专长凭证保底计数（扩列向后兼容——旧档缺键缺省 0）
+		"feat_ticket_sold": int(stop_frag.get("feat_ticket_sold", 0)),   # T5 专长凭证限购计数（同上）
+		"adventure_counters": counters.duplicate(true),   # adventure 域计数器随断点（续玩跨战账不丢——桶归宿主字典）
+		"vision_counter_used": int(journal_frag.get("vision_counter_used", 0)),   # 真视使用计数随断点（续玩跨战账不丢）
+		"refresh_stock": int(bank_frag.get("refresh_stock", 0)),   # 刷新存量账随断点
+		"attune_refresh_y": int(bank_frag.get("attune_refresh_y", 0)),   # Y 冒险周期池余量随断点（扩列向后兼容——旧档缺键回退参数面）
+		"bonus_result": stop_frag.get("bonus_result", {}),      # 已兑付待推进态（空 = 无——中断续玩不重兑付）
+		"keystone_drops": journal_frag.get("keystone_drops", []),  # 逐杀掉落明细（摘要归因续接）
+		"gain_journal": journal_frag.get("gain_journal", {}),      # 获得日记（唯一声明的断点扩列——日记为现行事实源）
+	}
+	# 拼盘完整性自断言（fail-fast——片段并集与登记键集不符即中止落盘）
+	var stray: Array[Variant] = []
+	for key in parts.keys():
+		if not BREAKPOINT_FIELDS.has(key):
+			stray.append(key)
+	if not stray.is_empty():
+		push_error("[冒险结构] 断点拼盘含未登记键: %s（fail-fast——片段与登记单源失同步）" % str(stray))
+	return parts
+
+
+# 续玩账面回填（生命/特性/钱包/加算区/已购档/钥石/逐杀明细/真视——主角账三件片段各还原各键；
+# bonus 子键 clamp 类夹 ≥0；日记在档=推导比对载入、缺键=旧档汇总直载）
+#（宿主侧账面语句——summary/levels_total/level_index/_pending_next_level——按语句序留宿主壳）
+func restore_ledger(bp: Dictionary, params: Dictionary) -> void:
+	_stats.restore_fragment(bp, params)
+	_wallet.restore_fragment(bp, params)
+	_journal.restore_fragment(bp, params)
+
+
+# 续玩三选一态回填（池与件计数归件、停点态归宿主；dual_merge/keep_on_null 策略见 BREAKPOINT_FIELDS）
+#（前置清理 _reset_curio_state 留宿主——桶归宿主字典；本函数承接其后的件侧还原语句，序逐步保形）
+func restore_curio_state(bp: Dictionary) -> void:
+	var bp_taken: Dictionary[Variant, Variant] = bp.get("bonus_taken", {}) as Dictionary
+	for id in _curio.taken.keys():
+		_curio.taken[id] = maxi(0, int(bp_taken.get(id, 0)))
+	for id in bp_taken.keys():
+		_curio.taken[String(id)] = maxi(0, int(bp_taken.get(id, 0)))   # 身份维键（relic:<feat_id>）随快照还原
+	# 令牌池余库还原（TP0 v2.2——快照缺键 = 旧版断点，保持满库重建态：旧档只读一版周期的防御口径；
+	# relic 令牌 feat_id 随还原）
+	var bp_deck = _bp_read("bonus_deck", bp)
+	if bp_deck is Array:
+		var restored: Array[Variant] = []
+		for t in (bp_deck as Array):
+			var tok: Dictionary[Variant, Variant] = t as Dictionary
+			var rtok := {"kind": String(tok.get("kind", "")), "tier": String(tok.get("tier", ""))}
+			if String(rtok["kind"]) == "relic":
+				rtok["feat_id"] = String(tok.get("feat_id", ""))   # relic 令牌 feat_id 随还原
+			restored.append(rtok)
+		_curio.deck = restored
+	# 特性持有集还原（缺键 = 旧版断点防御空集——主角数值账字段单点）
+	_stats.feats = []
+	for r in (bp.get("relics", []) as Array):
+		_stats.feats.append(String(r))
+
+
+# 续玩参数面——数值账规范化与越界钳制（件侧；宿主侧四重绑定与预算注入按语句序夹在两件侧调用之间）
+func apply_resume_params(params: Dictionary) -> void:
+	_stats.rebase_override(params.get("hero_override", {}))   # 续玩参数面同 start_adventure（规范化归数值账）
+	_stats.attack_type = String(params.get("attack_type", ""))   # 续玩参数面同 start_adventure（账号层选中态随 resume 重注入）
+	_stats.armor_type = String(params.get("armor_type", ""))
+	# 生命账本越界钳制（T17——spawn 守卫 EC16 免疫）：断点可能带出高于生效上限的账本值
+	#（如调试浮窗调高期写出的值，实例：hero_hp=28 > 基础 26）——恢复后钳到生效上限，
+	# 否则首战 spawn「hero_hp 入参越界」拒收 → 「敌人系统 spawn 被拒」fatal。钳制式单点归
+	# 数值账 clamp_hp_to_resume_cap（保守口径不含加算区——与原钳制式逐字同）。
+	_stats.clamp_hp_to_resume_cap(int(db.combat.hero.max_hp))
+
+
+# 停点件/刷新账片段回填（凭证计数；刷新存量/Y 池——Y 缺键回退参数面 params_fallback 类）
+func restore_stop_bank_fragments(bp: Dictionary, params: Dictionary) -> void:
+	_stop.restore_fragment(bp, params)
+	_refresh_bank.restore_fragment(bp, params)
+
+
+# 读侧单点（BREAKPOINT_FIELDS 策略标签分发；未登记键 fail-fast 不静默按 plain 兜）。
+# 二次消费面（_start_current_level 经 _resume_bp 取 node_id/visited_ids/aux_items）同走此口。
+func _bp_read(key: String, bp: Dictionary, fallback: Variant = null) -> Variant:
+	if not BREAKPOINT_FIELDS.has(key):
+		push_error("[冒险结构] 断点字段未登记（读侧）: %s" % key)
+	var v: Variant = bp.get(key, fallback)
+	if _bp_strategy(key) == "keep_on_null" and v != null and not (v is Dictionary or v is Array):
+		return null   # 类型不符——保持既有态（调用方跳过覆盖）
+	return v
+
+
+# 读侧策略标签（BREAKPOINT_FIELDS 读侧消费面单点）
+func _bp_strategy(key: String) -> String:
+	return String((BREAKPOINT_FIELDS.get(key, {}) as Dictionary).get("strategy", "plain"))
+
+
+# 数值类读侧（clamp 夹 ≥0 / params_fallback 断点缺键回退参数面整额注入 / plain 直取）
+func _bp_read_int(key: String, bp: Dictionary, fallback: int, params: Dictionary = {}) -> int:
+	match _bp_strategy(key):
+		"clamp":
+			return maxi(0, int(bp.get(key, fallback)))
+		"params_fallback":
+			return maxi(0, int(bp.get(key, int(params.get(key, fallback)))))
+		_:
+			return int(bp.get(key, fallback))

game/core/breakpoint_store.gd.uid

@@ -0,0 +1 @@
+uid://cw5qdd012h728

game/core/level_runner.gd

@@ -9,7 +9,7 @@
 class_name LevelRunner
 extends RefCounted
 
-signal node_entered(node: Dictionary, info: Dictionary)   ## info 按 type：battle/boss={} · reward={}（三选一停点空载荷——内容经 present_node_curio 拉取） · rest={healed,hp,max_hp} · shop={gp}
+signal node_entered(node: Dictionary, info: Dictionary)   ## info 按 type：battle/boss={} · reward={}（三选一停点空载荷——内容经 present_node_curio 拉取） · rest={healed,hp,max_hp} · shop={gp}（pool 态加 shelf:true）
 signal choices_presented(candidates: Array)               ## 选路口（兑付确认后——候选节点引用数组，零自动推进）
 signal step_row(row: Dictionary)                          ## 转发当前 战斗结算 结算行
 signal round_started(round_index: int)

game/presentation/views/board_cell_unit.gd

@@ -1,128 +1,31 @@
 ## VERTICAL SLICE - NOT FOR PRODUCTION
-## CellUnit——BoardView SubViewport 世界内逐格渲染件（Node2D），全部程序化 _draw 占位视觉（纹理槽位已留未装载）。
+## CellUnit——BoardView SubViewport 世界内逐格渲染件（Node2D），被动绘制壳：_draw 六步时序器
+## ＋视野迷雾域＋微光子件生命周期＋格件几何；基座层与标识叠加两绘制域件 _init 自建持有
+## （cell_base_layer/cell_mark_overlay——单一变化原因=迷雾规格与格件节点生命周期）。
 ## 无 class_name（类名缓存面纪律）——使用方经 preload 引用。
-## 内部状态件（u3 子域拆件——契约 9 职责语句「单格绘制输入集」）：本件为被动绘制壳，
-## 状态件 _CellPaintState 承载全部绘制入参（单一变化原因=格面呈现），setter 触发宿主重绘语义
-## 经 _owner 回引保持逐字；探针直读冻结成员（glyph/fog_state/plate/glyph_color）与 _glow_layer 住宿主。
+## 探针直读冻结成员（glyph/fog_state/plate/glyph_color）与 _glow_layer 住宿主；
+## hl_color/hl_visible/dot_visible/mutation_mark 探针读 u.face.*。
 extends Node2D
 
 const _GLOW_LAYER := preload("res://presentation/views/cell_type_glow_layer.gd")
+const _BASE_LAYER := preload("res://presentation/views/cell_base_layer.gd")
+const _MARK_OVERLAY := preload("res://presentation/views/cell_mark_overlay.gd")
 
-# ── D 投影档绘制常量（研究件实测取色——立面高光/双段暗带/地面投影；黑罩 alpha 叠加实测等效）──
-const FACADE_HIGHLIGHT_PX := 2.0                     # 口沿高光线厚（像素）
-const FACADE_NEAR_FRAC := 0.16                       # 立面近段高（格边比——研究件 10/64）
-const FACADE_FAR_FRAC := 0.25                        # 立面远段高（格边比——研究件 16/64）
-const FACADE_NEAR_COL := Color(0, 0, 0, 0.60)        # 立面近段黑罩（墙顶 132→52 实测 α≈0.61）
-const FACADE_FAR_COL := Color(0, 0, 0, 0.82)         # 立面远段黑罩（墙顶 132→24 实测 α≈0.82）
-const PROJECTION_NEAR_COL := Color(0, 0, 0, 0.28)    # 投影贴墙段（地面 66→46 实测 α≈0.28）
-const PROJECTION_MID_COL := Color(0, 0, 0, 0.16)     # 投影中段（渐隐）
-const PROJECTION_EDGE_COL := Color(0, 0, 0, 0.06)    # 投影远段（渐隐收边）
-# ── E 格高墙面（圣经 v3.5 冻结①——地面格南邻墙→南部 30% 承接墙面：墙顶纹理原亮度
-# 直贴零暗档零阴影；墙脚阴线只画地面/墙面交界；(b)-(c) 交界
-# 无边框由 BoardView 侧跳过墙格北向描边承载）──
-const E_FACADE_FRAC := 0.30                          # 墙面承接高（格边比 30%）
-
-
-## 单格绘制输入集（被动绘制壳的全部绘制入参——BoardView 直写面；setter 触发宿主重绘语义逐字）
-class _CellPaintState extends RefCounted:
-	var _owner: Node2D = null
-	var cell := Vector2i.ZERO          # 板坐标（诊断观测面）
-	var edge := 46.0:                  # 格边长（BoardView.set_cell_area 单点驱动）
-		set(v):
-			edge = v
-			if _owner._glow_layer != null and is_instance_valid(_owner._glow_layer):
-				_owner._glow_layer.setup(edge, glow_group)
-			_owner.queue_redraw()
-	var bg_sb: StyleBoxFlat = null     # 格底 StyleBox（BoardView 每次 paint 重建；呼吸微光就地改边框）
-	# ── 接触带微光绘制面（可挖域微光画在英雄格周界空间侧——art-bible §3.2 v2.8；
-	#     仅英雄格单元承载，BoardView.refresh 按可挖域写边/角码、_process 逐拍更新呼吸色）──
-	var contact_bands: Array[int] = []      # 正交接触边码 0=N/1=S/2=W/3=E（该侧整条边）
-	var contact_corners: Array[int] = []    # 斜向共享角码 0=NW/1=NE/2=SW/3=SE（角点+两侧各半条边）
-	var contact_col := Color(0, 0, 0, 0)   # 当前呼吸色（alpha 0 = 不画）
-	var outline_sides: Array[int] = []       # 墙格地面朝向描边码 0=N/1=S/2=W/3=E（程序侧结构件）
-	# ── 高墙感 D 投影档（研究件四变体定 D=C+地面投影，ITB 同款高度线索）──
-	# 南立面 = 墙格南缘内侧「口沿高光线 + 双段暗带」（邻地面格才画，墙群内聚）；地面投影 = 北邻墙格
-	# 在本已开格北缘投渐隐暗带。参数按研究件 64px 拼版实测比例换算（立面双段 0.16/0.25 格边、投影带
-	# 0.22 格边；坐标推导留档 commit）。素材缺位程序化回退同样服役（结构归程序——art-bible §8.5）。
-	var facade_south := false:          # 南立面开关（BoardView paint 按「南邻已开格」写入）
-		set(v):
-			facade_south = v
-			_owner.queue_redraw()
-	var proj_band := 0.0:               # 地面投影带宽（像素，0 = 不画——BoardView 按北邻墙判定写入）
-		set(v):
-			proj_band = v
-			_owner.queue_redraw()
-	var badge_glyph := "":             # 奖励徽章文字（右下角金——封印之下、变异纹之上、不进数字区）
-		set(v):
-			badge_glyph = v
-			if _owner._glow_layer != null and is_instance_valid(_owner._glow_layer):
-				_owner._glow_layer.set_badge_mask(v != "")
-			_owner.queue_redraw()
-	var dot_visible := false:          # BFS 路径预览点迹（中心 6×6 小人蓝）
-		set(v):
-			dot_visible = v
-			_owner.queue_redraw()
-	var hl_visible := false:           # 焦点高亮（悬停态边框覆盖层）
-		set(v):
-			hl_visible = v
-			_owner.queue_redraw()
-	var hl_color := UiKit.GOLD:        # 高亮色（金目标/封印朱/禁入灰禁红）
-		set(v):
-			hl_color = v
-			_owner.queue_redraw()
-	var font: Font = null              # 字体槽位（null = ThemeDB.fallback_font——BoardView.set_world_font 注入）
-	var bevel := 0.0:                  # 顶面倒角强度（0=关；档位 0/0.35/0.6/1.0）
-		set(v):
-			bevel = v
-			_owner.queue_redraw()
-	# ── 素材槽位（现全 null = 程序化占位服役；art-bible §8.2 格面 32×32 暂定档）──
-	var tex_base: Texture2D = null     # ① 砖面底
-	var tex_mutation: Texture2D = null # ② 变异纹带
-	var tex_glyph: Texture2D = null    # ③ 数字
-	var tex_badge: Texture2D = null    # ③' 徽章
-	var tex_seal: Texture2D = null:    # ④ 封印（槽位可运行时换装〔封印〕——同族 facade/treasure_mark
-		set(v):                        #  均 setter 触发重绘（普通 var 赋值不重绘=封印插上不显示））
-			if tex_seal != v:
-				tex_seal = v
-				_owner.queue_redraw()
-	var tex_facade: Texture2D = null   # ⑥ E 格墙面材质（v3.5——南邻墙顶 center 瓦片同源，BoardView 注入）
-	var facade_strip := false:         # E 格开关（BoardView paint 按「已开格且南邻未开墙」写入——瓦片态专用）
-		set(v):
-			facade_strip = v
-			_owner.queue_redraw()
-
-	# 变异角标（程序化，tex_mutation 纹带槽暂留）：
-	# "flat_damage" = 未开格伤害型变异，左下角危险红三角（开格有代价的策略纹理标记）
-	# 叠加层标记（秘宝整图叠加层的格面呈现；派生信息层零回写）：
-	# "mine_reveal" = 真视格（危险红内缩框——「这格是雷」的确定决策标记，封印照常计费）；
-	# "reward_preview" 格不复用本字段——预读徽章走 badge_glyph 注入（board_view refresh 注入 REWARD_BADGE 字形）
-	var treasure_mark := "":
-		set(v):
-			if treasure_mark != v:
-				treasure_mark = v
-				_owner.queue_redraw()
-	var mutation_mark := "":
-		set(v):
-			if mutation_mark != v:
-				mutation_mark = v
-				_owner.queue_redraw()
-
-	# ── 未开格类型微光（英雄 8 向相邻未开格的组粒度类型提示）
-	# 作用集 = 可挖域 ∩ 身份可查格，由 BoardView 侧派生下发；本件只承接绘制与子件生命周期。
-	# 静态：不呼吸、不入动效预算；相位门控（结算/道具窗口态隐藏）在 BoardView 侧。
-	var glow_group := 0:
-		set(v):
-			if glow_group != v:
-				glow_group = v
-				_owner._sync_glow_layer()
-
-	var removed_dim := false:             # 中立移除退色层（BoardView paint 按排雷玩法 is_removed 写入）
-		set(v):
-			removed_dim = v
-			_owner.queue_redraw()
-
-
-var st := _CellPaintState.new()
+var edge := 46.0:                  # 格边长（BoardView.set_cell_area 单点驱动）
+	set(v):
+		edge = v
+		if _glow_layer != null and is_instance_valid(_glow_layer):
+			_glow_layer.setup(edge, glow_group)
+		queue_redraw()
+var cell := Vector2i.ZERO          # 板坐标（诊断观测面）
+# ── 未开格类型微光（英雄 8 向相邻未开格的组粒度类型提示）
+# 作用集 = 可挖域 ∩ 身份可查格，由 BoardView 侧派生下发；本件只承接绘制与子件生命周期。
+# 静态：不呼吸、不入动效预算；相位门控（结算/道具窗口态隐藏）在 BoardView 侧。
+var glow_group := 0:
+	set(v):
+		if glow_group != v:
+			glow_group = v
+			_sync_glow_layer()
 var glyph := "":                   # 文字位——数字/雷/封印/人/？（现行视觉封印与数字互斥，同位承载；探针直读冻结）
 	set(v):
 		glyph = v
@@ -141,268 +44,51 @@ var fog_state := 0:                 # 探针直读冻结
 			queue_redraw()
 
 var _glow_layer: Node2D = null
+var base = null                     # 格面基座层绘制域件（_init 自建）
+var face = null                     # 格面标识与叠加层绘制域件（_init 自建）
 
 
 func _init() -> void:
-	st._owner = self
+	base = _BASE_LAYER.new(self)
+	face = _MARK_OVERLAY.new(self)
 
 
 func _draw() -> void:
-	var rect := Rect2(Vector2.ZERO, Vector2(st.edge, st.edge))
-	_draw_base_layer(rect)
-	_draw_mutation_marks()
-	_draw_glyph_layer(rect)
-	_draw_overlay_layers(rect)
-
-
-## ① 砖面底层域（占位 = StyleBoxFlat：格底色 + 暗化描边 + 3px 圆角；瓦片态描边覆盖层；
-## 呼吸微光/主角蓝框由 BoardView 改 bg_sb 后触发重绘。素材缺位回退走 elif 程序化原样，零观感变化）
-func _draw_base_layer(rect: Rect2) -> void:
-	if st.tex_base != null:
-		draw_texture_rect(st.tex_base, rect, false)
-		# 轮廓加强（轮廓线不明显）：墙格地面朝向边补 2px 深墨线（§8.5 结构归程序——
-		# 素材 1px 墨线在 45/36px 非整数缩放下视觉衰减，程序线保底；墙-墙内界不画，保墙群内聚；
-		# 坐标推导：各边内贴 2px 矩形，相邻边矩形全长相交=周界闭合）
-		if not st.outline_sides.is_empty():
-			_draw_outline_sides()
-		_draw_south_facade()
-		_draw_north_projection()
-		_draw_e_facade()
-		# 瓦片态描边覆盖层：tex_base 在位时 BoardView 传入的 bg_sb
-		# 已降级为「透明底 + 描边」载体——呼吸微光/主角蓝框画在瓦片之上（art-bible §1.2 叠层序
-		# 不变：底 < 纹带 < 数字 < 封印 < 焦点高亮）；素材缺位回退走 elif 程序化原样，零观感变化
-		if st.bg_sb != null:
-			draw_style_box(st.bg_sb, rect)
-	_draw_contact_or_fallback(rect)
-
-
-## 接触带微光或平色回退域（英雄格周界空间侧——正交邻墙=整条边；斜向=共享角点+两侧各半条边；光不进墙格）：
-## 带宽 4px 贴格边内侧（坐标推导：N=[0,0,edge,4] S=[0,edge-4,edge,4] W=[0,0,4,edge] E=[edge-4,0,4,edge]；
-## 半条边=沿邻边自角点起 edge/2；角点圆 r=6 贴角点圆心，近白芯 r=2.5 提亮）
-func _draw_contact_or_fallback(rect: Rect2) -> void:
-	if st.contact_col.a > 0.0:
-		_draw_north_projection()   # 平色回退+微光并发的英雄格补画（瓦片路径已画——同像素重复无观感差）
-		_draw_e_facade()           # E 格墙面补画（同上——英雄格兼 E 格时瓦片路径已画，重复无害）
-		_draw_contact_bands()
-	elif st.bg_sb != null:
-		draw_style_box(st.bg_sb, rect)
-		_draw_south_facade()      # 平色回退路径——D 投影档两件同样服役（结构归程序）
-		_draw_north_projection()
-		_draw_bevel()
-
-
-## ②③④ 中层域：变异纹带与标记／数字色牌与字形／徽章／封印
-func _draw_glyph_layer(rect: Rect2) -> void:
-	# ② 变异纹带（无程序化纹带——槽位先行，贴图落位即用）
-	if st.tex_mutation != null:
-		draw_texture_rect(st.tex_mutation, rect, false)
-	# ③ 数字/徽章（数字 ≥ 格高 50% 墨族对格底 ≥4.5:1；徽章右下角金，遮蔽态 = "?"）
-	if glyph != "":
-		if plate:
-			_draw_digit_plate()
-		if st.tex_glyph != null:
-			draw_texture_rect(st.tex_glyph, rect, false)
-		else:
-			_draw_glyph(glyph, glyph_color, maxi(18, int(ceil(st.edge * 0.5))))   # 字号下限 18（§7.4 冻结公式）
-	if st.badge_glyph != "":
-		if st.tex_badge != null:
-			draw_texture_rect(st.tex_badge, rect, false)
-		else:
-			_draw_badge(st.badge_glyph)
-	# ④ 封印（现行视觉封印文字在 ③ 文字位承载——独立槽位留给封印图）
-	if st.tex_seal != null:
-		draw_texture_rect(st.tex_seal, rect, false)
-
-
-## 数字色牌后备域（圣经 v3.5 冻结④：数字亮墨直画已开格底须垫牌；
-## 牌=后备件——雷/「?」维持牌载保读性（牌上深墨族 12:1）；
-## 牌尺寸 0.60/0.62 格边居中；封印=未开格不垫牌）
-func _draw_digit_plate() -> void:
-	var pw := st.edge * 0.60
-	var ph := st.edge * 0.62
-	var pr := Rect2((st.edge - pw) * 0.5, (st.edge - ph) * 0.5, pw, ph)
-	draw_rect(pr, UiKit.DIGIT_PLATE, true)
-	draw_rect(pr, UiKit.DIGIT_PLATE_EDGE, false, 1.0)
-
-
-## ⑤⑥⑦ 顶层域：路径点迹 + 焦点高亮 + 视野迷雾 + 中立移除退色
-func _draw_overlay_layers(rect: Rect2) -> void:
-	# ⑤ 路径点迹 + 焦点高亮（悬停态覆盖层，不参与命中）
-	if st.dot_visible:
-		var ds := 6.0
-		draw_rect(Rect2(Vector2((st.edge - ds) * 0.5, (st.edge - ds) * 0.5), Vector2(ds, ds)), UiKit.HERO_BLUE, true)
-	if st.hl_visible:
-		# 悬停高亮减淡（金框太明显——绘制时 55% alpha,hl_color 属性与探针断言面不动）
-		draw_rect(Rect2(1, 1, st.edge - 2.0, st.edge - 2.0), Color(st.hl_color, 0.55), false, 2.0)   # 2px 内描边
-	_draw_fog_layer()
-	# ⑦ 中立移除退色层（退色降档：暗幕压顶全层覆盖，暗淡记忆态同族呈现语义；
-	# 顶层于迷雾之上——移除格不再参与迷雾语义。本实现移除集=未揭示危险格（无数字无封印印））
-	if st.removed_dim:
-		draw_rect(Rect2(Vector2.ZERO, Vector2(st.edge, st.edge)), Color(0.12, 0.10, 0.09, 0.62), true)
+	var rect := Rect2(Vector2.ZERO, Vector2(edge, edge))
+	base.draw_base(self, rect)                                # 基座层整树（描边/立面/投影/接触带/倒角与其补画序）
+	face.draw_marks(self, rect)                               # 变异标记
+	face.draw_glyph_layer(self, rect, glyph, glyph_color, plate)   # 字形/色牌/徽章/封印
+	face.draw_overlay_under(self, rect)                       # 点迹＋高亮（雾层由宿主夹在其后）
+	_draw_fog_layer(rect)                                     # 宿主迷雾域（原位——雾夹在 hl 与 removed 之间）
+	face.draw_removed_dim(self, rect)                         # 退色层
 
 
 ## ⑥ 视野迷雾层（最顶遮罩，§6.5 落文）：
 ## 全黑=不透明纯黑盖全部叠层（含封印印/徽章/高亮——封印印记随格隐没，§6.5 显式推论）；
 ## 记忆态=记忆板素色压平（纹理免疫——色牌/封印印/徽章随板隐没）+数字记忆墨重画（数字可读硬指标 ≥4.5:1）
-func _draw_fog_layer() -> void:
+func _draw_fog_layer(rect: Rect2) -> void:
 	if fog_state == 1:
-		draw_rect(Rect2(Vector2.ZERO, Vector2(st.edge, st.edge)), Color(0, 0, 0, 1.0), true)
+		draw_rect(rect, Color(0, 0, 0, 1.0), true)
 	elif fog_state == 2:
-		_draw_fog_memory()
-
-
-## 墙格轮廓域：地面朝向边补 2px 深墨线（各边内贴 2px 矩形，相邻边矩形全长相交=周界闭合）
-func _draw_outline_sides() -> void:
-	var ow := 2.0
-	var oc := UiKit.FOG_OUTLINE
-	for b in st.outline_sides:
-		var or_ := Rect2()
-		match int(b):
-			0: or_ = Rect2(0, 0, st.edge, ow)
-			1: or_ = Rect2(0, st.edge - ow, st.edge, ow)
-			2: or_ = Rect2(0, 0, ow, st.edge)
-			3: or_ = Rect2(st.edge - ow, 0, ow, st.edge)
-		draw_rect(or_, oc, true)
-
-
-## 接触带微光域：正交整条边 + 斜向共享角点与两侧半条边
-func _draw_contact_bands() -> void:
-	var band := 4.0
-	var half := st.edge * 0.5
-	for b in st.contact_bands:
-		var r := Rect2()
-		match int(b):
-			0: r = Rect2(0, 0, st.edge, band)
-			1: r = Rect2(0, st.edge - band, st.edge, band)
-			2: r = Rect2(0, 0, band, st.edge)
-			3: r = Rect2(st.edge - band, 0, band, st.edge)
-		draw_rect(r, st.contact_col, true)
-	for cc in st.contact_corners:
-		_draw_contact_corner(int(cc), band, half)
-
-
-## 斜向角点域：角点圆 r=6 贴角点圆心 + 近白芯 r=2.5 提亮 + 半条边（角点沿两条邻边各延伸 edge/2——
-## 坐标推导：横带沿 N/S 自角点向板心侧 half；NW/SE 半带 x=y=角点坐标,NE/SE 半带自 edge-half 收进——
-## 正交整边时重叠同色无害）
-func _draw_contact_corner(cc: int, band: float, half: float) -> void:
-	var pt := Vector2.ZERO
-	match cc:
-		0: pt = Vector2(0, 0)
-		1: pt = Vector2(st.edge, 0)
-		2: pt = Vector2(0, st.edge)
-		3: pt = Vector2(st.edge, st.edge)
-	draw_circle(pt, 6.0, st.contact_col)
-	draw_circle(pt, 2.5, Color(1, 1, 1, minf(1.0, st.contact_col.a * 0.95)))
-	if cc == 0 or cc == 1:
-		# N 侧横带：NW 自 x=0、NE 自 x=edge-half
-		draw_rect(Rect2(pt.x if cc == 0 else pt.x - half, 0.0, half, band), st.contact_col, true)
-	if cc == 2 or cc == 3:
-		# S 侧横带：SW 自 x=0、SE 自 x=edge-half
-		draw_rect(Rect2(pt.x if cc == 2 else pt.x - half, st.edge - band, half, band), st.contact_col, true)
-	if cc == 0 or cc == 2:
-		# W 侧竖带：NW 自 y=0、SW 自 y=edge-half
-		draw_rect(Rect2(0.0, pt.y if cc == 0 else pt.y - half, band, half), st.contact_col, true)
-	if cc == 1 or cc == 3:
-		# E 侧竖带：NE 自 y=0、SE 自 y=edge-half
-		draw_rect(Rect2(st.edge - band, pt.y if cc == 1 else pt.y - half, band, half), st.contact_col, true)
-
-
-## 顶面倒角域（光源左上——上/左内沿受光 2px、下/右内沿背光 2px；内缩 2px 让
-## 呼吸微光/主角蓝边框保持最外沿可见；强度随档位）
-func _draw_bevel() -> void:
-	if st.bevel <= 0.0:
-		return
-	var base: Color = st.bg_sb.bg_color
-	var lit: Color = base.lightened(0.22 * st.bevel)
-	var dark: Color = base.darkened(0.22 * st.bevel)
-	var t := 2.0
-	draw_rect(Rect2(t, t, st.edge - t * 2.0, t), lit, true)
-	draw_rect(Rect2(t, t, t, st.edge - t * 2.0), lit, true)
-	draw_rect(Rect2(t, st.edge - t * 2.0, st.edge - t * 2.0, t), dark, true)
-	draw_rect(Rect2(st.edge - t * 2.0, t, t, st.edge - t * 2.0), dark, true)
-
-
-## 变异标记域：真视格=危险红内缩框／未开格伤害型变异=左下角危险红三角
-func _draw_mutation_marks() -> void:
-	if st.treasure_mark == "mine_reveal":
-		var inset := st.edge * 0.14
-		draw_rect(Rect2(inset, inset, st.edge - inset * 2.0, st.edge - inset * 2.0),
-			Color(UiKit.RED_MINE, 0.9), false, 2.0)
-	if st.mutation_mark == "flat_damage":
-		var mw := st.edge * 0.28
-		var mpts := PackedVector2Array([Vector2(0, st.edge - mw), Vector2(0, st.edge), Vector2(mw, st.edge)])
-		draw_colored_polygon(mpts, Color(UiKit.RED_MINE, 0.85))
+		_draw_fog_memory(rect)
 
 
 ## 记忆态换装域（demo 口径「地板纹理 + 灰罩 α.66」：
 ## 地板纹理原样直画 + FOG_MEMORY_PLATE α.66 灰罩压顶；素材零改动、格边长零改动。
 ## 记忆墨 FOG_MEMORY_INK 对合成底归一后（真实渲染面）三关 5.71–5.93:1 ≥4.5:1（§7.2 硬指标；
 ## 测点行值与素材随动，见 ui_contrast_probe 迷雾段））
-func _draw_fog_memory() -> void:
-	if st.tex_base != null:
-		draw_texture_rect(st.tex_base, Rect2(Vector2.ZERO, Vector2(st.edge, st.edge)), false)
-	draw_rect(Rect2(Vector2.ZERO, Vector2(st.edge, st.edge)), Color(UiKit.FOG_MEMORY_PLATE, 0.66), true)
+func _draw_fog_memory(rect: Rect2) -> void:
+	if base.tex_base != null:
+		draw_texture_rect(base.tex_base, rect, false)
+	draw_rect(rect, Color(UiKit.FOG_MEMORY_PLATE, 0.66), true)
 	if glyph != "":
-		_draw_glyph(glyph, UiKit.FOG_MEMORY_INK, maxi(18, int(ceil(st.edge * 0.5))))   # 字号下限 18（§7.4 冻结公式同源）
-
-
-# 南立面（D 档件一——墙格南缘内侧，自底边向上：双段暗带在下、口沿高光线贴其上沿）：
-# 坐标推导（自格底边起算）：远段=[edge−far, edge]，近段=[edge−far−near, edge−far]，
-# 高光线=[edge−far−near−hl, edge−far−near]——与研究件「墙顶面→高光→暗段→更暗段→格界」下行序一致
-func _draw_south_facade() -> void:
-	if not st.facade_south:
-		return
-	var far_h := st.edge * FACADE_FAR_FRAC
-	var near_h := st.edge * FACADE_NEAR_FRAC
-	var y_far := st.edge - far_h
-	var y_near := y_far - near_h
-	var y_hl := y_near - FACADE_HIGHLIGHT_PX
-	draw_rect(Rect2(0.0, y_hl, st.edge, FACADE_HIGHLIGHT_PX), UiKit.STAND_STONE_RIM, true)   # 口沿高光（UiKit.STAND_STONE_RIM 并档——同值单点）
-	draw_rect(Rect2(0.0, y_near, st.edge, near_h), FACADE_NEAR_COL, true)
-	draw_rect(Rect2(0.0, y_far, st.edge, far_h), FACADE_FAR_COL, true)
-
-
-# 地面投影（D 档件二——北邻墙格在本已开格北缘投渐隐暗带，自北缘向南三段衰减）：
-# 坐标推导：三等分 proj_band，α 0.28/0.16/0.06（研究件实测贴墙 α≈0.28、带末渐融入地面）
-func _draw_north_projection() -> void:
-	if st.proj_band <= 0.0:
-		return
-	var seg := st.proj_band / 3.0
-	draw_rect(Rect2(0.0, 0.0, st.edge, seg), PROJECTION_NEAR_COL, true)
-	draw_rect(Rect2(0.0, seg, st.edge, seg), PROJECTION_MID_COL, true)
-	draw_rect(Rect2(0.0, seg * 2.0, st.edge, seg), PROJECTION_EDGE_COL, true)
-
-
-# E 格高墙面（圣经 v3.5 冻结①——方向稿 draw_facade 移植）：本格已开且南邻为墙 →
-# 南部 30% 承接墙面。材质 = 墙顶 center 瓦片顶部 30% 区带**原亮度**直贴（零暗档零阴影）；
-# 墙脚阴线只画地面/墙面交界（strip 顶缘 1px）；墙面底缘（格界处）不画任何线——直接接南侧墙顶
-# （白边导致两截）。仅瓦片态服役（tex_facade 缺位 = 平色回退原语义不动）。
-func _draw_e_facade() -> void:
-	if not st.facade_strip or st.tex_facade == null:
-		return
-	var strip_h := st.edge * E_FACADE_FRAC
-	var y0 := st.edge - strip_h
-	var ts := st.tex_facade.get_size()
-	draw_texture_rect_region(st.tex_facade, Rect2(0.0, y0, st.edge, strip_h),
-		Rect2(0.0, 0.0, ts.x, ts.y * E_FACADE_FRAC))
-	draw_rect(Rect2(0.0, y0, st.edge, 1.0), UiKit.E_FACADE_FOOT_COL, true)
-
-
-# 文字位绘制：水平居中 + 垂直居中（基线 = (格高 − 字高)/2 + 上伸部）
-func _draw_glyph(g: String, col: Color, fs: int) -> void:
-	var f := st.font if st.font != null else ThemeDB.fallback_font
-	if f == null:
-		return
-	var asc := f.get_ascent(fs)
-	var desc := f.get_descent(fs)
-	draw_string(f, Vector2(0.0, (st.edge - (asc + desc)) * 0.5 + asc), g,
-		HORIZONTAL_ALIGNMENT_CENTER, st.edge, fs, col)
+		face.draw_centered_text(self, rect, glyph, UiKit.FOG_MEMORY_INK, maxi(18, int(ceil(edge * 0.5))))   # 字号下限 18（§7.4 冻结公式同源）
 
 
 # 微光子件生命周期：有组才建、组变即换、无组即撤——作用集 ≤8 格常驻，
 # 其余格零节点零绘制成本。与父件 _draw() 分离的三条理由见本件头注（命令序列／重绘预算／材质挂点）。
 func _sync_glow_layer() -> void:
-	if st.glow_group == 0:
+	if glow_group == 0:
 		if _glow_layer != null and is_instance_valid(_glow_layer):
 			_glow_layer.queue_free()
 		_glow_layer = null
@@ -410,15 +96,5 @@ func _sync_glow_layer() -> void:
 	if _glow_layer == null or not is_instance_valid(_glow_layer):
 		_glow_layer = _GLOW_LAYER.new()
 		add_child(_glow_layer)
-	_glow_layer.setup(st.edge, st.glow_group)
-	_glow_layer.set_badge_mask(st.badge_glyph != "")
-
-
-# 徽章绘制：右下角金（文字贴角内缩 2–3px）
-func _draw_badge(g: String) -> void:
-	var f := st.font if st.font != null else ThemeDB.fallback_font
-	if f == null:
-		return
-	var fs := maxi(10, int(st.edge * 0.28))
-	var sz := f.get_string_size(g, HORIZONTAL_ALIGNMENT_LEFT, -1, fs)
-	draw_string(f, Vector2(st.edge - sz.x - 2.0, st.edge - 3.0), g, HORIZONTAL_ALIGNMENT_LEFT, -1, fs, UiKit.GOLD)
+	_glow_layer.setup(edge, glow_group)
+	_glow_layer.set_badge_mask(face.badge_glyph != "")

game/presentation/views/board_hover.gd

@@ -0,0 +1,130 @@
+## VERTICAL SLICE - NOT FOR PRODUCTION
+## 悬停预承诺呈现域件（BoardView 拆件——单一变化原因=悬停反馈语义）：
+## 三语义光标、目标格边框、BFS 路径预览、chord 双击首遇锚的唯一承载（自 board_view 收编 11 函数族）。
+## 无 class_name（类名缓存面纪律）——经宿主 board_view preload 引用；构造＝引用束注入
+## （cells/minesweeper/diggable 共享引用＋格命中换算/壳级光标写入/hover_forbidden 与 chord 发射注入 Callable——
+## 输入经宿主三入站口委托，禁反向持宿主引用）；_r0 出生展开区成员留宿主。
+extends RefCounted
+
+const COL_HL_TARGET := UiKit.GOLD             # 悬停目标格边框（金）
+const COL_SEAL := UiKit.SEAL_BLACK            # 封印黑（与宿主 :658 双侧服役——各自 alias UiKit 单源）
+const CURSOR_DIG := Input.CURSOR_CROSS        # 挖——镐形自绘纹理载体
+const CURSOR_MOVE_SEM := Input.CURSOR_ARROW   # 移动——箭头（命名避开 Control.CURSOR_MOVE 原生成员遮蔽）
+const CHORD_WINDOW_MS := 350
+
+var _cells := {}            # 共享引用（宿主容器同对象——rebuild 只 clear 不重绑）
+var _minesweeper = null     # 排雷玩法 只读查询引用（宿主 rebuild 重绑时同拍回写本成员）
+var _diggable := {}         # 共享引用（可挖域——呼吸微光作用集同源）
+var _cb_cell_at: Callable   # 格命中换算（宿主 _cell_at——整图公式单点留宿主）
+var _cb_cursor: Callable    # 壳级光标写入（宿主 mouse_default_cursor_shape 单点）
+var _cb_forbidden: Callable # hover_forbidden 信号发射（首遇 toast 去重归组合根）
+var _cb_chord: Callable     # chord_attempted 信号发射（chord 肌肉记忆提示锚）
+var _hover := Vector2i(-9, -9)
+var _last_click := {"cell": Vector2i(-9, -9), "ms": -100000}
+
+
+func _init(bundle: Dictionary) -> void:
+	_cells = bundle["cells"]
+	_minesweeper = bundle["minesweeper"]
+	_diggable = bundle["diggable"]
+	_cb_cell_at = bundle["cell_at"]
+	_cb_cursor = bundle["cursor"]
+	_cb_forbidden = bundle["forbidden"]
+	_cb_chord = bundle["chord"]
+
+
+func _hover_at(pos: Vector2) -> void:
+	var c: Vector2i = _cb_cell_at.call(pos)
+	if c.x < 0:
+		if _hover.x >= 0:
+			_on_cell_unhover(_hover)
+	elif c != _hover:
+		if _hover.x >= 0:
+			_on_cell_unhover(_hover)
+		_on_cell_hover(c)
+
+
+func _on_shell_mouse_exited() -> void:
+	if _hover.x >= 0:
+		_on_cell_unhover(_hover)
+
+
+# chord 肌肉记忆首遇锚：同格双左击快开尝试（350ms 窗）——每 run 一次提示由组合根去重
+func _detect_chord(c: Vector2i) -> void:
+	var now := Time.get_ticks_msec()
+	if _last_click.cell == c and now - int(_last_click.ms) <= CHORD_WINDOW_MS:
+		_cb_chord.call(c)
+		_last_click.ms = -100000
+		return
+	_last_click = {"cell": c, "ms": now}
+
+
+func _on_cell_hover(c: Vector2i) -> void:
+	_hover = c
+	_apply_hover_visuals(c)
+
+
+func _on_cell_unhover(c: Vector2i) -> void:
+	if _hover == c:
+		_hover = Vector2i(-9, -9)
+	_clear_hover_visuals(c)
+
+
+func _refresh_hover_after_paint() -> void:
+	# 状态随 refresh 变化后光标/边框语义需重算（悬停格四格态可能已变）
+	if _hover.x >= 0 and _cells.has(_hover):
+		_apply_hover_visuals(_hover)
+
+
+func _apply_hover_visuals(c: Vector2i) -> void:
+	if _minesweeper == null or not _cells.has(c):
+		return
+	_clear_hover_visuals(c)
+	var u: Node2D = _cells[c]
+	var revealed: bool = _minesweeper.is_revealed(c)
+	var seal: bool = _minesweeper.has_seal(c)
+	var adjacent: bool = _diggable.has(c)
+	if revealed:
+		u.face.hl_visible = true
+		u.face.hl_color = COL_HL_TARGET   # 移动目标格边框（金）
+		_set_cursor_shape(c, CURSOR_MOVE_SEM)
+		_show_path_preview(c)
+	elif adjacent:
+		u.face.hl_visible = true
+		u.face.hl_color = COL_HL_TARGET   # 挖掘目标格边框（相邻封印格同此——左键直接挖）
+		_set_cursor_shape(c, CURSOR_DIG)
+	elif seal:
+		u.face.hl_visible = true
+		u.face.hl_color = COL_SEAL        # 已承诺封印标记（封印黑；无交互可供）
+		_set_cursor_shape(c, Input.CURSOR_FORBIDDEN)
+	else:
+		u.face.hl_visible = true
+		u.face.hl_color = UiKit.RED_FORBID   # 不可及域灰禁框（禁止光标+首遇 toast 双通道）
+		_set_cursor_shape(c, Input.CURSOR_FORBIDDEN)
+		_cb_forbidden.call(c)
+
+
+func _clear_hover_visuals(c: Vector2i) -> void:
+	if not _cells.has(c):
+		return
+	_cells[c].face.hl_visible = false
+	_hide_path_preview()
+
+
+func _set_cursor_shape(c: Vector2i, shape: int) -> void:
+	_cb_cursor.call(shape)   # 壳级光标（悬停格语义决定——单格悬停恒一）
+
+
+func _show_path_preview(c: Vector2i) -> void:
+	# 合法性指示：悬停已开格 → BFS 路径蓝细线点迹（compute_move_path 只读面）
+	if _minesweeper == null:
+		return
+	var path: Array[Variant] = _minesweeper.compute_move_path(c)
+	for pc in path:
+		if _cells.has(pc):
+			_cells[pc].face.dot_visible = true
+
+
+func _hide_path_preview() -> void:
+	for c in _cells:
+		_cells[c].face.dot_visible = false

game/presentation/views/board_hover.gd.uid

@@ -0,0 +1 @@
+uid://dojreaughx7tf

game/presentation/views/board_view.gd

@@ -12,6 +12,7 @@ const _CELL_UNIT := preload("res://presentation/views/board_cell_unit.gd")
 const _BOARD_WORLD := preload("res://presentation/views/board_world.gd")
 const _TILE_PALETTE := preload("res://presentation/views/tile_palette.gd")
 const _HERO_SPRITE := preload("res://presentation/views/hero_sprite.gd")
+const _BOARD_HOVER := preload("res://presentation/views/board_hover.gd")
 
 const COL_BRICK := UiKit.BRICK                # 未开——掩尘完整地砖（色板原语 #C9AF83）
 const COL_FLOOR := UiKit.FLOOR                # 已开——裸土 #B39A78（碎裂裸露地面）
@@ -20,17 +21,13 @@ const COL_HERO := UiKit.HERO_BLUE             # 小人边框——小人蓝
 const COL_SEAL := UiKit.SEAL_BLACK           # 封印黑 #000000
 const COL_GOLD := UiKit.GOLD                  # 奖励金 #F0A828
 const COL_CONTACT := UiKit.CONTACT_GLOW       # 接触带微光基色（蓝族浅一档·近白蓝——§3.2 v2.8）
-const COL_HL_TARGET := UiKit.GOLD             # 悬停目标格边框（金）
 const REWARD_BADGE := {                       # 已开格格面资源身份 icon（cell_type 九型键）
 	"attack": "攻", "defense": "守", "heal": "医", "blast": "爆", "weaken": "弱", "pierce": "穿", "magic": "魔",
 	"action": "行",   # 行 = 行动点型（ap_up/ap_drain 两行）
 	"gp": "金",       # 金 = GP 型（gp_gain/gp_loss 两行；金色系 ~40° 相位，禁入带紫赤 300–345° 外，取色 UiKit.GOLD 徽标色单点）
 }
 const BADGE_PLACEHOLDER := "?"                # 未知图标键占位纹样（HUD框架：禁静默空图标）
-const CURSOR_DIG := Input.CURSOR_CROSS            # 挖——镐形自绘纹理载体
 const CURSOR_SEAL := Input.CURSOR_POINTING_HAND   # 封印——封印形自绘纹理载体
-const CURSOR_MOVE_SEM := Input.CURSOR_ARROW       # 移动——箭头（命名避开 Control.CURSOR_MOVE 原生成员遮蔽）
-const CHORD_WINDOW_MS := 350
 const SEP := 2                                # 格间距（格尺寸公式与命中换算共用）
 
 # 棋盘立体参数
@@ -67,8 +64,6 @@ var _contact_unit: Node2D = null   # 接触带承载单元（=英雄格 CellUnit
 var _install_tw: Tween            # 入场淡入 tween（rebuild 重入先杀）
 var _ripple_tws: Array[Tween] = []       # R0 涟漪逐格 tween（rebuild 重入全杀）
 var _dig_glow := false      # 挖掘期才允许唯一在动元素（art-bible §2.1）
-var _hover := Vector2i(-9, -9)
-var _last_click := {"cell": Vector2i(-9, -9), "ms": -100000}
 var _r0 := {}               # 出生展开区 R₀（地图战斗资源 mapping 资格域 = S∖R₀——徽章查询跳过，防 E19 诊断噪音）
 var _desat_mat: ShaderMaterial
 var _desat_tween: Tween
@@ -77,6 +72,7 @@ var _cell := 46.0           # 当前格边长（set_cell_area 按容器尺寸重
 # ── 拆出件（状态单点在件内）──
 var _palette = _TILE_PALETTE.new()       # 瓦片件：装载缓存＋查表＋明度/墨族静态算法
 var _hero_sprite = _HERO_SPRITE.new()    # 英雄精灵件：_init 挂为本件子级（tween 需在树上）
+var _hover_comp: _BOARD_HOVER            # 悬停预承诺呈现域件：三语义光标/目标格边框/路径预览/chord 首遇锚（_init 建为子件——HeroSprite 挂载先例）
 
 # ── 件成员同名转发（探针直读面零改动：读 _palette.seal_tex、读写 _hero_sprite.tex_idle；其余为随迁状态单点再导出）──
 # ---- 视野迷雾（纯呈现层；现行事实源=HUD框架「视野迷雾」节 v0.13，渲染规格=art-bible §6.5 v3.5）----
@@ -120,6 +116,25 @@ func _init() -> void:
 	_hero_sprite.tex_idle = UiKit.load_tex(UiKit.TEX_HERO_IDLE)
 	_hero_sprite.tex_walk = UiKit.load_tex(UiKit.TEX_HERO_WALK)
 	_palette.load_board_tiles()   # 高墙/地面瓦片整批守卫装载（缺位静默回退——英雄同款纪律，禁刷屏）
+	_hover_comp = _BOARD_HOVER.new({
+		"cells": _cells, "minesweeper": _minesweeper, "diggable": _diggable,
+		"cell_at": _cell_at, "cursor": _set_shell_cursor,
+		"forbidden": _emit_hover_forbidden, "chord": _emit_chord_attempted,
+	})
+
+
+# ---- 悬停域注入面（件回调宿主的壳级单点——Callable 目标）----
+
+func _set_shell_cursor(shape: int) -> void:
+	mouse_default_cursor_shape = shape   # 壳级光标（悬停格语义决定——单格悬停恒一）
+
+
+func _emit_hover_forbidden(c: Vector2i) -> void:
+	hover_forbidden.emit(c)   ## 非相邻未开格悬停（首遇 toast 归组合根去重）
+
+
+func _emit_chord_attempted(c: Vector2i) -> void:
+	chord_attempted.emit(c)   ## 双击快开尝试（chord 肌肉记忆提示锚）
 
 
 func board() -> BoardData:
@@ -128,7 +143,7 @@ func board() -> BoardData:
 
 func _ready() -> void:
 	_apply_custom_cursors()
-	mouse_exited.connect(_on_shell_mouse_exited)
+	mouse_exited.connect(_hover_comp._on_shell_mouse_exited)
 
 
 # 结算期/道具窗口态：D 区去饱和 + 金橙偏移锁输入（明度不变——art-bible §2）；
@@ -182,7 +197,7 @@ func set_treasure_overlays(reveal_cells: Array, preview_cells: Array) -> void:
 func set_world_font(f: Font) -> void:
 	_world.board_font = f
 	for c in _cells:
-		_cells[c].st.font = f
+		_cells[c].face.font = f
 		_cells[c].queue_redraw()
 
 
@@ -201,7 +216,7 @@ func set_cell_area(avail: Vector2) -> void:
 	var stride := _cell + float(SEP)
 	for c in _cells:
 		var u: Node2D = _cells[c]
-		u.st.edge = _cell
+		u.edge = _cell
 		u.position = Vector2(c) * stride
 	if _world.hero != null and _hero_sprite.last.x >= 0:
 		_place_hero(_hero_sprite.last, _hero_sprite.last, true)   # 格边长变更（窗口缩放）——英雄即时随格重置（杀位移 tween 防飞陈旧落点）
@@ -224,6 +239,7 @@ func _refresh_slab() -> void:
 func rebuild(board: BoardData, minesweeper: MinesweeperRules) -> void:
 	_board = board
 	_minesweeper = minesweeper
+	_hover_comp._minesweeper = _minesweeper   # 件内只读引用随宿主重绑同拍回写（每战新排雷玩法对象）
 	_palette.bind_board(_board, _minesweeper)   # 查表族棋盘态随板同步（换板后首拍 refresh 前置）
 	for child in _world.get_children():
 		child.queue_free()
@@ -234,7 +250,7 @@ func rebuild(board: BoardData, minesweeper: MinesweeperRules) -> void:
 	_contact_unit = null
 	_hero_sprite.last = Vector2i(-99, -99)
 	_r0.clear()
-	_hover = Vector2i(-9, -9)
+	_hover_comp._hover = Vector2i(-9, -9)
 	for c in _board.compute_r0():
 		_r0[c] = true
 	# 瓦片套随板图型切换（board_gen 词表 v1.1 dungeon/underdark/deep_underdark；
@@ -255,17 +271,17 @@ func rebuild(board: BoardData, minesweeper: MinesweeperRules) -> void:
 # 逐格构建器（rebuild 建格循环唯一出函面）：.new() 与属性装配逐字迁入，循环体只调构建器
 func _build_cell_unit(c: Vector2i, stride: float) -> Node2D:
 	var u: Node2D = _CELL_UNIT.new()
-	u.st.cell = c
-	u.st.edge = _cell
+	u.cell = c
+	u.edge = _cell
 	u.position = Vector2(c) * stride
-	u.st.bevel = DEPTH_BEVEL   # 新建格单元继承
+	u.base.bevel = DEPTH_BEVEL   # 新建格单元继承
 	u.use_parent_material = true          # 去饱和材质挂 BoardWorld——单元随世界材质灰化
 	if _palette.tiles_ok:
 		# NEAREST 采样（32×32 源 × 45/36px 格边非整数缩放接受档，
 		# 与英雄小人 1.5× 豁免同级（圣经 §8.2）；只在瓦片
 		# 模式启用——程序化回退路径渲染零扰动（含格面文字采样不回退不变化）
 		u.texture_filter = CanvasItem.TEXTURE_FILTER_NEAREST
-	u.st.font = _world.board_font
+	u.face.font = _world.board_font
 	_world.add_child(u)
 	return u
 
@@ -283,7 +299,7 @@ func refresh() -> void:
 	for y in _board.height:
 		for x in _board.width:
 			_paint_cell(Vector2i(x, y), hero)
-	_refresh_hover_after_paint()
+	_hover_comp._refresh_hover_after_paint()
 	_apply_contact_bands()
 	_update_hero(hero)   # 英雄精灵 diff 驱动
 
@@ -433,33 +449,18 @@ func _update_world_size() -> void:
 
 
 # 真实输入路径（Node2D 迁移批 Decision 3）：壳层 _gui_input → 整图公式换算 → 复用既有 hover/点选/chord 出口
+#（悬停族已拆 board_hover 件——本壳留三入站口委托）
 func _gui_input(ev: InputEvent) -> void:
 	if _minesweeper == null:
 		return
 	if ev is InputEventMouseMotion:
-		_hover_at(ev.position)
+		_hover_comp._hover_at(ev.position)
 	elif ev is InputEventMouseButton and ev.pressed:
 		var c := _cell_at(ev.position)
 		if c.x >= 0:
 			_on_cell_input(c, ev)
 
 
-func _hover_at(pos: Vector2) -> void:
-	var c := _cell_at(pos)
-	if c.x < 0:
-		if _hover.x >= 0:
-			_on_cell_unhover(_hover)
-	elif c != _hover:
-		if _hover.x >= 0:
-			_on_cell_unhover(_hover)
-		_on_cell_hover(c)
-
-
-func _on_shell_mouse_exited() -> void:
-	if _hover.x >= 0:
-		_on_cell_unhover(_hover)
-
-
 func _on_cell_input(c: Vector2i, ev: InputEvent) -> void:
 	if _minesweeper == null or not (ev is InputEventMouseButton and ev.pressed):
 		return
@@ -468,7 +469,7 @@ func _on_cell_input(c: Vector2i, ev: InputEvent) -> void:
 			action_requested.emit(c, "move")
 		else:
 			action_requested.emit(c, "dig")
-		_detect_chord(c)
+		_hover_comp._detect_chord(c)
 	elif ev.button_index == MOUSE_BUTTON_RIGHT:
 		if not _minesweeper.has_seal(c):
 			action_requested.emit(c, "seal_place")
@@ -476,89 +477,6 @@ func _on_cell_input(c: Vector2i, ev: InputEvent) -> void:
 		# 左键相邻封印格直接挖（规则引擎放行）。
 
 
-# chord 肌肉记忆首遇锚：同格双左击快开尝试（350ms 窗）——每 run 一次提示由组合根去重
-func _detect_chord(c: Vector2i) -> void:
-	var now := Time.get_ticks_msec()
-	if _last_click.cell == c and now - int(_last_click.ms) <= CHORD_WINDOW_MS:
-		chord_attempted.emit(c)
-		_last_click.ms = -100000
-		return
-	_last_click = {"cell": c, "ms": now}
-
-
-# ---- 悬停预承诺（pattern 4）：三语义光标 + 目标格边框 + BFS 路径预览 ----
-
-func _on_cell_hover(c: Vector2i) -> void:
-	_hover = c
-	_apply_hover_visuals(c)
-
-
-func _on_cell_unhover(c: Vector2i) -> void:
-	if _hover == c:
-		_hover = Vector2i(-9, -9)
-	_clear_hover_visuals(c)
-
-
-func _refresh_hover_after_paint() -> void:
-	# 状态随 refresh 变化后光标/边框语义需重算（悬停格四格态可能已变）
-	if _hover.x >= 0 and _cells.has(_hover):
-		_apply_hover_visuals(_hover)
-
-
-func _apply_hover_visuals(c: Vector2i) -> void:
-	if _minesweeper == null or not _cells.has(c):
-		return
-	_clear_hover_visuals(c)
-	var u: Node2D = _cells[c]
-	var revealed: bool = _minesweeper.is_revealed(c)
-	var seal: bool = _minesweeper.has_seal(c)
-	var adjacent: bool = _diggable.has(c)
-	if revealed:
-		u.st.hl_visible = true
-		u.st.hl_color = COL_HL_TARGET   # 移动目标格边框（金）
-		_set_cursor_shape(c, CURSOR_MOVE_SEM)
-		_show_path_preview(c)
-	elif adjacent:
-		u.st.hl_visible = true
-		u.st.hl_color = COL_HL_TARGET   # 挖掘目标格边框（相邻封印格同此——左键直接挖）
-		_set_cursor_shape(c, CURSOR_DIG)
-	elif seal:
-		u.st.hl_visible = true
-		u.st.hl_color = COL_SEAL        # 已承诺封印标记（封印黑；无交互可供）
-		_set_cursor_shape(c, Input.CURSOR_FORBIDDEN)
-	else:
-		u.st.hl_visible = true
-		u.st.hl_color = UiKit.RED_FORBID   # 不可及域灰禁框（禁止光标+首遇 toast 双通道）
-		_set_cursor_shape(c, Input.CURSOR_FORBIDDEN)
-		hover_forbidden.emit(c)
-
-
-func _clear_hover_visuals(c: Vector2i) -> void:
-	if not _cells.has(c):
-		return
-	_cells[c].st.hl_visible = false
-	_hide_path_preview()
-
-
-func _set_cursor_shape(c: Vector2i, shape: int) -> void:
-	mouse_default_cursor_shape = shape   # 壳级光标（悬停格语义决定——单格悬停恒一）
-
-
-func _show_path_preview(c: Vector2i) -> void:
-	# 合法性指示：悬停已开格 → BFS 路径蓝细线点迹（compute_move_path 只读面）
-	if _minesweeper == null:
-		return
-	var path: Array[Variant] = _minesweeper.compute_move_path(c)
-	for pc in path:
-		if _cells.has(pc):
-			_cells[pc].st.dot_visible = true
-
-
-func _hide_path_preview() -> void:
-	for c in _cells:
-		_cells[c].st.dot_visible = false
-
-
 # ---- 奖励徽章（已开格身份 icon——封印之下、纹带之上、不进数字区） ----
 
 func _update_badge(c: Vector2i) -> String:
@@ -613,19 +531,19 @@ func _paint_cell(c: Vector2i, hero: Vector2i) -> void:
 	var is_hero: bool = c == hero
 	# 封印槽统一维护：封印格=封印印记纹理；其余格清 null（封印格挖开后残留在 tex_seal
 	#  会让 _draw 无条件把封印印画在已开格上——tex_seal 绘制无 revealed 条件）。缺盘走字形回退。
-	u.st.tex_seal = _palette.seal_tex if (seal and not revealed and _palette.seal_tex != null) else null
+	u.face.tex_seal = _palette.seal_tex if (seal and not revealed and _palette.seal_tex != null) else null
 	if removed:
 		revealed = false   # 移除格固定未开呈现基座（退色暗幕层承载；危险格本无数字，周边数字冻结）
 		seal = false
-		u.st.tex_seal = null
+		u.face.tex_seal = null
 	# 绘制层五段（字形与色牌→基底瓦片→立面投影→秘宝/变异叠加→迷雾）——段间交换经单元状态面
-	#（u.st/u.glyph/u.glyph_color），唯一例外=基底色 bg 经 ink 段返回值交 base 段（无单元场域承载）
+	#（u.base/u.face 域件与 u.glyph/u.glyph_color），唯一例外=基底色 bg 经 ink 段返回值交 base 段（无单元场域承载）
 	var bg: Color = _paint_cell_ink(c, u, revealed, seal)
 	_paint_cell_base(c, u, revealed, is_hero, bg)
 	_paint_cell_facade(c, u, revealed)
 	_paint_cell_overlays(c, u, revealed)
 	_paint_cell_fog(c, u, revealed, hero)
-	u.st.removed_dim = removed
+	u.face.removed_dim = removed
 	u.queue_redraw()
 
 
@@ -696,17 +614,17 @@ func _paint_cell_base(c: Vector2i, u: Node2D, revealed: bool, is_hero: bool, bg:
 			# 贴图缺位回退字形「人」（项目纹理槽惯例——贴图在位=格内字形退役，单位本体由独立精灵承载）
 			u.glyph = "人"
 			u.glyph_color = COL_HERO
-	u.st.tex_base = tile
-	u.st.bg_sb = sb
+	u.base.tex_base = tile
+	u.base.bg_sb = sb
 
 
 # 立面投影段：未开墙格南缘立面/轮廓描边码；已开格北缘投影暗带/E 格高墙面——段内重置与赋值同序
 func _paint_cell_facade(c: Vector2i, u: Node2D, revealed: bool) -> void:
-	u.st.outline_sides.assign([])   # typed Array[int]（assign 保持引用语义）
-	u.st.facade_south = false
-	u.st.proj_band = 0.0
-	u.st.tex_facade = null
-	u.st.facade_strip = false
+	u.base.outline_sides.assign([])   # typed Array[int]（assign 保持引用语义）
+	u.base.facade_south = false
+	u.base.proj_band = 0.0
+	u.base.tex_facade = null
+	u.base.facade_strip = false
 	# 封印槽不在此重置：尾部重置会与此上方条件赋值构成双写踩踏（把封印纹理恒清 null=素材在位时封印不可见）；
 	# 上方 else 分支已是全路径清残留，尾部重置系冗余且有害
 	var south_n: Vector2i = c + Vector2i(0, 1)
@@ -716,26 +634,26 @@ func _paint_cell_facade(c: Vector2i, u: Node2D, revealed: bool) -> void:
 	if not revealed:
 		# 高墙感 D 投影档：南邻地面格 → 墙格南缘立「口沿高光+双段暗带」立面
 		#（邻地面才画——墙-墙内界保墙群内聚）；板外=墙不画
-		u.st.facade_south = south_in and _minesweeper.is_revealed(south_n)
+		u.base.facade_south = south_in and _minesweeper.is_revealed(south_n)
 		# 轮廓加强：墙格四邻中已开(地面)格朝向记描边码（板外=墙不描——保墙群外轮廓只在墙/地交界）
 		for d in [Vector2i(0, -1), Vector2i(0, 1), Vector2i(-1, 0), Vector2i(1, 0)]:
 			var n: Vector2i = c + d
 			if n.x >= 0 and n.y >= 0 and n.x < _board.width and n.y < _board.height 					and _minesweeper.is_revealed(n):
 				var code := 0 if d.y < 0 else (1 if d.y > 0 else (2 if d.x < 0 else 3))
-				if code == 1 and u.st.facade_south:
+				if code == 1 and u.base.facade_south:
 					continue   # 南缘由立面件承载（高光+双段暗带）——2px 描边让位防三重叠黑
 				if code == 0 and _palette.tiles_ok:
 					continue   # v3.5 冻结① (b)-(c) 交界无边框：墙面直贴接墙顶（E 格墙面件在邻格承载）——北向描边不画（平色回退态保留描边）
-				u.st.outline_sides.append(code)
+				u.base.outline_sides.append(code)
 	else:
 		# 地面投影：北邻墙格在本已开格北缘投渐隐暗带（ITB 同款高度线索——带宽按格边比例常量）
 		if north_in and not _minesweeper.is_revealed(north_n):
-			u.st.proj_band = u.st.edge * WALL_PROJECTION_FRAC
+			u.base.proj_band = u.edge * WALL_PROJECTION_FRAC
 		# E 格高墙面（圣经 v3.5 冻结①——方向稿 is_facade_cell 口径）：已开格南邻未开墙 → 南部 30%
 		# 承接墙面（材质=同板墙顶 center 瓦片，原亮度直贴）；仅瓦片态启用——平色回退保持原语义
 		if south_in and not _minesweeper.is_revealed(south_n) and _palette.tiles_ok:
-			u.st.facade_strip = true
-			u.st.tex_facade = _palette.tiles.get("wall_center")
+			u.base.facade_strip = true
+			u.base.tex_facade = _palette.tiles.get("wall_center")
 
 
 # 秘宝/变异叠加段：真视红框/预读徽章/变异角标/奖励徽章/类型微光组号——glyph/digit_col 局部镜像
@@ -746,21 +664,21 @@ func _paint_cell_overlays(c: Vector2i, u: Node2D, revealed: bool) -> void:
 	var glyph: String = u.glyph
 	var digit_col: Color = u.glyph_color
 	if not revealed:
-		u.st.treasure_mark = "mine_reveal" if _treasure_reveal.has(c) else ""
+		u.face.treasure_mark = "mine_reveal" if _treasure_reveal.has(c) else ""
 		if _treasure_preview.has(c) and glyph == "":
 			var pid = _identity_cb.call(c) if _identity_cb.is_valid() else null
 			if pid != null and REWARD_BADGE.has(String(pid.get("cell_type", ""))):
 				glyph = String(REWARD_BADGE[String(pid.get("cell_type", ""))])
 				digit_col = COL_GOLD
-				u.st.badge_glyph = glyph
+				u.face.badge_glyph = glyph
 	# ②' 变异角标：未开格带伤害型变异 → 危险红角标（已开=威胁已兑现标记退位）；
 	# 回调缺位 = 无标记（程序化角标，tex_mutation 纹带槽暂留）
 	if not revealed and _vmark_cb.is_valid():
-		u.st.mutation_mark = String(_vmark_cb.call(c))
+		u.face.mutation_mark = String(_vmark_cb.call(c))
 	else:
-		u.st.mutation_mark = ""
-	u.st.badge_glyph = _update_badge(c)
-	u.st.glow_group = int(_glow.get(c, UiKit.GLOW_NONE))
+		u.face.mutation_mark = ""
+	u.face.badge_glyph = _update_badge(c)
+	u.glow_group = int(_glow.get(c, UiKit.GLOW_NONE))
 
 
 # 迷雾段：灯光区外未开格全黑/已开格记忆态灰显——纯呈现零逻辑（🔴 契约 1）
@@ -803,7 +721,7 @@ func _sync_glow_to_units() -> void:
 	for c in touched:
 		var u: Node2D = _cells.get(c)
 		if u != null:
-			u.st.glow_group = int(_glow.get(c, UiKit.GLOW_NONE))
+			u.glow_group = int(_glow.get(c, UiKit.GLOW_NONE))
 
 
 func _process(delta: float) -> void:
@@ -815,14 +733,14 @@ func _process(delta: float) -> void:
 	if UiKit.motion_scale < 1.0:
 		return   # 减动效：呼吸停格（refresh/enable 时已施静态色——静态可辨、无持续运动）
 	var k := 0.5 + 0.5 * sin(_breath_t * 3.0)   # 3 rad/s≈0.48Hz——无 >3 次/秒频闪（AC 基线）
-	_contact_unit.st.contact_col = COL_CONTACT.lerp(UiKit.CONTACT_GLOW_DEEP, 0.55 - 0.35 * k)
+	_contact_unit.base.contact_col = COL_CONTACT.lerp(UiKit.CONTACT_GLOW_DEEP, 0.55 - 0.35 * k)
 	_contact_unit.queue_redraw()
 
 
 # 带几何写入（refresh / set_dig_glow_enabled(true) 挂点）：清旧承载件→按英雄格可挖域写边/角码→施色
 func _apply_contact_bands() -> void:
 	if _contact_unit != null and is_instance_valid(_contact_unit) 			and (_cells.get(_minesweeper.hero_pos()) != _contact_unit if _minesweeper != null else true):
-		_contact_unit.st.contact_col = Color(0, 0, 0, 0)
+		_contact_unit.base.contact_col = Color(0, 0, 0, 0)
 		_contact_unit.queue_redraw()
 		_contact_unit = null
 	if _board == null or _minesweeper == null or not _dig_glow:
@@ -839,19 +757,19 @@ func _apply_contact_bands() -> void:
 	for d in [Vector2i(-1, -1), Vector2i(1, -1), Vector2i(-1, 1), Vector2i(1, 1)]:
 		if _diggable.has(_minesweeper.hero_pos() + d):
 			corners.append(0 if (d.x < 0 and d.y < 0) else (1 if d.x > 0 and d.y < 0 else (2 if d.x < 0 else 3)))
-	hu.st.contact_bands = bands
-	hu.st.contact_corners = corners
+	hu.base.contact_bands = bands
+	hu.base.contact_corners = corners
 	# 减动效：呼吸停格——refresh/enable 重放时施**静态**色（本件头注「已施静态色」的落実）；
 	# 0.5 = 呼吸周期中值（正常态 k 的均值）。否则减动效下每次 refresh 都会按当前相位重施色，
 	# 带色在 refresh 间跳变＝持续运动假象，且令 on/off 双帧取证无法隔离单一变量。
 	var k := 0.5 if UiKit.motion_scale < 1.0 else 0.5 + 0.5 * sin(_breath_t * 3.0)
-	hu.st.contact_col = COL_CONTACT.lerp(UiKit.CONTACT_GLOW_DEEP, 0.55 - 0.35 * k)
+	hu.base.contact_col = COL_CONTACT.lerp(UiKit.CONTACT_GLOW_DEEP, 0.55 - 0.35 * k)
 	hu.queue_redraw()
 
 
 func _reset_breath() -> void:
 	if _contact_unit != null and is_instance_valid(_contact_unit):
-		_contact_unit.st.contact_col = Color(0, 0, 0, 0)
+		_contact_unit.base.contact_col = Color(0, 0, 0, 0)
 		_contact_unit.queue_redraw()
 
 
@@ -898,9 +816,9 @@ func diggable_probe() -> Dictionary:
 	return _diggable.duplicate()
 
 
-# 悬停格只读出口（case① 悬停到达断言消费面）
+# 悬停格只读出口（case① 悬停到达断言消费面——读件投影，返回语义零变化）
 func hover_probe() -> Vector2i:
-	return _hover
+	return _hover_comp._hover
 
 
 # 迷雾参数只读快照（case⑮ 参数漂移断言消费面）
@@ -926,5 +844,5 @@ func cell_rect_probe(c: Vector2i) -> Rect2:
 	if host.size.x <= 0.0 or host.size.y <= 0.0 or vp_size.x <= 0.0 or vp_size.y <= 0.0:
 		return Rect2()
 	var k: Vector2 = host.size / vp_size
-	var local := Rect2(u.global_position, Vector2(u.st.edge, u.st.edge))
+	var local := Rect2(u.global_position, Vector2(u.edge, u.edge))
 	return Rect2(host.position + local.position * k, local.size * k)

game/presentation/views/cell_base_layer.gd

@@ -0,0 +1,204 @@
+## VERTICAL SLICE - NOT FOR PRODUCTION
+## 格面基座层绘制域件（CellUnit 拆件——单一变化原因=基座层视觉规格）：
+## 底面/描边/高墙立面/地面投影/接触带微光/顶面倒角的全部绘制入参与绘制命令。
+## 无 class_name（类名缓存面纪律）——经宿主 board_cell_unit preload 引用；宿主 _draw 按层序调
+## draw_base(canvas, rect) 把绘制命令落到宿主画布；setter 经 _owner 回引触发宿主重绘语义逐字。
+extends RefCounted
+
+# ── D 投影档绘制常量（研究件实测取色——立面高光/双段暗带/地面投影；黑罩 alpha 叠加实测等效）──
+const FACADE_HIGHLIGHT_PX := 2.0                     # 口沿高光线厚（像素）
+const FACADE_NEAR_FRAC := 0.16                       # 立面近段高（格边比——研究件 10/64）
+const FACADE_FAR_FRAC := 0.25                        # 立面远段高（格边比——研究件 16/64）
+const FACADE_NEAR_COL := Color(0, 0, 0, 0.60)        # 立面近段黑罩（墙顶 132→52 实测 α≈0.61）
+const FACADE_FAR_COL := Color(0, 0, 0, 0.82)         # 立面远段黑罩（墙顶 132→24 实测 α≈0.82）
+const PROJECTION_NEAR_COL := Color(0, 0, 0, 0.28)    # 投影贴墙段（地面 66→46 实测 α≈0.28）
+const PROJECTION_MID_COL := Color(0, 0, 0, 0.16)     # 投影中段（渐隐）
+const PROJECTION_EDGE_COL := Color(0, 0, 0, 0.06)    # 投影远段（渐隐收边）
+# ── E 格高墙面（圣经 v3.5 冻结①——地面格南邻墙→南部 30% 承接墙面：墙顶纹理原亮度
+# 直贴零暗档零阴影；墙脚阴线只画地面/墙面交界；(b)-(c) 交界
+# 无边框由 BoardView 侧跳过墙格北向描边承载）──
+const E_FACADE_FRAC := 0.30                          # 墙面承接高（格边比 30%）
+
+var _owner: Node2D = null
+var bg_sb: StyleBoxFlat = null     # 格底 StyleBox（BoardView 每次 paint 重建；呼吸微光就地改边框）
+# ── 接触带微光绘制面（可挖域微光画在英雄格周界空间侧——art-bible §3.2 v2.8；
+#     仅英雄格单元承载，BoardView.refresh 按可挖域写边/角码、_process 逐拍更新呼吸色）──
+var contact_bands: Array[int] = []      # 正交接触边码 0=N/1=S/2=W/3=E（该侧整条边）
+var contact_corners: Array[int] = []    # 斜向共享角码 0=NW/1=NE/2=SW/3=SE（角点+两侧各半条边）
+var contact_col := Color(0, 0, 0, 0)   # 当前呼吸色（alpha 0 = 不画）
+var outline_sides: Array[int] = []       # 墙格地面朝向描边码 0=N/1=S/2=W/3=E（程序侧结构件）
+# ── 高墙感 D 投影档（研究件四变体定 D=C+地面投影，ITB 同款高度线索）──
+# 南立面 = 墙格南缘内侧「口沿高光线 + 双段暗带」（邻地面格才画，墙群内聚）；地面投影 = 北邻墙格
+# 在本已开格北缘投渐隐暗带。参数按研究件 64px 拼版实测比例换算（立面双段 0.16/0.25 格边、投影带
+# 0.22 格边；坐标推导留档 commit）。素材缺位程序化回退同样服役（结构归程序——art-bible §8.5）。
+var facade_south := false:          # 南立面开关（BoardView paint 按「南邻已开格」写入）
+	set(v):
+		facade_south = v
+		_owner.queue_redraw()
+var proj_band := 0.0:               # 地面投影带宽（像素，0 = 不画——BoardView 按北邻墙判定写入）
+	set(v):
+		proj_band = v
+		_owner.queue_redraw()
+var bevel := 0.0:                   # 顶面倒角强度（0=关；档位 0/0.35/0.6/1.0）
+	set(v):
+		bevel = v
+		_owner.queue_redraw()
+var tex_base: Texture2D = null     # ① 砖面底（宿主迷雾记忆态公开单向读）
+var tex_facade: Texture2D = null   # ⑥ E 格墙面材质（v3.5——南邻墙顶 center 瓦片同源，BoardView 注入）
+var facade_strip := false:         # E 格开关（BoardView paint 按「已开格且南邻未开墙」写入——瓦片态专用）
+	set(v):
+		facade_strip = v
+		_owner.queue_redraw()
+
+
+func _init(owner: Node2D) -> void:
+	_owner = owner
+
+
+## ① 砖面底层域（占位 = StyleBoxFlat：格底色 + 暗化描边 + 3px 圆角；瓦片态描边覆盖层；
+## 呼吸微光/主角蓝框由 BoardView 改 bg_sb 后触发重绘。素材缺位回退走 elif 程序化原样，零观感变化）
+func draw_base(canvas: CanvasItem, rect: Rect2) -> void:
+	if tex_base != null:
+		canvas.draw_texture_rect(tex_base, rect, false)
+		# 轮廓加强（轮廓线不明显）：墙格地面朝向边补 2px 深墨线（§8.5 结构归程序——
+		# 素材 1px 墨线在 45/36px 非整数缩放下视觉衰减，程序线保底；墙-墙内界不画，保墙群内聚；
+		# 坐标推导：各边内贴 2px 矩形，相邻边矩形全长相交=周界闭合）
+		if not outline_sides.is_empty():
+			_draw_outline_sides(canvas, rect)
+		_draw_south_facade(canvas, rect)
+		_draw_north_projection(canvas, rect)
+		_draw_e_facade(canvas, rect)
+		# 瓦片态描边覆盖层：tex_base 在位时 BoardView 传入的 bg_sb
+		# 已降级为「透明底 + 描边」载体——呼吸微光/主角蓝框画在瓦片之上（art-bible §1.2 叠层序
+		# 不变：底 < 纹带 < 数字 < 封印 < 焦点高亮）；素材缺位回退走 elif 程序化原样，零观感变化
+		if bg_sb != null:
+			canvas.draw_style_box(bg_sb, rect)
+	_draw_contact_or_fallback(canvas, rect)
+
+
+## 接触带微光或平色回退域（英雄格周界空间侧——正交邻墙=整条边；斜向=共享角点+两侧各半条边；光不进墙格）：
+## 带宽 4px 贴格边内侧（坐标推导：N=[0,0,edge,4] S=[0,edge-4,edge,4] W=[0,0,4,edge] E=[edge-4,0,4,edge]；
+## 半条边=沿邻边自角点起 edge/2；角点圆 r=6 贴角点圆心，近白芯 r=2.5 提亮）
+func _draw_contact_or_fallback(canvas: CanvasItem, rect: Rect2) -> void:
+	if contact_col.a > 0.0:
+		_draw_north_projection(canvas, rect)   # 平色回退+微光并发的英雄格补画（瓦片路径已画——同像素重复无观感差）
+		_draw_e_facade(canvas, rect)           # E 格墙面补画（同上——英雄格兼 E 格时瓦片路径已画，重复无害）
+		_draw_contact_bands(canvas, rect)
+	elif bg_sb != null:
+		canvas.draw_style_box(bg_sb, rect)
+		_draw_south_facade(canvas, rect)      # 平色回退路径——D 投影档两件同样服役（结构归程序）
+		_draw_north_projection(canvas, rect)
+		_draw_bevel(canvas, rect)
+
+
+## 墙格轮廓域：地面朝向边补 2px 深墨线（各边内贴 2px 矩形，相邻边矩形全长相交=周界闭合）
+func _draw_outline_sides(canvas: CanvasItem, rect: Rect2) -> void:
+	var ow := 2.0
+	var oc := UiKit.FOG_OUTLINE
+	for b in outline_sides:
+		var or_ := Rect2()
+		match int(b):
+			0: or_ = Rect2(0, 0, rect.size.x, ow)
+			1: or_ = Rect2(0, rect.size.x - ow, rect.size.x, ow)
+			2: or_ = Rect2(0, 0, ow, rect.size.x)
+			3: or_ = Rect2(rect.size.x - ow, 0, ow, rect.size.x)
+		canvas.draw_rect(or_, oc, true)
+
+
+## 接触带微光域：正交整条边 + 斜向共享角点与两侧半条边
+func _draw_contact_bands(canvas: CanvasItem, rect: Rect2) -> void:
+	var band := 4.0
+	var half := rect.size.x * 0.5
+	for b in contact_bands:
+		var r := Rect2()
+		match int(b):
+			0: r = Rect2(0, 0, rect.size.x, band)
+			1: r = Rect2(0, rect.size.x - band, rect.size.x, band)
+			2: r = Rect2(0, 0, band, rect.size.x)
+			3: r = Rect2(rect.size.x - band, 0, band, rect.size.x)
+		canvas.draw_rect(r, contact_col, true)
+	for cc in contact_corners:
+		_draw_contact_corner(canvas, rect, int(cc), band, half)
+
+
+## 斜向角点域：角点圆 r=6 贴角点圆心 + 近白芯 r=2.5 提亮 + 半条边（角点沿两条邻边各延伸 edge/2——
+## 坐标推导：横带沿 N/S 自角点向板心侧 half；NW/SE 半带 x=y=角点坐标,NE/SE 半带自 edge-half 收进——
+## 正交整边时重叠同色无害）
+func _draw_contact_corner(canvas: CanvasItem, rect: Rect2, cc: int, band: float, half: float) -> void:
+	var pt := Vector2.ZERO
+	match cc:
+		0: pt = Vector2(0, 0)
+		1: pt = Vector2(rect.size.x, 0)
+		2: pt = Vector2(0, rect.size.x)
+		3: pt = Vector2(rect.size.x, rect.size.x)
+	canvas.draw_circle(pt, 6.0, contact_col)
+	canvas.draw_circle(pt, 2.5, Color(1, 1, 1, minf(1.0, contact_col.a * 0.95)))
+	if cc == 0 or cc == 1:
+		# N 侧横带：NW 自 x=0、NE 自 x=edge-half
+		canvas.draw_rect(Rect2(pt.x if cc == 0 else pt.x - half, 0.0, half, band), contact_col, true)
+	if cc == 2 or cc == 3:
+		# S 侧横带：SW 自 x=0、SE 自 x=edge-half
+		canvas.draw_rect(Rect2(pt.x if cc == 2 else pt.x - half, rect.size.x - band, half, band), contact_col, true)
+	if cc == 0 or cc == 2:
+		# W 侧竖带：NW 自 y=0、SW 自 y=edge-half
+		canvas.draw_rect(Rect2(0.0, pt.y if cc == 0 else pt.y - half, band, half), contact_col, true)
+	if cc == 1 or cc == 3:
+		# E 侧竖带：NE 自 y=0、SE 自 y=edge-half
+		canvas.draw_rect(Rect2(rect.size.x - band, pt.y if cc == 1 else pt.y - half, band, half), contact_col, true)
+
+
+## 顶面倒角域（光源左上——上/左内沿受光 2px、下/右内沿背光 2px；内缩 2px 让
+## 呼吸微光/主角蓝边框保持最外沿可见；强度随档位）
+func _draw_bevel(canvas: CanvasItem, rect: Rect2) -> void:
+	if bevel <= 0.0:
+		return
+	var base: Color = bg_sb.bg_color
+	var lit: Color = base.lightened(0.22 * bevel)
+	var dark: Color = base.darkened(0.22 * bevel)
+	var t := 2.0
+	canvas.draw_rect(Rect2(t, t, rect.size.x - t * 2.0, t), lit, true)
+	canvas.draw_rect(Rect2(t, t, t, rect.size.x - t * 2.0), lit, true)
+	canvas.draw_rect(Rect2(t, rect.size.x - t * 2.0, rect.size.x - t * 2.0, t), dark, true)
+	canvas.draw_rect(Rect2(rect.size.x - t * 2.0, t, t, rect.size.x - t * 2.0), dark, true)
+
+
+# 南立面（D 档件一——墙格南缘内侧，自底边向上：双段暗带在下、口沿高光线贴其上沿）：
+# 坐标推导（自格底边起算）：远段=[edge−far, edge]，近段=[edge−far−near, edge−far]，
+# 高光线=[edge−far−near−hl, edge−far−near]——与研究件「墙顶面→高光→暗段→更暗段→格界」下行序一致
+func _draw_south_facade(canvas: CanvasItem, rect: Rect2) -> void:
+	if not facade_south:
+		return
+	var far_h := rect.size.x * FACADE_FAR_FRAC
+	var near_h := rect.size.x * FACADE_NEAR_FRAC
+	var y_far := rect.size.x - far_h
+	var y_near := y_far - near_h
+	var y_hl := y_near - FACADE_HIGHLIGHT_PX
+	canvas.draw_rect(Rect2(0.0, y_hl, rect.size.x, FACADE_HIGHLIGHT_PX), UiKit.STAND_STONE_RIM, true)   # 口沿高光（UiKit.STAND_STONE_RIM 并档——同值单点）
+	canvas.draw_rect(Rect2(0.0, y_near, rect.size.x, near_h), FACADE_NEAR_COL, true)
+	canvas.draw_rect(Rect2(0.0, y_far, rect.size.x, far_h), FACADE_FAR_COL, true)
+
+
+# 地面投影（D 档件二——北邻墙格在本已开格北缘投渐隐暗带，自北缘向南三段衰减）：
+# 坐标推导：三等分 proj_band，α 0.28/0.16/0.06（研究件实测贴墙 α≈0.28、带末渐融入地面）
+func _draw_north_projection(canvas: CanvasItem, rect: Rect2) -> void:
+	if proj_band <= 0.0:
+		return
+	var seg := proj_band / 3.0
+	canvas.draw_rect(Rect2(0.0, 0.0, rect.size.x, seg), PROJECTION_NEAR_COL, true)
+	canvas.draw_rect(Rect2(0.0, seg, rect.size.x, seg), PROJECTION_MID_COL, true)
+	canvas.draw_rect(Rect2(0.0, seg * 2.0, rect.size.x, seg), PROJECTION_EDGE_COL, true)
+
+
+# E 格高墙面（圣经 v3.5 冻结①——方向稿 draw_facade 移植）：本格已开且南邻为墙 →
+# 南部 30% 承接墙面。材质 = 墙顶 center 瓦片顶部 30% 区带**原亮度**直贴（零暗档零阴影）；
+# 墙脚阴线只画地面/墙面交界（strip 顶缘 1px）；墙面底缘（格界处）不画任何线——直接接南侧墙顶
+# （白边导致两截）。仅瓦片态服役（tex_facade 缺位 = 平色回退原语义不动）。
+func _draw_e_facade(canvas: CanvasItem, rect: Rect2) -> void:
+	if not facade_strip or tex_facade == null:
+		return
+	var strip_h := rect.size.x * E_FACADE_FRAC
+	var y0 := rect.size.x - strip_h
+	var ts := tex_facade.get_size()
+	canvas.draw_texture_rect_region(tex_facade, Rect2(0.0, y0, rect.size.x, strip_h),
+		Rect2(0.0, 0.0, ts.x, ts.y * E_FACADE_FRAC))
+	canvas.draw_rect(Rect2(0.0, y0, rect.size.x, 1.0), UiKit.E_FACADE_FOOT_COL, true)

game/presentation/views/cell_base_layer.gd.uid

@@ -0,0 +1 @@
+uid://c2msg115y3oir

game/presentation/views/cell_mark_overlay.gd

@@ -0,0 +1,145 @@
+## VERTICAL SLICE - NOT FOR PRODUCTION
+## 格面标识与顶层叠加绘制域件（CellUnit 拆件——单一变化原因=标识与叠加层视觉规格）：
+## 变异标记/数字色牌与字形/奖励徽章/封印/路径点迹/焦点高亮/中立移除退色的全部绘制入参与绘制命令。
+## 无 class_name（类名缓存面纪律）——经宿主 board_cell_unit preload 引用；宿主 _draw 按层序调
+## draw_marks/draw_glyph_layer/draw_overlay_under/draw_removed_dim（雾层由宿主夹在 overlay_under 与 removed_dim 之间）；
+## setter 经 _owner 回引触发宿主重绘语义逐字（badge_glyph 的 glow mask 回引 _owner._glow_layer 原样）。
+extends RefCounted
+
+var _owner: Node2D = null
+var badge_glyph := "":             # 奖励徽章文字（右下角金——封印之下、变异纹之上、不进数字区）
+	set(v):
+		badge_glyph = v
+		if _owner._glow_layer != null and is_instance_valid(_owner._glow_layer):
+			_owner._glow_layer.set_badge_mask(v != "")
+		_owner.queue_redraw()
+var dot_visible := false:          # BFS 路径预览点迹（中心 6×6 小人蓝）
+	set(v):
+		dot_visible = v
+		_owner.queue_redraw()
+var hl_visible := false:           # 焦点高亮（悬停态边框覆盖层）
+	set(v):
+		hl_visible = v
+		_owner.queue_redraw()
+var hl_color := UiKit.GOLD:        # 高亮色（金目标/封印朱/禁入灰禁红）
+	set(v):
+		hl_color = v
+		_owner.queue_redraw()
+var font: Font = null              # 字体槽位（null = ThemeDB.fallback_font——BoardView.set_world_font 注入）
+# ── 素材槽位（现全 null = 程序化占位服役；art-bible §8.2 格面 32×32 暂定档）──
+var tex_mutation: Texture2D = null # ② 变异纹带
+var tex_glyph: Texture2D = null    # ③ 数字
+var tex_badge: Texture2D = null    # ③' 徽章
+var tex_seal: Texture2D = null:    # ④ 封印（槽位可运行时换装〔封印〕——同族 facade/treasure_mark
+	set(v):                        #  均 setter 触发重绘（普通 var 赋值不重绘=封印插上不显示））
+		if tex_seal != v:
+			tex_seal = v
+			_owner.queue_redraw()
+# 变异角标（程序化，tex_mutation 纹带槽暂留）：
+# "flat_damage" = 未开格伤害型变异，左下角危险红三角（开格有代价的策略纹理标记）
+# 叠加层标记（秘宝整图叠加层的格面呈现；派生信息层零回写）：
+# "mine_reveal" = 真视格（危险红内缩框——「这格是雷」的确定决策标记，封印照常计费）；
+# "reward_preview" 格不复用本字段——预读徽章走 badge_glyph 注入（board_view refresh 注入 REWARD_BADGE 字形）
+var treasure_mark := "":
+	set(v):
+		if treasure_mark != v:
+			treasure_mark = v
+			_owner.queue_redraw()
+var mutation_mark := "":
+	set(v):
+		if mutation_mark != v:
+			mutation_mark = v
+			_owner.queue_redraw()
+var removed_dim := false:             # 中立移除退色层（BoardView paint 按排雷玩法 is_removed 写入）
+	set(v):
+		removed_dim = v
+		_owner.queue_redraw()
+
+
+func _init(owner: Node2D) -> void:
+	_owner = owner
+
+
+## 变异标记域：真视格=危险红内缩框／未开格伤害型变异=左下角危险红三角
+func draw_marks(canvas: CanvasItem, rect: Rect2) -> void:
+	if treasure_mark == "mine_reveal":
+		var inset := rect.size.x * 0.14
+		canvas.draw_rect(Rect2(inset, inset, rect.size.x - inset * 2.0, rect.size.x - inset * 2.0),
+			Color(UiKit.RED_MINE, 0.9), false, 2.0)
+	if mutation_mark == "flat_damage":
+		var mw := rect.size.x * 0.28
+		var mpts := PackedVector2Array([Vector2(0, rect.size.x - mw), Vector2(0, rect.size.x), Vector2(mw, rect.size.x)])
+		canvas.draw_colored_polygon(mpts, Color(UiKit.RED_MINE, 0.85))
+
+
+## ②③④ 中层域：变异纹带与标记／数字色牌与字形／徽章／封印
+##（glyph/glyph_color/plate 三者住宿主冻结面——探针直读成员，作参数传入）
+func draw_glyph_layer(canvas: CanvasItem, rect: Rect2, glyph: String, glyph_color: Color, plate: bool) -> void:
+	# ② 变异纹带（无程序化纹带——槽位先行，贴图落位即用）
+	if tex_mutation != null:
+		canvas.draw_texture_rect(tex_mutation, rect, false)
+	# ③ 数字/徽章（数字 ≥ 格高 50% 墨族对格底 ≥4.5:1；徽章右下角金，遮蔽态 = "?"）
+	if glyph != "":
+		if plate:
+			_draw_digit_plate(canvas, rect)
+		if tex_glyph != null:
+			canvas.draw_texture_rect(tex_glyph, rect, false)
+		else:
+			draw_centered_text(canvas, rect, glyph, glyph_color, maxi(18, int(ceil(rect.size.x * 0.5))))   # 字号下限 18（§7.4 冻结公式）
+	if badge_glyph != "":
+		if tex_badge != null:
+			canvas.draw_texture_rect(tex_badge, rect, false)
+		else:
+			_draw_badge(canvas, rect, badge_glyph)
+	# ④ 封印（现行视觉封印文字在 ③ 文字位承载——独立槽位留给封印图）
+	if tex_seal != null:
+		canvas.draw_texture_rect(tex_seal, rect, false)
+
+
+## 数字色牌后备域（圣经 v3.5 冻结④：数字亮墨直画已开格底须垫牌；
+## 牌=后备件——雷/「?」维持牌载保读性（牌上深墨族 12:1）；
+## 牌尺寸 0.60/0.62 格边居中；封印=未开格不垫牌）
+func _draw_digit_plate(canvas: CanvasItem, rect: Rect2) -> void:
+	var pw := rect.size.x * 0.60
+	var ph := rect.size.x * 0.62
+	var pr := Rect2((rect.size.x - pw) * 0.5, (rect.size.x - ph) * 0.5, pw, ph)
+	canvas.draw_rect(pr, UiKit.DIGIT_PLATE, true)
+	canvas.draw_rect(pr, UiKit.DIGIT_PLATE_EDGE, false, 1.0)
+
+
+## ⑤ 路径点迹 + 焦点高亮（悬停态覆盖层，不参与命中）——宿主时序器在其后插雾层
+func draw_overlay_under(canvas: CanvasItem, rect: Rect2) -> void:
+	if dot_visible:
+		var ds := 6.0
+		canvas.draw_rect(Rect2(Vector2((rect.size.x - ds) * 0.5, (rect.size.x - ds) * 0.5), Vector2(ds, ds)), UiKit.HERO_BLUE, true)
+	if hl_visible:
+		# 悬停高亮减淡（金框太明显——绘制时 55% alpha,hl_color 属性与探针断言面不动）
+		canvas.draw_rect(Rect2(1, 1, rect.size.x - 2.0, rect.size.x - 2.0), Color(hl_color, 0.55), false, 2.0)   # 2px 内描边
+
+
+## ⑦ 中立移除退色层（退色降档：暗幕压顶全层覆盖，暗淡记忆态同族呈现语义；
+## 顶层于迷雾之上——移除格不再参与迷雾语义。本实现移除集=未揭示危险格（无数字无封印印））
+func draw_removed_dim(canvas: CanvasItem, rect: Rect2) -> void:
+	if removed_dim:
+		canvas.draw_rect(rect, Color(0.12, 0.10, 0.09, 0.62), true)
+
+
+## 文字位绘制单点（宿主迷雾记忆态复用——同公式同字号；水平居中 + 垂直居中，基线 = (格高 − 字高)/2 + 上伸部）
+func draw_centered_text(canvas: CanvasItem, rect: Rect2, text: String, col: Color, fs: int) -> void:
+	var f := font if font != null else ThemeDB.fallback_font
+	if f == null:
+		return
+	var asc := f.get_ascent(fs)
+	var desc := f.get_descent(fs)
+	canvas.draw_string(f, Vector2(0.0, (rect.size.x - (asc + desc)) * 0.5 + asc), text,
+		HORIZONTAL_ALIGNMENT_CENTER, rect.size.x, fs, col)
+
+
+# 徽章绘制：右下角金（文字贴角内缩 2–3px）
+func _draw_badge(canvas: CanvasItem, rect: Rect2, g: String) -> void:
+	var f := font if font != null else ThemeDB.fallback_font
+	if f == null:
+		return
+	var fs := maxi(10, int(rect.size.x * 0.28))
+	var sz := f.get_string_size(g, HORIZONTAL_ALIGNMENT_LEFT, -1, fs)
+	canvas.draw_string(f, Vector2(rect.size.x - sz.x - 2.0, rect.size.x - 3.0), g, HORIZONTAL_ALIGNMENT_LEFT, -1, fs, UiKit.GOLD)

game/presentation/views/cell_mark_overlay.gd.uid

@@ -0,0 +1 @@
+uid://c60e3su2qd1yq

game/presentation/views/standee_body.gd

@@ -2,9 +2,9 @@
 ## 站桩本体：B 区主角/敌人无框立绘+底座+血条+顺位/意图徽标的世界精灵（Node2D）。
 ## 站桩形态为定案——禁回卡片式；立绘素材缺位回退字形占位；击杀呈现禁瞬消（灰化塌陷）。
 ## 无 class_name——经 preload 引用；壳层坐标换算单点在 BattleStageView.world_to_shell()。
-## 内部状态件（u4 子域拆件——契约 9 职责语句「站桩演出状态」）：单一变化原因=站桩呈现与演出，
-## 成员共同表达站桩的行进态/演出计数/资产挂点。外部直访冻结成员（box/font/slot_row/has_world_hp_bar）
-## 与源码锚承载成员（_intent_charge——theme 源锚句所在行逐字保留）住宿主。
+## 内部状态两件（u4 拆件——st=身份命值态 standee_vitals、mo=资产演出态 standee_motion，_init 自建）；
+## 外部直访冻结成员（box/font/slot_row/has_world_hp_bar）与源码锚承载成员（_intent_charge——theme
+## 源锚句所在行逐字保留）与三个演出探针计数器住宿主。
 extends Node2D
 
 const CHARGE_SKILL_IDS := ["heavy"]
@@ -16,65 +16,28 @@ const ARMOR_ICONS := {"light": "◇", "ward": "◆", "heavy": "▣"}
 const DEATH_SHARD_N := 5            # 碎块数（§8.4 冻结值）
 const HIT_SPARK_N := 6              # 命中火花数（打击瞬间可读性一拍）
 
+const _VITALS := preload("res://presentation/views/standee_vitals.gd")
+const _MOTION := preload("res://presentation/views/standee_motion.gd")
 
-## 站桩演出状态（全部内部态单点——含 setter 触发宿主重绘语义，_owner 回引保持逐字）
-class _StandeeState extends RefCounted:
-	var _owner: Node2D = null
-	var _kind := "enemy"
-	var _portrait_sprite: Sprite2D = null   # 资产挂点（null = 未落位，字形在位）
-	var _portrait_tex: Texture2D = null     # 落位纹理引用（set_portrait_texture 装载；字形回退判据）
-	# 主角三态切换：state 名 → 纹理（battle_stage_view 组合点注册）；缺态=保持现纹理
-	# （缺位回退链延伸——三态素材缺任一不炸不空）。敌站桩不注册不消费。
-	var _hero_tex := {}
-	var _hero_state: int = 0
-	var _state_revert_tw: Tween
-	var _order := 1
-	var _intent_glyph := ""
-	var _intent_col := Color.WHITE
-	var _intent_visible := false
-	var _intent_scale := 1.0:           # 意图弹入动画参数
-		set(v):
-			_intent_scale = v
-			_owner.queue_redraw()
-	var _glyph_rot := 0.0:              # 立绘前倾角（贴图态无此动画）
-		set(v):
-			_glyph_rot = v
-			_owner.queue_redraw()
-	var _display_name := ""
-	var _enemy_id := ""
-	var _armor := "light"
-	var _dead := false
-	var _hp_max := 1.0
-	var _hp_cur := 0       # 血量数字显示面（HUD框架 验收「血量数字可读」）
-	var hp_value := 1.0:                # 血条值 0..1（直角递减——tween_property 目标，逐行刷新重启不累积）
-		set(v):
-			hp_value = clampf(v, 0.0, 1.0)
-			_owner.queue_redraw()
-	var _hp_tween: Tween
-	var _hp_flash_tw: Tween
-	var _death_shards := 0              # 探针出口计数（碎块节点回收后仍保留读数）
-	var _hit_sparks := 0                # 探针出口计数（命中火花累计）
-	var _flash_count := 0               # 探针出口计数（受击闪白触发次数——主角路由断言面）
-
-
-var st := _StandeeState.new()
+var st: _VITALS                    # 身份与命值态件实例（名字沿用——外部路径串 "st.hp_value" 与约 40 处引用零改）
+var mo: _MOTION                    # 资产与演出态件实例（_init 自建）
 var box := Vector2(150, 176)       # 站桩盒尺寸（实际高随壳层 row 布局注入；外部直访冻结）
 var font: Font = null              # 世界字体槽位（null = ThemeDB.fallback_font——world.world_font 注入；外部直访冻结）
 var slot_row: StatusSlotRow        # 状态效果唯一展示面 = 壳层伴随件（挂 BattleStageView 壳层，本体进世界；外部直访冻结）
 var _intent_charge := false          # 蓄力档（pid ∈ CHARGE_SKILL_IDS——意图三档 ③ 分支判据；源码锚承载成员住宿主）
 # 血条存在性探针出口（世界直角血条常在；外部直访冻结）
 var has_world_hp_bar := true
+# 演出探针计数器（写入方=宿主演出函数、读取方=宿主 fx_probe 出口——仪器跟着驱动它的函数走）
+var _death_shards := 0              # 探针出口计数（碎块节点回收后仍保留读数）
+var _hit_sparks := 0                # 探针出口计数（命中火花累计）
+var _flash_count := 0               # 探针出口计数（受击闪白触发次数——主角路由断言面）
 
 
 func _init(kind: String = "enemy") -> void:
-	st._owner = self
-	st._hero_state = HeroState.IDLE
+	st = _VITALS.new(self)
+	mo = _MOTION.new(self)
 	st._kind = kind
-
-
-enum HeroState { IDLE, RESET, ATTACK, HIT }   # 主角三态+复位哨兵（外部 String 契约=register/set 形参零变化）
-const _HS_NAME := {HeroState.IDLE: "idle", HeroState.RESET: "reset", HeroState.ATTACK: "attack", HeroState.HIT: "hit"}
-const _HS_VALUE := {"idle": HeroState.IDLE, "reset": HeroState.RESET, "attack": HeroState.ATTACK, "hit": HeroState.HIT}
+	mo._hero_state = _MOTION.HeroState.IDLE
 
 
 func _efont() -> Font:
@@ -92,7 +55,7 @@ func enemy_id() -> String:
 
 # 意图徽标探针出口
 func intent_probe() -> Dictionary:
-	return {"visible": st._intent_visible, "text": st._intent_glyph}
+	return {"visible": mo._intent_visible, "text": mo._intent_glyph}
 
 
 # 名字行探针出口（ui_probe 呈现口径 + 本批 V6/V8 断言面：armor_icon = 绑定纹理路径〔缺位回退字形〕、
@@ -118,7 +81,7 @@ func set_data(d: Dictionary) -> void:
 	st._enemy_id = String(d.get("enemy_id", ""))
 	st._armor = String(d.get("armor_type", "light"))
 	st._hp_max = float(maxi(1, int(d.get("max_hp", 1))))
-	_set_hp(int(d.get("hp", 0)))
+	st.apply_hp(int(d.get("hp", 0)))
 	_set_order(int(d.get("order", 1)))
 	set_pending(String(d.get("pending_type", "")), String(d.get("pending_skill", "")))
 	set_effects(d.get("effects", []))
@@ -129,21 +92,11 @@ func set_data(d: Dictionary) -> void:
 
 func set_hero(hp: int, max_hp: int) -> void:
 	st._hp_max = float(maxi(1, max_hp))
-	_set_hp(hp)
+	st.apply_hp(hp)
 	if st._dead and hp > 0:
 		_revive()   # 新战斗开场 HP 回正——主角死亡残位随之复活（敌侧 set_data 同款语义）
 
 
-# 血条短 tween 递减（直角递减占位）；逐行刷新时重启 tween 不累积
-func _set_hp(hp: int) -> void:
-	st._hp_cur = clampi(hp, 0, int(st._hp_max))
-	var target := float(st._hp_cur) / st._hp_max
-	if st._hp_tween != null and st._hp_tween.is_valid():
-		st._hp_tween.kill()
-	st._hp_tween = create_tween()
-	st._hp_tween.tween_property(st, "hp_value", target, UiKit.motion(0.15))
-
-
 # 主角/敌方共用——状态效果唯一展示面（壳层伴随件转发；空态 = 图标行隐藏不占位）
 func set_effects(effects: Array) -> void:
 	if slot_row == null:
@@ -182,12 +135,12 @@ func _set_order(i: int) -> void:
 func set_pending(ptype: String, pid: String) -> void:
 	if st._dead:
 		_intent_charge = false
-		st._intent_visible = false
+		mo._intent_visible = false
 		queue_redraw()
 		return
 	if ptype == "" or ptype == "basic":
 		_intent_charge = false
-		st._intent_visible = false   # 普通攻击零表示（完全不可预测——§2.4）
+		mo._intent_visible = false   # 普通攻击零表示（完全不可预测——§2.4）
 		queue_redraw()
 		return
 	var glyph := "⚔"               # 攻击系（damage）
@@ -201,60 +154,15 @@ func set_pending(ptype: String, pid: String) -> void:
 	_intent_charge = pid in CHARGE_SKILL_IDS
 	if _intent_charge:
 		col = UiKit.GOLD_INK       # 重击类蓄力档（深金墨——浅垫牌上 ≥4.5:1）
-	st._intent_glyph = glyph
-	st._intent_col = col
-	st._intent_visible = true
-	_play_intent_motion()
+	mo._intent_glyph = glyph
+	mo._intent_col = col
+	mo._intent_visible = true
+	mo.play_intent_motion(_intent_charge)
 
 
-# 意图三档动作动画（§4.6.4 三档：①普通攻击=零表示〔set_pending 早退〕
-# ②特殊准备=徽标弹入+二次弹跳（高举语义，运动手段 §2）③重击/硬化=缓推蓄力+定格微顿+回落；
-# 三档运动签名互异，灰度/剪影层可辨）。摇定时一次性短动画，随后静帧保持。
-func _play_intent_motion() -> void:
-	var tw := create_tween()
-	tw.tween_property(st, "_intent_scale", 1.6, UiKit.motion(0.10))
-	tw.tween_property(st, "_intent_scale", 1.0, UiKit.motion(0.16))
-	tw.parallel().tween_property(st, "_glyph_rot", 4.0, UiKit.motion(0.10))
-	tw.tween_property(st, "_glyph_rot", 0.0, UiKit.motion(0.14))
-	if _intent_charge:
-		tw.tween_property(st, "_intent_scale", 1.22, UiKit.motion(0.28)).set_trans(Tween.TRANS_SINE)   # ③蓄力缓推
-		tw.tween_interval(UiKit.motion(0.40))                                                            #   定格微顿
-		tw.tween_property(st, "_intent_scale", 1.0, UiKit.motion(0.18))
-	else:
-		tw.tween_property(st, "_intent_scale", 1.26, UiKit.motion(0.11))   # ②二次弹跳（高举）
-		tw.tween_property(st, "_intent_scale", 1.0, UiKit.motion(0.13))
-
-
-# 资产挂点：tex 落位后字形隐退、纹理立绘顶位——零代码换装契约；tex=null 回退字形。
-# flip = 立绘朝向翻转（素材基准朝左时传 true 呈现朝右）。盒高 96px = 48px 立绘源整数 2×
-# （圣经 §8.2 禁非整数缩放）——源换代时随源重算。
+# 资产挂点转调壳（签名外形零变——box 由宿主传入件内）
 func set_portrait_texture(tex: Texture2D, flip: bool = false) -> void:
-	if tex == null:
-		if st._portrait_sprite != null:
-			st._portrait_sprite.visible = false
-		queue_redraw()
-		return
-	st._portrait_tex = tex
-	if st._portrait_sprite == null:
-		st._portrait_sprite = Sprite2D.new()
-		st._portrait_sprite.centered = false
-		st._portrait_sprite.texture_filter = CanvasItem.TEXTURE_FILTER_NEAREST   # 像素帧放大防糊
-		add_child(st._portrait_sprite)
-	st._portrait_sprite.texture = tex
-	st._portrait_sprite.flip_h = flip
-	st._portrait_sprite.visible = true
-	_place_portrait()
-
-
-func _place_portrait() -> void:
-	# 立绘盒 = (0,44)-(box.x, box.y-36)；48 源 ×2 整数档居中
-	if st._portrait_sprite == null or st._portrait_tex == null:
-		return
-	var box_h := box.y - 44.0 - 36.0
-	var w := st._portrait_tex.get_width() * 2.0
-	var h := st._portrait_tex.get_height() * 2.0
-	st._portrait_sprite.scale = Vector2(2.0, 2.0)   # 整数 2×（C5）
-	st._portrait_sprite.position = Vector2((box.x - w) * 0.5, 44.0 + (box_h - h) * 0.5)
+	mo.set_portrait_texture(tex, flip, box)
 
 
 func mark_dead() -> void:
@@ -268,8 +176,8 @@ func mark_dead() -> void:
 	tw.tween_property(self, "rotation_degrees", 0.0, UiKit.motion(0.08))
 	_spawn_death_shards()   # 碎裂退场（§4.6.4 语义硬规则：灰化+碎裂禁瞬间消失；§8.4 v2 冻结 5 块 0.45s）
 	_intent_charge = false
-	st._intent_visible = false   # 死亡残位意图退位
-	_set_hp(0)
+	mo._intent_visible = false   # 死亡残位意图退位
+	st.apply_hp(0)
 	if slot_row != null:
 		slot_row.visible = false   # 状态行随 mark_dead 同拍隐藏
 
@@ -279,7 +187,7 @@ func mark_dead() -> void:
 
 # 死亡碎块弹飞：立绘盒中心五块碎石抛物线散落（程序化色块——确定性散布，禁全局随机）
 func _spawn_death_shards() -> void:
-	st._death_shards = DEATH_SHARD_N
+	_death_shards = DEATH_SHARD_N
 	var center := _portrait_rect().get_center()
 	for i in DEATH_SHARD_N:
 		_spawn_death_shard(i, center)
@@ -305,7 +213,7 @@ func _spawn_death_shard(i: int, center: Vector2) -> void:
 
 # 演出探针出口（fx_probe——死亡碎裂/命中火花/闪白计数断言面）
 func fx_probe() -> Dictionary:
-	return {"death_shards": st._death_shards, "hit_sparks": st._hit_sparks, "flash_count": st._flash_count}
+	return {"death_shards": _death_shards, "hit_sparks": _hit_sparks, "flash_count": _flash_count}
 
 
 # 命中瞬间打击特效：立绘盒中心六枚短火花放射（程序化色块，确定性方向
@@ -319,7 +227,7 @@ func play_hit_impact() -> void:
 
 ## 单火花域（循环体提函数——放射弹道+渐隐+回收）
 func _spawn_hit_spark(i: int, center: Vector2) -> void:
-	st._hit_sparks += 1
+	_hit_sparks += 1
 	var spark := ColorRect.new()
 	spark.color = UiKit.GOLD_LIT if i % 2 == 0 else UiKit.WARM
 	spark.size = Vector2(4, 3)
@@ -340,7 +248,7 @@ func is_dead() -> bool:
 
 # 受击闪白（结算演出占位——§2.2 受击反馈；强度时长维持现行）
 func flash_hit() -> void:
-	st._flash_count += 1
+	_flash_count += 1
 	if st._hp_flash_tw != null and st._hp_flash_tw.is_valid():
 		st._hp_flash_tw.kill()
 	st._hp_flash_tw = create_tween()
@@ -353,8 +261,7 @@ func _revive() -> void:
 	modulate = Color(1, 1, 1)
 	rotation_degrees = 0.0
 	if st._kind == "hero":
-		st._hero_state = HeroState.RESET   # 强制回 idle 态（绕过同态早退）
-		set_hero_state("idle")
+		mo.reset_state()
 	if slot_row != null:
 		slot_row.visible = true
 	queue_redraw()
@@ -372,45 +279,24 @@ func _portrait_glyph() -> String:
 
 # 立绘落位探针出口（站桩纹理非空断言面；缺位回退链保持的对照面）
 func portrait_probe() -> Dictionary:
-	return {"has_tex": st._portrait_sprite != null and st._portrait_sprite.texture != null}
+	return {"has_tex": mo._portrait_sprite != null and mo._portrait_sprite.texture != null}
 
 
 # ---- 主角三态切换（攻击演出→attack/受击→hit/结算回 idle；§8.4 帧数档挂点） ----
 
-# 组合点注册（battle_stage_view _init——UiKit 常量 load_tex，缺位 null 不注册=该态保持现纹理）
+# 组合点注册转调壳（签名外形零变）
 func register_hero_state(state: String, tex: Texture2D) -> void:
-	if tex != null:
-		st._hero_tex[state] = tex
+	mo.register_hero_state(state, tex)
 
 
-# 状态切换：现纹理换注册态（attack/hit）；未注册态名或缺位 = 保持现纹理不炸。
-# 非 idle 态自动短驻回归 idle（0.35s——演出一拍即回，结算收尾另有显式 idle 兜底）。
+# 状态切换转调壳（签名外形零变——is_hero 由宿主 vitals 参判传入，早退序逐字在件内）
 func set_hero_state(state: String) -> void:
-	var target: int = _HS_VALUE.get(state, -1)
-	if st._kind != "hero" or target == st._hero_state:
-		return
-	if not st._hero_tex.has(state) and state != "idle":
-		return
-	st._hero_state = target
-	if st._portrait_sprite != null and st._hero_tex.has(state):
-		st._portrait_sprite.texture = st._hero_tex[state]
-	if st._state_revert_tw != null and st._state_revert_tw.is_valid():
-		st._state_revert_tw.kill()
-	if state != "idle":
-		st._state_revert_tw = create_tween()
-		st._state_revert_tw.tween_interval(UiKit.motion(0.35))
-		st._state_revert_tw.tween_callback(_settle_hero_idle)
+	mo.apply_hero_state(state, st._kind == "hero")
 
 
-func _settle_hero_idle() -> void:
-	st._hero_state = HeroState.IDLE
-	if st._portrait_sprite != null and st._hero_tex.has("idle"):
-		st._portrait_sprite.texture = st._hero_tex["idle"]
-
-
-# 三态探针出口（fx_probe——当前态名+注册态集合）
+# 三态探针出口（fx_probe——当前态名+注册态集合；读件投影外形零变）
 func hero_state_probe() -> Dictionary:
-	return {"state": _HS_NAME.get(st._hero_state, "idle"), "registered": st._hero_tex.keys()}
+	return mo.state_probe()
 
 
 func _portrait_color() -> Color:
@@ -535,7 +421,7 @@ func _draw_hp_bar(f: Font) -> void:
 
 ## 立绘域：贴图在位 = Sprite2D（set_portrait_texture 落位）；缺位 = 字形回退
 func _draw_portrait(f: Font) -> void:
-	if st._portrait_sprite != null and st._portrait_sprite.texture != null and st._portrait_sprite.visible:
+	if mo._portrait_sprite != null and mo._portrait_sprite.texture != null and mo._portrait_sprite.visible:
 		return
 	var prect := _portrait_rect()
 	var glyph := _portrait_glyph()
@@ -543,7 +429,7 @@ func _draw_portrait(f: Font) -> void:
 	# 坐标系注记：draw_set_transform 原点已置于 center——draw_string 的
 	# pos 是**变换后的局部坐标**，须传相对 center 的偏移（-w/2 水平居中、+0.35h 基线下移）；
 	# 传绝对 center 会成双重偏移、把字形画到盒外。
-	draw_set_transform(center, deg_to_rad(st._glyph_rot), Vector2.ONE)
+	draw_set_transform(center, deg_to_rad(mo._glyph_rot), Vector2.ONE)
 	var ts := f.get_string_size(glyph, HORIZONTAL_ALIGNMENT_LEFT, -1, 42)
 	f.draw_string(get_canvas_item(), Vector2(-ts.x * 0.5, ts.y * 0.35), glyph,
 		HORIZONTAL_ALIGNMENT_LEFT, -1, 42, _portrait_color())
@@ -552,18 +438,17 @@ func _draw_portrait(f: Font) -> void:
 
 ## 意图徽标域（敌 only——立绘上半部居中悬浮，CENTER_TOP 74..98 等价）：弹入 scale 动画
 func _draw_intent_badge(f: Font) -> void:
-	if not st._intent_visible:
+	if not mo._intent_visible:
 		return
 	var icenter := Vector2(box.x * 0.5, 86.0)
-	draw_set_transform(icenter, 0.0, Vector2(st._intent_scale, st._intent_scale))
-	var its := f.get_string_size(st._intent_glyph, HORIZONTAL_ALIGNMENT_LEFT, -1, 15)
+	draw_set_transform(icenter, 0.0, Vector2(mo._intent_scale, mo._intent_scale))
+	var its := f.get_string_size(mo._intent_glyph, HORIZONTAL_ALIGNMENT_LEFT, -1, 15)
 	# 对比度垫牌（四色墨直压立绘纹理/暗舞台底 1.5-3.3:1 违 §7.2
 	# 「文字禁直压纹理底」；垫 PANEL_DATA 素牌后 atk 5.3/buf 4.8/debuff 4.7/charge 4.9 全 ≥4.5:1；
 	# atk/debuff 零换墨、buf 换 HERO_BLUE_DEEP、charge 换 GOLD_INK；随弹入 transform 同步缩放）
 	draw_rect(Rect2(-its.x * 0.5 - 4.0, -its.y * 0.75, its.x + 8.0, its.y * 1.1), UiKit.PANEL_DATA, true)
-	f.draw_string(get_canvas_item(), Vector2(-its.x * 0.5, its.y * 0.35), st._intent_glyph,
-		HORIZONTAL_ALIGNMENT_LEFT, -1, 15, st._intent_col)   # 局部坐标（同上注记——双重偏移修复）
-	draw_set_transform(Vector2.ZERO, 0.0, Vector2.ONE)
+	f.draw_string(get_canvas_item(), Vector2(-its.x * 0.5, its.y * 0.35), mo._intent_glyph,
+		HORIZONTAL_ALIGNMENT_LEFT, -1, 15, mo._intent_col)   # 局部坐标（同上注记——双重偏移修复）
 
 
 ## 名字行域（敌 only——AC 数值不展示，类型图标化）：整行垫 HP_BAR_BACK 素底牌（§6.1/§7.2

game/presentation/views/standee_motion.gd

@@ -0,0 +1,128 @@
+## VERTICAL SLICE - NOT FOR PRODUCTION
+## 站桩资产与演出态件（StandeeBody 拆件——单一变化原因=美术素材落位规则与演出编排设计）：
+## 站桩的资产挂点与一次性演出——立绘精灵落位与换装、主角三态注册与 0.35s 短驻回归、意图徽标弹入动画。
+## 无 class_name（类名缓存面纪律）——经宿主 standee_body preload 引用（mo 实例）；
+## 两个属性 setter 经 _owner 回引触发宿主重绘语义逐字；tween 经 _owner 创建（同一 Node 生命绑定）。
+extends RefCounted
+
+enum HeroState { IDLE, RESET, ATTACK, HIT }   # 主角三态+复位哨兵（外部 String 契约=register/set 形参零变化）
+const _HS_NAME := {HeroState.IDLE: "idle", HeroState.RESET: "reset", HeroState.ATTACK: "attack", HeroState.HIT: "hit"}
+const _HS_VALUE := {"idle": HeroState.IDLE, "reset": HeroState.RESET, "attack": HeroState.ATTACK, "hit": HeroState.HIT}
+
+var _owner: Node2D = null
+var _portrait_sprite: Sprite2D = null   # 资产挂点（null = 未落位，字形在位）
+var _portrait_tex: Texture2D = null     # 落位纹理引用（set_portrait_texture 装载；字形回退判据）
+# 主角三态切换：state 名 → 纹理（battle_stage_view 组合点注册）；缺态=保持现纹理
+# （缺位回退链延伸——三态素材缺任一不炸不空）。敌站桩不注册不消费。
+var _hero_tex := {}
+var _hero_state: int = 0
+var _state_revert_tw: Tween
+var _intent_glyph := ""
+var _intent_col := Color.WHITE
+var _intent_visible := false
+var _intent_scale := 1.0:           # 意图弹入动画参数
+	set(v):
+		_intent_scale = v
+		_owner.queue_redraw()
+var _glyph_rot := 0.0:              # 立绘前倾角（贴图态无此动画）
+	set(v):
+		_glyph_rot = v
+		_owner.queue_redraw()
+
+
+func _init(owner: Node2D) -> void:
+	_owner = owner
+
+
+# 资产挂点：tex 落位后字形隐退、纹理立绘顶位——零代码换装契约；tex=null 回退字形。
+# flip = 立绘朝向翻转（素材基准朝左时传 true 呈现朝右）。盒高 96px = 48px 立绘源整数 2×
+# （圣经 §8.2 禁非整数缩放）——源换代时随源重算。（box = 宿主冻结 var，由宿主传入）
+func set_portrait_texture(tex: Texture2D, flip: bool, box: Vector2) -> void:
+	if tex == null:
+		if _portrait_sprite != null:
+			_portrait_sprite.visible = false
+		_owner.queue_redraw()
+		return
+	_portrait_tex = tex
+	if _portrait_sprite == null:
+		_portrait_sprite = Sprite2D.new()
+		_portrait_sprite.centered = false
+		_portrait_sprite.texture_filter = CanvasItem.TEXTURE_FILTER_NEAREST   # 像素帧放大防糊
+		_owner.add_child(_portrait_sprite)
+	_portrait_sprite.texture = tex
+	_portrait_sprite.flip_h = flip
+	_portrait_sprite.visible = true
+	_place_portrait(box)
+
+
+func _place_portrait(box: Vector2) -> void:
+	# 立绘盒 = (0,44)-(box.x, box.y-36)；48 源 ×2 整数档居中
+	if _portrait_sprite == null or _portrait_tex == null:
+		return
+	var box_h := box.y - 44.0 - 36.0
+	var w := _portrait_tex.get_width() * 2.0
+	var h := _portrait_tex.get_height() * 2.0
+	_portrait_sprite.scale = Vector2(2.0, 2.0)   # 整数 2×（C5）
+	_portrait_sprite.position = Vector2((box.x - w) * 0.5, 44.0 + (box_h - h) * 0.5)
+
+
+# 组合点注册（battle_stage_view _init——UiKit 常量 load_tex，缺位 null 不注册=该态保持现纹理）
+func register_hero_state(state: String, tex: Texture2D) -> void:
+	if tex != null:
+		_hero_tex[state] = tex
+
+
+# 状态切换：现纹理换注册态（attack/hit）；未注册态名或缺位 = 保持现纹理不炸。
+# 非 idle 态自动短驻回归 idle（0.35s——演出一拍即回，结算收尾另有显式 idle 兜底）。
+#（is_hero = 宿主 vitals._kind == "hero" 参判传入——三连早退条件序逐字）
+func apply_hero_state(state: String, is_hero: bool) -> void:
+	var target: int = _HS_VALUE.get(state, -1)
+	if not is_hero or target == _hero_state:
+		return
+	if not _hero_tex.has(state) and state != "idle":
+		return
+	_hero_state = target
+	if _portrait_sprite != null and _hero_tex.has(state):
+		_portrait_sprite.texture = _hero_tex[state]
+	if _state_revert_tw != null and _state_revert_tw.is_valid():
+		_state_revert_tw.kill()
+	if state != "idle":
+		_state_revert_tw = _owner.create_tween()
+		_state_revert_tw.tween_interval(UiKit.motion(0.35))
+		_state_revert_tw.tween_callback(_settle_hero_idle)
+
+
+func _settle_hero_idle() -> void:
+	_hero_state = HeroState.IDLE
+	if _portrait_sprite != null and _hero_tex.has("idle"):
+		_portrait_sprite.texture = _hero_tex["idle"]
+
+
+# 复位强制绕同态早退两拍封装（原 _revive 内 hero 分支——先置 RESET 哨兵再回 idle）
+func reset_state() -> void:
+	_hero_state = HeroState.RESET   # 强制回 idle 态（绕过同态早退）
+	apply_hero_state("idle", true)
+
+
+# 意图三档动作动画（§4.6.4 三档：①普通攻击=零表示〔set_pending 早退〕
+# ②特殊准备=徽标弹入+二次弹跳（高举语义，运动手段 §2）③重击/硬化=缓推蓄力+定格微顿+回落；
+# 三档运动签名互异，灰度/剪影层可辨）。摇定时一次性短动画，随后静帧保持。
+#（charge = 宿主 _intent_charge 分档布尔参判传入）
+func play_intent_motion(charge: bool) -> void:
+	var tw := _owner.create_tween()
+	tw.tween_property(self, "_intent_scale", 1.6, UiKit.motion(0.10))
+	tw.tween_property(self, "_intent_scale", 1.0, UiKit.motion(0.16))
+	tw.parallel().tween_property(self, "_glyph_rot", 4.0, UiKit.motion(0.10))
+	tw.tween_property(self, "_glyph_rot", 0.0, UiKit.motion(0.14))
+	if charge:
+		tw.tween_property(self, "_intent_scale", 1.22, UiKit.motion(0.28)).set_trans(Tween.TRANS_SINE)   # ③蓄力缓推
+		tw.tween_interval(UiKit.motion(0.40))                                                            #   定格微顿
+		tw.tween_property(self, "_intent_scale", 1.0, UiKit.motion(0.18))
+	else:
+		tw.tween_property(self, "_intent_scale", 1.26, UiKit.motion(0.11))   # ②二次弹跳（高举）
+		tw.tween_property(self, "_intent_scale", 1.0, UiKit.motion(0.13))
+
+
+# 三态探针出口（fx_probe——当前态名+注册态集合；宿主 hero_state_probe 读件投影，外形零变）
+func state_probe() -> Dictionary:
+	return {"state": _HS_NAME.get(_hero_state, "idle"), "registered": _hero_tex.keys()}

game/presentation/views/standee_motion.gd.uid

@@ -0,0 +1 @@
+uid://cdfo2jgp2w7ei

game/presentation/views/standee_vitals.gd

@@ -0,0 +1,36 @@
+## VERTICAL SLICE - NOT FOR PRODUCTION
+## 站桩身份与命值态件（StandeeBody 拆件——单一变化原因=战斗结算快照投影的字段形态）：
+## 站桩是谁、活没活、血量几何的唯一账面——身份五元组（种类/名/id/护甲/顺位）+存活位+血量账与两条血量系 tween 槽。
+## 无 class_name（类名缓存面纪律）——经宿主 standee_body preload 引用（st 实例名沿用）；
+## hp_value 属性 setter 经 _owner 回引触发宿主重绘语义逐字。
+extends RefCounted
+
+var _owner: Node2D = null
+var _kind := "enemy"
+var _display_name := ""
+var _enemy_id := ""
+var _armor := "light"
+var _order := 1
+var _dead := false
+var _hp_max := 1.0
+var _hp_cur := 0       # 血量数字显示面（HUD框架 验收「血量数字可读」）
+var hp_value := 1.0:                # 血条值 0..1（直角递减——tween_property 目标，逐行刷新重启不累积）
+	set(v):
+		hp_value = clampf(v, 0.0, 1.0)
+		_owner.queue_redraw()
+var _hp_tween: Tween
+var _hp_flash_tw: Tween
+
+
+func _init(owner: Node2D) -> void:
+	_owner = owner
+
+
+# 血条短 tween 递减（直角递减占位）；逐行刷新时重启 tween 不累积
+func apply_hp(hp: int) -> void:
+	_hp_cur = clampi(hp, 0, int(_hp_max))
+	var target := float(_hp_cur) / _hp_max
+	if _hp_tween != null and _hp_tween.is_valid():
+		_hp_tween.kill()
+	_hp_tween = _owner.create_tween()
+	_hp_tween.tween_property(self, "hp_value", target, UiKit.motion(0.15))

game/presentation/views/standee_vitals.gd.uid

@@ -0,0 +1 @@
+uid://bjd7t5nmepbey

game/probe/ui_input_probe.gd

@@ -231,8 +231,8 @@ func _ready() -> void:
 	if bv.hover_probe() != seal_t:
 		_problems.append("case① 悬停未到达（_hover=%s 应=%s）" % [bv.hover_probe(), seal_t])
 	var u1 = bv.cells_probe()[seal_t]
-	if not u1.st.hl_visible or u1.st.hl_color != UiKit.GOLD:
-		_problems.append("case① 悬停金框缺失（visible=%s color=%s）" % [str(u1.st.hl_visible), str(u1.st.hl_color)])
+	if not u1.face.hl_visible or u1.face.hl_color != UiKit.GOLD:
+		_problems.append("case① 悬停金框缺失（visible=%s color=%s）" % [str(u1.face.hl_visible), str(u1.face.hl_color)])
 	if bv.mouse_default_cursor_shape != Input.CURSOR_CROSS:
 		_problems.append("case① 挖掘光标未切十字（%d）" % bv.mouse_default_cursor_shape)
 	# ---- case② 悬停禁入：hover_forbidden 信号 + 灰禁红框 ----
@@ -240,14 +240,14 @@ func _ready() -> void:
 	await get_tree().process_frame
 	if _forbids.is_empty() or _forbids[_forbids.size() - 1] != forbid_t:
 		_problems.append("case② hover_forbidden 未达（%s）" % [str(_forbids)])
-	if bv.cells_probe()[forbid_t].st.hl_color != UiKit.RED_FORBID:
-		_problems.append("case② 禁入红框缺失（color=%s）" % str(bv.cells_probe()[forbid_t].st.hl_color))
+	if bv.cells_probe()[forbid_t].face.hl_color != UiKit.RED_FORBID:
+		_problems.append("case② 禁入红框缺失（color=%s）" % str(bv.cells_probe()[forbid_t].face.hl_color))
 	# ---- case③ 悬停已开格：路径预览点迹 + 移动光标 ----
 	_push_motion(_pos(bv, reveal_t))
 	await get_tree().process_frame
 	var dots := 0
 	for c in bv.cells_probe():
-		if bv.cells_probe()[c].st.dot_visible:
+		if bv.cells_probe()[c].face.dot_visible:
 			dots += 1
 	if dots < 1:
 		_problems.append("case③ 路径预览点迹未亮（dots=0）")
@@ -266,8 +266,8 @@ func _ready() -> void:
 	# 掩盖）——有盘断言纹理在槽、缺盘断言字形回退，两分支防双写踩踏复活 ----
 	var seal_unit = bv.cells_probe().get(seal_t)
 	if bv._palette.seal_tex != null:
-		if seal_unit == null or seal_unit.st.tex_seal != bv._palette.seal_tex:
-			_problems.append("case④b 封印纹理槽未挂封印印记纹理（tex_seal=%s）" % ["无单元" if seal_unit == null else str(seal_unit.st.tex_seal)])
+		if seal_unit == null or seal_unit.face.tex_seal != bv._palette.seal_tex:
+			_problems.append("case④b 封印纹理槽未挂封印印记纹理（tex_seal=%s）" % ["无单元" if seal_unit == null else str(seal_unit.face.tex_seal)])
 	elif seal_unit == null or seal_unit.glyph != "封":
 		_problems.append("case④b 缺盘字形回退缺失（glyph=%s）" % ["无单元" if seal_unit == null else String(seal_unit.glyph)])
 	# ---- case⑤ 双击 chord：禁入格双左击（核心拒挖零副作用）→ chord_attempted ----
@@ -371,12 +371,12 @@ func _ready() -> void:
 	if mark_t.x >= 0:
 		bv.set_variant_mark_resolver(func(_c): return "flat_damage")
 		bv.refresh()
-		if String(bv.cells_probe()[mark_t].st.mutation_mark) != "flat_damage":
-			_problems.append("case⑭ 变异角标未落位（mutation_mark=%s）" % str(bv.cells_probe()[mark_t].st.mutation_mark))
+		if String(bv.cells_probe()[mark_t].face.mutation_mark) != "flat_damage":
+			_problems.append("case⑭ 变异角标未落位（mutation_mark=%s）" % str(bv.cells_probe()[mark_t].face.mutation_mark))
 		bv.set_variant_mark_resolver(Callable())
 		bv.refresh()
-		if String(bv.cells_probe()[mark_t].st.mutation_mark) != "":
-			_problems.append("case⑭ 角标未随 resolver 复位（mutation_mark=%s）" % str(bv.cells_probe()[mark_t].st.mutation_mark))
+		if String(bv.cells_probe()[mark_t].face.mutation_mark) != "":
+			_problems.append("case⑭ 角标未随 resolver 复位（mutation_mark=%s）" % str(bv.cells_probe()[mark_t].face.mutation_mark))
 	else:
 		_problems.append("case⑭ 无未开格可验（板面异常）")
 	# ---- case⑮ 视野迷雾（三态呈态/半径圈/移动跟随/开关两态零扰动/提灯插值位；

game/tests/.gates/.gitignore

@@ -1,4 +1,9 @@
 # 本目录只入库 baseline.json（存量基线，需随代码走以保证各 worktree 判定口径一致）。
-# receipt.json 是每跑批覆写的当次回执、*.log 是跑批当场日志——两者都是中间产物，不入库。
+# receipt.json 是每跑批覆写的当次回执、ci-status.json/ci-history.jsonl 是本地 CI 判定与流水账、
+# ci.lock/ci.rerun 是跑批件锁与补跑标记、*.log 是跑批当场日志——均为中间产物，不入库。
 receipt.json
-*.log
+ci-status.json
+ci-history.jsonl
+ci.lock
+ci.rerun
+*.log

game/tests/.gates/baseline.json

@@ -1,61 +1,61 @@
 {
- "note": "存量基线·闸况变化时本脚本会判红，需人工确认后重生成；2026-10-29 二次记账＝03/04/05 三闸按 80b49c0f 先例经用户裁决记入现行红项指纹（03=8a3cae0d0446/04=591b27250b36/05=de89589e49ed）——master 同值复现非迭代42新增（stash 对照法取证，承「迭代 41 测试债修复」条目扩展）；原 2026-10-17 06 条目人工重生成记录见 git 提交史",
- "gates": {
-  "00 冒烟测试": {
-   "exit": "0",
-   "fp": "green"
-  },
-  "01 系统测试": {
-   "exit": "0",
-   "fp": "green"
-  },
-  "02 单元与集成测试": {
-   "exit": "1",
-   "fp": "f9865f1a5a44"
-  },
-  "03 场景探针": {
-   "exit": "0",
-   "fp": "green"
-  },
-  "05 渲染闸": {
-   "exit": "1",
-   "fp": "de89589e49ed"
-  },
-  "06 gdd_lint": {
-   "exit": "0",
-   "fp": "green"
-  },
-  "06b 变更记录节": {
-   "exit": "0",
-   "fp": "green"
-  },
-  "07 doc_link": {
-   "exit": "0",
-   "fp": "green"
-  },
-  "08 doc_term": {
-   "exit": "0",
-   "fp": "green"
-  },
-  "08c 流水线闸": {
-   "exit": "0",
-   "fp": "green"
-  },
-  "09 静态扫描": {
-   "exit": "1",
-   "fp": "1a9ad773489f"
-  },
-  "10 熵增闸": {
-   "exit": "0",
-   "fp": "green"
-  },
-  "08d 引用可核": {
-   "exit": "0",
-   "fp": "green"
-  },
-  "08e 能力审计": {
-   "exit": "0",
-   "fp": "green"
+  "note": "\u5b58\u91cf\u57fa\u7ebf\u00b7\u95f8\u51b5\u53d8\u5316\u65f6\u672c\u811a\u672c\u4f1a\u5224\u7ea2\uff0c\u9700\u4eba\u5de5\u786e\u8ba4\u540e\u91cd\u751f\u6210\uff1b2026-10-29 \u4e8c\u6b21\u8bb0\u8d26\uff1d03/04/05 \u4e09\u95f8\u6309 80b49c0f \u5148\u4f8b\u7ecf\u7528\u6237\u88c1\u51b3\u8bb0\u5165\u73b0\u884c\u7ea2\u9879\u6307\u7eb9\uff0803=8a3cae0d0446/04=591b27250b36/05=de89589e49ed\uff09\u2014\u2014master \u540c\u503c\u590d\u73b0\u975e\u8fed\u4ee342\u65b0\u589e\uff08stash \u5bf9\u7167\u6cd5\u53d6\u8bc1\uff0c\u627f\u300c\u8fed\u4ee3 41 \u6d4b\u8bd5\u503a\u4fee\u590d\u300d\u6761\u76ee\u6269\u5c55\uff09\uff1b\u539f 2026-10-17 06 \u6761\u76ee\u4eba\u5de5\u91cd\u751f\u6210\u8bb0\u5f55\u89c1 git \u63d0\u4ea4\u53f2\uff1b2026-10-30 \u4e09\u952e\u6362\u4ee3\uff1d02/05/09 \u6309\u5de5\u7a0b\u5c0f\u4ef6\u6279\u56de\u6267 6a3203a8 \u5b9e\u6d4b\u7eff\u91cd\u951a\uff0802 \u5173\u8054\u6863\u5206\u72474/4\u5168\u7eff\uff0f05 \u6e32\u67d3\u95f8\u771f\u8dd1\u7eff\uff0f09 \u9759\u6001\u626b\u63cf\u7eff\u2014\u2014run_all \u9017\u53f7\u89e3\u6790\u4fee\u590d\uff0b\u6052\u771f\u4e94\u6761\u5224\u636e\u4fee\u6b63\u6279\uff0c\u4e09\u952e\u65e7\u7ea2\u6307\u7eb9\u5168\u90e8\u5f52\u7eff\u6d88\u9664\uff09",
+  "gates": {
+    "00 \u5192\u70df\u6d4b\u8bd5": {
+      "exit": "0",
+      "fp": "green"
+    },
+    "01 \u7cfb\u7edf\u6d4b\u8bd5": {
+      "exit": "0",
+      "fp": "green"
+    },
+    "02 \u5355\u5143\u4e0e\u96c6\u6210\u6d4b\u8bd5": {
+      "exit": "0",
+      "fp": "green"
+    },
+    "03 \u573a\u666f\u63a2\u9488": {
+      "exit": "0",
+      "fp": "green"
+    },
+    "05 \u6e32\u67d3\u95f8": {
+      "exit": "0",
+      "fp": "green"
+    },
+    "06 gdd_lint": {
+      "exit": "0",
+      "fp": "green"
+    },
+    "06b \u53d8\u66f4\u8bb0\u5f55\u8282": {
+      "exit": "0",
+      "fp": "green"
+    },
+    "07 doc_link": {
+      "exit": "0",
+      "fp": "green"
+    },
+    "08 doc_term": {
+      "exit": "0",
+      "fp": "green"
+    },
+    "08c \u6d41\u6c34\u7ebf\u95f8": {
+      "exit": "0",
+      "fp": "green"
+    },
+    "09 \u9759\u6001\u626b\u63cf": {
+      "exit": "0",
+      "fp": "green"
+    },
+    "10 \u71b5\u589e\u95f8": {
+      "exit": "0",
+      "fp": "green"
+    },
+    "08d \u5f15\u7528\u53ef\u6838": {
+      "exit": "0",
+      "fp": "green"
+    },
+    "08e \u80fd\u529b\u5ba1\u8ba1": {
+      "exit": "0",
+      "fp": "green"
+    }
   }
- }
 }

game/tests/run_all.gd

@@ -66,9 +66,10 @@ func _init() -> void:
 	for a in OS.get_cmdline_user_args():
 		if a.begins_with("--only="):
 			has_only = true
-			var term := a.trim_prefix("--only=").strip_edges()
-			if term != "":
-				only_terms.append(term)
+			for part in a.trim_prefix("--only=").split(","):
+				var term := part.strip_edges()
+				if term != "":
+					only_terms.append(term)
 		elif a == "--only-source=gates":
 			only_from_gates = true
 		elif a.begins_with("--shard="):

game/tests/static_scan.sh

@@ -334,7 +334,7 @@ else
     grep -rnE '\bawait\b' $S8_FILES 2>/dev/null | grep -vE '^[^:]+:[0-9]+:[[:space:]]*#' | grep -vE '"[^"]*\bawait\b[^"]*"'
     fail=1
   else
-    echo "[static_scan] S8 ok（扫描面 B1 文件集 9 个 .gd，await 零命中）"
+    echo "[static_scan] S8 ok（扫描面 B1 文件集 10 个 .gd，await 零命中）"
   fi
 fi
 

game/tests/unit/contracts/system_contracts_test.gd

@@ -63,8 +63,11 @@ func _test_rng_tag_closure(db) -> void:
 	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))
+	var unique_tags: Dictionary = {}
+	for t in RngServiceScript.PURPOSE_TAGS:
+		unique_tags[String(t)] = true
 	Kit.check("RngService 用途标签词表非空且互异（封闭语义由流改标签）",
-		RngServiceScript.PURPOSE_TAGS.size() > 0)
+		RngServiceScript.PURPOSE_TAGS.size() > 0 and unique_tags.size() == RngServiceScript.PURPOSE_TAGS.size())
 
 
 # ---- B1→D1 行协议：单据九栏缺省齐备 + 协议公共键形态 ----

game/tests/unit/core/breakpoint_resume_test.gd

@@ -8,6 +8,7 @@ extends SceneTree
 
 const SaveManagerScript := preload("res://core/save_manager.gd")
 const AdventureRunnerScript := preload("res://core/adventure_runner.gd")
+const BreakpointStoreScript := preload("res://core/breakpoint_store.gd")
 const Kit := preload("res://tests/unit/test_kit.gd")   # T6 收口：check/汇总退出样板单点（静默收集通道）
 
 var _bp_path := "user://test_breakpoint_resume.json"
@@ -182,7 +183,7 @@ func _init() -> void:
 		"P7 同种子重开局同图（开局入口复现承载）〔v7〕")
 
 	# ---- Part 8：断点字段登记单源（登记键集 == 写侧实拼字典键集；键名增删即红）----
-	var fields: Dictionary = AdventureRunnerScript.BREAKPOINT_FIELDS
+	var fields: Dictionary = BreakpointStoreScript.BREAKPOINT_FIELDS   # 断点域拆件改址——登记单源随件（判据零变化）
 	var reg_keys: Array = fields.keys()
 	reg_keys.sort()
 	var bp_keys: Array = bp_j.keys()

game/tests/unit/core/feat_vouchers_test.gd

@@ -48,7 +48,11 @@ func _init() -> void:
 	a.stop()._node_pending = {}
 	# 摘牌：选中即消尽（禁早退路径零摘牌）
 	var deck_refresh_before: int = a.deck().pool_stock("refresh")
-	Kit.check_quiet(deck_refresh_before == 0 or true, "牌库 refresh 令牌读数在域（投放 %d）" % deck_refresh_before)
+	var deck_refresh_quota := 0
+	for tier in db.run.adventure.TIERS:
+		deck_refresh_quota += int(db.run.adventure.curio_quota("refresh", String(tier)))
+	Kit.check_quiet(deck_refresh_before == deck_refresh_quota - 1,
+		"牌库 refresh 令牌读数=表配额−本会话已兑付一张（读数 %d／配额 %d）" % [deck_refresh_before, deck_refresh_quota])
 
 	# V9-2 储备金袋：待注入账 + 战首注入（节点级）
 	a.stop()._pending = {"candidates": [{"kind": "rap", "tier": "rare"}]}   # 停点候选直写（构造面——pick_curio 真实入口前置）

game/tests/unit/core/level_shop_economy_test.gd

@@ -570,6 +570,7 @@ func _smoke_level_graph() -> void:
 	var green_ok := true
 	var green_min_hp := 99999
 	var green_wins := 0
+	var green_hp_floor_ok := true   # 胜局 HP>0 旗（绿档记录义务——败局样本不入账，胜局 0 血即红）
 	for i in range(12):
 		var g_runner = load("res://core/level_runner.gd").new(_db, _fresh_rng(9100 + i))
 		g_runner.start_level(2, 9100 + i)
@@ -589,9 +590,11 @@ func _smoke_level_graph() -> void:
 			green_wins += 1
 			if int(g_box.get("hero_hp", 0)) > 0:
 				green_min_hp = mini(green_min_hp, int(g_box.hero_hp))
+			else:
+				green_hp_floor_ok = false
 	Kit.check("首遇位零踩雷：完美档 12 种子（节点 0 熊地精）恒零踩雷", green_ok)
 	Kit.check("首遇战胜局 ≥7/12（实际 %d——阶段拔高后锚行退出绿档，多数胜口径）" % green_wins, green_wins >= 7)
-	Kit.check("首遇战胜后 HP 下探读数 %d（>0——绿档记录）" % green_min_hp, green_min_hp > 0)
+	Kit.check("首遇战胜后 HP 下探读数 %d（>0——绿档记录）" % green_min_hp, green_hp_floor_ok and green_min_hp < 99999)
 	# ⑦ 跨表覆盖义务：L2 现行起关图每战斗/Boss 节点深度的敌侧落带 ≥ 请求深度（顶 clamp 消解即红）
 	# ＋每深度 board_gen 精确命中（判据实现与〔v11〕种子扫描段同源——_enemy_band_covers/_board_row_exact 单点）
 	var cov2 := _coverage_scan(2, nodes2)
@@ -675,6 +678,7 @@ func _smoke_level_graph() -> void:
 	# （零加成基线红档属预期——断言口径 = 成长代理档，非基线；跑法同 ⑥）
 	var green3_ok := true
 	var green3_min_hp := 99999
+	var green3_hp_floor_ok := true   # 胜局 HP>0 旗（绿档记录义务——胜局 0 血即红）
 	for i in range(12):
 		var g3_runner = load("res://core/level_runner.gd").new(_db, _fresh_rng(9100 + i))
 		g3_runner.set_hero_override(200, 100)
@@ -693,8 +697,10 @@ func _smoke_level_graph() -> void:
 			green3_ok = false
 		elif int(g3_box.get("hero_hp", 0)) > 0:
 			green3_min_hp = mini(green3_min_hp, int(g3_box.hero_hp))
+		else:
+			green3_hp_floor_ok = false
 	Kit.check("L3 首遇位绿档：成长代理档口径（atk_pct=200/hp_pct=100）完美档 12 种子首遇战（节点 0 灰矮人）全胜且零踩雷", green3_ok)
-	Kit.check("L3 首遇战胜后 HP 下探读数 %d（>0——绿档记录）" % green3_min_hp, green3_min_hp > 0)
+	Kit.check("L3 首遇战胜后 HP 下探读数 %d（>0——绿档记录）" % green3_min_hp, green3_hp_floor_ok and green3_min_hp < 99999)
 
 	# ⑫ 混编行集运行面正反断言：注入带键 (1,battle,5)/(1,battle,6) =
 	# L1 节点图与全部既有扫描面之外的新带键（带命中精确取注入行集——新 L 会被 ceil 封顶到 L3 不可用），

game/tests/unit/core/treasure_effects_test.gd

@@ -260,7 +260,7 @@ func _init() -> void:
 		if not overlay11.has(c_v):
 			overlay_ok = false
 	Kit.check_quiet(overlay_ok, "天眼正常：窗口全格入真视叠加层（危险格显示=C5 有差别开格）")
-	Kit.check_quiet(not ob11.minesweeper.clear_map_cleared() or true, "天眼开格走普通挖格链（连锁/资源兑付=fx_reveal 通道——免 AP 即效果本身）")
+	Kit.check_quiet(not ob11.minesweeper.clear_map_cleared(), "天眼开格走普通挖格链（连锁/资源兑付=fx_reveal 通道——免 AP 即效果本身）")
 
 	# ⑫ 信标网络（封印不限相邻/封印价照付）
 	var rng12 = load("res://core/rng_service.gd").new(); rng12.set_master_seed(311)

reports/工程改动报告-工程小件批-2026-10-30.md

@@ -0,0 +1,23 @@
+# 工程改动报告——工程小件批（run_all 解析／注释与消息订正／恒真断言五条／基线三键换代）
+
+> 接收方：待办清单「迭代 42 批末移交小件」「恒真与名实不符断言五条」「闸基线 02/05/09 三键换代」三条目（批后整条删除，本报告为过程凭据留档）。分支 engsmall-20261030，基点 14054d9d。
+
+## 改动清单
+
+| # | 件 | 改动 | 提交 |
+|---|---|---|---|
+| 1 | run_all.gd --only 逗号解析 | 解析段补 `split(",")` 拆分，对齐头注契约 `<词[,词…]>`；闸脚本关联档单旗标逗号拼接传参自此可用（此前多词必零命中 quit(2)，缺陷起于 6caf56b5） | d32ff342 |
+| 2 | level_runner.gd:12 信号注释 | `shop={gp}` → `shop={gp}（pool 态加 shelf:true）`，与发射点两形态（legacy/pool）对齐 | dd2de10e |
+| 3 | static_scan.sh S8 ok 消息 | 文件集 9→10（S8_FILES 实含 10 文件，board_installer.gd 随迭代 42 入集） | dd2de10e |
+| 4 | 恒真与名实不符断言五条 | ①feat_vouchers 恒真改绑投放装配面（读数==Σ表配额−本会话已兑付一张）；②treasure_effects 去恒真尾缀绑清图判定未触发；③④level_shop_economy 恒真 min 改绑胜局 HP>0 旗＋扫描面非空双条件；⑤system_contracts 互异半缺失补值集去重计数 | 6a3203a8 |
+| 5 | 基线 02/05/09 三键换代 | 按本批回执实测绿重锚（旧红指纹 f9865f1a5a44／de89589e49ed／1a9ad773489f 归绿消除），note 记账 | 28223074 |
+
+## 验收凭据
+
+- 孤立验证：逗号拼接四词形态 `--only=feat_vouchers,treasure_effects,level_shop_economy,system_contracts` 实跑四套件全绿（level_shop_economy 192 checks）——件 1 解析与件 4 判据同轮验证。
+- 批末闸：`run_all_gates.sh --code` 两次全绿。第一次（commit 6a3203a8，旧基线）02/05/09 三键「基线红→现绿（改善）」；重锚后第二次（commit 28223074）全绿无改善项，回执 domain=code、scope=related、dirty_game=false。
+- 件核：改后全仓 `or true` 残留零命中；五条旧形态清零。
+
+## 实现决定记录
+
+零拍板——五件修法均按待办登记既定方向执行，无超范围事项。件 1 修法选「解析补拆分」而非「闸脚本改逐词传参」：头注契约 `<词[,词…]>` 是文档承诺，实现向契约对齐，闸脚本零改动。

reports/需求卡片-gdstyle尾波补件批-2026-10-29.md

@@ -1,6 +1,6 @@
 # 需求卡片——gdstyle 尾波补件批
 
-> **版本状态**：v1.0 定稿——零待裁点（2026-10-29 用户裁：恢复尾波卡 v2.0 裁去的 D2/D4 两拆件项；D5 五降值键＝留债、零豁免延伸）。
+> **版本状态**：v1.1——2026-10-30 用户裁 T2 机制＝R2 整族归件（实现段停卡呈报 `reports/iter45-停机呈报-断点域拆件规格缺口-2026-10-30.md` 裁决），第 7 节 T2 条款改述、其余条款沿 v1.0 定稿——零待裁点（2026-10-29 用户裁：恢复尾波卡 v2.0 裁去的 D2/D4 两拆件项；D5 五降值键＝留债、零豁免延伸）。
 > **接收方**：待办清单条目「gdstyle 尾波补件批——悬停域与断点域拆件（2026-10-29 登记）」。
 > **来源**：尾波清偿批设计闭合后的用户再裁（D2/D4 改判拆件）。**唯一事实源**：`design/engineering/architecture/architecture.md` v1.25（「模块归属·呈现层」表 board_hover 行、「核心层」表 breakpoint_store 行、「冒险域拆分」节断点随动句、「呈现层装配」节屏成员寻址句）。
 
@@ -65,7 +65,7 @@ architecture.md v1.25 三处在册设计（2026-10-29 零豁免裁设计闭合
 **T2 breakpoint_store 拆件（1–1.5 工作日）**
 
 - [ ] 建 `game/core/breakpoint_store.gd`（RefCounted；构造＝引用束注入：db、rng、主角账三件、curio/stop/bank/loadout 引用——防 max-parameters 新键）
-- [ ] 断点域 6 成员＋`BREAKPOINT_FIELDS`＋函数族 9 个迁出（逐字搬运）；`resume_adventure` 留宿主薄壳；`set_save_manager` 转发件
+- [ ] 断点域 6 成员＋`BREAKPOINT_FIELDS`＋函数族 9 个归件（v1.1 R2 整族归件，机制＝所有权缝语句分家）：纯读侧三函数（`_bp_read`/`_bp_strategy`/`_bp_read_int`）逐字；`_bp_parts`/`_snapshot_breakpoint` body 逐字（宿主输入 state/level_index/master_seed/runner/adventure_counters 逐调传参——件不反向持宿主）；四 `_resume_*` 按所有权缝语句分家——件侧语句（主角账三件片段回填、curio 池与特性持有集还原、stop/bank 片段回填、六成员改写）迁入 store，宿主侧语句（summary/levels_total/level_index/_shop_mode/_treasure_unlocked/_attunement/_tree_rules/adventure_counters 重绑定与 `_reset_curio_state`/`_attune_refresh_x_total` 宿主调用）按原语句序吸收进 `resume_adventure` 壳，语句序逐步保形、27 键冻结；宿主保留 `_snapshot_breakpoint` 一行委托壳（CurioStop 的 Callable 目标零改）与 `set_save_manager` 转发件；宿主对六成员的其余读写点改址经件
 - [ ] `breakpoint_resume_test.gd:185` 改址为 breakpoint_store 常量（判据零变化——第 14 节申报）
 - [ ] 孤立验证：`--script res://tests/run_all.gd -- --only=breakpoint_resume,save_rng_roundtrip,cross_system_flow` 全绿＋`python tools/run_smoke.py`
 
@@ -103,7 +103,7 @@ architecture.md v1.25 三处在册设计（2026-10-29 零豁免裁设计闭合
 
 ## 11. 待裁点
 
-零待裁点，开工门=U0。（裁决记录：2026-10-29 用户裁——恢复 D2/D4 拆件；D5 五降值键留债、零豁免延伸；`_r0` 留宿主；断点域六成员全迁。）
+零待裁点，开工门=U0。（裁决记录：2026-10-29 用户裁——恢复 D2/D4 拆件；D5 五降值键留债、零豁免延伸；`_r0` 留宿主；断点域六成员全迁。2026-10-30 用户裁——T2 机制＝R2 整族归件、四 `_resume_*` 所有权缝语句分家、宿主侧语句吸收进壳；呈报=reports/iter45-停机呈报-断点域拆件规格缺口-2026-10-30.md。）
 
 ## 12. 落位与可复用性预检
 

reports/需求卡片-棋盘格边长口径收口批-2026-10-30.md

@@ -0,0 +1,183 @@
+# 需求卡片——棋盘格边长口径收口批（探针门槛纠偏＋格边长算式单点＋冒烟扩四档板型）
+
+状态行：v1.0 定稿——零待裁点（2026-10-30 用户裁：①探针不扩到 L3 推关；②最紧档 14×14 的可读断言落单元四档＋探针实板推定两处；③算式单点提取用私有静态名，依据见 §2 第 5 条）
+
+接收方：待办清单条目「棋盘格边长三方取值不一致——待扩板定档处置（2026-10-06 登记，来源=批次移交）」（`待办清单.md` 在册，状态「待写卡」）
+
+来源：**设计事实源**＝`design/gdd/ux/battle.md`「棋盘格尺寸公式」节（Last Updated 2026-10-29；格边长口径的**唯一事实源**——公式、可读下限 30px、结构钳制 [26,46] 三项都在此节）。指路文档（2026-10-26 已归一、不再存算例）＝`design/art/art-bible.md` §8.1／§8.2、`design/gdd/systems/表现与支撑/HUD框架.md`。四档板型事实源＝`game/data/tables/board_gen.tres`。
+
+## 1. 目标与完成定义
+
+这批做什么：把「棋盘格边长」在代码侧残留的两处旧口径收干净。文档侧已于 2026-10-26 归一（口径只剩 battle.md 一节），代码侧还差两件——探针的可读门槛仍是 12×12 时代的 36px（比 battle.md 的可读下限 30px 严 6px，属用旧值当新标准），格边长冒烟只跑 L1/L2（13×13 与 14×14 两档板型无断言）。本批顺带把格边长算式收成单点（现在它内联在 `set_cell_area` 里，任何「在别的板型/别的面积上求值」的需求都只能复写算式＝造第二口径）。
+
+**行为零变化**：算式逐位不变，`set_cell_area` 的副作用顺序（英雄脚锚重置 → `_refresh_slab` → `_update_world_size`）零改动，玩家可见画面零变化。
+
+完成定义（全部满足才算完）：
+1. 代码侧可读门槛＝30px，与 battle.md「可读下限 30px」一致；旧值 36 在 `game/` 下零残留。
+2. 格边长算式只剩一处落点（`BoardView._cell_for`），`set_cell_area` 只调它；探针与单元测试不再各自复写算式。
+3. 13×13 与 14×14 两档进入断言并在当轮真实跑批中执行通过（单元四档＋探针实板面积推定两条）。
+4. 代码域闸全绿；`tools/gdstyle_baseline.txt` 中 board_view.gd 各键只许持平或下降（MATCH——`max-public-methods` 保持 27）。
+5. 产出物三份落 `reports/`（实现报告／反哺点清单／验收审计报告），独立验收审计未过不合并。
+
+**编队注记与估时**：估时 **0.5 个工作日**（T0 0.1／T1 0.15／T2 0.1／T3 0.1／T4 0.05），远低于迭代冻结线（5 个工作日），可编批；编入哪个迭代由迭代编排段定。本批触面＝`game/presentation/views/board_view.gd`＋`game/probe/layout_probe.gd`＋`game/tests/unit/core/board_gen_reward_test.gd`＋`game/tests/README.md`（写卡段已同批入表），与在飞批次无文件交叠需编排段复核。
+
+## 2. 现状事实
+
+全部行号为 **2026-10-30 实查**——本批编入后须由 T0 按 T0 时点 master 重测重锚。
+
+1. 算式内联在 `game/presentation/views/board_view.gd:191-209`（`set_cell_area`）：`:194` N＝`maxi(width,height)`、`:195` `sep := SEP`（`SEP := 2`，`:34`）、`:196-197` `d := DEPTH_PX`（`8.0`，`:37`）与 `reserve := 24.0 + d`、`:198` 一条 `int(floor((minf(avail.x - 12.0 - d, avail.y - reserve) - float((n - 1) * sep)) / float(n)))`、`:199` `clampi(cell, 26, 46)`。副作用尾链 `:200-209`（英雄脚锚重置／`_refresh_slab`／`_update_world_size`）。
+2. 生产调用路径两条：`game/presentation/views/board_zone_view.gd:91-92`（`board_area.resized` → `set_cell_area(_board_area.size)`）与 `game/presentation/views/board_view.gd:250`（`rebuild` 末尾 `set_cell_area(size)`）——传入的都是棋盘视图实际可用区尺寸，`board_view` 为 `PRESET_FULL_RECT` 子级，故 `board_view.size` 即生产传入值。
+3. 探针门槛：`game/probe/layout_probe.gd:15` `const MIN_CELL := 36.0`，注释自陈「battle.md §棋盘格尺寸公式 1280 档 12×12 → 36px」；`:92-94` 断言 `cell < MIN_CELL` 记红。探针只进 L1（`:27` 起始冒险）、`:31` `press_candidate(0)`，故实跑只会遇到 10×10（格边约 45px），门槛 36 从未在 30–35px 区间生效过。
+4. 格边长冒烟：`game/tests/unit/core/board_gen_reward_test.gd:53-69`（`_smoke_layout_cell_formula`）：`:57` `for L in [1, 2]`、`:58` `generate(L, 0, ...)`、`:60` 样本 `avail := Vector2(1036, 460)`、`:63` 读 `board_view.get("_cell")`、`:64-66` 网格高 ≤ 可用高−24、`:67-68` 格边长 ∈ [26,46]。13×13 与 14×14 两档从未进入断言。
+5. **S13 顶格事实（本机 gdstyle v0.4.0 实测）**：`tools/gdstyle_baseline.txt:22` 登记 `game/presentation/views/board_view.gd|quality/max-public-methods = 27`，与实测公开方法数 27 相等。对同一文件副本加一个公开静态函数后实测升到 **28**（WORSENED 红）；改名为下划线前缀（`_cell_for`）后实测仍为 **27**（零新发现）。故算式提取必须用私有名。
+6. 四档板型取档（`game/data/tables/board_gen.tres` 实查 (level_index, node_depth) → 尺寸）：L1 depth 0–3＝10×10、L1 depth 4–6＝12×12、L2 depth 0–9＝12×12、L3 depth 0–8＝13×13、L3 depth 9–13＝14×14。即 `generate(1,0)`＝10、`generate(2,0)`＝12、`generate(3,0)`＝13、`generate(3,9)`＝14。
+7. 规格侧：`battle.md:137-146` 公式与两项判据——结构钳制区间 [26,46]px（`:143`，管算式不越界）、**可读下限 30px**（`:144`，管玩家能否看清，与钳制分开）；`:148-152` 算例表按「1280 档可用高 486px」推算 43/36/33/30，文内明标「随布局与板型变化，不是契约值」。
+8. 实机可用面积与算例不同源：`game/presentation/ui_assembler.gd:20-28` 结构为 B 区 252px ＋ C/D 两列占余高（该文件 `:24` 注释写明 548px），D 列内 `board_zone_view.gd:24-36` 再减 AP 条 44px 与 4px 间距——与 battle.md 算例假设的 486 可用高存在偏差（与待办清单在册的「B 区高度 270 vs 252」同源）。本卡不把算例当契约，实板可用面积一律以探针实读 `board_view.size` 为准。
+
+## 3. 设计契约（违反即返工，标 🔴 触碰＝L3 停机呈报）
+
+- 🔴 **算式单点**：格边长算式只在 `BoardView._cell_for` 一处；`set_cell_area` 只调它。探针、测试、任何新调用方都不得复写这条算式（复写＝造第二口径，本批立项原因就是三处口径打架）。
+- 🔴 **两个数不得合并**：可读下限 30px（battle.md 判据）与结构钳制 [26,46]px（算式不越界）是两个概念。前者只出现在探针门槛与断言里，后者只出现在 `_cell_for` 内；禁止用钳制区间替代下限判据，也禁止把下限塞进 `cell_for` 的 clamp。
+- 🔴 **私有名固定**：提取函数名必须是 `_cell_for`（下划线前缀）。依据＝§2 第 5 条的实测：公开名即令 `max-public-methods` 27→28 恶化。实现期「顺手改成公开方法更好看」＝L3。
+- 🔴 **行为零变化**：`set_cell_area` 的副作用顺序与数值逐位不变；`rebuild`／`resized` 两条调用路径不改；画面像素零变化。
+- 🔴 **测试削弱申报制**：允许改动的旧断言全集见 §8「测试削弱申报」，未申报的删改由独立验收审计判红。
+- 🔴 **禁变异类测试与撤销类取证**：不得靠回退 hunk 或注入破坏证明断言有效。
+
+## 4. 范围边界
+
+做：算式提取为 `_cell_for` 并改调；探针门槛 36→30 与注释改指 battle.md；探针新增「实板可用面积下 13/14 板格边长推定」断言与 board_view 零尺寸前置；格边长冒烟扩到四档板型并加算式单点等价断言；`game/tests/README.md` 能力行入表（写卡段同批，见 §5）。
+
+不做（明示去向）：
+1. **探针扩到 L3 推关**——2026-10-30 用户裁不做：成本是探针要真打穿两关（main 无跳关入口），且一旦红因是推关而非布局会污染该闸；最大板可读面改由 §7.3 的推定断言承担。
+2. **battle.md 算例表改数**——实现批禁写 `design/`；实测与算例的偏差走 §5 反哺点通道。
+3. **四档板型数值调整**——`board_gen.tres` 板尺寸由设计侧定，本批只读不写。
+4. **B 区高度 252 vs 270**——另一条在册待办（迭代 43 批后待裁三点），本批不碰。
+5. **`set_cell_area` 副产物顺序调整**——零触碰。
+6. **MC／数值验证**——无数值改动零跑。
+
+## 5. 关联文档同步面
+
+| 文档 | 关联点（本批实现会改变它的哪条陈述） | 同步义务 |
+|---|---|---|
+| design/gdd/ux/battle.md（设计权威——实现批禁直改） | ①`:148-152` 算例表按「可用高 486px」推算 43/36/33/30，而实机 D 列结构为 548px（§2 第 8 条）——探针实测格边长若与算例不符，是算例随布局漂移而非代码错；②「可读下限 30px」（`:144`）条本身不变，本批正是向它对齐 | 反哺点通道：把探针 L1 实测格边长与 13/14 推定读数逐条列进 `reports/iter<N>-反哺点-<日期>.md`（改哪一节＝`:148-152` 算例表、改成什么＝填实测值或标注「按旧布局口径」、依据＝实测读数），用户会话裁决后归文档批落文 |
+| game/tests/README.md（机械面——归写卡段维护） | 新增能力行「战斗屏三区几何与棋盘格边长（分辨率两档×四档板型）」，覆盖域表 HUD框架.md 行同步补名 | 写卡段已于本卡成文同批入表，实现批零增删零改行 |
+| design/gdd/systems/表现与支撑/HUD框架.md、design/art/art-bible.md §8.1／§8.2（已归一为指路） | 本批不改二者的任何陈述（2026-10-26 归一后它们只写规则与指针，不存算例与定值档） | 无（本行占位——按规约查不出也要写明） |
+
+## 6. 卡前文件结构图
+
+| 文件 | 职责 | 新增/复用 | 行为改动? |
+|---|---|---|---|
+| game/presentation/views/board_view.gd | 修改：`set_cell_area` 内联算式抽成 `static func _cell_for(n, avail) -> int`，`set_cell_area` 改调；注释补「算式唯一落点」句 | 复用既有（抽自本文件既有代码，不新增文件/类） | 否（算式逐位相同——对照表行 2 的等价断言承载） |
+| game/probe/layout_probe.gd | 修改：门槛 36→30＋注释改指 battle.md；新增 board_view 零尺寸前置与 13/14 板格边长推定断言 | 修改 | 是（守卫面变化——对照表行 1/4） |
+| game/tests/unit/core/board_gen_reward_test.gd | 修改：格边长冒烟循环扩四档板型＋板型一致断言＋算式单点等价断言 | 修改 | 是（测试面——对照表行 2/3） |
+| game/tests/README.md | 修改：能力清单加一行＋覆盖域表 HUD框架行补名 | 修改 | 否（机械面文档，写卡段同批完成） |
+
+不触碰：`board_zone_view.gd`、`ui_assembler.gd`、`data/tables/board_gen.tres`、全部 `core/` 与 `data/` 代码、其余探针与测试套件。
+
+## 7. 任务卡 T0..T4
+
+### 7.1 T0——读数重锚与取档对账（估时 0.1 个工作日）
+
+- [ ] 按 T0 时点 master 重测重锚 §2 全部行号：`layout_probe.gd:15`／`:92-94`／`:27`／`:31`、`board_view.gd:34`／`:37`／`:191-209`／`:250`、`board_zone_view.gd:91-92`、`board_gen_reward_test.gd:53-69`。
+- [ ] 四档取档复核：对 `db.combat.board_gen.resolve_row(L, D)` 逐组取 (1,0)(2,0)(3,0)(3,9)，实测返回 `board_width` 依次为 10/12/13/14——不符＝L3 停卡退回写卡段。
+- [ ] 改前基线读数（孤立验证）：`python tools/gdstyle_gate.py`（board_view.gd `max-public-methods` 实测 27 持平）＋单件跑 `board_gen_reward_test`（绿）＋单件跑 `layout_probe`（两档绿）。三条读数进实现报告 T0 节。
+- 取用：本卡 §2。产出：重锚后的行号与三份改前读数（T1–T4 对拍基准）。
+
+### 7.2 T1——算式单点提取（估时 0.15 个工作日）
+
+- [ ] `board_view.gd` 新增 `static func _cell_for(n: int, avail: Vector2) -> int`，函数体＝`:195-199` 五行算式逐字搬入（`SEP`／`DEPTH_PX` 仍读本文件既有常量，`clampi(..., 26, 46)` 留在该函数内），返回 `int`。
+- [ ] `set_cell_area` 的 `:194-199` 六行替换为 `_cell = float(_cell_for(maxi(_board.width, _board.height), avail))`；`:200-209` 副作用尾链一字不动。
+- [ ] `:189-190` 注释块补一句：算式唯一落点＝`_cell_for`（探针与单元测试共用）；名字带下划线是 S13 `max-public-methods` 27 顶格的约束，禁改公开名。
+- [ ] 孤立验证：单件跑 `board_gen_reward_test`（既有四套断言全绿＝算式等价性证明）＋`python tools/gdstyle_gate.py`（board_view.gd 各键持平，`max-public-methods` 仍 27）。
+- 取用：T0 读数。产出：`BoardView._cell_for(n: int, avail: Vector2) -> int`（公开静态调用面，T2/T3 逐字消费）。
+
+### 7.3 T2——探针门槛与最大板推定（估时 0.1 个工作日）
+
+- [ ] `layout_probe.gd:15` 改 `const MIN_CELL := 30.0`，注释改为「可读下限 30px（battle.md §棋盘格尺寸公式；结构钳制 [26,46] 管算式不越界，是另一回事）」。
+- [ ] 顶部加 `const BoardViewScript := preload("res://presentation/views/board_view.gd")`（静态调用载体）。
+- [ ] `_check_one` 在既有格子断言之后追加两段：①board_view 零尺寸前置——`bv.size.x <= 0.0 or bv.size.y <= 0.0` 时记问题「board_view 零尺寸（可用面积不可信，格边长推定无依据）」；②推定断言——对 `n in [13, 14]` 取 `BoardViewScript._cell_for(n, bv.size)`，`< int(MIN_CELL)` 即记问题，消息含实板可用面积、板型、算出的格边长与下限。
+- [ ] 收口 PASS 消息补一句「13/14 板推定 ≥30px」。
+- [ ] 孤立验证：单件跑 `layout_probe`（两档全绿）＋`tools/probe_gate.sh` 默认段（含本探针在内的默认段退出码 0）。
+- 取用：T1 `_cell_for`。产出：绿的两档探针日志（T4 对拍基准）。
+
+### 7.4 T3——格边长冒烟扩四档（估时 0.1 个工作日）
+
+- [ ] `_smoke_layout_cell_formula` 的 `:57` 循环集改为四档取样表：`[{L:1,D:0,n:10}, {L:2,D:0,n:12}, {L:3,D:0,n:13}, {L:3,D:9,n:14}]`（按 §2 第 6 条的实表取档）。
+- [ ] 每档追加两条断言：①板型一致——`maxi(b.width, b.height) == 取样 n`（表改动导致取样落错档时红）；②算式单点——`int(cell) == BoardViewScript._cell_for(n, avail)`（`set_cell_area` 写入值与纯函数返回同值）。
+- [ ] 既有两条断言（网格高 ≤ 可用高−24、格边长 ∈ [26,46]）逐字保留，仅把消息前缀从 `L%d` 扩成 `L%d D%d`；`:60` 样本 `Vector2(1036, 460)` 不改（本卡把「真实可用面积」的可读面交给探针，样本只承担算式不溢出面）。
+- [ ] 孤立验证：单件跑 `board_gen_reward_test`（四档全绿）。
+- 取用：T1 `_cell_for`、T0 取档对账。产出：四档冒烟日志（T4 对拍基准）。
+
+### 7.5 T4——批末收口与产出物落位（估时 0.05 个工作日）
+
+- [ ] 批末代码域闸：`tools/run_all_gates.sh --code` 全绿（本批改动含 `game/` 下非 `.md` 行为载体 → 代码域；02 单元与集成按关联档选跑 `board_gen_reward` 套件，冒烟／系统测试／静态扫描三件恒跑）。里程碑步出口跑一次全套；波内修复只做出红最小单元的最窄确认。
+- [ ] S13 键账对账：board_view.gd 各键持平（`max-public-methods` 27 不变、`max-class-variables` 32 不变、无 NEW 键）；探针与测试不在 S13 扫描面。
+- [ ] **产出物落位卡**（轻闸全绿后、合并前写齐，方算收口）：
+  - `reports/iter<N>-实现报告-<日期>.md`——各卡状态＋T0 三份改前读数与各卡改后读数对拍＋探针实读的 `board_view.size`（两档视口）与 L1 格边长实测值＋13/14 推定值＋实机目检总清单（登记不阻塞：「第三关 14×14 板格面数字清楚可辨」一项，时间由用户自定）。
+  - `reports/iter<N>-反哺点-<日期>.md`——§5 同步面第 1 行（battle.md 算例表 vs 实测）逐条有落点。
+  - `reports/iter<N>-验收审计-<日期>.md`——独立验收审计（未参与实现的会话或子代理执行，未过不得合并）。
+- 取用：T1–T3 全部产出。产出：代码域闸回执＋三份 reports/ 产出物。
+
+## 8. 验证闸（改动—验收对照表）
+
+本批三处改动全部落在守卫面（探针门槛／测试覆盖／算式落点），游戏行为零变化，故无新玩法验收；用户目检一项登记不阻塞（T4）。对照表 5 行对应 §1 完成定义第 1–5 条。
+
+| # | 需求点 | 改动（文件:行/行为） | 验收测试（名称＋落点＋尾缀） | 层级 | 真实入口 | 判据绑定面 | 能力行 |
+|---|---|---|---|---|---|---|---|
+| 1 | 探针可读门槛与 battle.md 对齐（36→30） | `layout_probe.gd:15` 常量与注释；`:92-94` 断言文本沿用 | 「layout_probe 两档几何不变量」`layout_probe.gd:_ready`（尾缀〔格边长 V1〕） | 探针 | `godot --headless --path game res://probe/layout_probe.tscn` | 探针经真实战斗屏装配读到 `board_view.cell_size` 且 ≥30px（下限判据直接作用于实机取值） | 新增：战斗屏三区几何与棋盘格边长（分辨率两档×四档板型） |
+| 2 | 算式单点（`_cell_for`） | `board_view.gd:191-209` 抽函数并改调；`:189-190` 注释补唯一落点句 | 「格边长算式单点等价」`board_gen_reward_test.gd:_smoke_layout_cell_formula`（尾缀〔格边长 V2〕） | 单元 | `godot --headless --path game --script res://tests/unit/core/board_gen_reward_test.gd` | `set_cell_area` 写入的 `_cell` 与 `BoardView._cell_for(n, avail)` 返回值逐档严格相等（同一事实两路读取，分叉即红） | 新增：战斗屏三区几何与棋盘格边长（分辨率两档×四档板型） |
+| 3 | 13×13／14×14 进入冒烟 | `board_gen_reward_test.gd:53-69` 循环集改四档取样＋板型一致断言 | 「格边长冒烟四档板型」同函数（尾缀〔格边长 V3〕） | 单元 | 同上 | 13/14 两档首次被断言：取档尺寸与实表一致、网格高 ≤ 可用高−24、格边长 ∈ [26,46]（此前从未执行） | 新增：战斗屏三区几何与棋盘格边长（分辨率两档×四档板型） |
+| 4 | 最大板可读推定（实板可用面积） | `layout_probe.gd:_check_one` 新增 board_view 零尺寸前置＋`n∈{13,14}` 推定断言 | 「最大板格边长推定」同探针（尾缀〔格边长 V4〕） | 探针 | `godot --headless --path game res://probe/layout_probe.tscn` | 以探针实读 `board_view.size` 代入 `_cell_for(13／14, size)` 得 ≥30px（真实容器尺寸下的最大板可读面——不推关即可覆盖） | 新增：战斗屏三区几何与棋盘格边长（分辨率两档×四档板型） |
+| 5 | 批末收口 | 全批 | 代码域闸：`tools/run_all_gates.sh --code` | 全量闸 | `tools/run_all_gates.sh --code` | 所选域全绿回执（`game/tests/.gates/receipt.json`） | 新增：战斗屏三区几何与棋盘格边长（分辨率两档×四档板型） |
+
+**测试削弱申报**（实现期允许的旧断言改动全集，超出即审计判红）：
+1. **探针门槛 36→30＝阈值放宽**，依据 battle.md `:144`「可读下限 30px」（旧值 36 是 12×12 旧锚点的误用，探针实跑从未触及 30–35px 区间，等于该门槛对大板无效）。补偿＝第 4 行新增推定断言与第 3 行四档冒烟——原门槛守不住的面由两者接管。
+2. 第 3 行循环集从 2 档扩到 4 档＝纯增量；`avail` 样本值不改；既有两条断言（网格高、区间）逐字保留。
+3. 探针新增断言＝纯增量，既有格子断言与两档视口表不改。
+4. 显式禁止：删任何旧断言、放宽区间 [26,46]、把格子读取从 `cell_size`／`_cell` 换成别的入口。
+
+**独立验收审计**：入口与报告＝`reports/iter<N>-验收审计-<日期>.md`；审计方＝未参与实现的会话或子代理，逐行核对对照表两端、抽查判据绑定面是否绑在被测改动特有的可观测面（`cell_size`／`_cell` 取值与 `_cell_for` 返回）、核对削弱申报、确认全文无变异／撤销类取证；未过不得合并。
+
+## 9. 异常分级
+
+- **L1 自救**：单件跑红→定位该件最小单元修后重跑；探针单件超时→孤立复跑该件；`--only` 选跑零命中（用法错 exit 2）→修正选词重跑。
+- **L2 记录继续**：同一红连续 3 次同因→在实现报告「实现决定记录」记因后继续最窄确认。
+- **L3 停机写报告等用户**：
+  1. **机检预算互斥＝上游缺陷停卡退回写卡段**——`gdstyle_gate` 出 NEW 键或 `board_view.gd|quality/max-public-methods` 升到 28（即 `_cell_for` 的下划线被去掉）；本批零新增文件、零新增成员，任何键恶化都不许改基线换绿，禁开豁免。
+  2. **实板可读面本身不达标**——探针实测 L1 `cell_size` < 30，或实板可用面积代入 13/14 后 < 30。这是产品面问题（不是断言错），停卡呈报，禁调低下限、禁换样本凑绿。
+  3. **四档取档对不上**——`resolve_row(1,0)/(2,0)/(3,0)/(3,9)` 实测尺寸与 §2 第 6 条不符（表已改而本卡未跟上）。
+  4. **算式等价性破**——T1 后既有四套断言出现改前不存在的红，说明提取改变了算式语义。
+
+## 10. 代拍板白名单（逐条列，超清单记实现报告「实现决定记录」）
+
+1. `_cell_for` 内部局部变量名与注释措辞（算式、常量、clamp 数值不变）。
+2. 四档取样表用字典数组还是三元组数组（取值与断言不变）。
+3. 探针推定断言与零尺寸前置的失败消息文案、PASS 消息措辞（判据不变）。
+4. 尾缀〔格边长 V1〕–〔格边长 V4〕的字样编排（含义不变）。
+5. `BoardViewScript` 常量名（preload 载体命名）。
+
+## 11. 待裁点
+
+**零待裁点，开工门＝U0。** 2026-10-30 用户三项裁定已定案：①探针不扩到 L3（推关成本与红因混淆，最大板改走推定断言）；②最紧档 14×14 的断言落两处（单元四档＋探针实板推定）；③算式提取用 `_cell_for` 私有名（§2 第 5 条 S13 实测依据）。编批由迭代编排段定。
+
+## 12. 落位与可复用性预检
+
+**复用面**：本批零新增文件、零新增类。`_cell_for` 抽自 `board_view.set_cell_area` 既有内联算式——不能只留在原处内联，是因为探针要在「非当前板型（13/14）× 真实可用面积」上求值、单元测试要在四档板型上求值，内联形态无法复用，复写算式就是造第二口径（正是本卡要消灭的缺陷形态）。探针与测试的既有工具件（`probe_ui_util.gd`、`test_kit.gd`）与本批职责无关，不复用也不扩展。
+
+**唯一面**：算式唯一落点＝`BoardView._cell_for`；可读下限 30px 的唯一代码判据面＝`layout_probe.MIN_CELL`（文本出处＝battle.md `:144`）；四档板型唯一事实源＝`board_gen.tres`（测试按 (L,D) 取行，不复制取值）。2026-10-30 实查 `game/` 下无 `cell_for`／`_cell_for` 同名或同义函数，无第二落点。
+
+**分层与交互面**：`_cell_for` 是无状态纯函数——零成员读写、零信号、零 RNG、零 UI 依赖、零 `load()`；调用路径＝`set_cell_area`（生产）／探针 `_check_one`（经脚本常量静态调用）／单元测试（同前）。preservation：不新增跨层依赖，Core 零 UI 红线零触碰（本批不触 `core/`）。
+
+## 13. 实现规范预算
+
+**新件三查**：本批零新增文件——三查不适用（写「无新增件」）。
+
+**存量触面一查**：触碰的存量件为 `board_view.gd`（S13 扫描面内）与探针／测试两件（不在 S13 扫描面）。`board_view.gd` 预期：`quality/max-public-methods` 保持 **27**（私有静态不计数，§2 第 5 条实测）、`quality/max-class-variables` 保持 32、`quality/max-branches|_paint_cell` 等函数级键持平（本批不增分支、不增成员、不增局部变量——`set_cell_area` 局部变量反而减少）。达成手段：算式整体搬出，函数体只留一行调用。
+
+**指标例外申报**：无。
+
+## 14. 源码级断言与探针契约面的随批义务（防漏项清单）
+
+1. `layout_probe` 的既有两档视口表（`VIEWPORTS`）与三条几何不变量（三区非零／不越视口／互不重叠／view 含于 D 区）本批零改动——T2 只追加断言，不改判据。
+2. `board_view` 的对外只读出口（`cell_size`，`board_view.gd:93-95`）是探针取值面，本批不动；测试内部读 `_cell`（测试惯例已如此，`board_gen_reward_test.gd:63`），不改为公开出口。
+3. `game/tests/README.md` 能力行由写卡段同批入表（本卡成文时已落），实现批不写该文件；批末核对表上名字与实况一致。

tools/ci_runner.sh

@@ -0,0 +1,92 @@
+#!/usr/bin/env bash
+# 本地 CI 跑批件——合回 master 后的全量验证执行器（git 钩子触发、后台运行，2026-10-30 用户裁）。
+# 触发语义（钩子只负责拉起，判定在本件）：
+#   merge  模式＝合回验证点：主工作区 git merge 落地后（tools/hooks/post-merge）对 master 尖无条件
+#          跑一次全量域闸；任务 worktree 内的合并不触发（钩子里限主工作区）。
+#   commit 模式＝红态追绿：仅当最近一次 CI 判红时（tools/hooks/post-commit）本提交触发复验；
+#          绿态与无状态零触发——小批直提不重复跑全量，有意义的重跑只剩「验证修复」一类。
+# 并跑语义＝跑完补跑（coalesce，2026-10-30 用户裁）：跑批期间新触发不中断当前轮——锁被占时，
+#   在跑实例的尖端就是当前尖端则本触发无事可做，否则落 ci.rerun 标记；当前轮跑完见标记或尖端
+#   前移，对最新尖端自动补跑一轮。绝不逐笔触发各跑一轮，最终只测最新尖端。
+# 产物（均不入库，本目录 .gitignore 已收）：ci-status.json＝最新一跑判定（commit/verdict/红闸/
+#   关键日志行/耗时），ci-history.jsonl＝逐次流水账，ci.log＝当轮全量闸完整输出，
+#   ci.lock＝锁目录（内含在跑尖端），ci.rerun＝补跑标记。
+# 用法: tools/ci_runner.sh merge|commit
+set -u
+REPO="$(cd "$(dirname "$0")/.." && pwd)"
+GATES_DIR="$REPO/game/tests/.gates"
+LOCK="$GATES_DIR/ci.lock"
+RERUN="$GATES_DIR/ci.rerun"
+STATUS="$GATES_DIR/ci-status.json"
+HISTORY="$GATES_DIR/ci-history.jsonl"
+LOG="$GATES_DIR/ci.log"
+GODOT="${GODOT_BIN:-/d/code/godot/Godot_v4.7.2-stable_win64_console.exe}"
+export PYTHONIOENCODING=utf-8
+
+MODE="${1:-commit}"
+
+# ── 触发判定 ──
+if [ "$MODE" = "commit" ]; then
+	[ -f "$STATUS" ] || exit 0
+	grep -q '"verdict": "red"' "$STATUS" || exit 0
+fi
+
+# ── 锁（mkdir 原子）；被占时按在跑尖端判定：同尖＝已在验这份字节，异尖＝落补跑标记 ──
+TIP="$(git -C "$REPO" rev-parse HEAD)"
+if ! mkdir "$LOCK" 2>/dev/null; then
+	if [ "$(cat "$LOCK/tip" 2>/dev/null)" = "$TIP" ]; then
+		exit 0
+	fi
+	touch "$RERUN"
+	exit 0
+fi
+trap 'rm -rf "$LOCK"' EXIT
+
+# ── 跑批主循环（跑完补跑）──
+while :; do
+	rm -f "$RERUN"
+	TIP="$(git -C "$REPO" rev-parse HEAD)"
+	echo "$TIP" > "$LOCK/tip"
+	_start="$(date +%s)"
+
+	# 起手刷类名缓存：.godot 缓存不入 git，与合并后代码失配会假红假绿（在册坑）——
+	# 原「合并后零复跑」的秒级动作由本件接管，全量闸跑的就是刷新后的字节
+	"$GODOT" --headless --path "$REPO/game" --editor --quit >>"$LOG" 2>&1
+
+	bash "$REPO/tools/run_all_gates.sh" >"$LOG" 2>&1
+	RC=$?
+	_end="$(date +%s)"
+
+	# 判定与记录：读闸脚本写的回执（all_green／各闸退出码），红项关键行取自本轮 ci.log
+	python - "$REPO" "$TIP" "$RC" "$((_end - _start))" <<'PY'
+import json, re, sys, datetime
+repo, tip, rc, dur = sys.argv[1], sys.argv[2], int(sys.argv[3]), int(sys.argv[4])
+gates_dir = repo + "/game/tests/.gates"
+entry = {"commit": tip,
+         "timestamp": datetime.datetime.now().astimezone().isoformat(timespec="seconds"),
+         "exit_code": rc, "verdict": "green" if rc == 0 else "red",
+         "duration_s": dur, "red_gates": [], "key_lines": []}
+try:
+    with open(gates_dir + "/receipt.json", encoding="utf-8") as f:
+        r = json.load(f)
+    entry["red_gates"] = [g["name"] for g in r.get("gates", []) if str(g.get("exit")) != "0"]
+except Exception:
+    pass
+try:
+    with open(gates_dir + "/ci.log", encoding="utf-8", errors="replace") as f:
+        lines = [l.rstrip() for l in f]
+    entry["key_lines"] = [l for l in lines if re.search(r"FAIL|红项|Error|error", l)][-12:]
+except Exception:
+    pass
+with open(gates_dir + "/ci-status.json", "w", encoding="utf-8") as f:
+    json.dump(entry, f, ensure_ascii=False, indent=1)
+with open(gates_dir + "/ci-history.jsonl", "a", encoding="utf-8") as f:
+    f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+PY
+
+	# 轮尾补跑判定：跑批期间有新触发（标记在）或尖端前移 → 对最新尖端再来一轮
+	_newtip="$(git -C "$REPO" rev-parse HEAD)"
+	if [ ! -f "$RERUN" ] && [ "$_newtip" = "$TIP" ]; then
+		exit 0
+	fi
+done

tools/hooks/post-commit

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+# 红态追绿钩子（本地 CI 触发钩子，2026-10-30 用户裁）——仅当最近一次 CI 判红时，本提交触发
+# 后台复验（tools/ci_runner.sh commit，判定在跑批件内）；绿态与无状态零触发——
+# 小批直提不重复跑全量，同一份字节禁止第二次人手跑。主工作区限定。
+set -u
+_GD="$(cd "$(git rev-parse --git-dir)" && pwd)"
+_CD="$(cd "$(git rev-parse --git-common-dir)" && pwd)"
+[ "$_GD" = "$_CD" ] || exit 0
+REPO="$(git rev-parse --show-toplevel)"
+( nohup bash "$REPO/tools/ci_runner.sh" commit >/dev/null 2>&1 & )
+exit 0

tools/hooks/post-merge

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+# 合回验证点（本地 CI 触发钩子，2026-10-30 用户裁）——主工作区 git merge 落地后无条件触发
+# 全量域闸后台跑批（tools/ci_runner.sh merge，约 4 分钟，不阻塞合并动作本身）。
+# 任务 worktree 内的合并不触发（CI 只认 master；worktree 批要提前验证就手动跑 ci_runner.sh）。
+# CI 红了不回滚合并——红项记入 game/tests/.gates/ci-status.json，修复提交经 post-commit 追绿。
+set -u
+_GD="$(cd "$(git rev-parse --git-dir)" && pwd)"
+_CD="$(cd "$(git rev-parse --git-common-dir)" && pwd)"
+[ "$_GD" = "$_CD" ] || exit 0
+REPO="$(git rev-parse --show-toplevel)"
+( nohup bash "$REPO/tools/ci_runner.sh" merge >/dev/null 2>&1 & )
+exit 0

tools/hooks/pre-commit

@@ -1,31 +1,15 @@
 #!/usr/bin/env bash
-# 直改车道闸（git pre-commit，2026-10-26 车道铁律）——staged 不含代码面的提交，提交点现场跑
-# 文档域闸（tools/run_all_gates.sh --docs，秒级文本扫描）：绿＝落地，红＝中止。
-# 代码面＝game/ 下非 .md 的行为载体（判据与改动域划分同一）。staged 含代码面时：
-# 主工作区＝拦（代码面唯一合法路径＝worktree 批合回）；任务 worktree＝跳过（归批末闸＋合回闸管，
-# 不打扰迭代批中间提交）。--no-verify 绕过仅属用户（agent 侧由 worktree-guard 拦截）。
+# 直改车道闸（git pre-commit，2026-10-30 本地 CI 化换代）——提交点现场跑文档域闸
+# （tools/run_all_gates.sh --docs，秒级文本扫描）：绿＝落地，红＝中止。
+# 代码面提交不再拦（2026-10-30 用户裁：主区直改全面放开）——代码验证归合回后的本地 CI
+# （tools/hooks/post-merge 全量跑批；CI 红态下 tools/hooks/post-commit 追绿复验）。
+# 合并收尾提交跳过（MERGE_HEAD 在＝冲突合并的收尾 commit）——内容归合回后的 CI 全量验。
+# --no-verify 绕过仅属用户（agent 侧由 worktree-guard 拦截）。
 set -u
 REPO="$(git rev-parse --show-toplevel)"
 
-# staged 路径集（首提交无 HEAD 时对 --root 比）；空集放行，交回 git 自身报「无改动可提」
-if git rev-parse --verify -q HEAD >/dev/null 2>&1; then
-	STAGED="$(git diff --cached --name-only)"
-else
-	STAGED="$(git diff --cached --name-only --root)"
-fi
-[ -z "$STAGED" ] && exit 0
-
-# 代码面判定：staged 里任一路径落在 game/ 且非 .md
-if printf '%s\n' "$STAGED" | grep '^game/' | grep -viE '\.md$' | grep -q .; then
-	# 主区判定：git-dir 与 common-dir 同一＝主工作区（非链接 worktree）
-	_GD="$(cd "$(git rev-parse --git-dir)" && pwd)"
-	_CD="$(cd "$(git rev-parse --git-common-dir)" && pwd)"
-	if [ "$_GD" = "$_CD" ]; then
-		echo "[直改闸] 主工作区禁止直提代码面（game/ 下非 .md）——代码面改动走迭代批独立 worktree（git worktree add ../g-plan2-<任务名> -b <任务分支>），收尾在主工作区 git merge --no-ff 合回。" >&2
-		exit 1
-	fi
-	exit 0
-fi
+# 合并收尾提交：跳过文档闸，交合回后 CI
+[ -f "$(git rev-parse --git-dir)/MERGE_HEAD" ] && exit 0
 
 RC=0
 bash "$REPO/tools/run_all_gates.sh" --docs || RC=$?

tools/run_all_gates.sh

@@ -1,14 +1,12 @@
 #!/usr/bin/env bash
-# 验证闸唯一入口（全部验证闸的清单与域划分，批末与合回按改动域跑）——
-# 闸清单的唯一定义处。文档只写「收口跑本脚本」，禁在文档里另列闸件清单（那正是 iter27
+# 验证闸唯一入口（全部验证闸的清单与域划分）——
+# 闸清单的唯一定义处。文档只写「验证跑本脚本」，禁在文档里另列闸件清单（那正是 iter27
 # 漏跑 probe_gate --full 的成因：清单散落三份文档、彼此不一致、且无机器校验）。
 #
 # 跑完写回执 game/tests/.gates/receipt.json（commit＋内容树哈希＋各闸退出码＋存量基线比对＋时间戳）；
-# .zcode/hooks/worktree-guard.sh 在主工作区 git merge 时校验本回执，缺或红即拦截。
-#
-# 本脚本是合回前的终局动作：跑之前先冻结（代码与断言不再改）并把 master 并入本分支；每批只跑
-# 一次。回执必须覆盖住分支尖的代码面（game/ 下非 .md 的行为载体）——闸后再改一个代码面文件，
-# 回执即作废须重跑；跑闸时若代码面还带着未提交改动，回执会标 dirty_game，合回闸拒绝采信。
+# 本地 CI（tools/ci_runner.sh，2026-10-30 用户裁）读回执写 ci-status.json——强制验证点＝合回 master
+# 后 post-merge 钩子触发的全量跑批；本脚本手动调用（--code/--docs/全量档）只服务开发期按域跑批。
+# 跑闸时代码面带着未提交改动，回执会标 dirty_game（验的不是 HEAD 字节），CI 判定照常落账留痕。
 #
 # 用法：tools/run_all_gates.sh [--code|--docs|--quick]
 #   --code  只跑代码域闸（00 冒烟测试／01 系统测试／02 单元与集成测试／03 场景探针／
@@ -98,7 +96,7 @@ fi
 # 每次跑批前自愈重建，避免「清目录重跑」把 .gitignore 一起带走。
 mkdir -p "$STAMP_DIR"
 if [ ! -f "$STAMP_DIR/.gitignore" ]; then
-	printf '# 本目录只入库 baseline.json（存量基线，需随代码走以保证各 worktree 判定口径一致）。\n# receipt.json 是每跑批覆写的当次回执、*.log 是跑批当场日志——两者都是中间产物，不入库。\nreceipt.json\n*.log\n' \
+	printf '# 本目录只入库 baseline.json（存量基线，需随代码走以保证各 worktree 判定口径一致）。\n# receipt.json 是每跑批覆写的当次回执、ci-status.json/ci-history.jsonl 是本地 CI 判定与流水账、\n# ci.lock/ci.rerun 是跑批件锁与补跑标记、*.log 是跑批当场日志——均为中间产物，不入库。\nreceipt.json\nci-status.json\nci-history.jsonl\nci.lock\nci.rerun\n*.log\n' \
 		> "$STAMP_DIR/.gitignore"
 	echo "[gates] 已自愈重建 $STAMP_DIR/.gitignore"
 fi

待办清单.md

@@ -2,21 +2,6 @@
 
 本清单是流水线的唯一登记处：要做的事先在此登记一条，随流水线段推进改状态，做完整条删除；各系统文档的「待办」节只留一行指路存根，不再自建条目。条目格式（标题＝登记元数据含可选优先级，正文＝实况/缺口/改动面/状态四属性）与状态机以 [doc-conventions §12.1](design/engineering/doc-conventions.md) 为权威。
 
-#### 迭代 42 批末移交小件——工具与注释四条（2026-10-30 登记，来源=批次移交）
-
-**实况**：证据＝迭代 42 实现报告 §5-1/§5-5/§5-6 与验收审计报告表述性瑕疵 3/4（已按吸收即死退役，git 历史可考）。逐条：
-
-| # | 事项 | 要点 |
-|---|---|---|
-| 1 | run_all.gd --only 逗号形态解析缺陷 | 头注文档形态 `--only=<词[,词…]>` 与闸脚本传参形态（tools/run_all_gates.sh 关联档选跑逗号拼接单旗标）自 6caf56b5 起与解析不符——整串当一个词对套件路径做子串匹配，多词必零命中 quit(2)；修法二选一：run_all.gd 补逗号拆分，或闸脚本改逐词重复 `--only=` 传参（迭代 42 施工曾以逐词重复形态绕过） |
-| 2 | 坑速查补条 | .zcode/skills/iter/SKILL.md「坑速查」节补条：worktree 冷检出 --editor --quit 首跑 --path 误指仓库根（未建 .godot 类缓存致首跑解析红），改指 game 切片目录重刷后正常 |
-| 3 | level_runner.gd:12 node_entered 信号注释陈旧 | 注释 `shop={gp}` 与 pool 态实际载荷 `{gp, shelf:true}` 不符（迭代 42 改动前即如此，本批未触载荷） |
-| 4 | static_scan.sh S8 ok 消息陈旧字面量 | :337「扫描面 B1 文件集 9 个 .gd」——S8_FILES 实含 10 文件（board_installer.gd 随迭代 42 入集），扫面无缩小，仅消息文本过期 |
-
-**改动面**：游戏代码＋工具代码
-
-**状态**：待执行
-
 #### 迭代 43 批后待裁三点——B 区高度对齐／名字行字号档位／换色常量退役（2026-10-30 登记，来源=批次移交）
 
 **实况**：证据＝迭代 43 反哺点清单 1/8/10（已按吸收即死退役，git 历史可考）。①**B 区高度 270 vs 252**——battle.md 区表文 270、代码 252，18px 差异；样张按代码 252 出（样张反映实机）。②**站桩名字行 12px 档位归属**——standee_body.gd 名字行取 `UiKit.FS_CAPTION`（12px），art-bible §7.4 字号档位表下属「清单外 11–13px」。③**art-bible §4.1 换色合并残余三处**——`STAGE_BG` 换值（#3E342A→#3E362C）未执行；`STAND_STONE_RIM`（#C4AC84）仍被 board_cell_unit 口沿高光在役引用；`STAND_STONE_EDGE`（#5A4C3A）由地台缺位回退路径在役引用。
@@ -68,14 +53,6 @@
 
 **状态**：文档设计已闭合
 
-#### 恒真与名实不符断言五条——判据缺陷修正（2026-10-29 登记，来源=会话提及）
-
-**实况**：存量断言精简 A+B 批余账④转正：五条断言属判据缺陷（恒真占位或名实不符），不是冗余合并可解的账，按 test-conventions §8.4 真实入口口径逐条修正，不计入精简条数。逐条：①`game/tests/unit/core/feat_vouchers_test.gd:51` cond 为 `deck_refresh_before == 0 or true`——恒真；②`game/tests/unit/core/treasure_effects_test.gd:263` cond 尾缀 `or true`——恒真；③`game/tests/unit/core/level_shop_economy_test.gd:593` `green_min_hp > 0`——初值 99999、仅 hp>0 分支取 min，恒真；④同文件 `:696` `green3_min_hp > 0`——同型恒真；⑤`game/tests/unit/contracts/system_contracts_test.gd:66-67` 标签称「非空且互异」而 cond 只查 `size() > 0`——互异半缺失，名实不符。修正方向：能绑判据的改绑真实可观测面（互异改值集去重计数、HP 读数改与门槛比对），造不出可观测面的按 §8.4 出口停卡呈报。
-
-**改动面**：游戏代码
-
-**状态**：待执行
-
 #### 断言提取器改版——覆盖 Kit.check_quiet 静默通道（2026-10-29 登记，来源=会话提及）
 
 **实况**：`tools/extract_checks.py:67` 的 `CALL_RE = check\(` 只认即时通道，静默收集通道 `Kit.check_quiet(cond, desc)` 静态站点实测 407 个在提取口径外（证据＝`grep -rn "check_quiet(" game/tests --include="*.gd"` 实数；test-conventions §5.2 已备案该工具局限）。能力清单以 `文件:函数` 为锚，不受影响；但要把断言面全账纳入机器对账（重建账本或全量断言面审计），须先改版提取器：识别 `check_quiet(` 并按反参序（cond 在前）提取标签与 cond。改版后须以全量套件跑一遍 `--diff` 自证提取面覆盖、且 `Kit.check(` 与 `check_quiet(` 不双计。
@@ -92,14 +69,6 @@
 
 **状态**：待执行
 
-#### 闸基线 02/05/09 三键换代——存量红指纹已消除或现行不复现（2026-10-29 登记、2026-10-30 并入 05，来源=批次移交）
-
-**实况**：证据＝迭代 41 测试债批代码域闸实测（worktree 分支 `testdebt-20261029`，回执 commit afd1a41f、域=code、scope=full、零新增红），02 单元与集成与 09 静态扫描两闸判「基线红 → 现绿（改善）」；05 渲染闸在 2026-10-30 脚本错误扫描批主区真跑 `bash tools/render_gate.sh` exit=0 全绿（shot/fx/board 三段扫描零命中、残留 Godot=0、golden changed 0.00%），其红键在现行主区不复现。基线 `game/tests/.gates/baseline.json` 里这三键仍记着历史红指纹（02 fp f9865f1a5a44＝9 套件失败；05 fp de89589e49ed；09 fp 1a9ad773489f＝S9 24 处＋S10 4 处＋S11 1 处），留着不动的后果＝日后同类红回归会被判「存量红·对基线零新增」静默放行。待做＝三键按归绿实测重生成（写 exit=0／绿指纹），改的是 `game/` 下非 .md 文件＝代码面，须随下一个代码批在 worktree 内一并落、禁主区直改；05 须在素材齐盘预检后跑出真值（冷检出空盘态下的渲染红不作数）。人工确认凭据＝上述回执、reports/迭代41测试债批-实现报告-2026-10-29.md 第三节与本批提交说明。本条目无设计段（机械重锚），不走写卡与编排。
-
-**改动面**：游戏代码
-
-**状态**：待执行
-
 #### gdstyle 尾波补件批——悬停域与断点域拆件（2026-10-29 登记，来源=会话提及）
 
 **实况**：尾波卡 v2.0 裁去的 D2/D4 两拆件项经用户再裁恢复（2026-10-29，零豁免延伸＋D5 留债）。设计闭合凭据＝architecture.md v1.25（呈现层表 board_hover 行／核心层表 breakpoint_store 行／「冒险域拆分」节随动句）。需求卡片：reports/需求卡片-gdstyle尾波补件批-2026-10-29.md（v1.0 定稿零待裁点）。范围：board_view 拆 board_hover（11 函数族＋2 成员，`_r0` 留宿主）＋adventure_runner 拆 breakpoint_store（6 成员＋`BREAKPOINT_FIELDS` 27 键冻结函数族，`resume_adventure` 留宿主薄壳）。键账预期：board_view 类变量 32→约30、公开方法 27 持平、adventure_runner 类变量 28→约22——三键**留债**（键留基线冻结禁恶化、禁落豁免登记）。编队：待迭代 42 合回后编入；与呈现层状态件批同代时其先行（u.st 写入面改型后 hover 拆件在新面上施工）。估时 2.5–3.5 工作日。