秘宝批T7组E-2：内部标识符全族换词（inventory/unlocked/replace/overlays/slot/settlement use_aux等60+token）+存档键零触碰专项核通过（37文件六键普查零差异，点号访问零存在）+行为探针四件全绿+任务书§1.2基线回填（755/0实测）

design/gdd/systems/冒险循环/奇物.md

@@ -19,7 +19,7 @@
 
 一次冒险要走三关，如果走完时角色和开局毫无区别，中途的每一次取舍就都不算数了。奇物就是那个把"这一局玩成了什么样"落下来的东西：让玩家在冒险过程中不断变强，且每一局变强的方向不同。
 
-它同时要和跨冒险的成长隔开：永久保留的东西是[魔法道具](../排雷循环/魔法道具.md)（带在身上的物品）与[元进度](../跨局循环/元进度.md)（账号级的树），奇物只在当局存在，冒险收束即清零——它不是"你的存档变强了"，而是"这一次下矿的你变强了"。
+它同时要和跨冒险的成长隔开：永久保留的东西是[魔法道具](../排雷循环/秘宝.md)（带在身上的物品）与[元进度](../跨局循环/元进度.md)（账号级的树），奇物只在当局存在，冒险收束即清零——它不是"你的存档变强了"，而是"这一次下矿的你变强了"。
 
 **边界判据（一句话）**：**一次冒险内获得、冒险收束即清零的，是奇物；跨冒险跟着你走的，是魔法道具。**
 
@@ -270,7 +270,7 @@
 
 | 相邻概念 | 关系（只写关系，不写对方的规则） |
 |---|---|
-| [魔法道具](../排雷循环/魔法道具.md) | 最需要分清的一对，判据是生命周期：**奇物当局清零，魔法道具跨冒险保留**。两者互不相通——奇物永不进同调位，魔法道具永不进当局随机渠道。 |
+| [魔法道具](../排雷循环/秘宝.md) | 最需要分清的一对，判据是生命周期：**奇物当局清零，魔法道具跨冒险保留**。两者互不相通——奇物永不进同调位，魔法道具永不进当局随机渠道。 |
 | [元进度](../跨局循环/元进度.md)（树） | 树管账号永久的规则与容量，奇物管当局构筑，两层互不代替。 |
 | [战斗结算](../战斗循环/战斗结算.md) | 专长的挂点位于结算管线的各段；挂点清单与语义归结算文档。 |
 | [行动经济](../排雷循环/行动经济.md)、[地形变异](../排雷循环/地形变异.md) | 部分挂点落在行动点结转与地形处理上，语义归各自文档。 |

design/research/任务书-秘宝代码词族对齐批-2026-10-05.md

@@ -28,6 +28,8 @@
 | 5 | 收口五步 | active.md 快照 / 台账条目 / roadmap 里程碑行 / stage.txt（如变）/ 闸序列留痕 |
 
 > ⚠️ **基线纪律**：迭代 15 调试整合批已把冒烟推进到 **747 项**。本批开工前必须重测基线取实际值（本任务书不写死数字，T0 复核后回填），**禁止用本文档的历史数字当闸门**。
+>
+> ✅ **T0 回填（2026-10-05 实测，主区 3c4291d 实跑）**：冒烟基线 = **755 项 / 0 失败**（§1.2 的 747 与判式批出口 750 均系②批前旧数，作废）；run_all = 15 套件 14 绿，唯一红 = `reward_overlay_test.gd`（**② 奇物批遗留基线红**，与本批无关，对照口径=零新增）；词族实数 = **364 处 / 36 文件**（§2 F1 的 358 处系②批前口径）；`treasure_*` 词根全仓零冲突；§4.1 六存档键引用普查 HEAD↔批末逐键零差异。
 
 ## 2. 现状事实（代码级，T0 须自行复核）
 

game/core/adventure_runner.gd

@@ -43,7 +43,7 @@ extends RefCounted
 signal level_started(level_index: int, display_name: String)   # 每关开始（含冒险首关）——呈现层重取 runner()、刷新图条与层名行
 signal bonus_choice_presented(payload: Dictionary)             # 提升三选一停点（非末关通关恰一次；迭代 10 大奖励重构——big_reward_paid 退役）——{level_index, candidates, heal_gained, hp_before, hp_after, keystone_gained, keystone_total, gp, aux_cleared}
 signal bonus_resolved(result: Dictionary)                      # 三选一兑付完成（pick_bonus/替换受理后恰一次）——{picked, value, hp_before, hp_after, level_index}
-signal aux_replace_presented(items: Array, incoming: Dictionary)  # 同调位满位替换子交互（pick_bonus 道具件满位时）——items=现有持有件记录、incoming=新件记录
+signal treasure_replace_presented(items: Array, incoming: Dictionary)  # 同调位满位替换子交互（pick_bonus 道具件满位时）——items=现有持有件记录、incoming=新件记录
 signal adventure_finished(summary: Dictionary)                 # 冒险结算（completed/failed/abandoned）——summary 五件事：打穿没有/通关几关/止步第几关/钥石合计/主种子（+additive keystone_drops 迭代 10）
 # ---- 转发族（签名与 LevelRunner 同款——呈现层对接透明；ADR-0001 S6 经 _forward_* 方法）----
 signal node_entered(node: Dictionary, info: Dictionary)
@@ -70,12 +70,12 @@ var _last_level_payload := {}             # 最近一次关卡结束载荷（失
 var _override := [0, 0]                   # 调试浮窗百分比通道 [atk_pct, hp_pct]（每关新 runner 都要应用）
 var _base_override := {"atk": 0, "max_hp": 0, "armor_class": 0}
 var _first_script := false                # 首次脚本模式（关卡节点图生成 v0.4——true = 全关零抽签取池内模板 0；测量夹具恒 false）   # 永久强化 flat 注入（元进度实现批——冒险开始参数面 params.hero_override 存入，共享给 LevelRunner；全零 = 白板）
-var _last_aux_cleared := 0                 # additive（迭代 7 T4——最近一次关卡末清空计数，summary 取数面）
-var _aux_unlocked := {}                   # aux 解锁门控集（迭代 7 T5——params.aux_unlocked 接收面）
+var _last_treasure_cleared := 0                 # additive（迭代 7 T4——最近一次关卡末清空计数，summary 取数面）
+var _treasure_unlocked := {}                   # aux 解锁门控集（迭代 7 T5——params.treasure_unlocked 接收面）
 var _attunement: Array = []               # 同调装配集（迭代 11 第①批 T5——params.attunement 接收面，start_level 外下传 LevelRunner）
 var _attune_refresh_x := 0                # 刷新件余量（迭代 11 第①批 T5b P1 甲——每碰三选一重置=X 表值；优先消耗、不结转）
 var _attune_refresh_y := 0                # Y 冒险周期池（开局参数面注入，用完即无——营地升级行表值）
-var attune_charges := {}                  # 同调主动件冒险充能账本（迭代 11 第①批 T6——跨关卡共享 dict；settlement use_aux 扣减直改同引用；断点随 attunement_charges 键入档）
+var attune_charges := {}                  # 同调主动件冒险充能账本（迭代 11 第①批 T6——跨关卡共享 dict；settlement use_treasure 扣减直改同引用；断点随 attunement_charges 键入档）
 var _save_manager = null                  # 断点承载注入（迭代 8 卡①——null = 不写断点；模拟/冒烟缺省）
 var _resume_bp := {}                      # 续玩快照暂存（resume_adventure → _start_current_level 单跳传递）
 # ---- 三选一停点态（迭代 10 奖励重构批）----
@@ -85,9 +85,9 @@ var _relics: Array[String] = []           # 特性持有集（迭代 12 T1——
 var _tree_rules: Array = []               # 树 rule 键集（迭代 12 T10——Fork 激活侧 effects 透传；下传 enc.tree_rules 消费面）
 var _bonus_pending := {}                  # 停点态：{"candidates": Array, "payload": Dictionary, "chosen"/"incoming": 替换在途}——空 = 无停点
 var _bonus_result := {}                   # 已兑付待推进态（bonus_resolved 载荷副本——中断续玩不重兑付）
-var _bonus_aux_carry: Array[String] = []  # 道具件跨关携带（兑付后注入下一关库存——清库后授予的体验窗）
+var _bonus_treasure_carry: Array[String] = []  # 道具件跨关携带（兑付后注入下一关库存——清库后授予的体验窗）
 var _keystone_drops: Array = []           # Boss 逐杀掉落明细（additive 摘要键 keystone_drops——结算明细/复盘归因数据源）
-var _last_draw_aux: Array[String] = []    # 最近一次抽签掷定的道具件（掷定前置——卡片直显具体道具；追加批二）
+var _last_draw_treasure: Array[String] = []    # 最近一次抽签掷定的道具件（掷定前置——卡片直显具体道具；追加批二）
 var _node_bonus_pending := {}             # 奖励节点三选一停点态（迭代 10 追加批——共享池；断点不载：续玩重建到选路停点重走，恢复的计数器保证同候选重抽）
 var _shop_mode := "legacy"                # 商店模式（迭代 11 第②批 T3——"legacy"=固定三件加定价〔off 对照承载，缺省零扰动〕/"pool"=共享池抽 3 买 1 重抽；真实入口 main.gd 显式投 pool）
 
@@ -121,7 +121,7 @@ func start_adventure(seed_val: int, params: Dictionary = {}) -> bool:
 	_base_override = _normalize_override(params.get("hero_override", {}))
 	_first_script = bool(params.get("first_script", false))   # 缺省 = 非首次（抽签路径；真实侧由呈现层读存档布尔位传入）
 	_shop_mode = "pool" if String(params.get("shop_mode", "legacy")) == "pool" else "legacy"   # 迭代 11 第②批 T3——缺省 legacy（off 对照零扰动）
-	_aux_unlocked = params.get("aux_unlocked", {}) if params.get("aux_unlocked", {}) is Dictionary else {}
+	_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（迭代 11 第①批 T5）
 	_attune_refresh_y = maxi(0, int(params.get("attune_refresh_y", 0)))   # additive（迭代 11 第①批 T5b——Y 冒险周期池）
 	_seed_attune_charges()   # 迭代 11 第①批 T6——冒险开始充能账本按装备主动件重置（每冒险充能语义）   # additive（迭代 7 T5）
@@ -195,7 +195,7 @@ func resume_adventure(bp: Dictionary, params: Dictionary = {}) -> bool:
 	for r in (bp.get("relics", []) as Array):
 		_relics.append(String(r))
 	for v in (bp.get("bonus_aux_carry", []) as Array):
-		_bonus_aux_carry.append(String(v))
+		_bonus_treasure_carry.append(String(v))
 	_keystone_drops = (bp.get("keystone_drops", []) as Array).duplicate(true)
 	_base_override = _normalize_override(params.get("hero_override", {}))
 	# 生命账本越界钳制（T17——spawn 守卫 EC16 免疫）：断点可能由旧口径版本写出（如调试上限
@@ -207,7 +207,7 @@ func resume_adventure(bp: Dictionary, params: Dictionary = {}) -> bool:
 		int(round(float(int(db.hero.max_hp) + int(_base_override.get("max_hp", 0))) * (100.0 + float(_override[1])) / 100.0))))
 	_first_script = false   # 续玩模板已随快照强制（已抽模板零重抽）——脚本模式不重放
 	_shop_mode = "pool" if String(params.get("shop_mode", "legacy")) == "pool" else "legacy"   # 迭代 11 第②批 T3——续玩参数面同 start_adventure（缺省 legacy）
-	_aux_unlocked = params.get("aux_unlocked", {}) if params.get("aux_unlocked", {}) is Dictionary else {}
+	_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（迭代 11 第①批 T5）
 	_attune_refresh_y = maxi(0, int(params.get("attune_refresh_y", 0)))   # additive（迭代 11 第①批 T5b——Y 冒险周期池）
 	_seed_attune_charges()   # 迭代 11 第①批 T6——冒险开始充能账本按装备主动件重置（每冒险充能语义）
@@ -234,7 +234,7 @@ func resume_adventure(bp: Dictionary, params: Dictionary = {}) -> bool:
 			state = "running"
 			bonus_choice_presented.emit(payload)
 			# 替换在途续发（呈现层直落替换子态——持有件记录按恢复后 carry 重建）
-			aux_replace_presented.emit(_carry_records(),
+			treasure_replace_presented.emit(_carry_records(),
 				{"index": -1, "item_id": String(incoming[0]) if not incoming.is_empty() else "", "count": incoming.size()})
 			return true
 		state = "running"
@@ -262,7 +262,7 @@ func _reset_bonus_state() -> void:
 	_relics = []
 	_bonus_pending = {}
 	_bonus_result = {}
-	_bonus_aux_carry = []
+	_bonus_treasure_carry = []
 	_keystone_drops = []
 	_node_bonus_pending = {}
 
@@ -364,7 +364,7 @@ func pick_bonus(kind: String, tier: String = "", relic_id: String = "") -> bool:
 	var value: int = int(db.adventure.feature_value(kind, tier))
 	var hp_before := int(ledger.get("hero_hp", 0))
 	if kind == "treasure_item":
-		return _pick_aux_item(value)   # 道具件分派通关渠道（持有容器 = 跨关携带——与节点渠道分轨；池种退役后不可达）
+		return _pick_treasure_item(value)   # 道具件分派通关渠道（持有容器 = 跨关携带——与节点渠道分轨；池种退役后不可达）
 	if not _apply_bonus_pick(kind, tier, value, relic_id):
 		push_error("[冒险结构] pick_bonus 拒绝——未知件: %s|%s|%s" % [kind, tier, relic_id])
 		return false
@@ -473,39 +473,39 @@ func _pool_stock_snapshot() -> Dictionary:
 	return out
 
 
-# 道具件兑付（同调位约束）：有位直接入跨关携带；满位转替换子交互（incoming 暂存、等 resolve_aux_replace）。
-# 掷定前置（追加批二）：具体道具随候选抽定（_last_draw_aux / _bonus_pending.aux_detail）——本函数消费预掷值，
+# 道具件兑付（同调位约束）：有位直接入跨关携带；满位转替换子交互（incoming 暂存、等 resolve_treasure_replace）。
+# 掷定前置（追加批二）：具体道具随候选抽定（_last_draw_treasure / _bonus_pending.aux_detail）——本函数消费预掷值，
 # 断点续玩/无预掷值时回退当场掷定（流序不同但消费数不变，确定性由调用序保证）。
-# 持有容器 = 跨关携带 _bonus_aux_carry（与节点渠道的关卡域库存分轨——容器差异保守不合，注记在案）。
-func _pick_aux_item(count: int) -> bool:
-	var picked: Array = _draw_pending_aux(_bonus_pending, count, true)
+# 持有容器 = 跨关携带 _bonus_treasure_carry（与节点渠道的关卡域库存分轨——容器差异保守不合，注记在案）。
+func _pick_treasure_item(count: int) -> bool:
+	var picked: Array = _draw_pending_treasure(_bonus_pending, count, true)
 	if picked.is_empty():
-		push_error("[冒险结构] pick_bonus(aux_item) 拒绝——解锁道具池空集（白板/门控态不入牌库的防御兜底）")
+		push_error("[冒险结构] pick_bonus(treasure_item) 拒绝——解锁道具池空集（白板/门控态不入牌库的防御兜底）")
 		return false
 	var hp_before := int(ledger.get("hero_hp", 0))
 	# 迭代 11 第①批 T7——同调位守卫随过渡键退役拆除（aux 卡出池后本路径不可达；能力件容量闸
 	# 正主 = 营地装配面 Attunement.slots 满位禁选）
 	for iid in picked:
-		_bonus_aux_carry.append(String(iid))
+		_bonus_treasure_carry.append(String(iid))
 	_finish_bonus_pick("treasure_item", picked.size(), hp_before)
 	return true
 
 
 # 替换子交互受理（discard_index = -1 放弃新件不获取；否则丢该件腾位收新）——终态恒 ≤ 同调位
 # 持有容器 = 跨关携带（序号寻址）；与节点渠道（库存句柄寻址）的丢弃/授予/收尾三步保守不合。
-func resolve_aux_replace(discard_index: int) -> bool:
+func resolve_treasure_replace(discard_index: int) -> bool:
 	if not _replace_in_transit(_bonus_pending):
-		push_error("[冒险结构] resolve_aux_replace 拒绝——无替换在途")
+		push_error("[冒险结构] resolve_treasure_replace 拒绝——无替换在途")
 		return false
 	var incoming: Array = _bonus_pending.get("incoming", []) as Array
 	var hp_before := int(ledger.get("hero_hp", 0))
 	if discard_index >= 0:
-		if discard_index >= _bonus_aux_carry.size():
-			push_error("[冒险结构] resolve_aux_replace 拒绝——序号不在持有集: %d" % discard_index)
+		if discard_index >= _bonus_treasure_carry.size():
+			push_error("[冒险结构] resolve_treasure_replace 拒绝——序号不在持有集: %d" % discard_index)
 			return false
-		_bonus_aux_carry.remove_at(discard_index)
+		_bonus_treasure_carry.remove_at(discard_index)
 		for iid in incoming:
-			_bonus_aux_carry.append(String(iid))
+			_bonus_treasure_carry.append(String(iid))
 	# 放弃新件（discard_index < 0）= 原持有集不动、新件不获取
 	_finish_bonus_pick("treasure_item", incoming.size(), hp_before)
 	return true
@@ -535,12 +535,12 @@ func _finish_bonus_pick(picked: String, value: int, hp_before: int, tier: String
 # 掷定前置（追加批二）：返回 dict 带 aux_detail（道具件具体道具）供卡片直显。
 func node_bonus_candidates() -> Dictionary:
 	var cands: Array = _draw_bonus_candidates()
-	return {"candidates": cands, "aux_detail": _last_draw_aux.duplicate()}
+	return {"candidates": cands, "aux_detail": _last_draw_treasure.duplicate()}
 
 
-func present_node_bonus(candidates: Array, aux_detail: Array = []) -> void:
+func present_node_bonus(candidates: Array, treasure_detail: Array = []) -> void:
 	_reset_refresh_x()   # 迭代 11 第①批 T5b——碰三选一重置 X 余量（不结转）
-	_node_bonus_pending = {"candidates": candidates.duplicate(true), "aux_detail": aux_detail.duplicate(true)}
+	_node_bonus_pending = {"candidates": candidates.duplicate(true), "aux_detail": treasure_detail.duplicate(true)}
 
 
 # 点选兑付（节点域——无部分回血无钥石；令牌消费与牌库摘牌与通关三选一同库；relic 同权入持有集）
@@ -554,7 +554,7 @@ func apply_node_bonus(kind: String, tier: String = "", relic_id: String = "") ->
 		return false
 	var value: int = int(db.adventure.feature_value(kind, tier))
 	if kind == "treasure_item":
-		return _apply_node_aux(value)   # 道具件分派节点渠道（持有容器 = 关卡域库存——与通关渠道分轨；池种退役后不可达）
+		return _apply_node_treasure(value)   # 道具件分派节点渠道（持有容器 = 关卡域库存——与通关渠道分轨；池种退役后不可达）
 	if not _apply_bonus_pick(kind, tier, value, relic_id):
 		push_error("[冒险结构] apply_node_bonus 拒绝——未知件: %s|%s|%s" % [kind, tier, relic_id])
 		return false
@@ -565,19 +565,19 @@ func apply_node_bonus(kind: String, tier: String = "", relic_id: String = "") ->
 # 节点渠道道具件（同调位约束）：持有=关卡域库存+跨关携带，有位直接入本关库存（当关可用）；
 # 满位转替换子交互（丢弃目标=库存件 handle——与通关渠道的 carry 序号分轨，容器语义保守不合）。
 # 掷定前置：消费 _node_bonus_pending.aux_detail 预掷值（缺省回退当场掷定）。
-func _apply_node_aux(count: int) -> bool:
-	var picked: Array = _draw_pending_aux(_node_bonus_pending, count, false)
+func _apply_node_treasure(count: int) -> bool:
+	var picked: Array = _draw_pending_treasure(_node_bonus_pending, count, false)
 	if picked.is_empty():
-		push_error("[冒险结构] apply_node_bonus(aux_item) 拒绝——解锁道具池空集（白板/门控态不入牌库的防御兜底）")
+		push_error("[冒险结构] apply_node_bonus(treasure_item) 拒绝——解锁道具池空集（白板/门控态不入牌库的防御兜底）")
 		return false
 	var records: Array = []
-	if _runner != null and _runner.aux_inventory != null:
-		records = _runner.aux_inventory.holding_records()
-	# 迭代 11 第①批 T7——守卫随过渡键退役拆除（FEATURE_KINDS 已除名 aux_item，本分支不可达；
+	if _runner != null and _runner.treasure_inventory != null:
+		records = _runner.treasure_inventory.holding_records()
+	# 迭代 11 第①批 T7——守卫随过渡键退役拆除（FEATURE_KINDS 已除名 treasure_item，本分支不可达；
 	# 替换子交互路由随容量闸一并退役——能力件容量闸正主 = 营地装配面满位禁选）
 	if _runner != null:
 		for iid in picked:
-			var rec: Dictionary = _runner.grant_aux_item(String(iid), "reward_node")
+			var rec: Dictionary = _runner.grant_treasure_item(String(iid), "reward_node")
 			if rec.is_empty():
 				push_warning("[冒险结构] 奖励节点道具授予被拒（防御兜底留痕）: %s" % String(iid))
 	_finish_node_bonus("treasure_item", picked.size())
@@ -590,11 +590,11 @@ func _resolve_node_replace(discard_handle: int) -> bool:
 		return false
 	var incoming: Array = _node_bonus_pending.get("incoming", []) as Array
 	if discard_handle >= 0:
-		if _runner == null or _runner.aux_inventory == null or not _runner.aux_inventory.discard_item(discard_handle):
+		if _runner == null or _runner.treasure_inventory == null or not _runner.treasure_inventory.discard_item(discard_handle):
 			push_error("[冒险结构] resolve_node_replace 拒绝——句柄不在持有集: %d" % discard_handle)
 			return false
 		for iid in incoming:
-			var rec: Dictionary = _runner.grant_aux_item(String(iid), "reward_node")
+			var rec: Dictionary = _runner.grant_treasure_item(String(iid), "reward_node")
 			if rec.is_empty():
 				push_warning("[冒险结构] 替换子道具授予被拒（防御兜底留痕）: %s" % String(iid))
 	# 放弃新件（discard_handle < 0）= 原持有集不动、新件不获取
@@ -648,10 +648,10 @@ func refresh_bonus() -> bool:
 			_attune_refresh_y -= 1
 		var cands: Array = _draw_bonus_candidates()
 		_bonus_pending["candidates"] = cands.duplicate(true)
-		_bonus_pending["aux_detail"] = _last_draw_aux.duplicate()
+		_bonus_pending["aux_detail"] = _last_draw_treasure.duplicate()
 		var payload: Dictionary = (_bonus_pending.get("payload", {}) as Dictionary).duplicate(true)
 		payload["candidates"] = cands
-		payload["aux_detail"] = _last_draw_aux.duplicate()
+		payload["aux_detail"] = _last_draw_treasure.duplicate()
 		bonus_choice_presented.emit(payload)   # 同信号重 present（零自动推进契约不破——停点仍在途）
 		_snapshot_breakpoint()
 		return true
@@ -662,34 +662,34 @@ func refresh_bonus() -> bool:
 			_attune_refresh_y -= 1
 		var cands2: Array = _draw_bonus_candidates()
 		_node_bonus_pending["candidates"] = cands2.duplicate(true)
-		_node_bonus_pending["aux_detail"] = _last_draw_aux.duplicate()
+		_node_bonus_pending["aux_detail"] = _last_draw_treasure.duplicate()
 		return true
 	return false
 
 
-# 替换在途守卫（2026-10-02 修复批——双渠道替换受理的共用前置谓词：停点态非空且 chosen=aux_item）
+# 替换在途守卫（2026-10-02 修复批——双渠道替换受理的共用前置谓词：停点态非空且 chosen=treasure_item）
 func _replace_in_transit(pending: Dictionary) -> bool:
 	return not pending.is_empty() and String(pending.get("chosen", "")) == "treasure_item"
 
 
-# 双渠道道具件掷定共享体（2026-10-02 修复批——_pick_aux_item/_apply_node_aux 复制债收口一步）：
+# 双渠道道具件掷定共享体（2026-10-02 修复批——_pick_treasure_item/_apply_node_treasure 复制债收口一步）：
 # 解锁道具池空集守卫 + N 件掷定（先消费停点预掷 aux_detail，不足部分当场经 reward_pick 封闭流补掷——
 # 取数序与拆分前逐位一致）。返回空数组 = 池空集（调用方按渠道名报错）。
-# 保守不合处：通关渠道允许回退 _last_draw_aux（allow_detail_fallback）、节点渠道不回退——掷定回退
+# 保守不合处：通关渠道允许回退 _last_draw_treasure（allow_detail_fallback）、节点渠道不回退——掷定回退
 # 语义渠道各异，参数化保留差异；持有容器与兑付收尾仍归调用方渠道。
-func _draw_pending_aux(pending: Dictionary, count: int, allow_detail_fallback: bool) -> Array:
-	var pool: Array = _bonus_aux_pool()
+func _draw_pending_treasure(pending: Dictionary, count: int, allow_detail_fallback: bool) -> Array:
+	var pool: Array = _bonus_treasure_pool()
 	if pool.is_empty():
 		return []
 	var picked: Array = []
 	var detail: Array = (pending.get("aux_detail", []) as Array).duplicate()
 	if detail.is_empty() and allow_detail_fallback:
-		detail = _last_draw_aux.duplicate()
+		detail = _last_draw_treasure.duplicate()
 	for i in maxi(1, count):
 		if i < detail.size():
 			picked.append(String(detail[i]))
 		else:
-			picked.append(_roll_bonus_aux_item(pool))
+			picked.append(_roll_bonus_treasure_item(pool))
 	return picked
 
 
@@ -697,7 +697,7 @@ func _draw_pending_aux(pending: Dictionary, count: int, allow_detail_fallback: b
 func resolve_bonus_replace(discard: int) -> bool:
 	if not _node_bonus_pending.is_empty() and _node_bonus_pending.has("incoming"):
 		return _resolve_node_replace(discard)
-	return resolve_aux_replace(discard)
+	return resolve_treasure_replace(discard)
 
 
 func _finish_node_bonus(picked: String, value: int, tier: String = "", relic_id: String = "") -> void:
@@ -718,9 +718,9 @@ func _finish_node_bonus(picked: String, value: int, tier: String = "", relic_id:
 # kind 出现率∝剩余令牌数〔档位配额即分布——无独立权重 knob〕；抽签不摘牌、兑付才摘牌=未选
 # 自动回池；池耗即枯竭——余库不足 N kind 时出齐剩余，空库 = 零候选合法态）。候选 = 令牌字典
 # {"kind","tier"}。消费 reward_pick 封闭流——一次停点恰一 scope，同种子同候选；道具件掷定前置
-# 随池种退役拆除（_last_draw_aux 恒空集，机械惰性承载）。
+# 随池种退役拆除（_last_draw_treasure 恒空集，机械惰性承载）。
 func _draw_bonus_candidates() -> Array:
-	_last_draw_aux = []
+	_last_draw_treasure = []
 	var pool := _bonus_deck.duplicate()
 	var rg: RandomNumberGenerator = rng.open_stream("reward_pick")
 	for i in pool.size():
@@ -745,29 +745,29 @@ func _draw_bonus_candidates() -> Array:
 
 
 func _roll_from(rg: RandomNumberGenerator) -> String:
-	var pool: Array = _bonus_aux_pool()
+	var pool: Array = _bonus_treasure_pool()
 	return String(pool[rg.randi_range(0, pool.size() - 1)])
 
 
 # 三选一道具件随机池（与投放门控同源：aux 活行 ∩ 解锁门控集——空集 = 道具件不入牌库）
-func _bonus_aux_pool() -> Array:
+func _bonus_treasure_pool() -> Array:
 	var out: Array = []
 	var live: Dictionary = db.treasure_live_ids()
 	for iid in live.keys():
-		if _aux_unlocked.has(String(iid)):
+		if _treasure_unlocked.has(String(iid)):
 			out.append(String(iid))
 	return out
 
 
-func _roll_bonus_aux_item(pool: Array) -> String:
+func _roll_bonus_treasure_item(pool: Array) -> String:
 	var rg: RandomNumberGenerator = rng.open_stream("reward_pick")
 	return String(pool[rg.randi_range(0, pool.size() - 1)])
 
 
 func _carry_records() -> Array:
 	var out: Array = []
-	for i in _bonus_aux_carry.size():
-		out.append({"index": i, "item_id": _bonus_aux_carry[i]})
+	for i in _bonus_treasure_carry.size():
+		out.append({"index": i, "item_id": _bonus_treasure_carry[i]})
 	return out
 
 
@@ -837,11 +837,11 @@ func _start_current_level() -> bool:
 		# 注入面随停点渠道退役拆除（容器字段保留=替换子交互机械惰性承载，零投放零行为）
 		level_started.emit(level_index, String(_runner.level_row.get("display_name", "")))
 		# 入口停点断点（node_id=-1）与 defer_entry 同态（node_index=-1+单候选）——走入口呈现；
-		# 中途停点（node_id>=0）走停点呈现（restore_aux_items 先于呈现=C 区库存就位）。
+		# 中途停点（node_id>=0）走停点呈现（restore_treasure_items 先于呈现=C 区库存就位）。
 		if resume_state.is_empty() or int(resume_state.get("node_id", -1)) < 0:
 			_runner.present_entry_choice()
 		else:
-			_runner.restore_aux_items(_resume_bp.get("aux_items", []) as Array)
+			_runner.restore_treasure_items(_resume_bp.get("aux_items", []) as Array)
 			_runner.present_resumed_choice()
 	_resume_bp = {}
 	return ok
@@ -861,7 +861,7 @@ func _on_level_finished(payload: Dictionary) -> void:
 	if result != "victory":
 		push_error("[冒险结构] 关卡结束结果出域: %s" % result)
 		return
-	_last_aux_cleared = int(payload.get("aux_cleared", 0))   # additive（迭代 7 T4——末关 summary 取数面）
+	_last_treasure_cleared = int(payload.get("aux_cleared", 0))   # additive（迭代 7 T4——末关 summary 取数面）
 	# Boss 钥石逐杀掉落（迭代 10——渠道改击杀掉落，末关照常入账；首杀/复杀读 meta.tres boss_keystone）
 	_boss_keystone_drop(level_index)
 	if level_index < levels_total:
@@ -877,7 +877,7 @@ func _on_level_finished(payload: Dictionary) -> void:
 		var pick_payload: Dictionary = {
 			"level_index": level_index,
 			"candidates": _draw_bonus_candidates(),
-			"aux_detail": _last_draw_aux.duplicate(),   # 掷定前置（追加批二——道具件具体道具随候选抽定，卡片直显）
+			"aux_detail": _last_draw_treasure.duplicate(),   # 掷定前置（追加批二——道具件具体道具随候选抽定，卡片直显）
 			"heal_gained": heal,
 			"hp_before": hp_before,
 			"hp_after": int(ledger.get("hero_hp", 0)),
@@ -887,7 +887,7 @@ func _on_level_finished(payload: Dictionary) -> void:
 			"aux_cleared": int(payload.get("aux_cleared", 0)),   # additive 扩签（迭代 7 T4——关卡末清空反馈取数）
 		}
 		_bonus_pending = {"candidates": (pick_payload["candidates"] as Array).duplicate(true),
-			"aux_detail": _last_draw_aux.duplicate(),
+			"aux_detail": _last_draw_treasure.duplicate(),
 			"payload": pick_payload.duplicate(true)}
 		bonus_choice_presented.emit(pick_payload)
 		_snapshot_breakpoint()   # 选择停点可中断（契约 5——续玩不重抽不静默丢失）
@@ -905,7 +905,7 @@ func _settle(result: String) -> void:
 		"stopped_at": 0 if result == "completed" else level_index,
 		"keystone_total": keystone,
 		"master_seed": master_seed,
-		"aux_cleared_last": _last_aux_cleared,   # additive 扩签（迭代 7 T4——末关清空反馈；非末关走 bonus 载荷）
+		"aux_cleared_last": _last_treasure_cleared,   # additive 扩签（迭代 7 T4——末关清空反馈；非末关走 bonus 载荷）
 		"keystone_drops": _keystone_drops.duplicate(true),   # additive 扩签（迭代 10——逐杀掉落明细；settle 入账明细/复盘归因数据源）
 		"pool_stock": _pool_stock_snapshot(),   # additive 扩签（迭代 11 第②批 T5——终局池读数：清账前快照，商店买走 vs 奖励领走 vs 枯竭的终局面）
 		"relics": _relics.duplicate(),   # additive 扩签（迭代 12 T1——特性终局持有集：清账前快照，成型判读取数面）
@@ -948,9 +948,9 @@ func _forward_choices_presented(candidates: Array) -> void:
 func _snapshot_breakpoint() -> void:
 	if _save_manager == null or state != "running":
 		return
-	var aux_items: Array = []
-	if _runner != null and _runner.aux_inventory != null:
-		aux_items = _runner.aux_inventory.snapshot_inventory()
+	var treasure_snapshot: Array = []
+	if _runner != null and _runner.treasure_inventory != null:
+		treasure_snapshot = _runner.treasure_inventory.snapshot_inventory()
 	# 三选一停点续玩分支 _runner 为 null（关卡已收束、下一关未开）——节点域字段按缺省落档，
 	# 该两态的续玩只消费 bonus_* 附随件（选择停点/已兑付停点快照，迭代 10）
 	var bp: Dictionary = {
@@ -973,13 +973,13 @@ func _snapshot_breakpoint() -> void:
 		"rng_counter": rng.counter(),
 		"keystone": keystone,
 		"visited_ids": _runner.visited_ids() if _runner != null else [],
-		"aux_items": aux_items,
+		"aux_items": treasure_snapshot,
 		"bonus_taken": _bonus_taken.duplicate(true),            # 三选一件获取次数（kind 维度派生账本——断点附随件与读数承载）
 		"bonus_deck": _bonus_deck.duplicate(true),              # 令牌池余库（TP0 v2.2——池消耗即上限，续玩余库逐枚还原）
 		"relics": _relics.duplicate(),                          # 特性持有集（迭代 12 T1——局内随机渠道获得态续玩防丢失）
 		"bonus_pending": _bonus_pending.duplicate(true),        # 三选一停点态（空 = 无停点——选择停点可中断契约）
 		"bonus_result": _bonus_result.duplicate(true),          # 已兑付待推进态（空 = 无——中断续玩不重兑付）
-		"bonus_aux_carry": _bonus_aux_carry.duplicate(true),    # 道具件跨关携带（注入前中断防静默丢失）
+		"bonus_aux_carry": _bonus_treasure_carry.duplicate(true),    # 道具件跨关携带（注入前中断防静默丢失）
 		"keystone_drops": _keystone_drops.duplicate(true),      # 逐杀掉落明细（摘要归因续接——迭代 10）
 	}
 	_save_manager.set_breakpoint(bp)

game/core/battle_orchestrator.gd

@@ -50,7 +50,7 @@ var action_economy: ActionEconomy
 var _enemy_system: UnitContainer
 var _status_effects: StatusContainer
 var _reward_economy: RewardEconomy
-var aux_inventory: TreasureItems                   # 迭代 7 T3——LevelRunner 注入的关卡域库存引用；
+var treasure_inventory: TreasureItems                   # 迭代 7 T3——LevelRunner 注入的关卡域库存引用；
 						  # 每战新建本类，库存不归本类所有——注入面
 var _damage: DamageController   # 伤害控制器（伤害管线单据化批 2026-09-24——单据唯一兑付管线）
 
@@ -69,7 +69,7 @@ var _board_from_midround_refresh := false  # 装板 provenance：轮内刷新换
 var _flag_consumed := {}                   # 兑付资格以雷格实例为键（板级；换图重置）
 # 同调装配运行态（迭代 11 第①批 T5——begin_battle 经 enc.attunement 注入；off=空集全部效果零扰动）
 var attunement: Array = []                 # 装备中同调件 item_id 集
-var _attune_charges_ref: Dictionary = {}   # 充能账本共享引用（迭代 11 第①批 T6——use_aux 消费直改）
+var _attune_charges_ref: Dictionary = {}   # 充能账本共享引用（迭代 11 第①批 T6——use_treasure 消费直改）
 var _attune_bank := 0                      # 掘进蓄能积点（battle 域——每 charge_n 安全格 +1 点）
 var _attune_safe_seen := 0                 # 掘进蓄能 battle 域安全开格计数
 # 特性运行态（迭代 12 T2——relic 持有集经 enc.relics 注入；求值旗注 damage_controller.relic_flags；
@@ -242,7 +242,7 @@ func begin_battle(enc: Dictionary) -> bool:
 	# 同调装配运行态注入（迭代 11 第①批 T5——enc.attunement 携带；off=空集零扰动。淬毒 N 注入
 	# 伤害控制器、偏运 N 注入地图战斗资源——均须先于首板 install）
 	attunement = (enc.get("attunement", []) as Array).duplicate()
-	_attune_charges_ref = enc.get("attune_charges", {})   # 共享 dict 引用（level/adventure 同账本——use_aux 扣减直改）
+	_attune_charges_ref = enc.get("attune_charges", {})   # 共享 dict 引用（level/adventure 同账本——use_treasure 扣减直改）
 	_attune_bank = 0
 	_attune_safe_seen = 0
 	_damage.attune_venom = _attune_mag("venom_edge") if _attune_has("venom_edge") else 0
@@ -318,8 +318,8 @@ func _install_new_board(during_round := false) -> bool:
 	_board_from_midround_refresh = during_round   # 轮内刷新装板 = 刷新图（清图奖励不发）；常规换图/开战装板 = false
 	_board_seq += 1
 	board_changed.emit()
-	if aux_inventory != null:
-		aux_inventory.retire_overlays()   # 迭代 7 T3——叠加层随图消亡（换图/刷新图装板点；已花道具不返还）
+	if treasure_inventory != null:
+		treasure_inventory.retire_overlays()   # 迭代 7 T3——叠加层随图消亡（换图/刷新图装板点；已花道具不返还）
 	return true
 
 
@@ -619,22 +619,22 @@ func _relic_yield_adjust(snap: Dictionary, positive: bool) -> Dictionary:
 # 「动作 × 格型」矩阵的执行面：snap = 缓冲期冻结身份快照（cell_type = 该格装板期摇定的类型身份），
 # polarity 由动作决定（开安全格/标中旗 = positive，开雷格/标错旗 = negative），
 # 兑付行 = 奖励字典（类型, 极性）行。返回 true = percent 行实际生效（flat 行恒 false——兑付结果由行协议承载）。
-# ---- 秘宝（use_aux 四步受理编排保留给同调主动件复用——迭代 11 第①批 T7：过渡授予路由
-# _grant_aux 随掉落/停点渠道退役拆除；能力件注入归 LevelRunner.set_attune_charges 骑库存面）----
+# ---- 秘宝（use_treasure 四步受理编排保留给同调主动件复用——迭代 11 第①批 T7：过渡授予路由
+# _grant_treasure 随掉落/停点渠道退役拆除；能力件注入归 LevelRunner.set_attune_charges 骑库存面）----
 
 
-# use_aux 四步受理（registry use_orchestration 规范序——唯一调用权归本类；序即原子：
+# use_treasure 四步受理（registry use_orchestration 规范序——唯一调用权归本类；序即原子：
 # ① 相位 gate（Active——行动经济 phase getter）→ ② validate_use（目标校验读 排雷玩法 只读面，零消耗）→
 # ③ 逐 kind 应用（顺序钉死：空间先、ap_grant 后——effect_kinds 列表序非运行时语义）→ ④ consume。
 # 拒绝全部发生在 ①②（后两步合法输入下无失败路径）；使用零 AP 成本（不经 try_spend）。
 # 结算明细无道具行（GDD——效果即时可见：overlay 呈现+AP 条刷新；AP 过账本 grant_ap 走 _reject 面）。
-func use_aux(handle: int, target: Vector2i) -> Dictionary:
-	if aux_inventory == null:
+func use_treasure(handle: int, target: Vector2i) -> Dictionary:
+	if treasure_inventory == null:
 		return {"ok": false, "reason": "库存未接线"}
 	if action_economy.phase != action_economy.PHASE_ACTIVE:
 		return {"ok": false, "reason": "非挖掘期（使用窗口=Active）"}
-	var board: MinesweeperRules = minesweeper   # 恒等包装退役（2026-10-02 修复批——use_aux 直引公有成员）
-	var v: Dictionary = aux_inventory.validate_use(handle, target,
+	var board: MinesweeperRules = minesweeper   # 恒等包装退役（2026-10-02 修复批——use_treasure 直引公有成员）
+	var v: Dictionary = treasure_inventory.validate_use(handle, target,
 		Vector2(board.width, board.height),
 		func(c: Vector2i): return not board.is_revealed(c))
 	if not bool(v.ok):
@@ -647,9 +647,9 @@ func use_aux(handle: int, target: Vector2i) -> Dictionary:
 		_attune_bank -= 1
 	var kinds: Array = v.kinds
 	if kinds.has("mine_reveal"):
-		aux_inventory.apply_overlay("mine_reveal", v.resolved)
+		treasure_inventory.apply_overlay("mine_reveal", v.resolved)
 	if kinds.has("reward_preview"):
-		aux_inventory.apply_overlay("reward_preview", v.resolved)
+		treasure_inventory.apply_overlay("reward_preview", v.resolved)
 	if kinds.has("ap_grant"):
 		if not action_economy.grant_ap(int(v.magnitude)):
 			return {"ok": false, "reason": "行动点加量被拒（相位防御）"}
@@ -664,7 +664,7 @@ func use_aux(handle: int, target: Vector2i) -> Dictionary:
 		var blasted: Array = board.remove_mines_in(v.resolved)
 		if blasted.is_empty():
 			return {"ok": false, "reason": "爆破工兵包：3×3 区域内无可移除雷格（须未揭示且未插旗）"}
-	var rec: Dictionary = aux_inventory.consume(handle)
+	var rec: Dictionary = treasure_inventory.consume(handle)
 	# 同调主动件充能扣减（迭代 11 第①批 T6——共享账本直改：adventure/level/settlement 同一字典引用）
 	if not rec.is_empty() and String(rec.get("source_class", "")) == "attunement":
 		var used_iid: String = String(rec.get("item_id", ""))
@@ -674,12 +674,12 @@ func use_aux(handle: int, target: Vector2i) -> Dictionary:
 
 
 # aux 解锁门控转发（迭代 7 T5——LevelRunner 注入；E1/E3 封装：外部经公有面，禁直读 _reward_economy）
-func set_aux_unlocked(ids: Dictionary) -> void:
-	_reward_economy.set_aux_unlocked(ids)
+func set_treasure_unlocked(ids: Dictionary) -> void:
+	_reward_economy.set_treasure_unlocked(ids)
 
 
 func _grant_routed(snap: Dictionary, polarity: String, source_class: String, cell: Vector2i, ri: int, highlight: String = "", label_suffix: String = "") -> bool:
-	# 迭代 11 第①批 T7——aux 授予分支随掉落/停点渠道退役拆除（reward 词表第十型 aux_item 保留但零投放：
+	# 迭代 11 第①批 T7——aux 授予分支随掉落/停点渠道退役拆除（reward 词表第十型 treasure_item 保留但零投放：
 	# 无 aux 行入池、FEATURE_KINDS 词表已除名）；剩余类型走极性字典路由。
 	var row: Dictionary = _reward_economy.polarity_row(String(snap.get("cell_type", "")), polarity)
 	if row.is_empty():
@@ -1127,8 +1127,8 @@ func _battle_over(result: String) -> void:
 	_reward_economy.retire_mapping()
 	_enemy_system.despawn_all()
 	_status_effects.notify_battle_end()
-	if aux_inventory != null:
-		aux_inventory.retire_overlays()   # 迭代 7 T3——叠加层随战斗结束清空（库存不动——关卡域跨战斗）
+	if treasure_inventory != null:
+		treasure_inventory.retire_overlays()   # 迭代 7 T3——叠加层随战斗结束清空（库存不动——关卡域跨战斗）
 	action_economy.notify_combat_end()   # → Idle，RAP 清零（2026-10-02 修复批：原被 tab 事故并进上一行行尾注释从不执行——每战新建实例掩盖了症状；P0-3）
 	db.set_reload_gate(false)
 	_reset_round_facts()

game/core/config_db_cross_validator.gd

@@ -41,11 +41,11 @@ func cross_validate(loaded: Dictionary, push_diag: Callable) -> void:
 		for row in rt.rows:
 			if String(row.get("cell_type", "")) != RewardTable.TREASURE_ITEM_TYPE:
 				continue
-			var aux_eff: String = String(row.get("effect_id", ""))
-			if aux_eff == "":   # 负占位行（雷格极性字典兜底，零兑付）——不入投放词表校验
+			var treasure_eff: String = String(row.get("effect_id", ""))
+			if treasure_eff == "":   # 负占位行（雷格极性字典兜底，零兑付）——不入投放词表校验
 				continue
-			if not treasure_live.has(aux_eff):
-				push_diag.call("error", "reward_dangling_treasure", "RewardTable %s aux 行引用无效道具 %s（retired/deferred/不存在）: %s" % [row.get("reward_id"), aux_eff, "双表校验"])
+			if not treasure_live.has(treasure_eff):
+				push_diag.call("error", "reward_dangling_treasure", "RewardTable %s aux 行引用无效道具 %s（retired/deferred/不存在）: %s" % [row.get("reward_id"), treasure_eff, "双表校验"])
 	# ①c F2 投放维度覆盖（秘宝 GDD——五维度各 ≥1 掉落权重为正的活行）：豁免面 {plan, info, counter}
 	# = 罗盘退役（plan，2026-09-29 拍板①乙）+显影件 Alpha 重定（info/counter 悬置）——豁免随 Alpha 重定批消减
 	# ①c F2 投放维度覆盖校验随战斗掉落渠道退役（2026-10-01 用户拍板甲——挖格不掉道具，秘宝

game/core/level_runner.gd

@@ -62,10 +62,10 @@ var base_override := {"atk": 0, "max_hp": 0, "armor_class": 0}   # 永久强化
 var _shop_purchased := {}                 # product_id → 已购档数（现价重算输入；冒险开始清零）
 # 协作对象私有（E1/E3 封装收口 2026-09-13）：settlement 读取经 current_battle() 成文出口
 var _settlement: BattleOrchestrator = null        # 当前战斗编排器（关卡结束置 null）
-var aux_inventory: TreasureItems = null                # 秘宝 关卡域库存（迭代 7 T3——TreasureItems；跨战斗延续，
-var _aux_unlocked := {}                        # aux 解锁门控集（迭代 7 T5——拍板③甲；空集=零投放）
+var treasure_inventory: TreasureItems = null                # 秘宝 关卡域库存（迭代 7 T3——TreasureItems；跨战斗延续，
+var _treasure_unlocked := {}                        # aux 解锁门控集（迭代 7 T5——拍板③甲；空集=零投放）
 var _attunement: Array = []                    # 同调装配集（迭代 11 第①批 T5——adventure params.attunement 下传，begin_battle enc 携带进战斗结算；空集=off 零扰动）
-var _attune_charges: Dictionary = {}           # 同调主动件充能账本（迭代 11 第①批 T6——adventure 共享 dict 引用；settlement use_aux 扣减直改同引用）
+var _attune_charges: Dictionary = {}           # 同调主动件充能账本（迭代 11 第①批 T6——adventure 共享 dict 引用；settlement use_treasure 扣减直改同引用）
                                                   # 关卡末清空+快照计数入 level_finished 载荷）
 # ---- 商店共享池模式态（迭代 11 第②批 T3——缺省 legacy=固定三件加定价 off 对照承载，零 RNG 零池消费；TP0 令牌池换代）----
 var _shop_pool_mode := false               # pool 模式旗（set_shop_pool 注入时置位——AdventureRunner 按 params.shop_mode 下传）
@@ -295,11 +295,11 @@ func present_resumed_choice() -> bool:
 
 
 # 断点道具库存回填（迭代 8 卡①——奖励节点已选道具随停点快照回局；幂等，先清后入受理序重排）
-func restore_aux_items(items: Array) -> void:
-	if aux_inventory == null:
-		aux_inventory = TreasureItems.new(db)
-	aux_inventory.reset()
-	aux_inventory.restore_inventory(items)
+func restore_treasure_items(items: Array) -> void:
+	if treasure_inventory == null:
+		treasure_inventory = TreasureItems.new(db)
+	treasure_inventory.reset()
+	treasure_inventory.restore_inventory(items)
 
 
 func _find_level_row(level_index: int) -> Dictionary:
@@ -460,11 +460,11 @@ func _enter_node(node: Dictionary) -> bool:
 
 func _start_battle(node: Dictionary) -> bool:
 	_settlement = BattleOrchestrator.new(db, rng)
-	if aux_inventory == null:
-		aux_inventory = TreasureItems.new(db)   # 惰性建——关卡域单实例（跨战斗延续）
-	_settlement.aux_inventory = aux_inventory   # 迭代 7 T3——库存注入（授予路由+use_aux 编排消费面）
+	if treasure_inventory == null:
+		treasure_inventory = TreasureItems.new(db)   # 惰性建——关卡域单实例（跨战斗延续）
+	_settlement.treasure_inventory = treasure_inventory   # 迭代 7 T3——库存注入（授予路由+use_treasure 编排消费面）
 	if _settlement != null:
-		_settlement.set_aux_unlocked(_aux_unlocked)   # 迭代 7 T5——解锁门控下传（装板摇号前）
+		_settlement.set_treasure_unlocked(_treasure_unlocked)   # 迭代 7 T5——解锁门控下传（装板摇号前）
 	# core↔core 接线只许方法 Callable（ADR-0001 静态规则 S6——lambda 捕获 self 会延长
 	# RefCounted 生命周期乃至成环：settlement 的信号持捕获 runner 的 lambda，runner 又持 settlement）
 	_settlement.step_row.connect(_forward_step_row)
@@ -514,13 +514,13 @@ func _on_battle_finished(payload: Dictionary) -> void:
 			close_wallet()   # 单关模式：关卡收束即冒险收束（GP 清零）；冒险模式归 AdventureRunner._settle
 		_phase = Phase.ENDED
 		_settlement = null
-		var aux_cleared := 0
-		if aux_inventory != null:
-			aux_cleared = aux_inventory.inventory_count()   # 快照计数（清空前——「剩余道具随关卡结束清空」可见反馈取数）
-			aux_inventory.reset()   # 迭代 7 T3——关卡末库存清空（无论输赢，幂等）
+		var treasure_cleared := 0
+		if treasure_inventory != null:
+			treasure_cleared = treasure_inventory.inventory_count()   # 快照计数（清空前——「剩余道具随关卡结束清空」可见反馈取数）
+			treasure_inventory.reset()   # 迭代 7 T3——关卡末库存清空（无论输赢，幂等）
 		level_finished.emit({"result": level_result, "hp": hp_left, "node_index": node_index,
 			"node_id": _node_id(node), "node_type": String(node.get("type", "")),
-			"aux_cleared": aux_cleared})   # additive 扩签（不参与派生——node_map 扩签先例）
+			"aux_cleared": treasure_cleared})   # additive 扩签（不参与派生——node_map 扩签先例）
 		return
 	# 接口漂移清偿（关卡节点地图 v1.0 ⑦）：战斗胜利不再自动推进——确认后进选路口
 	_settlement = null
@@ -579,10 +579,10 @@ func current_battle():
 	return _settlement
 
 # aux 解锁门控集注入（迭代 7 T5——AdventureRunner 自 params 传递）
-func set_aux_unlocked(ids: Dictionary) -> void:
-	_aux_unlocked = ids
+func set_treasure_unlocked(ids: Dictionary) -> void:
+	_treasure_unlocked = ids
 	if _settlement != null:
-		_settlement.set_aux_unlocked(ids)
+		_settlement.set_treasure_unlocked(ids)
 
 
 # 同调装配集注入（迭代 11 第①批 T5——冒险开始参数面；AdventureRunner 唯一调用方）
@@ -617,23 +617,23 @@ func set_tree_rules(rules: Array) -> void:
 # 差额注入防续玩双份——resume 路径 restore_inventory 已含断点内 attune 记录）
 func set_attune_charges(charges: Dictionary) -> void:
 	_attune_charges = charges
-	if aux_inventory == null:
-		aux_inventory = TreasureItems.new(db)
+	if treasure_inventory == null:
+		treasure_inventory = TreasureItems.new(db)
 	for iid in charges:
 		var existing := 0
-		for r in aux_inventory.snapshot_inventory():
+		for r in treasure_inventory.snapshot_inventory():
 			if String(r.item_id) == String(iid) and String(r.source_class) == "attunement" and not bool(r.used):
 				existing += 1
 		for i in range(maxi(0, int(charges[iid]) - existing)):
-			aux_inventory.add_item(String(iid), "attunement", Vector2i(-1, -1), 0)
+			treasure_inventory.add_item(String(iid), "attunement", Vector2i(-1, -1), 0)
 
 # 奖励节点兑付透传（迭代 7 T5——呈现层三选一 → 关卡域库存；来源归因 reward_node）。
 # 迭代 11 第①批 T7——同调位持有闸随过渡键退役拆除（aux 卡出池后仅剩防御面；能力件容量闸
 # 正主 = 营地装配面 Attunement.slots 满位禁选）。
-func grant_aux_item(item_id: String, source: String) -> Dictionary:
-	if aux_inventory == null:
-		aux_inventory = TreasureItems.new(db)
-	return aux_inventory.add_item(item_id, source, Vector2i(-1, -1), 0)
+func grant_treasure_item(item_id: String, source: String) -> Dictionary:
+	if treasure_inventory == null:
+		treasure_inventory = TreasureItems.new(db)
+	return treasure_inventory.add_item(item_id, source, Vector2i(-1, -1), 0)
 
 
 # 三选一 GP 袋件入账（迭代 10——钱包收口扩「奖励入账」入口；复用战斗完成同一入账原语，

game/core/reward_economy.gd

@@ -296,11 +296,11 @@ func weighted_pick(rows: Array, r: int) -> String:
 
 # aux 解锁门控集（迭代 7 T5——拍板③甲「解锁→进投放池」：未解锁 aux 行不入摇号池。
 # 空集默认 = 全部 aux 不投放（白板/夹具态零投放——模拟读数零扰动；真实侧 main 组装工坊解锁集传入）
-var _aux_unlocked := {}
+var _treasure_unlocked := {}
 
 
-func set_aux_unlocked(ids: Dictionary) -> void:
-	_aux_unlocked = ids
+func set_treasure_unlocked(ids: Dictionary) -> void:
+	_treasure_unlocked = ids
 
 
 func _rollable_rows() -> Array:
@@ -309,7 +309,7 @@ func _rollable_rows() -> Array:
 	for row in db.reward.rows:
 		if String(row.get("cell_type", "")) == RewardTable.TREASURE_ITEM_TYPE:
 			var iid := String(row.get("effect_id", ""))
-			if iid == "" or not _aux_unlocked.has(iid):
+			if iid == "" or not _treasure_unlocked.has(iid):
 				continue
 		if String(row.get("pool_tag", "")) == "cell" and String(row.get("polarity", "")) == "positive" and int(row.weight) > 0:
 			out.append(row)

game/core/treasure_items.gd

@@ -1,7 +1,7 @@
 # VERTICAL SLICE - NOT FOR PRODUCTION
 # Validation Question: 道具从掉落到使用的全程零随机零特判——同操作序列重放两遍，库存与叠加层投影逐位相同（P0）
 # Date: 2026-09-29（迭代 7 T2 core 骨架——秘宝内容批；设计权威 design/gdd/systems/排雷循环/秘宝.md
-#   + registry aux_items api 8 入口/load_bearing_rules/use_orchestration）
+#   + registry 秘宝条目（键 aux_items 沿用）api 8 入口/load_bearing_rules/use_orchestration）
 # 秘宝 关卡域库存 + 板级叠加层（自持派生信息层）。
 # 结构冻结照抄（违反即返工）：
 #   零随机（零 RNG 流消费——信息只来自 排雷玩法 恒真数字/地图战斗资源 Ready 映射/行动经济 账本三既有事实源）；
@@ -11,7 +11,7 @@
 #   真视恒可用（零雷窗口=「这 9 格没雷」信息非空）；点击级零信息不消耗（拒绝零消耗——预读窗口全已开）；
 #   零特判（排雷玩法 代码零本系统分支——本类不写任何其他系统状态）。
 # 负空间：无自动使用入口/无重掷/无事件订阅/无 RNG 直连/无 排雷玩法/地图战斗资源 写入口；
-#   相位检查归 战斗结算 use_aux 编排第一步（本类不管相位——validate_use 是纯谓词+投影）。
+#   相位检查归 战斗结算 use_treasure 编排第一步（本类不管相位——validate_use 是纯谓词+投影）。
 # 呈现取数面：query_inventory（C 区槽位）/query_overlays（棋盘叠加层标记）——只读投影，零数据复制
 #   （预读徽章数据源=战斗结算 query_reward_identity 既有读面，本类只记「哪些格要额外显示」）。
 class_name TreasureItems
@@ -116,7 +116,7 @@ func _item_row(item_id: String) -> Dictionary:
 		return _db.treasure_item_row(item_id)   # 表访问收口（2026-10-02——正式面走 ConfigDB 访问器）
 	return _db.treasure_items.row_by_id(item_id)   # 桩表面（单测 StubDB 无访问器——直读保留，随测试面演进退役）
 
-# 不标具体类型原因：单元测试注入 StubDB 桩表（aux_items_test.gd）——typed 赋值会运行期拒收，保守保持 null 注
+# 不标具体类型原因：单元测试注入 StubDB 桩表（treasure_items_test.gd）——typed 赋值会运行期拒收，保守保持 null 注
 var _db = null   # ConfigDB（行定义读取——_init 注入；测试可注入桩表）
 
 
@@ -124,7 +124,7 @@ func _init(db_ref = null) -> void:
 	_db = db_ref
 
 
-# ---- 使用校验（战斗结算 use_aux 编排第二步——纯谓词+投影，零消耗零副作用）----
+# ---- 使用校验（战斗结算 use_treasure 编排第二步——纯谓词+投影，零消耗零副作用）----
 
 # target = 目标格（空间行=3×3 窗口中心；ap 行忽略）。board_size = 板维度；
 # cell_unrevealed_cb = Callable(Vector2i) -> bool（排雷玩法 只读面——预读窗口信息判据）。

game/data/schemas/reward_table.gd

@@ -46,7 +46,7 @@ func validate() -> Array:
 		if atk_type != "" and not ["normal", "pierce", "magic"].has(atk_type):
 			errs.append({"category": "enum", "message": "%s attack_type 出域 {normal, pierce, magic}: %s" % [rid, atk_type]})
 		# aux 投放行专属校验（迭代 7 T1）：极性恒正/加权入池/effect_id=item_id 非空（悬空在 config_db 跨表层
-		# 对 aux_items 词表校验——reward_dangling_aux）/无 power 无区间（数值语义不复用，道具效果读 TreasureItemTable）
+		# 对秘宝词表校验——reward_dangling_treasure）/无 power 无区间（数值语义不复用，道具效果读 TreasureItemTable）
 		if ctype == TREASURE_ITEM_TYPE:
 			# 负向行 = 雷格极性字典占位（雷安同池摇号下雷格可摇中 aux 身份——负路由零兑付兜底，
 			# effect_id 空/power 0/weight 0 不入池；2026-09-29 T1）

game/data/schemas/treasure_item_table.gd

@@ -1,10 +1,10 @@
 # VERTICAL SLICE - NOT FOR PRODUCTION
 # Validation Question: 挖掘期撞上推理断头时，玩家能否从掉落池捡到秘宝、在关键时刻花掉买回情报或行动点（P0）
 # Date: 2026-09-29（迭代 7 T1 数据面——秘宝内容批；设计权威 design/gdd/systems/排雷循环/秘宝.md v0.4+
-#   + registry aux_items 六行 mvp_content；2026-09-29 用户拍板：①乙 探宝罗盘退役留痕 ④甲 显影尘/地穴全图卷失义件
+#   + registry 秘宝条目六行 mvp_content；2026-09-29 用户拍板：①乙 探宝罗盘退役留痕 ④甲 显影尘/地穴全图卷失义件
 #   六行全建零投放「已解锁·能力封存中」）
 # 数据配置 TreasureItemTable schema（秘宝 回填 owner）。
-# 行 = Dictionary，键 item_id（Rule 4 豁免：定义表——registry aux_items Rule 4 豁免先例）。
+# 行 = Dictionary，键 item_id（Rule 4 豁免：定义表——registry 秘宝条目 Rule 4 豁免先例）。
 # 七字段（registry fields 全量）：item_id 主键 / display_name / dimension_tags ⊆ 五维 非空 /
 #   effect_kinds ⊆ {mine_reveal, reward_preview, ap_grant}（活性校验见下）/ target ∈ {none, area_3x3, board_wide} /
 #   magnitude [0,999]（仅 ap_grant 行消费，加载校验 ≥1）/ use_phase ∈ {active_dig}。

game/presentation/battle_narrator.gd

@@ -94,8 +94,8 @@ static func bonus_pick_header(payload: Dictionary) -> String:
 
 # 三选一选项卡文案（件名 + 档位 + 效果读数；值 = 冒险表行值，组合根喂入；TP0 令牌池——档位词
 # 对齐 v2.2 追认 b 口径：小/大前缀（小GP/大GP 族）、恢复/AP 不带档位词；道具件掷定前置时
-# aux_line = 具体道具「名 · 效果摘要」行——池种退役后恒空走通用分支，机械惰性保留）
-static func bonus_card_text(id: String, tier: String, value: int, aux_line: String = "") -> String:
+# treasure_line = 具体道具「名 · 效果摘要」行——池种退役后恒空走通用分支，机械惰性保留）
+static func bonus_card_text(id: String, tier: String, value: int, treasure_line: String = "") -> String:
 	var ts := ""
 	if tier == "common":
 		ts = " · 小"
@@ -113,8 +113,8 @@ static func bonus_card_text(id: String, tier: String, value: int, aux_line: Stri
 		"heal":
 			return "恢复药剂\n生命 +%d（当即回复）" % value
 		"treasure_item":
-			if aux_line != "":
-				return "秘宝\n%s" % aux_line
+			if treasure_line != "":
+				return "秘宝\n%s" % treasure_line
 			return "秘宝\n随机获得一件"
 		"ap":
 			return "行动点提升\n每战首轮 AP +%d" % value

game/presentation/bonus_interact_controller.gd

@@ -29,7 +29,7 @@ var _gp_summary: Callable               # () → 战斗总结 GP 行文案（组
 
 var _pending_bonus := {}                # 三选一停点载荷暂存（迭代 10——战斗总结结算确认后开三选一面；续玩停点复用）
 var _bonus_context := "level_clear"     # 三选一面上下文（level_clear=通关停点→推进下一关 / reward_node=奖励节点→回图选路）
-var _last_replace_items: Array = []     # 替换子态续玩重建缓存（aux_replace_presented 载荷）
+var _last_replace_items: Array = []     # 替换子态续玩重建缓存（treasure_replace_presented 载荷）
 var _last_replace_incoming := {}        # 同上——incoming 记录
 
 
@@ -87,7 +87,7 @@ func on_presented(payload: Dictionary) -> void:
 	_refresh_presentations.call()
 
 
-# 三选一面开出（战斗总结结算确认 / 续玩停点恢复；替换在途由 aux_replace_presented 续发直落子态）
+# 三选一面开出（战斗总结结算确认 / 续玩停点恢复；替换在途由 treasure_replace_presented 续发直落子态）
 # 奖励节点三选一（迭代 10 追加批——与通关三选一共享同池同权重同上限；BonusPickOverlay 共用面，
 # 道具件满位替换子交互同构）。原「秘宝投放渠道」三选一（迭代 7 过渡形态）随批退役。
 func present_node_bonus() -> void:
@@ -101,7 +101,7 @@ func present_node_bonus() -> void:
 	bonus_overlay.set_refresh_info(adventure.attune_refresh_left())   # 迭代 11 第①批 T5b——刷新余量投喂
 
 
-# 三选一面开出（战斗总结结算确认 / 续玩停点恢复；替换在途由 aux_replace_presented 续发直落子态）
+# 三选一面开出（战斗总结结算确认 / 续玩停点恢复；替换在途由 treasure_replace_presented 续发直落子态）
 func show_pick() -> void:
 	var payload: Dictionary = _pending_bonus
 	_open_modal.call(bonus_overlay)
@@ -111,11 +111,11 @@ func show_pick() -> void:
 	_refresh_presentations.call()
 
 
-func _bonus_card_texts(candidates: Array, aux_detail: Array = []) -> Array:
+func _bonus_card_texts(candidates: Array, treasure_detail: Array = []) -> Array:
 	# TP0 令牌池——候选 = {"kind","tier"} 令牌字典；卡片 id = "kind|tier|relic_id" 复合键（同 kind
 	# 大小两档/同档多 relic 可同屏，kind 单键不构成唯一身份），确认回程拆键（on_pick_confirmed）
 	var out: Array = []
-	var aux_i := 0
+	var treasure_i := 0
 	for tok in candidates:
 		var kind := String((tok as Dictionary).get("kind", ""))
 		var tier := String((tok as Dictionary).get("tier", ""))
@@ -125,9 +125,9 @@ func _bonus_card_texts(candidates: Array, aux_detail: Array = []) -> Array:
 		if kind == "relic":
 			text = Narrator.relic_card_text(db.relic_row(rid))
 		elif kind == "treasure_item":
-			var iid := String(aux_detail[aux_i]) if aux_i < aux_detail.size() else ""
-			aux_i += 1
-			text = Narrator.bonus_card_text(kind, tier, int(db.adventure.feature_value(kind, tier)), _aux_card_line(iid))
+			var iid := String(treasure_detail[treasure_i]) if treasure_i < treasure_detail.size() else ""
+			treasure_i += 1
+			text = Narrator.bonus_card_text(kind, tier, int(db.adventure.feature_value(kind, tier)), _treasure_card_line(iid))
 		else:
 			text = Narrator.bonus_card_text(kind, tier, int(db.adventure.feature_value(kind, tier)))
 		out.append({"id": cid, "text": text})
@@ -135,7 +135,7 @@ func _bonus_card_texts(candidates: Array, aux_detail: Array = []) -> Array:
 
 
 # 道具件卡片行（掷定前置——具体道具名 + 效果摘要；空 iid = 无预掷回退态显示通用文案）
-func _aux_card_line(iid: String) -> String:
+func _treasure_card_line(iid: String) -> String:
 	if iid == "":
 		return ""
 	var row: Dictionary = db.treasure_item_row(iid)
@@ -185,7 +185,7 @@ func on_pick_confirmed(item_id: String) -> void:
 		push_error("[bonus_interact] 三选一兑付被拒——见输出日志")
 
 
-func on_aux_replace_presented(items: Array, incoming: Dictionary) -> void:
+func on_treasure_replace_presented(items: Array, incoming: Dictionary) -> void:
 	_last_replace_items = items.duplicate(true)
 	_last_replace_incoming = incoming.duplicate(true)
 	if not bonus_overlay.visible:

game/presentation/main.gd

@@ -36,7 +36,7 @@ const ModalStack := preload("res://presentation/modal_stack.gd")
 const TuneSimController := preload("res://presentation/tune_sim_controller.gd")
 const DebugSessionScript := preload("res://presentation/debug_session.gd")
 const RowPacer := preload("res://presentation/row_pacer.gd")                       # 结算行排播泵（T3 拆件批）
-const AuxInteractController := preload("res://presentation/treasure_interact_controller.gd")   # 秘宝两步交互（T3 拆件批）
+const TreasureInteractController := preload("res://presentation/treasure_interact_controller.gd")   # 秘宝两步交互（T3 拆件批）
 const GpShadowLedgerScript := preload("res://presentation/gp_shadow_ledger.gd")    # GP 影子账本（T3 拆件批）
 const BonusInteractController := preload("res://presentation/bonus_interact_controller.gd")   # 三选一与替换子交互（T4/D4 拆件批）
 const CampShopPresenter := preload("res://presentation/camp_shop_presenter.gd")    # 营地/商店投影（T4/D4 拆件批）
@@ -90,7 +90,7 @@ var settlement_fx: SettlementFxView       # 结算演出覆盖层（跨区弹道
 
 # T3 拆件批（2026-10-02）——三件迁出后的组合根持有面（职责见各类头注；装配见 _build_ui）
 var _row_pacer = null                     # 结算行排播泵（row_pacer.gd——本类只入队/排空/读队列）
-var _aux = null                           # 秘宝两步交互（treasure_interact_controller.gd——本类只接线与转发意图）
+var _treasure_ui = null                           # 秘宝两步交互（treasure_interact_controller.gd——本类只接线与转发意图）
 var _bonus = null                         # 三选一与替换子交互（bonus_interact_controller.gd——本类只接线与回调注入）
 var _camp_pres = null                     # 营地/商店投影（camp_shop_presenter.gd——本类只接线、探针缝保缝转发）
 var _gp_ledger := GpShadowLedgerScript.new()   # GP 冒险钱包影子账（gp_shadow_ledger.gd——wallet 事件投喂）
@@ -219,11 +219,11 @@ func _build_ui() -> void:
 	add_child(_row_pacer)
 	# 秘宝两步交互（T3 拆件批——迁 treasure_interact_controller.gd；settlement/runner 随关卡更替，
 	# 经现值回调注入——仿 identity_resolver 只读回调先例）
-	_aux = AuxInteractController.new(db, meta, info_panel, board_zone.toast, board_view,
+	_treasure_ui = TreasureInteractController.new(db, meta, info_panel, board_zone.toast, board_view,
 		func() -> Variant: return settlement, func() -> Variant: return runner)
 
 	board_zone.action_requested.connect(_on_board_action)
-	info_panel.aux_slot_clicked.connect(_aux.on_slot_clicked)   # 迭代 7 T4——两步交互第一步
+	info_panel.treasure_slot_clicked.connect(_treasure_ui.on_slot_clicked)   # 迭代 7 T4——两步交互第一步
 	board_zone.stop_pressed.connect(_on_stop_pressed)
 	board_zone.refresh_confirmed.connect(_on_refresh_confirmed)
 	board_zone.legend_toggled.connect(_on_legend_toggled)
@@ -434,7 +434,7 @@ func _resume_from_menu() -> void:
 	log_view.clear()
 	logger.start_session(int(bp.get("master_seed", 0)))
 	adventure.set_hero_override(debug_overlay.atk_pct(), debug_overlay.hp_pct())
-	if not adventure.resume_adventure(bp, {"hero_override": meta.hero_override() if meta != null else {}, "aux_unlocked": _aux.unlocked_set()}):
+	if not adventure.resume_adventure(bp, {"hero_override": meta.hero_override() if meta != null else {}, "treasure_unlocked": _treasure_ui.unlocked_set()}):
 		_fatal_screen("续玩恢复失败——见输出日志")
 		return
 
@@ -452,7 +452,7 @@ func _wire_adventure() -> void:
 	# 迭代 10 奖励重构批——big_reward_paid 退役，三选一信号族接线
 	adventure.bonus_choice_presented.connect(_bonus.on_presented)
 	adventure.bonus_resolved.connect(_bonus.on_resolved)
-	adventure.aux_replace_presented.connect(_bonus.on_aux_replace_presented)
+	adventure.treasure_replace_presented.connect(_bonus.on_treasure_replace_presented)
 	adventure.adventure_finished.connect(_on_adventure_finished)
 	adventure.level_started.connect(_on_adventure_level_started)
 	adventure.set_save_manager(save_manager)   # 断点承载注入（迭代 8 卡①——停点快照写盘；调试/模拟不经过此路径）
@@ -472,7 +472,7 @@ func _start_adventure() -> void:
 	# 永久强化注入（元进度实现批）：冒险开始参数面——meta 现算 override 显式传参（全零 = 白板）
 	# 首次冒险脚本（关卡节点图生成 v0.4）：存档布尔位 false = 全关固定模板 0（教学重放）；置位后逐关抽签
 	var first_script: bool = not save_manager.is_first_adventure_done()
-	if not adventure.start_adventure(seed_val, {"hero_override": meta.hero_override() if meta != null else {}, "first_script": first_script, "aux_unlocked": _aux.unlocked_set(), "shop_mode": "pool"}):
+	if not adventure.start_adventure(seed_val, {"hero_override": meta.hero_override() if meta != null else {}, "first_script": first_script, "treasure_unlocked": _treasure_ui.unlocked_set(), "shop_mode": "pool"}):
 		_fatal_screen("冒险启动失败——见输出日志")
 		return
 
@@ -956,15 +956,15 @@ func _on_board_action(cell: Vector2i, kind: String) -> void:
 		return
 	# 秘宝选中态劫持（迭代 7 T4——两步交互第二步）：点格=使用目标拾取，不落挖格；
 	# 只劫持挖掘点击（move/flag 语义不冲突——选中期玩家仍可移动/插旗）
-	var aux_sel: int = _aux.active_selection()
-	if aux_sel != 0 and kind == "dig":
-		_aux.attempt_use(aux_sel, cell)
+	var treasure_sel: int = _treasure_ui.active_selection()
+	if treasure_sel != 0 and kind == "dig":
+		_treasure_ui.attempt_use(treasure_sel, cell)
 		return
 	var outcomes: Array = settlement.minesweeper.settle_batch([{"action": kind, "cell": cell}])
 	var accepted: bool = not outcomes.is_empty() and bool(outcomes[0].accepted)
 	logger.log_action(kind, cell, accepted)
-	if runner != null and runner.aux_inventory != null:
-		_aux.refresh_slots()   # 迭代 7 T4——授予发生在 settle_batch 结算段内（同步走完，行尾重查）
+	if runner != null and runner.treasure_inventory != null:
+		_treasure_ui.refresh_slots()   # 迭代 7 T4——授予发生在 settle_batch 结算段内（同步走完，行尾重查）
 	_handle_outcome_feedback(outcomes[0] if not outcomes.is_empty() else {})
 	# settle_batch 内部同步走完 结算→战斗结束→关卡推进（事件同步发射）——关卡终局时 settlement 已被
 	# runner 置空，清图演出判定须先判 settlement（基线既有重入隐患，2026-09-13 加固）

game/presentation/treasure_interact_controller.gd

@@ -2,16 +2,16 @@
 # 秘宝两步交互控制器（迭代 7 T4；T3 拆件批 2026-10-02 自 main.gd 迁出——规范 1.1 单一职责）：
 # C 区槽位选中/取消（toggle）→ 棋盘点格使用目标拾取的两步交互状态机 + 库存/叠加层只读投影装配。
 # 数据源 = runner 级库存只读面（query_inventory/query_overlays）+ 表行投影（display_name/target/effect_kinds）；
-# 写调用唯一经 战斗结算.use_aux（core 侧四步编排——拒绝零消耗 toast 可辨认）。
+# 写调用唯一经 战斗结算.use_treasure（core 侧四步编排——拒绝零消耗 toast 可辨认）。
 # 装配纪律：settlement/runner 随关卡逐关更替——经组合根现值回调注入（仿 identity_resolver 只读回调
 # 先例）；呈现句柄（信息面板/toast/棋盘叠加层）由组合根注入；ADR-0001——信号连接不在此发生，
-# info_panel.aux_slot_clicked 由组合根接至 on_slot_clicked。
+# info_panel.treasure_slot_clicked 由组合根接至 on_slot_clicked。
 # 无目标使用显式化（T3 收口）：AP 类（target=none）本无坐标可给——原调用面伪造 Vector2i(-9,-9)
 # 哨兵坐标；现调用面一律 attempt_use(handle)（cell 缺省=null=显式「无目标」），core 契约的
-# Vector2i 形参收口于本类常量（aux_items.validate_use 对 ap 行忽略目标值，哨兵不出本类）。
+# Vector2i 形参收口于本类常量（treasure_items.validate_use 对 ap 行忽略目标值，哨兵不出本类）。
 extends RefCounted
 
-const NO_TARGET := Vector2i(-9, -9)   # core use_aux 形参占位（仅 target=none 行到达——validate_use 忽略该值）
+const NO_TARGET := Vector2i(-9, -9)   # core use_treasure 形参占位（仅 target=none 行到达——validate_use 忽略该值）
 
 var db
 var meta                       # 解锁门控数据源（工坊解锁×活行交集——冒险开始组装；组合根 _ready 建立后注入）
@@ -56,7 +56,7 @@ func active_selection() -> int:
 func on_slot_clicked(slot_handle: int) -> void:
 	var settlement = _settlement_get.call()
 	var runner = _runner_get.call()
-	if settlement == null or runner == null or runner.aux_inventory == null:
+	if settlement == null or runner == null or runner.treasure_inventory == null:
 		return
 	if slot_handle == 0:
 		_use_selection = 0
@@ -82,13 +82,13 @@ func on_slot_clicked(slot_handle: int) -> void:
 		toast.show_toast("%s：点击目标格使用（9 宫窗口），再点道具取消" % String(rec.get("name", "")), "info")
 
 
-# 使用受理（第二步；cell=空间类目标格，null=无目标；core 侧 use_aux 四步编排——拒绝零消耗 toast 可辨认）
+# 使用受理（第二步；cell=空间类目标格，null=无目标；core 侧 use_treasure 四步编排——拒绝零消耗 toast 可辨认）
 func attempt_use(handle: int, cell: Variant = null) -> void:
 	var settlement = _settlement_get.call()
 	if settlement == null:
 		return
 	var target: Vector2i = cell if cell != null else NO_TARGET
-	var v: Dictionary = settlement.use_aux(handle, target)
+	var v: Dictionary = settlement.use_treasure(handle, target)
 	if not bool(v.ok):
 		toast.show_toast(String(v.get("reason", "无法使用")), "warn")
 		return
@@ -103,7 +103,7 @@ func attempt_use(handle: int, cell: Variant = null) -> void:
 # 库存投影（C 区四槽取数面——字形=名首字；usable=板级零信息预判回调接排雷玩法只读面）
 func inventory_projection() -> Array:
 	var runner = _runner_get.call()
-	if runner == null or runner.aux_inventory == null:
+	if runner == null or runner.treasure_inventory == null:
 		return []
 	var settlement = _settlement_get.call()
 	var ms = settlement.minesweeper if settlement != null else null
@@ -112,7 +112,7 @@ func inventory_projection() -> Array:
 		cb = func(_c: Vector2i) -> bool:
 			return ms.has_unrevealed()   # 只读查询面（排雷玩法 has_unrevealed——手搓全板双循环收口）
 	var out: Array = []
-	for rec in runner.aux_inventory.query_inventory(cb):
+	for rec in runner.treasure_inventory.query_inventory(cb):
 		var arow: Dictionary = db.treasure_item_row(String(rec.get("item_id", "")))
 		var dn := String(arow.get("display_name", ""))
 		out.append({
@@ -127,13 +127,13 @@ func inventory_projection() -> Array:
 
 
 func refresh_slots() -> void:
-	info_panel.set_aux_inventory(inventory_projection(), _use_selection)
+	info_panel.set_treasure_inventory(inventory_projection(), _use_selection)
 
 
 # 叠加层投影注入（use 成功/三清后——棋盘标记与预读徽章重算）
 func refresh_overlays() -> void:
 	var runner = _runner_get.call()
-	if runner == null or runner.aux_inventory == null or board_view == null:
+	if runner == null or runner.treasure_inventory == null or board_view == null:
 		return
-	var ov: Dictionary = runner.aux_inventory.query_overlays()
-	board_view.set_aux_overlays(ov.get("mine_reveal", []), ov.get("reward_preview", []))
+	var ov: Dictionary = runner.treasure_inventory.query_overlays()
+	board_view.set_treasure_overlays(ov.get("mine_reveal", []), ov.get("reward_preview", []))

game/presentation/views/board_cell_unit.gd

@@ -82,7 +82,7 @@ var tex_base: Texture2D = null     # ① 砖面底
 var tex_mutation: Texture2D = null # ② 变异纹带
 var tex_glyph: Texture2D = null    # ③ 数字
 var tex_badge: Texture2D = null    # ③' 徽章
-var tex_flag: Texture2D = null:    # ④ 旗（T17 修复：槽位可运行时换装〔插旗〕——同族 facade/aux_mark
+var tex_flag: Texture2D = null:    # ④ 旗（T17 修复：槽位可运行时换装〔插旗〕——同族 facade/treasure_mark
 	set(v):                        #  均 setter 触发重绘；旧普通 var 赋值不重绘=旗插上不显示）
 		if tex_flag != v:
 			tex_flag = v
@@ -98,10 +98,10 @@ var facade_strip := false:         # E 格开关（BoardView paint 按「已开
 # 叠加层标记（迭代 7 T4——秘宝板级叠加层的格面呈现；派生信息层零回写）：
 # "mine_reveal" = 真视格（危险红内缩框——「这格是雷」的确定决策标记，插旗照常计费）；
 # "reward_preview" 格不复用本字段——预读徽章走 badge_glyph 注入（board_view refresh 注入 REWARD_BADGE 字形）
-var aux_mark := "":
+var treasure_mark := "":
 	set(v):
-		if aux_mark != v:
-			aux_mark = v
+		if treasure_mark != v:
+			treasure_mark = v
 			queue_redraw()
 var mutation_mark := "":
 	set(v):
@@ -213,7 +213,7 @@ func _draw() -> void:
 	# ②' 变异角标（迭代 6 T6）：左下角危险红三角（危险红=「开此格有代价」语义位，与雷族同源；
 	# 尺寸随格边比例——灰色可辨辅助=红对砖面明度差，禁喧宾）
 	# ②" 秘宝叠加层（迭代 7 T4）：真视格=危险红内缩框（策略纹理——确定决策输入不喧宾）
-	if aux_mark == "mine_reveal":
+	if treasure_mark == "mine_reveal":
 		var inset := edge * 0.14
 		draw_rect(Rect2(inset, inset, edge - inset * 2.0, edge - inset * 2.0),
 			Color(UiKit.RED_MINE, 0.9), false, 2.0)

game/presentation/views/board_view.gd

@@ -98,8 +98,8 @@ var _minesweeper = null              # 排雷玩法 只读查询引用（refresh
 var _identity_cb := Callable()   # 地图战斗资源 身份解析回调（组合根注入只读面）——Vector2i → Dictionary/null
 var _mask_cb := Callable()       # 地形变异 数字遮蔽回调（组合根注入只读面）——Vector2i → bool（true = 该格数字不显示）
 var _vmark_cb := Callable()      # 地形变异 角标回调（迭代 6 T6 只读面）——Vector2i → String（"flat_damage"=伤害型变异未开格；""=无）
-var _aux_reveal := {}            # 秘宝 真视集（迭代 7 T4——Vector2i → true；组合根 set_aux_overlays 注入投影）
-var _aux_preview := {}           # 秘宝 预读集（同上——未开格徽章呈现挂点）
+var _treasure_reveal := {}            # 秘宝 真视集（迭代 7 T4——Vector2i → true；组合根 set_treasure_overlays 注入投影）
+var _treasure_preview := {}           # 秘宝 预读集（同上——未开格徽章呈现挂点）
 var _diggable := {}         # 可挖域（8 向相邻未开格）——呼吸微光作用集
 var _breath_t := 0.0
 var _contact_unit: Node2D = null   # 接触带承载单元（=英雄格 CellUnit；rebuild 随清场复位）
@@ -214,13 +214,13 @@ func set_variant_mark_resolver(cb: Callable) -> void:
 	_vmark_cb = cb
 
 # 秘宝叠加层投影注入（迭代 7 T4——组合根在 use 成功/三清后调；refresh 消费）
-func set_aux_overlays(reveal_cells: Array, preview_cells: Array) -> void:
-	_aux_reveal.clear()
-	_aux_preview.clear()
+func set_treasure_overlays(reveal_cells: Array, preview_cells: Array) -> void:
+	_treasure_reveal.clear()
+	_treasure_preview.clear()
 	for c in reveal_cells:
-		_aux_reveal[Vector2i(c)] = true
+		_treasure_reveal[Vector2i(c)] = true
 	for c in preview_cells:
-		_aux_preview[Vector2i(c)] = true
+		_treasure_preview[Vector2i(c)] = true
 	refresh()
 
 
@@ -791,8 +791,8 @@ func _paint_cell(c: Vector2i, hero: Vector2i) -> void:
 	# ②( 秘宝叠加层（迭代 7 T4）：真视格=红内缩框；预读格=奖励身份徽章（identity_resolver 既有
 	# 只读面取字形——零数据复制，badge 位复用）；已开格标记自然退位（refresh 逐拍重算）
 	if not revealed:
-		u.aux_mark = "mine_reveal" if _aux_reveal.has(c) else ""
-		if _aux_preview.has(c) and glyph == "":
+		u.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", ""))])

game/presentation/views/bonus_pick_overlay.gd

@@ -172,7 +172,7 @@ func show_result(text: String) -> void:
 	visible = true
 
 
-# 同调位替换子态（aux_replace_presented 到达）：items = [{index, item_id, display_name}]（组合根
+# 同调位替换子态（treasure_replace_presented 到达）：items = [{index, item_id, display_name}]（组合根
 # 喂显示名）。两路出口：丢旧收新（逐件钮）/ 放弃新件——终态恒 ≤ 同调位由核心受理面保证。
 func open_replace(items: Array, incoming_name: String, holding: int, slots: int) -> void:
 	_label.text = "同调位已满（%d/%d）——收下「%s」需丢弃一件已有道具，或放弃新件" % [holding, slots, incoming_name]

game/presentation/views/hero_info_panel_view.gd

@@ -14,11 +14,11 @@ const COL_INK := UiKit.INK
 
 var _atk_label: Label
 var _armor_label: Label
-signal aux_slot_clicked(handle: int)       # 迭代 7 T4——槽点击（组合根消费：AP 类即用/空间类进选中态）
+signal treasure_slot_clicked(handle: int)       # 迭代 7 T4——槽点击（组合根消费：AP 类即用/空间类进选中态）
 var item_slots: HBoxContainer              # 秘宝槽（迭代 7 T4 接线——库存条常读+两步交互第一步）
 var _slot_panels: Array = []               # 槽 PanelContainer 引用（选中高亮/置灰重刷）
 var _selected_handle := 0                  # 选中态（0=无；组合根回写维持单源）
-var _slot_handles: Array = []              # 槽位→handle 映射（set_aux_inventory 刷新）
+var _slot_handles: Array = []              # 槽位→handle 映射（set_treasure_inventory 刷新）
 var _bonus_section: VBoxContainer          # 特性（预留——空态隐藏，接线归大奖励/锻造呈现批）
 var _bonus_list: VBoxContainer
 var _relic_section: VBoxContainer          # 特性持有段（迭代 12 呈现补齐——空态隐藏）
@@ -66,7 +66,7 @@ func _init() -> void:
 		slot.gui_input.connect(func(ev: InputEvent):
 			if ev is InputEventMouseButton and ev.pressed and ev.button_index == MOUSE_BUTTON_LEFT:
 				# 空槽/越界槽点击=取消选中（handle 0）；有效槽发其 handle（组合根判 AP 即用/进选中态）
-				aux_slot_clicked.emit(_slot_handles[idx] if idx < _slot_handles.size() else 0))
+				treasure_slot_clicked.emit(_slot_handles[idx] if idx < _slot_handles.size() else 0))
 		item_slots.add_child(slot)
 		_slot_panels.append(slot)
 
@@ -166,7 +166,7 @@ func _data_line() -> Label:
 # 投影行 = {handle, glyph, name, used, usable}（组合根组装：字形=道具名首字；数据源 runner 级库存只读面）。
 # 空槽=虚位；used=暗态「已用」保留占位（Used 不可逆——受理序展示语义）；不可用=置灰（板级零信息）；
 # selected=金框高亮（两步交互第一步的可见态）。tooltip=全名+维度语义。
-func set_aux_inventory(items: Array, selected_handle: int) -> void:
+func set_treasure_inventory(items: Array, selected_handle: int) -> void:
 	_selected_handle = selected_handle
 	_slot_handles.clear()
 	for i in 4:

game/smoke/level_autoplay.gd

@@ -153,7 +153,7 @@ static func run_adventure(db, seed_val: int, atk_pct: int, hp_pct: int, collect_
 	# 道具件满位替换放弃新件、兑付后推进下一关——零随机流自开，同种子逐位可复放）
 	adr.bonus_choice_presented.connect(_on_adventure_bonus.bind(st, adr))
 	adr.bonus_resolved.connect(_on_adventure_bonus_resolved.bind(st, adr))
-	adr.aux_replace_presented.connect(_on_adventure_aux_replace.bind(st, adr))
+	adr.treasure_replace_presented.connect(_on_adventure_treasure_replace.bind(st, adr))
 	adr.adventure_finished.connect(_on_adventure_finished.bind(st, logger))
 	adr.set_hero_override(atk_pct, hp_pct)
 	# 同调分层注入（迭代 11 第①批 T8——缺省 {} 与既有调用方逐位一致零行为变更）
@@ -302,8 +302,8 @@ static func _pick_token(candidates: Array, relic_mode: String = "off") -> Dictio
 
 
 # 同调位满位替换子交互（确定性策略：放弃新件不获取——分发面按停点上下文裁决节点/通关渠道）
-static func _on_adventure_aux_replace(items: Array, incoming: Dictionary, st: Dictionary, adr) -> void:
-	st.reward_events.append({"aux_replace": incoming.duplicate(true)})
+static func _on_adventure_treasure_replace(items: Array, incoming: Dictionary, st: Dictionary, adr) -> void:
+	st.reward_events.append({"treasure_replace": incoming.duplicate(true)})
 	if not adr.resolve_bonus_replace(-1):
 		st.result = "advance_failed"
 

game/smoke/smoke_all.gd

@@ -541,7 +541,7 @@ func _smoke_adventure() -> void:
 	# ⑪ 池耗即枯竭 + 池收缩 + 满血回 0（TP0——white-box：耗尽 attack/ap 令牌后候选零出现；
 	# 种类次数上限退役，「达上限剔除」语义由牌库耗尽承载）
 	var a11 = load("res://core/adventure_runner.gd").new(_db, _fresh_rng(11))
-	check(a11.start_adventure(11, {"first_script": true, "aux_unlocked": {"blast_kit": true}}),
+	check(a11.start_adventure(11, {"first_script": true, "treasure_unlocked": {"blast_kit": true}}),
 		"剔牌库/替换场景：冒险启动（seed 11——道具解锁集只含 blast_kit）")
 	for di in range(a11._bonus_deck.size() - 1, -1, -1):
 		var dk := String((a11._bonus_deck[di] as Dictionary).get("kind", ""))
@@ -556,13 +556,13 @@ func _smoke_adventure() -> void:
 	check((draw as Array).size() >= 2, "池耗后候选恒 ≥2（稀有/罕见档余量——防「三选项全不可选」死角）")
 	# 池收缩（迭代 11 同调批 T7——aux 卡退役出三选一牌库：重复抽样零 aux 候选；同调位替换两路
 	# white-box 测试随停点渠道退役拆除——机械惰性承载，零投放零行为）
-	var aux_seen := false
+	var treasure_seen := false
 	for i in 40:
 		for t in a11._draw_bonus_candidates():
 			if String((t as Dictionary).get("kind", "")) == "treasure_item":
-				aux_seen = true
+				treasure_seen = true
 				break
-	check(not aux_seen, "池收缩——40 次重抽零 aux 候选（停点渠道 aux 卡退役，迭代 11 第①批 T7）")
+	check(not treasure_seen, "池收缩——40 次重抽零 aux 候选（停点渠道 aux 卡退役，迭代 11 第①批 T7）")
 	# 满血回 0 合法（通关回血封顶口径）
 	var a12 = load("res://core/adventure_runner.gd").new(_db, _fresh_rng(12))
 	a12.start_adventure(12, {"first_script": true})
@@ -575,7 +575,7 @@ func _smoke_adventure() -> void:
 		"满血通关回血 0 合法（封顶口径——heal_gained=0 非负溢出）")
 	# ⑬ 奖励节点共享池（迭代 10 追加批——同库同池同摘牌；TP0：attack 令牌耗尽后节点域同样零出现）
 	var a13 = load("res://core/adventure_runner.gd").new(_db, _fresh_rng(13))
-	check(a13.start_adventure(13, {"first_script": true, "aux_unlocked": {"blast_kit": true}}),
+	check(a13.start_adventure(13, {"first_script": true, "treasure_unlocked": {"blast_kit": true}}),
 		"节点共享池场景：冒险启动（seed 13）")
 	for di13 in range(a13._bonus_deck.size() - 1, -1, -1):
 		if String((a13._bonus_deck[di13] as Dictionary).get("kind", "")) == "attack":
@@ -4492,8 +4492,8 @@ func _smoke_save() -> void:
 	var bp_visited: Array = bp.get("visited_ids", [])
 	check(bp_visited.size() == 3 and int(bp_visited[0]) == 0 and int(bp_visited[2]) == 5,
 		"断点附随件往返：已到节点序")
-	var bp_aux: Array = bp.get("aux_items", [])
-	check(bp_aux.size() == 1 and String(bp_aux[0].get("item_id", "")) == "aux_scout",
+	var bp_treasure: Array = bp.get("aux_items", [])
+	check(bp_treasure.size() == 1 and String(bp_treasure[0].get("item_id", "")) == "aux_scout",
 		"断点附随件往返：道具库存")
 	bp["hero_hp"] = 999
 	check(int((rb.breakpoint_snapshot() as Dictionary).get("hero_hp", -1)) == 13,

game/tests/unit/core/breakpoint_resume_test.gd

@@ -26,7 +26,7 @@ func _init() -> void:
 	var sm_a = SaveManagerScript.new(_bp_path)
 	var adr_a = AdventureRunnerScript.new(db, rng_a)
 	adr_a.set_save_manager(sm_a)
-	var params := {"hero_override": {}, "aux_unlocked": {}}
+	var params := {"hero_override": {}, "treasure_unlocked": {}}
 	Kit.check_quiet(adr_a.start_adventure(1234, params), "冒险启动（入口停点）")
 	Kit.check_quiet(sm_a.has_breakpoint(), "入口停点断点在档")
 	Kit.check_quiet(int((sm_a.breakpoint_snapshot() as Dictionary).get("level_index", -1)) == 1, "断点关卡序号 = 1")
@@ -91,7 +91,7 @@ func _init() -> void:
 	var sm_e = SaveManagerScript.new(_bp_path)
 	var adr_e = AdventureRunnerScript.new(db, rng_e)
 	adr_e.set_save_manager(sm_e)
-	var params_e := {"hero_override": {}, "aux_unlocked": {"blast_kit": true}}
+	var params_e := {"hero_override": {}, "treasure_unlocked": {"blast_kit": true}}
 	Kit.check_quiet(adr_e.start_adventure(4321, params_e), "P5 冒险启动（seed 4321）")
 	adr_e._bonus_taken["attack"] = 1   # 白盒预置计数（断点附随件往返的判据面——计数不可由加算区反推）
 	adr_e._on_level_finished({"result": "victory", "hp": 30, "node_index": 1, "node_id": 1, "node_type": "shop"})