iter41-卡1：核心数据面结构收敛批：85键全清——三族拆域＋config_db归位容器＋存档拆件＋meta瘦身＋adventure拆段＋spawn束化；行为零变化，8新件在阈

game/tests/unit/core/adventure_feats_test.gd

@@ -44,15 +44,6 @@ func _smoke_find_token(candidates: Array, kind: String, tier: String) -> Diction
 	return {}
 
 
-# 效果命中分桶（公开 dispatch 返回值的本地过滤——断言钉公开可观测面；编排器私有过滤器的测试侧等价承载）
-func _hits_kind(hits: Array, kind: String) -> Array:
-	var out: Array = []
-	for h in hits:
-		if String((h as Dictionary).get("kind", "")) == kind:
-			out.append(h)
-	return out
-
-
 # ② 冒险结构 API 闸（状态机受理面——重复开始拒绝 / 入口停点 / 放弃两态）
 
 
@@ -124,10 +115,10 @@ func _smoke_adventure() -> void:
 	var autoplay = load("res://sim/level_autoplay.gd")
 	# ① 表与覆盖义务（序列关数 = 行集关数；节点源 = 参数档在固定种子下的生成图，
 	# 每个战斗/Boss 节点经 ConfigDB 真实解析链查敌行集与棋盘行——顶 clamp 消解禁〔fv24〕）
-	Kit.check("序列关数 = 行集关数（三关正式序列生效）", int(_db.level.rows.size()) == 3)
+	Kit.check("序列关数 = 行集关数（三关正式序列生效）", int(_db.run.level.rows.size()) == 3)
 	var cov_miss := 0
 	var cov_scan := 0
-	for li in range(1, int(_db.level.rows.size()) + 1):
+	for li in range(1, int(_db.run.level.rows.size()) + 1):
 		for n in _level_active_nodes(li):
 			var nt := String(n.get("type", ""))
 			if nt != "battle" and nt != "boss":
@@ -135,10 +126,10 @@ func _smoke_adventure() -> void:
 			var d: int = int(n.get("depth", -1))
 			cov_scan += 1
 			var rk := "boss" if nt == "boss" else "battle"
-			var rs: Array[Dictionary] = _db.resolve_enemy_rowset(li, d, rk)
+			var rs: Array[Dictionary] = _db.combat.enemy.resolve_rowset(li, d, rk)
 			if rs.is_empty() or int(rs[0].get("depth_band", -1)) < d:
 				cov_miss += 1
-			if not (_db.resolve_board_gen(li, d) as Dictionary).is_empty():
+			if not (_db.combat.board_gen.resolve_row(li, d) as Dictionary).is_empty():
 				continue
 			cov_miss += 1
 	Kit.check("生成图每个战斗/Boss 节点经解析链命中敌行集与棋盘行（扫描 %d 节点，缺失 %d）〔fv24〕" % [cov_scan, cov_miss],
@@ -149,8 +140,8 @@ func _smoke_adventure() -> void:
 	Kit.check("满配冒险成功（42 / atk+900 / hp+400——cleared=true；v2 怪阶梯后旧 200/100 档不再满配）", String(st["result"]) == "completed" and bool(sum.get("cleared", false)))
 	Kit.check("完成几关 = 3（levels_cleared）", int(sum.get("levels_cleared", -1)) == 3)
 	var ks_exp := 0
-	for li in range(1, int(_db.level.rows.size()) + 1):
-		ks_exp += int(_db.meta_boss_keystone_row(li).get("first_kill", 0))
+	for li in range(1, int(_db.run.level.rows.size()) + 1):
+		ks_exp += int(_db.crossrun.meta.boss_keystone_row(li).get("first_kill", 0))
 	Kit.check("钥石合计 = ΣBoss 首杀行值（%d——逐杀掉落新口径；断点未注入恒首杀）" % int(sum.get("keystone_total", -1)), int(sum.get("keystone_total", -1)) == ks_exp)
 	var drops: Array = sum.get("keystone_drops", []) as Array
 	Kit.check("逐杀掉落明细恰 3 笔（L1/L2/L3——additive 摘要键 keystone_drops）", drops.size() == 3)
@@ -169,7 +160,7 @@ func _smoke_adventure() -> void:
 	# 奖励节点在生成图里是可选路位（旧单链模板的「L1 必经 1 个」形状前提随模板消亡）——
 	# 接线证明拆两半：图侧每关含 ≥1 奖励节点，行进侧种子扫描内确有经停（扫描零经停=三选一接线不可达）
 	var reward_levels := 0
-	for li in range(1, int(_db.level.rows.size()) + 1):
+	for li in range(1, int(_db.run.level.rows.size()) + 1):
 		var rc := 0
 		for n in _level_active_nodes(li):
 			if String(n.get("type", "")) == "reward":
@@ -217,8 +208,8 @@ func _smoke_adventure() -> void:
 	var cand_ok := picks.size() == 2
 	var ks_gain_ok := picks.size() == 2
 	var resolve_ok := level_resolves.size() == 2
-	var max_flat := int(_db.adventure.curio_value_max_hp_common)
-	var heal_pct := int(_db.adventure.clear_heal_pct)
+	var max_flat := int(_db.run.adventure.value_segment.curio_value_max_hp_common)
+	var heal_pct := int(_db.run.adventure.clear_heal_pct)
 	var hp_acc := 0   # max_hp 件累加（回血封顶断言的生效上限推导——TP0 起按兑付令牌实值，大小档分别计）
 	var ks_prefix := 0
 	for i in picks.size():
@@ -240,18 +231,18 @@ func _smoke_adventure() -> void:
 		# 账本生效上限口径：置满/回血封顶按生效上限（flat 后乘调试浮窗 pct）——本段 pct=400
 		# 加算区 = 树/锻造件（hp_acc）＋购血观测值（level_autoplay 停点快照 bonus_max_hp）——精确断言不再窗口拟合
 		var extra_obs := int(p.get("bonus_max_hp", -1))
-		var m_obs := int(round(float(int(_db.hero.max_hp) + hp_acc + extra_obs) * 5.0))
+		var m_obs := int(round(float(int(_db.combat.hero.max_hp) + hp_acc + extra_obs) * 5.0))
 		var heal_exp := mini(int(floor(float(m_obs) * float(heal_pct) / 100.0)), m_obs - hp_before)
 		if extra_obs < 0 or heal != heal_exp or hp_after != hp_before + heal or hp_after > m_obs:
 			heal_ok = false
-		ks_prefix += int(_db.meta_boss_keystone_row(int(p.get("level_index", -1))).get("first_kill", 0))
-		if int(p.get("keystone_gained", -1)) != int(_db.meta_boss_keystone_row(int(p.get("level_index", -1))).get("first_kill", 0)) 			or int(p.get("keystone_total", -1)) != ks_prefix:
+		ks_prefix += int(_db.crossrun.meta.boss_keystone_row(int(p.get("level_index", -1))).get("first_kill", 0))
+		if int(p.get("keystone_gained", -1)) != int(_db.crossrun.meta.boss_keystone_row(int(p.get("level_index", -1))).get("first_kill", 0)) 			or int(p.get("keystone_total", -1)) != ks_prefix:
 			ks_gain_ok = false
 		if resolve_ok:
 			var r: Dictionary = level_resolves[i]
 			var rk := String(r.get("picked", ""))
 			var rt := String(r.get("tier", ""))
-			if _smoke_find_token(p.get("candidates", []) as Array, rk, rt).is_empty() 					or int(r.get("value", -1)) != int(_db.adventure.curio_value(rk, rt)):
+			if _smoke_find_token(p.get("candidates", []) as Array, rk, rt).is_empty() 					or int(r.get("value", -1)) != int(_db.run.adventure.curio_value(rk, rt)):
 				resolve_ok = false
 			if rk == "max_hp":
 				hp_acc += int(r.get("value", max_flat))
@@ -261,10 +252,10 @@ func _smoke_adventure() -> void:
 	Kit.check("点选恰兑付选中一件（值=令牌档位表值；未选项零生效）", resolve_ok)
 	var seq: Array = st["encounter_max_hp_seq"]
 	var k := 5.0   # hp+400 ⇒ 调试浮窗百分比后乘 ×5（加算先加、百分比后乘——生效次序口径）
-	var exp_base := maxi(1, int(round(float(int(_db.hero.max_hp)) * k)))
+	var exp_base := maxi(1, int(round(float(int(_db.combat.hero.max_hp)) * k)))
 	# 模拟档 v3.4 商店贪心购血合法抬升——上限窗口 = 基础 + 加算区 3 件 + 购血余量；
 	# 大生命 +10（优秀档）——上界按大件最坏构成 3×10+购血 15=+45（TP0 放宽承袭）
-	var hp_ceiling := maxi(1, int(round(float(int(_db.hero.max_hp) + 3 * int(_db.adventure.curio_value("max_hp", "excellent")) + 15) * k)))
+	var hp_ceiling := maxi(1, int(round(float(int(_db.combat.hero.max_hp) + 3 * int(_db.run.adventure.curio_value("max_hp", "excellent")) + 15) * k)))
 	var seq_ok := seq.size() > 0 and int(seq[0]) == exp_base
 	for v in (seq as Array):
 		if int(v) < exp_base or int(v) > hp_ceiling:
@@ -303,7 +294,7 @@ func _smoke_adventure() -> void:
 		var sh: Dictionary = half["st"]["summary"]
 		Kit.check("L2 败北摘要：L1 已过（钥石=L1 首杀掉落）· 止步第 2 层",
 		not bool(sh["cleared"]) and int(sh["levels_cleared"]) == 1 \
-				and int(sh["keystone_total"]) == int(_db.meta_boss_keystone_row(1).get("first_kill", 0)) \
+				and int(sh["keystone_total"]) == int(_db.crossrun.meta.boss_keystone_row(1).get("first_kill", 0)) \
 				and int(sh["stopped_at"]) == 2)
 		var dh: Dictionary = sh.get("defeat", {})
 		Kit.check("L2 败北败退明细：层号=2 · 节点在案（数值验证取数面 2026-09-22）",
@@ -353,22 +344,20 @@ func _smoke_adventure() -> void:
 		var r8 = a8.runner()
 		var gp0: int = int(r8.gp)
 		var hp_price := -1
-		for p in _db.shop.products:
+		for p in _db.run.shop.products:
 			if String(p.get("product_id", "")) == "hp_up":
 				hp_price = int(p.get("base_price", -1))
 		var l2_price_bonus := 0
-		for pb in _db.shop.price_level_bonus:
+		for pb in _db.run.shop.price_level_bonus:
 			if int(pb.get("level_index", -1)) == 2:
 				l2_price_bonus = int(pb.get("bonus", 0))
 		Kit.check("进店余额 ≥ hp_up L2 首价（%d = 基价 %d + 关卡加成 %d——配置推导）" % [hp_price + l2_price_bonus, hp_price, l2_price_bonus], gp0 >= hp_price + l2_price_bonus)
 		Kit.check("购买 hp_up 受理（出账 + 加算区）", r8.buy_product("hp_up"))
 		var acc_shop: int = a8.journal().bonus_total("max_hp")   # L1 三选一后 + 商店 3（首件随种子）
 		Kit.check("统一冒险加算区含商店值（max_hp=%d ≥ 商店 3——L1 三选一件值另计）" % acc_shop, acc_shop >= 3)
-		var l2_cap := {"payload": {}}   # 公开信号面采集（curio_choice_presented 停点载荷——容器写回规避 lambda 按值捕获）
-		a8.stop().curio_choice_presented.connect(func(p): l2_cap["payload"] = p)
 		a8._on_level_finished({"result": "victory", "hp": int(r8.hero_hp), "node_index": r8.node_index,
 			"node_id": r8.current_node_id(), "node_type": "shop"})   # 模拟 L2 关卡完成（victory 载荷直调——非末关）
-		Kit.check("L2 关卡完成三选一停点在案（直调兑付前——零自动推进）〔拆件批 V2〕", not (l2_cap["payload"] as Dictionary).is_empty())
+		Kit.check("L2 关卡完成三选一停点在案（直调兑付前——零自动推进）〔拆件批 V2〕", not a8.stop()._pending.is_empty())
 		Kit.check("未兑付推进拒绝（选择停点零自动推进契约）", not a8.continue_to_next_level())
 		var l2_cands: Array = a8.stop()._pending["candidates"]
 		var l2_pick: Dictionary = l2_cands[0]
@@ -448,8 +437,8 @@ func _smoke_adventure() -> void:
 	a13.stop().present_node_curio(ncands13)
 	a13.stop().present_node_curio([{"kind": "gp", "tier": "common"}])
 	var gp13: int = a13.wallet().gp
-	Kit.check("奖励节点 GP 件入账（钱包「奖励入账」收口——+%d）" % int(_db.adventure.curio_value("gp", "common")), a13.stop().apply_node_curio("gp", "common") and a13.wallet().gp == gp13 + int(_db.adventure.curio_value("gp", "common")))
-	Kit.check("节点停点态兑付后清零（恰一次语义同构）", (a13.stop().node_curio_pending_state().get("candidates", []) as Array).is_empty())
+	Kit.check("奖励节点 GP 件入账（钱包「奖励入账」收口——+%d）" % int(_db.run.adventure.curio_value("gp", "common")), a13.stop().apply_node_curio("gp", "common") and a13.wallet().gp == gp13 + int(_db.run.adventure.curio_value("gp", "common")))
+	Kit.check("节点停点态兑付后清零（恰一次语义同构）", a13.stop()._node_pending.is_empty())
 	var s10: Dictionary = a10.summary
 	Kit.check("放弃摘要：abandoned · 未打穿（已获大奖励不追回——同失败型结算）", String(s10.get("result", "")) == "abandoned" and not bool(s10.get("cleared", true)))
 
@@ -462,8 +451,8 @@ func _smoke_adventure() -> void:
 func _smoke_feats() -> void:
 	print("--- 专长重设计实装（feat_table 四级 · 专长带池接线 · 订阅面逐件）---")
 	# ① 现行表牌库构成：30 件全量入池——102 数值令牌+30 relic 令牌（四级 rarity 直映射）
-	Kit.check("feat_table 已加载（30 件=基础 27+迁入 2+卡② 完美保险 1——迭代 31 卡② 换代）", _db.feats != null and (_db.feats.rows as Array).size() == 30)
-	Kit.check("feat_table.validate 零违例（四级 rarity/cap 域/trigger 词表/行键白名单全过）", _db.feats.validate().is_empty())
+	Kit.check("feat_table 已加载（30 件=基础 27+迁入 2+卡② 完美保险 1——迭代 31 卡② 换代）", _db.feats != null and (_db.crossrun.feats.rows as Array).size() == 30)
+	Kit.check("feat_table.validate 零违例（四级 rarity/cap 域/trigger 词表/行键白名单全过）", _db.crossrun.feats.validate().is_empty())
 	var a_r0 = load("res://core/adventure_runner.gd").new(_db, _fresh_rng(71))
 	Kit.check("专长带场景：冒险启动（seed 71）", a_r0.start_adventure(71))
 	var feat_tokens := 0
@@ -473,34 +462,34 @@ func _smoke_feats() -> void:
 			feat_tokens += 1
 			var tk := String((t as Dictionary).get("tier", ""))
 			tier_counts[tk] = int(tier_counts.get(tk, 0)) + 1
-	Kit.check("专长带入池：30 件四级直映射（普通 12/优秀 9/稀有 9/传说 0）——牌库 102+30=132〔专长批 V2＋卡② 完美保险迁入〕", feat_tokens == 30 and int(tier_counts.get("common", 0)) == 12 and int(tier_counts.get("excellent", 0)) == 9 and int(tier_counts.get("rare", 0)) == 9 and a_r0.deck().deck.size() == 132)
+	Kit.check("专长带入池：30 件四级直映射（普通 12/优秀 9/稀有 9/传说 0）——牌库 102+30=132〔专长批 V2＋卡② 完美保险迁入〕", feat_tokens == 30 and int(tier_counts.get("common", 0)) == 12 and int(tier_counts.get("excellent", 0)) == 9 and int(tier_counts.get("rare", 0)) == 9 and a_r0._curio.deck.size() == 132)
 	# ② 旧 27 件零残留钉面（V2——arcane_ember 系旧件表首行；全仓 grep 零残留归静态核查）
-	Kit.check("旧 27 件已退役：arcane_ember/magma_body 表内零残留〔专长批 V2〕", _db.feats.row_by_id("arcane_ember").is_empty() and _db.feats.row_by_id("magma_body").is_empty())
-	Kit.check("迁出收尾：treasure_items 无 venom_edge/seal_burst 行（同调目录自然收窄）〔专长批 V13〕", _db.treasure_items.row_by_id("venom_edge").is_empty() and _db.treasure_items.row_by_id("seal_burst").is_empty())
+	Kit.check("旧 27 件已退役：arcane_ember/magma_body 表内零残留〔专长批 V2〕", _db.crossrun.feats.row_by_id("arcane_ember").is_empty() and _db.crossrun.feats.row_by_id("magma_body").is_empty())
+	Kit.check("迁出收尾：treasure_items 无 venom_edge/seal_burst 行（同调目录自然收窄）〔专长批 V13〕", _db.crossrun.treasure_items.row_by_id("venom_edge").is_empty() and _db.crossrun.treasure_items.row_by_id("seal_burst").is_empty())
 	# ③ 契约面静态钉扎（V18/V19/V21/V22——人工核对 V20/V21 裁决面以外的可机检半）
 	var kinds_ok := true
 	for t in a_r0._curio.deck:
 		var kk := String((t as Dictionary).get("kind", ""))
-		if kk != "relic" and not _db.adventure.CURIO_KINDS.has(kk):
+		if kk != "relic" and not _db.run.adventure.CURIO_KINDS.has(kk):
 			kinds_ok = false
 	Kit.check("层级纪律：牌库 kind 全集=CURIO_KINDS+relic（秘宝 item_id 零入池）〔专长批 V18〕", kinds_ok)
 	var rewrite_rows := 0
-	for row_v in (_db.feats.rows as Array):
+	for row_v in (_db.crossrun.feats.rows as Array):
 		for tv in ((row_v as Dictionary).get("triggers", []) as Array):
 			if String(((tv as Dictionary).get("do", {}) as Dictionary).get("kind", "")) == "rewrite_board":
 				rewrite_rows += 1
 	Kit.check("棋盘事实不可变：新 30 行零棋盘改写类订阅（rewrite_board 已除名消费面）〔专长批 V19〕", rewrite_rows == 0)
 	var bad_words := 0
-	for row_v in (_db.feats.rows as Array):
+	for row_v in (_db.crossrun.feats.rows as Array):
 		var r_d: Dictionary = row_v as Dictionary
 		for txt_v in [String(r_d.get("display_name", "")), String(r_d.get("desc", ""))]:
 			if String(txt_v).contains("雷") or String(txt_v).contains("旗"):
 				bad_words += 1
 	Kit.check("对外命名纪律：30 行 display_name/desc 零「雷/旗」字面（封印/陷阱风味系）〔专长批 V21 初筛〕", bad_words == 0)
 	Kit.check("数值纪律：陷阱爆发倍率>1 · 血蜜回复<典型陷阱伤 · 石肤上限 3 在册（结构锚形态内 provisional）〔专长批 V22 机检半〕",
-		float((_db.feats.row_by_id("trap_burst").get("triggers", [{}])[0] as Dictionary).get("do", {}).get("mult", 0)) > 1.0
-		and int((_db.feats.row_by_id("blood_honey").get("triggers", [{}])[0] as Dictionary).get("do", {}).get("value", 99)) < 5
-		and int((_db.feats.row_by_id("stone_skin").get("triggers", [{}])[0] as Dictionary).get("do", {}).get("cap", 0)) == 3)
+		float((_db.crossrun.feats.row_by_id("trap_burst").get("triggers", [{}])[0] as Dictionary).get("do", {}).get("mult", 0)) > 1.0
+		and int((_db.crossrun.feats.row_by_id("blood_honey").get("triggers", [{}])[0] as Dictionary).get("do", {}).get("value", 99)) < 5
+		and int((_db.crossrun.feats.row_by_id("stone_skin").get("triggers", [{}])[0] as Dictionary).get("do", {}).get("cap", 0)) == 3)
 	# ④ 临时表注入（新 schema 形态——零 archetype/cap 直用）：5 行 relic 入牌库/兑付/踢池/断点往返
 	var rt := FeatTable.new()
 	rt.rows = [
@@ -524,7 +513,7 @@ func _smoke_feats() -> void:
 	for t in a_r._curio.deck:
 		if String((t as Dictionary).get("kind", "")) == "relic":
 			deck_relic += 1
-	Kit.check("专长带入池：5 行 relic 每件 1 张（四级 rarity 直映射）——牌库 102+5=107", deck_relic == 5 and a_r.deck().deck.size() == 107)
+	Kit.check("专长带入池：5 行 relic 每件 1 张（四级 rarity 直映射）——牌库 102+5=107", deck_relic == 5 and a_r._curio.deck.size() == 107)
 	# 渠道白名单断言（渠道轴定位：关卡完成渠道只出专长/节点渠道零专长）
 	var feat_seen: Dictionary = {}
 	var node_relic_seen := false
@@ -558,12 +547,12 @@ func _smoke_feats() -> void:
 	Kit.check("A5 专长面兑付受理（专长凭证开出候选可正常入持有集）", (a_t.feats_held() as Array).size() == feats_n + 1)
 	# A6 保底：pity 直填 5 → 下次展示必出（第 6 次必出口径）；限购满 → 恒不触发
 	a_t.stop()._deck.ticket_sold = 0   # A5 已兑付一枚专长凭证（sold=1=limit）——A6 段重置计数隔离验证
-	a_t.stop()._deck.ticket_pity = int(a_t.db.adventure.feat_ticket_pity_step)
+	a_t.stop()._deck.ticket_pity = int(a_t.db.run.adventure.feat_ticket_pity_step)
 	var rg_t: RandomNumberGenerator = a_t.rng.open_stream("reward_pick")
 	Kit.check("A6 保底触发（pity=5 → 第 6 次展示必出——概率无关）", a_t.deck().feat_ticket_consider(rg_t))
-	Kit.check("A6 触发后清零", a_t.deck().ticket_pity == 0)
-	a_t.stop()._deck.ticket_sold = int(a_t.db.adventure.feat_ticket_limit)
-	a_t.stop()._deck.ticket_pity = int(a_t.db.adventure.feat_ticket_pity_step)
+	Kit.check("A6 触发后清零", a_t.stop()._deck.ticket_pity == 0)
+	a_t.stop()._deck.ticket_sold = int(a_t.db.run.adventure.feat_ticket_limit)
+	a_t.stop()._deck.ticket_pity = int(a_t.db.run.adventure.feat_ticket_pity_step)
 	Kit.check("A6 限购满不再触发（保底冻结）", not a_t.deck().feat_ticket_consider(rg_t))
 	a_t.stop()._deck.ticket_sold = 0
 	a_t.stop()._deck.ticket_pity = 0
@@ -604,13 +593,13 @@ func _smoke_feats() -> void:
 	fx.rebuild(["geologist"], [], [])
 	var geo_hits: Array = fx.dispatch(orch.fx_host().counters_ctx, "dig_reveal", {"new_resource_type": true})
 	apply_fx.call(geo_hits)
-	Kit.check("地质学家：首开新类型集 1 点〔专长批 V3〕", _hits_kind(geo_hits, "counter_add").size() == 1)
+	Kit.check("地质学家：首开新类型集 1 点〔专长批 V3〕", orch._hits_of(geo_hits, "counter_add").size() == 1)
 	EffectEngine.counter_add(orch.fx_host().counters_ctx, "geo_types", 2)   # 手动基数补齐（row1 已落账 1+2=3——满 4 种的预评估现值）
 	var geo_hits2: Array = fx.dispatch(orch.fx_host().counters_ctx, "dig_reveal", {"new_resource_type": true})
 	apply_fx.call(geo_hits2)
-	Kit.check("地质学家：满 4 种（预评估现值 3+本格）→揭示 1 格·计数清零〔专长批 V3〕", _hits_kind(geo_hits2, "reveal_tiles").size() == 1 and EffectEngine.counter(orch.fx_host().counters_ctx, "geo_types") == 0)
+	Kit.check("地质学家：满 4 种（预评估现值 3+本格）→揭示 1 格·计数清零〔专长批 V3〕", orch._hits_of(geo_hits2, "reveal_tiles").size() == 1 and EffectEngine.counter(orch.fx_host().counters_ctx, "geo_types") == 0)
 	var geo_hits3: Array = fx.dispatch(orch.fx_host().counters_ctx, "dig_reveal", {"new_resource_type": false})
-	Kit.check("地质学家反例：同类型重复首开不叠点〔专长批 V3〕", _hits_kind(geo_hits3, "counter_add").is_empty())
+	Kit.check("地质学家反例：同类型重复首开不叠点〔专长批 V3〕", orch._hits_of(geo_hits3, "counter_add").is_empty())
 	fx.rebuild(["hard_hat"], [], [])
 	apply_fx.call(fx.dispatch(orch.fx_host().counters_ctx, "dig_reveal", {}))
 	apply_fx.call(fx.dispatch(orch.fx_host().counters_ctx, "dig_reveal", {}))
@@ -624,29 +613,29 @@ func _smoke_feats() -> void:
 	fx.rebuild(["skip_mining"], [], [])
 	var sk_zero: Array = fx.dispatch(orch.fx_host().counters_ctx, "dig_reveal", {"is_blank_zero": true})
 	apply_fx.call(sk_zero)
-	Kit.check("跳格采掘：空白 0 格攒 1 点〔专长批 V3〕", _hits_kind(sk_zero, "counter_add").size() == 1)
+	Kit.check("跳格采掘：空白 0 格攒 1 点〔专长批 V3〕", orch._hits_of(sk_zero, "counter_add").size() == 1)
 	EffectEngine.counter_add(orch.fx_host().counters_ctx, "skip_pts", 1)   # 手动基数补齐（已落账 1+1=2——满 3 点的预评估现值）
 	var sk_full: Array = fx.dispatch(orch.fx_host().counters_ctx, "dig_reveal", {"is_blank_zero": true})
 	apply_fx.call(sk_full)
-	Kit.check("跳格采掘：满 3 点→揭示 1 格〔专长批 V3〕", _hits_kind(sk_full, "reveal_tiles").size() == 1)
-	Kit.check("跳格采掘反例：普通开格不计点〔专长批 V3〕", _hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "dig_reveal", {"is_blank_zero": false}), "counter_add").is_empty())
+	Kit.check("跳格采掘：满 3 点→揭示 1 格〔专长批 V3〕", orch._hits_of(sk_full, "reveal_tiles").size() == 1)
+	Kit.check("跳格采掘反例：普通开格不计点〔专长批 V3〕", orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "dig_reveal", {"is_blank_zero": false}), "counter_add").is_empty())
 	fx.rebuild(["blast_accounting"], [], [])
 	for i in 5:
 		var ba_hits: Array = fx.dispatch(orch.fx_host().counters_ctx, "dig_paid", {"ap_cost": 1})
 		for h in ba_hits:
 			if String(h.get("kind", "")) == "counter_add":
 				EffectEngine.counter_add(orch.fx_host().counters_ctx, String(h.get("counter_id", "")), 1)
-	Kit.check("爆破会计：本轮挖格花费≥5→+1 GP〔专长批 V3〕", _hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "round_end", {}), "grant_gp").size() == 1)
+	Kit.check("爆破会计：本轮挖格花费≥5→+1 GP〔专长批 V3〕", orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "round_end", {}), "grant_gp").size() == 1)
 	fx.rebuild(["frontier_miner"], [], [])
 	Kit.check("边陲矿工：边缘格产出 +1·中心格反例零产出〔专长批 V3〕",
-		_hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "dig_reveal", {"is_edge_cell": true}), "grant_material").size() == 1
-		and _hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "dig_reveal", {"is_edge_cell": false}), "grant_material").is_empty())
+		orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "dig_reveal", {"is_edge_cell": true}), "grant_material").size() == 1
+		and orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "dig_reveal", {"is_edge_cell": false}), "grant_material").is_empty())
 	# 封印系
 	fx.rebuild(["seal_echo"], [], [])
 	apply_fx.call(fx.dispatch(orch.fx_host().counters_ctx, "seal_hit", {}))
 	apply_fx.call(fx.dispatch(orch.fx_host().counters_ctx, "seal_hit", {}))
 	var se_hits: Array = fx.dispatch(orch.fx_host().counters_ctx, "round_end", {})
-	Kit.check("封印回响：标中计数≥2→轮末返 1 AP（下轮 queue）〔专长批 V3〕", _hits_kind(se_hits, "grant_ap").size() == 1 and String((_hits_kind(se_hits, "grant_ap")[0] as Dictionary).get("mode", "")) == "queue")
+	Kit.check("封印回响：标中计数≥2→轮末返 1 AP（下轮 queue）〔专长批 V3〕", orch._hits_of(se_hits, "grant_ap").size() == 1 and String((orch._hits_of(se_hits, "grant_ap")[0] as Dictionary).get("mode", "")) == "queue")
 	fx.rebuild(["seal_smith"], [], [])
 	var sm_remove := 0
 	for i in 3:
@@ -658,10 +647,10 @@ func _smoke_feats() -> void:
 	Kit.check("封印匠：标中每第 3 次→中立移除恰一次（频率闸死）〔专长批 V3〕", sm_remove == 1)
 	fx.rebuild(["seal_stake"], [], [])
 	Kit.check("封印桩：标中本轮 AC +N（round 域——round_start 清零）〔专长批 V3〕",
-		_hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "seal_hit", {}), "ac_bonus").size() == 1
-		and String((_hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "seal_hit", {}), "ac_bonus")[0] as Dictionary).get("mode", "")) == "round")
+		orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "seal_hit", {}), "ac_bonus").size() == 1
+		and String((orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "seal_hit", {}), "ac_bonus")[0] as Dictionary).get("mode", "")) == "round")
 	fx.rebuild(["warning_beacon"], [], [])
-	Kit.check("示警烟火：标中揭示 3×3 资源类型（不揭安危位置）〔专长批 V3〕", _hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "seal_hit", {}), "preview_area").size() == 1)
+	Kit.check("示警烟火：标中揭示 3×3 资源类型（不揭安危位置）〔专长批 V3〕", orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "seal_hit", {}), "preview_area").size() == 1)
 	# 踩雷/受伤系
 	fx.rebuild(["pain_memory"], [], [])
 	apply_fx.call(fx.dispatch(orch.fx_host().counters_ctx, "mine_hit", {}))
@@ -677,13 +666,13 @@ func _smoke_feats() -> void:
 	for h in fw_hits:
 		if String(h.get("kind", "")) == "shield":
 			fw_shield += int(h.get("value", 0))
-	Kit.check("保险丝反例：单次 <5 不攒点不触发〔专长批 V3〕", _hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "damage_taken", {"kind": "terrain", "amount": 3}), "shield").is_empty())
+	Kit.check("保险丝反例：单次 <5 不攒点不触发〔专长批 V3〕", orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "damage_taken", {"kind": "terrain", "amount": 3}), "shield").is_empty())
 	for h in fx.dispatch(orch.fx_host().counters_ctx, "damage_taken", {"kind": "terrain", "amount": 6}):
 		if String(h.get("kind", "")) == "counter_add":
 			EffectEngine.counter_add(orch.fx_host().counters_ctx, String(h.get("counter_id", "")), int(h.get("value", 0)))
 	Kit.check("保险丝：首点不出盾（2 点才出——预评估口径）〔专长批 V3〕", fw_shield == 0)
 	fx.rebuild(["blood_insight"], [], [])
-	Kit.check("见血开窍：踩雷揭示 1 格〔专长批 V3〕", _hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "mine_hit", {}), "reveal_tiles").size() == 1)
+	Kit.check("见血开窍：踩雷揭示 1 格〔专长批 V3〕", orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "mine_hit", {}), "reveal_tiles").size() == 1)
 	fx.rebuild(["trap_instinct"], [], [])
 	apply_fx.call(fx.dispatch(orch.fx_host().counters_ctx, "mine_hit", {}))
 	var ti_hits: Array = fx.dispatch(orch.fx_host().counters_ctx, "attack_commit", {"atk": 10, "target": "敌", "matchup": "", "dig_streak": 0, "nest_count": 0})
@@ -699,67 +688,67 @@ func _smoke_feats() -> void:
 	fx.rebuild(["trap_burst"], [], [])
 	var tb_hits: Array = fx.dispatch(orch.fx_host().counters_ctx, "mine_hit", {"damage": 8})
 	Kit.check("陷阱爆发：全体敌雷伤×倍率直伤（blast_scaled——施加面值=damage×mult）〔专长批 V3〕",
-		_hits_kind(tb_hits, "blast_scaled").size() == 1
-		and float((_hits_kind(tb_hits, "blast_scaled")[0] as Dictionary).get("mult", 0)) > 1.0)
+		orch._hits_of(tb_hits, "blast_scaled").size() == 1
+		and float((orch._hits_of(tb_hits, "blast_scaled")[0] as Dictionary).get("mult", 0)) > 1.0)
 	fx.rebuild(["blood_honey"], [], [])
-	Kit.check("血蜜：踩雷回复 N 生命〔专长批 V3〕", _hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "mine_hit", {}), "heal").size() == 1)
+	Kit.check("血蜜：踩雷回复 N 生命〔专长批 V3〕", orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "mine_hit", {}), "heal").size() == 1)
 	fx.rebuild(["stone_skin"], [], [])
 	var ss_hits: Array = fx.dispatch(orch.fx_host().counters_ctx, "damage_taken", {"kind": "enemy_skill", "amount": 5, "source": "s", "round": 1})
 	Kit.check("石肤：受伤 AC+1（本场域 cap 3——达上限不再涨由累积器封顶）〔专长批 V3〕",
-		_hits_kind(ss_hits, "ac_bonus").size() == 1
-		and int((_hits_kind(ss_hits, "ac_bonus")[0] as Dictionary).get("cap", 0)) == 3)
+		orch._hits_of(ss_hits, "ac_bonus").size() == 1
+		and int((orch._hits_of(ss_hits, "ac_bonus")[0] as Dictionary).get("cap", 0)) == 3)
 	fx.rebuild(["last_stand"], [], [])
 	Kit.check("背水：生命≤50% 减伤·过半血反例零减伤〔专长批 V3〕",
-		_hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "damage_taken", {"kind": "enemy_skill", "amount": 5, "source": "s", "round": 1, "hp_ratio": 40}), "damage_reduce").size() == 1
-		and _hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "damage_taken", {"kind": "enemy_skill", "amount": 5, "source": "s", "round": 2, "hp_ratio": 80}), "damage_reduce").is_empty())
+		orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "damage_taken", {"kind": "enemy_skill", "amount": 5, "source": "s", "round": 1, "hp_ratio": 40}), "damage_reduce").size() == 1
+		and orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "damage_taken", {"kind": "enemy_skill", "amount": 5, "source": "s", "round": 2, "hp_ratio": 80}), "damage_reduce").is_empty())
 	# 跨族桥
 	fx.rebuild(["breaker_strike"], [], [])
 	Kit.check("破封一击：挖开带封印危险格 +1 层·无封印反例零触发〔专长批 V3〕",
-		_hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "mine_hit", {"dug_under_seal": true}), "counter_add").size() == 1
-		and _hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "mine_hit", {"dug_under_seal": false}), "counter_add").is_empty())
+		orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "mine_hit", {"dug_under_seal": true}), "counter_add").size() == 1
+		and orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "mine_hit", {"dug_under_seal": false}), "counter_add").is_empty())
 	# 节奏系
 	fx.rebuild(["map_exchange"], [], [])
 	var me_hits: Array = fx.dispatch(orch.fx_host().counters_ctx, "dig_stop", {"ap_left": 4})
 	apply_fx.call(me_hits)
 	EffectEngine.counter_add(orch.fx_host().counters_ctx, "stop_swap", 4)   # value_event="ap_left" 解析归施加面（action_economy 载荷取值）——冒烟手动落账
-	Kit.check("弃图兑换：停手剩余 AP≥3 入账〔专长批 V3〕", _hits_kind(me_hits, "counter_add").size() == 1)
+	Kit.check("弃图兑换：停手剩余 AP≥3 入账〔专长批 V3〕", orch._hits_of(me_hits, "counter_add").size() == 1)
 	var me_atk := 0
 	for h in orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "attack_commit", {"atk": 10, "target": "敌", "matchup": "", "dig_streak": 0, "nest_count": 0}), "attack_bonus"):
 		me_atk = EffectEngine.counter(orch.fx_host().counters_ctx, String(h.get("value_counter", "")))
 	Kit.check("弃图兑换：折为攻击伤害=剩余 AP 全额·用后清零〔专长批 V3〕", me_atk == 4)
-	Kit.check("弃图兑换反例：剩余 AP<3 不触发〔专长批 V3〕", _hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "dig_stop", {"ap_left": 2}), "counter_add").is_empty())
+	Kit.check("弃图兑换反例：剩余 AP<3 不触发〔专长批 V3〕", orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "dig_stop", {"ap_left": 2}), "counter_add").is_empty())
 	fx.rebuild(["last_drop"], [], [])
 	var ld_hits: Array = fx.dispatch(orch.fx_host().counters_ctx, "round_start", {"round": 2, "ap_exhausted_last": true})
-	Kit.check("一滴不剩：上轮 AP 耗尽→+1 AP〔专长批 V3〕", _hits_kind(ld_hits, "grant_ap").size() == 1)
-	Kit.check("一滴不剩反例：上轮有余不发〔专长批 V3〕", _hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "round_start", {"round": 3, "ap_exhausted_last": false}), "grant_ap").is_empty())
+	Kit.check("一滴不剩：上轮 AP 耗尽→+1 AP〔专长批 V3〕", orch._hits_of(ld_hits, "grant_ap").size() == 1)
+	Kit.check("一滴不剩反例：上轮有余不发〔专长批 V3〕", orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "round_start", {"round": 3, "ap_exhausted_last": false}), "grant_ap").is_empty())
 	fx.rebuild(["market_close"], [], [])
 	for i in 8:
 		for h in fx.dispatch(orch.fx_host().counters_ctx, "dig_reveal", {}):
 			if String(h.get("kind", "")) == "counter_add":
 				EffectEngine.counter_add(orch.fx_host().counters_ctx, String(h.get("counter_id", "")), 1)
-	Kit.check("收盘：本轮开格≥8→+1 GP〔专长批 V3〕", _hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "round_end", {}), "grant_gp").size() == 1)
+	Kit.check("收盘：本轮开格≥8→+1 GP〔专长批 V3〕", orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "round_end", {}), "grant_gp").size() == 1)
 	# 战斗系
 	fx.rebuild(["execution_scholar"], [], [])
-	Kit.check("斩首学者：击杀揭示 1 格〔专长批 V3〕", _hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "kill", {"target": "敌", "overflow": 0}), "reveal_tiles").size() == 1)
+	Kit.check("斩首学者：击杀揭示 1 格〔专长批 V3〕", orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "kill", {"target": "敌", "overflow": 0}), "reveal_tiles").size() == 1)
 	fx.rebuild(["executioner"], [], [])
 	var ex_hits: Array = fx.dispatch(orch.fx_host().counters_ctx, "enemy_hp_threshold", {"unit": "e1", "pct": 30, "is_boss": false})
 	Kit.check("处刑台：敌血量≤30% 挂单位标记加伤·阈值外反例零命中〔专长批 V3〕",
-		_hits_kind(ex_hits, "target_attack_bonus").size() == 1
-		and _hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "enemy_hp_threshold", {"unit": "e1", "pct": 60, "is_boss": false}), "target_attack_bonus").is_empty())
+		orch._hits_of(ex_hits, "target_attack_bonus").size() == 1
+		and orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "enemy_hp_threshold", {"unit": "e1", "pct": 60, "is_boss": false}), "target_attack_bonus").is_empty())
 	fx.rebuild(["field_dressing"], [], [])
-	Kit.check("战地包扎：战斗胜利回复 N 生命（battle_won 新挂点）〔专长批 V3〕", _hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "battle_won", {"round": 2}), "heal").size() == 1)
+	Kit.check("战地包扎：战斗胜利回复 N 生命（battle_won 新挂点）〔专长批 V3〕", orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "battle_won", {"round": 2}), "heal").size() == 1)
 	# 契约尖点
 	fx.rebuild(["blood_tax"], [], [])
 	Kit.check("血税：双向同局账本（踩陷阱−2max_hp/封印命中+1atk——bonus_delta 战末汇入）〔专长批 V3〕",
-		_hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "mine_hit", {}), "bonus_delta").size() == 1
-		and String((_hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "seal_hit", {}), "bonus_delta")[0] as Dictionary).get("axis", "")) == "atk")
+		orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "mine_hit", {}), "bonus_delta").size() == 1
+		and String((orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "seal_hit", {}), "bonus_delta")[0] as Dictionary).get("axis", "")) == "atk")
 	# 迁入 2 件
 	fx.rebuild(["venom_edge"], [], [])
 	Kit.check("淬毒刃纹（迁入）：克制正面（magic_vs_heavy 矩阵值>0）追加·中性面反例零触发〔专长批 V3〕",
-		_hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "clamp_check", {"matchup": "magic_vs_heavy"}), "modify_ticket").size() == 1
-		and _hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "clamp_check", {"matchup": "normal_vs_light"}), "modify_ticket").is_empty())
+		orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "clamp_check", {"matchup": "magic_vs_heavy"}), "modify_ticket").size() == 1
+		and orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "clamp_check", {"matchup": "normal_vs_light"}), "modify_ticket").is_empty())
 	fx.rebuild(["seal_burst"], [], [])
-	Kit.check("封印爆裂（迁入）：标中全体敌群伤〔专长批 V3〕", _hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "seal_hit", {}), "open_ticket").size() == 1)
+	Kit.check("封印爆裂（迁入）：标中全体敌群伤〔专长批 V3〕", orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "seal_hit", {}), "open_ticket").size() == 1)
 	# 零持有
 	var orch0 = load("res://core/battle_orchestrator.gd").new(_db, _fresh_rng(74))
 	orch0.fx_host().rebuild_subscriptions([], [], [])
@@ -910,4 +899,4 @@ func _fresh_rng(seed_val: int):
 # 生成图取数面（图 = f(关卡行参数档, 种子 42)——与 runner 起关同图；节点键 id/type/depth/next）
 func _level_active_nodes(level_index: int) -> Array:
 	var gen = NodeMapGenerator.new(_fresh_rng(42))
-	return (gen.generate(_db.level_gen_params_row(level_index), 42) as Dictionary).get("nodes", [])
+	return (gen.generate(_db.run.level_gen_params.row_by_level_index(level_index), 42) as Dictionary).get("nodes", [])

game/tests/unit/core/board_gen_reward_test.gd

@@ -105,7 +105,7 @@ func _smoke_reward_identity_unit() -> void:
 	var cs2: Dictionary = reward_economy.grant_clear()
 	Kit.check("清图批尾身份 = clear_blast（clear_default 唯一活行）", String(cs1.cell_type) == "blast" and String(cs1.reward_id) == "clear_blast")
 	var cb_range := [-1, -1]
-	for row in _db.reward.rows:
+	for row in _db.run.reward.rows:
 		if String(row.reward_id) == "clear_blast":
 			cb_range = [int(row.get("power_min", row.power)), int(row.get("power_max", row.power))]
 	Kit.check("清图奖励 power ∈ 表区间 [%d, %d]（roll 值 %d——配置推导）" % [cb_range[0], cb_range[1], int(cs1.power)],
@@ -120,9 +120,13 @@ func _smoke_reward_identity_unit() -> void:
 
 # 板行覆盖桩（cap 压线行为断言；接口面 = resolve_board_gen 单点）
 class _BoardRowStub:
-	var row: Dictionary
-	func resolve_board_gen(_L: int, _D: int) -> Dictionary:
-		return row
+	class _StubBoardGen:
+		var row: Dictionary
+		func resolve_row(_L: int, _D: int) -> Dictionary:
+			return row
+	class _StubCombat:
+		var board_gen := _StubBoardGen.new()
+	var combat := _StubCombat.new()
 	func status_effect_row(_id: String) -> Dictionary:
 		return {}
 
@@ -131,27 +135,27 @@ func _smoke_board_generator() -> void:
 	print("--- 棋盘生成 ---")
 	var board_generator = load("res://core/board_generator.gd").new()
 	for L in [1, 2]:
-		var row = _db.resolve_board_gen(L, 0)
+		var row = _db.combat.board_gen.resolve_row(L, 0)
 		Kit.check("BoardGen 行解析 (%d,0)" % L, not row.is_empty())
 		if L == 2:
 			# 迭代 35 生成图深度扩面覆盖批随动（声明）：旧口径「(2,3) 无精确行→ceil 上取到 4」的判据对象
 			# 是模板时代键域缺口；覆盖批补齐 0–13 后 (2,3) 有精确行，生产表上不再存在可走 ceil 的空位。
 			# 判据不丢——精确命中改判在册，ceil 能力用「临时摘除该行」的夹具面保留，随后原样还原。
-			var exact_row: Dictionary = _db.resolve_board_gen(2, 3)
+			var exact_row: Dictionary = _db.combat.board_gen.resolve_row(2, 3)
 			Kit.check("BoardGen 精确命中 (2,3)（覆盖批键域补齐）", int(exact_row.get("node_depth", -1)) == 3)
 			var gap_idx := -1
-			for i in _db.board_gen.rows.size():
-				if int(_db.board_gen.rows[i].get("level_index", -1)) == 2 and int(_db.board_gen.rows[i].get("node_depth", -1)) == 3:
+			for i in _db.combat.board_gen.rows.size():
+				if int(_db.combat.board_gen.rows[i].get("level_index", -1)) == 2 and int(_db.combat.board_gen.rows[i].get("node_depth", -1)) == 3:
 					gap_idx = i
 					break
-			var saved: Dictionary = _db.board_gen.rows[gap_idx]
-			var rows_before: int = _db.board_gen.rows.size()
-			_db.board_gen.rows.remove_at(gap_idx)
-			var ceil_row: Dictionary = _db.resolve_board_gen(2, 3)
+			var saved: Dictionary = _db.combat.board_gen.rows[gap_idx]
+			var rows_before: int = _db.combat.board_gen.rows.size()
+			_db.combat.board_gen.rows.remove_at(gap_idx)
+			var ceil_row: Dictionary = _db.combat.board_gen.resolve_row(2, 3)
 			Kit.check("R1 ceil 能力不失（夹具摘除 (2,3)→向上取整到 4·偏难口径）", int(ceil_row.get("node_depth", -1)) == 4)
-			_db.board_gen.rows.insert(gap_idx, saved)
+			_db.combat.board_gen.rows.insert(gap_idx, saved)
 			Kit.check("夹具表原样还原（行数与解析回到覆盖批现值）",
-				_db.board_gen.rows.size() == rows_before and int(_db.resolve_board_gen(2, 3).get("node_depth", -1)) == 3)
+				_db.combat.board_gen.rows.size() == rows_before and int(_db.combat.board_gen.resolve_row(2, 3).get("node_depth", -1)) == 3)
 		var b1 = board_generator.generate(L, 0, _rng.open_stream("board_gen"), _db)
 		Kit.check("L%d 生成产物非空" % L, b1 != null)
 		if b1 == null:
@@ -172,6 +176,8 @@ func _smoke_board_generator() -> void:
 			b1.degraded_product == (mode == "accept_best"))
 		Kit.check("L%d 非法产物标记 = (accept_mode==accept_worst)（%s→%s）" % [L, mode, str(b1.illegal_product)],
 			b1.illegal_product == (mode == "accept_worst"))
+		Kit.check("L%d 降级/非法产物标记互斥（两出口不可同真）" % L,
+			not b1.degraded_product or not b1.illegal_product)
 		Kit.check("L%d 产物断言：实际雷数 %d ≤ 目标雷数 N=%d（先布后删只减不增）" % [L, int(b1.metrics.actual_mines), int(b1.metrics.target_mines)],
 			int(b1.metrics.actual_mines) <= int(b1.metrics.target_mines))
 		Kit.check("L%d attempts_used ∈ [1,%d]" % [L, int(row.max_gen_attempts)],
@@ -200,7 +206,7 @@ func _smoke_board_generator() -> void:
 		row9["r0_max_cap"] = BoardData.SPAWN_AREA_CELLS
 		row9["max_gen_attempts"] = 4
 		var stub9 := _BoardRowStub.new()
-		stub9.row = row9
+		stub9.combat.board_gen.row = row9
 		var b9 = board_generator.generate(1, 0, _mk_stream("board_gen", 909), stub9)
 		Kit.check("L1 cap 压线 9：出图 R₀=%d %s（三分出口诚实降级——超阈即 accept_worst 非法标记，玩家永不卡死）" % [int(b9.metrics.r0_count), "≤9" if int(b9.metrics.r0_count) <= BoardData.SPAWN_AREA_CELLS else ">9→illegal_product"],
 			b9 != null and (int(b9.metrics.r0_count) <= BoardData.SPAWN_AREA_CELLS or b9.illegal_product))
@@ -227,7 +233,7 @@ func _smoke_power_interval() -> void:
 	#    行清单与区间值全部随表走——现行区间行 heal_minor/clear_blast 只是恰然，不再是锚。
 	var interval_rows := {}   # rid → [lo, hi]（读表）
 	var anchors_ok := true
-	for row in _db.reward.rows:
+	for row in _db.run.reward.rows:
 		var rid := String(row.reward_id)
 		if row.has("power_min") or row.has("power_max"):
 			var lo: int = int(row.get("power_min", -1))
@@ -297,7 +303,7 @@ func _smoke_power_interval() -> void:
 
 
 func _row_power(rid: String) -> int:
-	for row in _db.reward.rows:
+	for row in _db.run.reward.rows:
 		if String(row.reward_id) == rid:
 			return int(row.power)
 	return -1

game/tests/unit/core/board_generator_test.gd

@@ -41,7 +41,7 @@ func _test_generate_shape_and_mines() -> void:
 	if b == null:
 		Kit.check("生成返回棋盘", false)
 		return
-	var row: Dictionary = _db.resolve_board_gen(1, 0)
+	var row: Dictionary = _db.combat.board_gen.resolve_row(1, 0)
 	var want_w: int = int(row.get("board_width", 0))
 	var want_h: int = int(row.get("board_height", 0))
 	Kit.check("棋盘尺寸与 board_gen 表一致（%dx%d）" % [want_w, want_h],
@@ -60,7 +60,7 @@ func _test_target_mine_count_single_source() -> void:
 	var bad := 0
 	var checked := 0
 	for L in [1, 2, 3]:
-		var row: Dictionary = _db.resolve_board_gen(L, 0)
+		var row: Dictionary = _db.combat.board_gen.resolve_row(L, 0)
 		if row.is_empty():
 			continue
 		var params := {
@@ -77,7 +77,7 @@ func _test_target_mine_count_single_source() -> void:
 	if b == null:
 		Kit.check("生成返回棋盘（雷数单点段）", false)
 		return
-	var row1: Dictionary = _db.resolve_board_gen(1, 0)
+	var row1: Dictionary = _db.combat.board_gen.resolve_row(1, 0)
 	Kit.check("产物断言读数 = target_mine_count 同源（metrics.target_mines）〔wd14〕",
 		int(b.metrics.get("target_mines", -1)) == BoardGeneratorScript.target_mine_count({
 			"w": int(row1.board_width), "h": int(row1.board_height), "density": float(row1.mine_density)}))

game/tests/unit/core/breakpoint_resume_test.gd

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

game/tests/unit/core/config_db_cross_validator_test.gd

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

game/tests/unit/core/config_db_resolver_test.gd

@@ -54,16 +54,17 @@ func _difficulty_table():
 
 
 func _test_band_hit() -> void:
-	var hit: Array = _resolver.resolve_enemy_rowset(1, 4, "battle")
+	var hit: Array = _resolver.combat.enemy.resolve_rowset(1, 4, "battle")
 	Kit.check("带命中取偏难一侧：请求深度 4 命中带 5（逐字不回带 0）〔fv1〕",
 		hit.size() == 1 and String((hit[0] as Dictionary).get("enemy_id", "")) == "hobgoblin")
-	var exact: Array = _resolver.resolve_enemy_rowset(1, 5, "battle")
+	var exact: Array = _resolver.combat.enemy.resolve_rowset(1, 5, "battle")
 	Kit.check("精确落带：请求深度 5 命中带 5〔fv1〕",
 		exact.size() == 1 and String((exact[0] as Dictionary).get("enemy_id", "")) == "hobgoblin")
 
 
 func _test_rowset_order_preserved() -> void:
-	var rows: Array = _resolver.resolve_enemy_rowset(1, 0, "battle")
+	var rows: Array = _resolver.combat.enemy.resolve_rowset(1, 0, "battle")
+	Kit.check("行集返回同带全部行（2 行）〔fv2〕", rows.size() == 2)
 	var ids: Array[String] = []
 	for r in rows:
 		ids.append(String((r as Dictionary).get("enemy_id", "")))
@@ -73,7 +74,7 @@ func _test_rowset_order_preserved() -> void:
 
 func _test_top_band_clamp() -> void:
 	_diags.clear()
-	var rows: Array = _resolver.resolve_enemy_rowset(1, 99, "battle")
+	var rows: Array = _resolver.combat.enemy.resolve_rowset(1, 99, "battle")
 	Kit.check("越顶带 clamp 取顶带行集（battle 顶带 5）〔fv3〕",
 		rows.size() == 1 and String((rows[0] as Dictionary).get("enemy_id", "")) == "hobgoblin")
 	var clamp_hit := false
@@ -82,13 +83,13 @@ func _test_top_band_clamp() -> void:
 			clamp_hit = true
 	Kit.check("越顶带发 warning resolve_depth_clamp〔fv3〕", clamp_hit)
 	var warn_before: int = _diags.size()
-	_resolver.resolve_enemy_rowset(1, 99, "battle")
+	_resolver.combat.enemy.resolve_rowset(1, 99, "battle")
 	Kit.check("同键重复请求警告去重（四元组注册表）〔fv3〕", _diags.size() == warn_before)
 
 
 func _test_row_kind_routing() -> void:
-	var battle_rows: Array = _resolver.resolve_enemy_rowset(1, 0, "battle")
-	var boss_rows: Array = _resolver.resolve_enemy_rowset(1, 0, "boss")
+	var battle_rows: Array = _resolver.combat.enemy.resolve_rowset(1, 0, "battle")
+	var boss_rows: Array = _resolver.combat.enemy.resolve_rowset(1, 0, "boss")
 	Kit.check("行类路由：同请求深度 battle 与 boss 命中不同键域〔fv4〕",
 		battle_rows.size() == 2 and boss_rows.size() == 1
 		and String((boss_rows[0] as Dictionary).get("enemy_id", "")) == "ogre_chief")
@@ -96,13 +97,13 @@ func _test_row_kind_routing() -> void:
 
 func _test_request_oob() -> void:
 	_diags.clear()
-	_resolver.resolve_enemy_rowset(0, 0, "battle")
+	_resolver.combat.enemy.resolve_rowset(0, 0, "battle")
 	Kit.check("关卡序号 <1 → fatal request_oob〔fv5〕", _has_fatal_oob())
 	_diags.clear()
-	_resolver.resolve_enemy_rowset(1, -1, "battle")
+	_resolver.combat.enemy.resolve_rowset(1, -1, "battle")
 	Kit.check("节点深度 <0 → fatal request_oob〔fv5〕", _has_fatal_oob())
 	_diags.clear()
-	_resolver.resolve_enemy_rowset(1, 0, "elite")
+	_resolver.combat.enemy.resolve_rowset(1, 0, "elite")
 	Kit.check("row_kind 非法 → fatal request_oob〔fv5〕", _has_fatal_oob())
 
 
@@ -114,11 +115,11 @@ func _has_fatal_oob() -> bool:
 
 
 func _test_difficulty_clamp() -> void:
-	var m: Dictionary = _resolver.resolve_difficulty_modifiers(1, 0)
+	var m: Dictionary = _resolver.run.difficulty.resolve_modifiers(1, 0)
 	Kit.check("难度乘数越域被 clamp：hp 99 → 上限 10", absf(float(m.get("hp_mult", 0.0)) - 10.0) < 0.001)
 	Kit.check("难度乘数越域被 clamp：atk 0.01 → 下限 0.1", absf(float(m.get("atk_mult", 0.0)) - 0.1) < 0.001)
 	Kit.check("未登记坐标返回空修饰（零值不伪装成 ×1）",
-		_resolver.resolve_difficulty_modifiers(3, 3).is_empty())
+		_resolver.run.difficulty.resolve_modifiers(3, 3).is_empty())
 
 
 class _FakeDifficulty:

game/tests/unit/core/curio_refresh_paid_test.gd

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

game/tests/unit/core/feat_vouchers_test.gd

@@ -32,9 +32,8 @@ func _init() -> void:
 
 	# V9-1 刷新券：入存量账（冒险级）——反例=写进 _attune_refresh_x（X 每停点重置会吞存量）
 	a.refresh_bank().reset_x()   # X 归零基线（模拟新停点）
-	a.stop()._pending = {"candidates": [{"kind": "refresh", "tier": "excellent"}]}   # 停点候选直写（构造面——pick_curio 真实入口前置）
-	Kit.check_quiet(a.stop().pick_curio("refresh", "excellent"), "刷新券兑付受理〔专长批 V9〕")
-	Kit.check_quiet(a.refresh_bank().refresh_stock() == 1 and a.refresh_bank().free_left() == a.refresh_bank().refresh_stock() + a.refresh_bank().refresh_y(),
+	Kit.check_quiet(a.stop()._apply_curio_pick("refresh", "excellent", 1), "刷新券兑付受理〔专长批 V9〕")
+	Kit.check_quiet(a.refresh_bank().refresh_stock() == 1 and a.refresh_bank()._refresh_x == 0,
 		"F-1 修复：刷新券入存量账、X 账零写入（写错账反例不复发）〔专长批 V9〕")
 	a.refresh_bank().reset_x()   # 再碰停点——X 重置但存量不吞
 	Kit.check_quiet(a.refresh_bank().refresh_stock() == 1 and a.refresh_bank().free_left() == 1,
@@ -51,50 +50,44 @@ func _init() -> void:
 	Kit.check_quiet(deck_refresh_before == 0 or true, "牌库 refresh 令牌读数在域（投放 %d）" % deck_refresh_before)
 
 	# V9-2 储备金袋：待注入账 + 战首注入（节点级）
-	a.stop()._pending = {"candidates": [{"kind": "rap", "tier": "rare"}]}   # 停点候选直写（构造面——pick_curio 真实入口前置）
-	Kit.check_quiet(a.stop().pick_curio("rap", "rare"), "储备金袋兑付受理〔专长批 V9〕")
+	Kit.check_quiet(a.stop()._apply_curio_pick("rap", "rare", 3), "储备金袋兑付受理〔专长批 V9〕")
 	Kit.check_quiet(a.stop()._pending_rap == 3, "储备金袋：待注入 RAP +3（节点级账）〔专长批 V9〕")
 
 	# V9-3 时沙：下一战首轮 AP 队列（回合级池增量）
-	a.stop()._pending = {"candidates": [{"kind": "time_sand", "tier": "rare"}]}   # 停点候选直写（构造面——pick_curio 真实入口前置）
-	Kit.check_quiet(a.stop().pick_curio("time_sand", "rare"), "时沙兑付受理〔专长批 V9〕")
+	Kit.check_quiet(a.stop()._apply_curio_pick("time_sand", "rare", 2), "时沙兑付受理〔专长批 V9〕")
 	Kit.check_quiet(a.stop()._time_sand_queue == 2, "时沙：首轮 AP 队列 +2（池增量非上限）〔专长批 V9〕")
 
 	# V23 两件出池（R1——同调电池删除／完美保险迁专长）
-	Kit.check_quiet(not db.adventure.CURIO_KINDS.has("attune_battery")
-		and not db.adventure.CURIO_KINDS.has("perfect_insurance"),
+	Kit.check_quiet(not db.run.adventure.CURIO_KINDS.has("attune_battery")
+		and not db.run.adventure.CURIO_KINDS.has("perfect_insurance"),
 		"出池词表：CURIO_KINDS 零两件（三选一池物理不可再出）〔卡② R1〕")
-	Kit.check_quiet(not a.stop().consume_pool_purchase("attune_battery", "rare")
-		and not a.stop().consume_pool_purchase("perfect_insurance", "rare"),
+	Kit.check_quiet(not a.stop()._apply_curio_pick("attune_battery", "rare", 1)
+		and not a.stop()._apply_curio_pick("perfect_insurance", "rare", 1),
 		"出池反例：两件兑付不再受理（牌库无令牌=拒绝零副作用）〔卡② R1〕")
 	Kit.check_quiet(not a.has_method("choose_battery_target") and not a.has_method("battery_pending"),
 		"电池符号清零：runner 无点选函数与 getter（编译级孤儿面）〔卡② R1〕")
-	Kit.check_quiet(int(db.adventure.curio_cap("attune_battery")) == 99,
+	Kit.check_quiet(int(db.run.adventure.curio_cap("attune_battery")) == 99,
 		"出池后未知 kind 走分发表 default（cap 读数兜底 99——零崩溃面）〔卡② R1〕")
 	# 账本保留（契约 1）：主动件充能与每冒险种行入口零改动（单源化后=差额种行幂等——不吞装配）
 	a._attunement = ["incense_stick"]
 	a._loadout.set_attunement(["incense_stick"])
 	a._loadout_seeded = false   # 模拟首关 bind 时点（分派走 seed_for_adventure 分支）
 	a._loadout_on_level_inventory()   # 种行（首关 bind 时点语义）
-	var incense_left := 0
-	for r in a.runner().treasure_inventory.snapshot_inventory():
-		if String(r.get("item_id", "")) == "incense_stick" and String(r.get("source_class", "")) == "attunement" and not bool(r.get("used", false)):
-			incense_left += 1
-	Kit.check_quiet(incense_left == 1,
+	Kit.check_quiet(a._loadout.charges_left("incense_stick", a.runner().treasure_inventory) == 1,
 		"账本保留：种行按装备表值投行（线香 battle 级 1——attune_charges 语义零变化）〔卡② R1〕")
 	# V24 配额净删锚（R3——「净删」口径，rare 9→7／总量 104→102）
 	var rare_sum := 0
 	var rare_kinds: Array[String] = []
-	for k in db.adventure.CURIO_KINDS:
-		var q := int(db.adventure.curio_quota(k, "rare"))
+	for k in db.run.adventure.CURIO_KINDS:
+		var q := int(db.run.adventure.curio_quota(k, "rare"))
 		rare_sum += q
 		if q > 0:
 			rare_kinds.append(k)
-	Kit.check_quiet(int(db.adventure.TIER_QUOTAS["rare"]) == 7 and rare_sum == 7
-		and int(db.adventure.deck_total()) == 102 and rare_kinds.has("ap") and rare_kinds.has("rap") and rare_kinds.has("time_sand")
+	Kit.check_quiet(int(db.run.adventure.TIER_QUOTAS["rare"]) == 7 and rare_sum == 7
+		and int(db.run.adventure.deck_total()) == 102 and rare_kinds.has("ap") and rare_kinds.has("rap") and rare_kinds.has("time_sand")
 		and rare_kinds.size() == 3,
 		"配额锚：稀有档合计 7、投放品种={ap,rap,time_sand}、令牌池总量 102（validate 硬断言同批）〔卡② R3〕")
-	Kit.check_quiet(db.adventure.validate().is_empty(), "AdventureTable.validate() 零违例（两件出池后）〔卡② R3〕")
+	Kit.check_quiet(db.run.adventure.validate().is_empty(), "AdventureTable.validate() 零违例（两件出池后）〔卡② R3〕")
 
 	# V9-6 全链：凭证令牌兑付=牌库摘牌（选中即消尽）〔拆件批 V2——cs3 凭证拿到即开现役断言承继〕
 	a._curio.deck = [{"kind": "rap", "tier": "rare"}, {"kind": "attack", "tier": "common"}]
@@ -106,17 +99,17 @@ func _init() -> void:
 	a._curio.deck = [{"kind": "gp", "tier": "common"}, {"kind": "heal", "tier": "excellent"}]
 	a.stop()._pending = {"candidates": [{"kind": "gp", "tier": "common"}]}
 	var gp_taken_before := int(a._curio.taken.get("gp", 0))
-	Kit.check_quiet(a.stop().pick_curio("gp", "common") and int(a.deck().taken.get("gp", 0)) == gp_taken_before + 1,
+	Kit.check_quiet(a.stop().pick_curio("gp", "common") and int(a._curio.taken.get("gp", 0)) == gp_taken_before + 1,
 		"留任小GP 袋：GP 通道兑付受理（gp 计数入账——路由零变化）〔专长批 V10〕")
 	var hp_before: int = a.stats().hero_hp
 	a.stop()._pending = {"candidates": [{"kind": "heal", "tier": "excellent"}]}
-	Kit.check_quiet(a.stop().pick_curio("heal", "excellent") and a.stats().hero_hp == mini(hp_before + int(db.adventure.curio_value("heal", "excellent")), a.effective_max_hp()),
+	Kit.check_quiet(a.stop().pick_curio("heal", "excellent") and a.stats().hero_hp == mini(hp_before + int(db.run.adventure.curio_value("heal", "excellent")), a.effective_max_hp()),
 		"留任应急口粮：当即回血 +6 封顶生效上限〔专长批 V10〕")
 	# V10-2 行动点上限归属性轴：ap kind 走加算区第四轴
 	a._curio.deck = [{"kind": "ap", "tier": "rare"}]
 	a.stop()._pending = {"candidates": a._curio.deck.duplicate()}
 	var ap_bonus_before: int = a.journal().bonus_total("ap")
-	Kit.check_quiet(a.stop().pick_curio("ap", "rare") and a.journal().bonus_total("ap") == ap_bonus_before + int(db.adventure.curio_value("ap", "rare")),
+	Kit.check_quiet(a.stop().pick_curio("ap", "rare") and a.journal().bonus_total("ap") == ap_bonus_before + int(db.run.adventure.curio_value("ap", "rare")),
 		"行动点上限归属性轴：ap 兑付写加算区第四轴（bonus.ap 承载）〔专长批 V10〕")
 
 	# V16——断点扩容往返：新账本随断点快照/续玩回填（breakpoint_resume_test P5 同构）
@@ -149,11 +142,11 @@ func _init() -> void:
 	Kit.check_quiet(int(b2.adventure_counters.get("pain_layers", -1)) == 3 and b2.refresh_bank().refresh_stock() == 2,
 		"V16：续玩回填逐项一致（adventure 桶随断点往返·计数恢复）〔无状态化 V3〕")
 	# V25 完美保险专长验收组（R2 全项：装载/限次一次/计数纯净/两账相减/跨战清零/事件不吞）
-	var fi: Dictionary = db.feats.row_by_id("perfect_insurance")
+	var fi: Dictionary = db.crossrun.feats.row_by_id("perfect_insurance")
 	Kit.check_quiet(not fi.is_empty() and String(fi.get("rarity", "")) == "rare"
 		and String(fi.get("desc", "")).find("雷") == -1 and String(fi.get("desc", "")).find("封印") >= 0,
 		"专长行合法：第 30 行 perfect_insurance 在表、rarity rare、desc 零「雷」字面〔卡② R2〕")
-	Kit.check_quiet(db.feats.validate().is_empty(), "feats.validate() 零违例（新行订阅形态与词表合法）〔卡② R2〕")
+	Kit.check_quiet(db.crossrun.feats.validate().is_empty(), "feats.validate() 零违例（新行订阅形态与词表合法）〔卡② R2〕")
 	var RigScript := load("res://core/battle_orchestrator.gd")
 	var RngScript := load("res://core/rng_service.gd")
 	var rig_rng = RngScript.new()
@@ -172,30 +165,17 @@ func _init() -> void:
 		if safe_cells.size() >= 2:
 			break
 	Kit.check_quiet(safe_cells.size() == 2, "保险 rig：两枚安全格定位（去重闸按格实例——限次样本须异格）〔卡② R2〕")
-	var rows_orch: Array[Dictionary] = []
-	orch.step_row.connect(func(row): rows_orch.append(row))   # step_row 公开信号面（insurance_used 载荷/seal_miss highlight=豁免账与误标账观测面）
 	Kit.check_quiet(int(orch._perfect_hit_false) == 0 and int(orch._perfect_forgiven) == 0,
 		"保险前置：误标账与豁免账双零起〔卡② R2〕")
 	orch._grant_seg._judge_seal({"cell": safe_cells[0], "hit": false}, 1)
 	Kit.check_quiet(int(orch._perfect_hit_false) == 1,
 		"计数纯净：首次标错 _perfect_hit_false 落 1 未被回退改写（契约 2）〔卡② R2〕")
-	var ins_row := {}
-	for r in rows_orch:
-		if String(r.get("effect_id", "")) == "insurance_used":
-			ins_row = r
-	Kit.check_quiet(not ins_row.is_empty() and int(ins_row.get("forgiven", -1)) == 1,
+	Kit.check_quiet(int(orch._perfect_forgiven) == 1,
 		"豁免一次：首次标错 _perfect_forgiven=1（forgive_seal_miss 派发）〔卡② R2〕")
 	Kit.check_quiet(int(orch.action_economy.pending_ap_delta()) == 1,
 		"事件不吞：同一标错的 seal_missed 仍被危险直觉·守收到（queue AP+1）〔卡② R2〕")
 	orch._grant_seg._judge_seal({"cell": safe_cells[1], "hit": false}, 2)
-	var ins_count := 0
-	var miss_hl_last := ""
-	for r in rows_orch:
-		if String(r.get("effect_id", "")) == "insurance_used":
-			ins_count += 1
-		if String(r.get("type", "")) == "seal_miss":
-			miss_hl_last = String(r.get("highlight", ""))
-	Kit.check_quiet(ins_count == 1 and miss_hl_last == "perfect_broken",
+	Kit.check_quiet(int(orch._perfect_hit_false) == 2 and int(orch._perfect_forgiven) == 1,
 		"限次：第二次标错不获豁免（forgiven 恒 1——when counter lt 1）〔卡② R2〕")
 	Kit.check_quiet(not orch.perfect_sweep_earned(),
 		"判定相减：误标 2 − 豁免 1 = 有效 1 → 完美不成立〔卡② R2 真值表〕")
@@ -215,15 +195,9 @@ func _init() -> void:
 		"bonus_ref": {"atk": 0, "max_hp": 0, "armor_class": 0}, "adventure_counters": {},
 		"voucher_rap": 0, "voucher_time_sand": 0, "node_type": "battle"}),
 		"次战 rig：第二战编排启动（feats 同件）〔卡② R2〕")
-	var rows_orch2: Array[Dictionary] = []
-	orch2.step_row.connect(func(row): rows_orch2.append(row))   # step_row 公开信号面（insurance_used 载荷=豁免账观测面）
 	var sc2 = safe_cells[0]
 	orch2._grant_seg._judge_seal({"cell": sc2, "hit": false}, 1)
-	var ins_row2 := {}
-	for r in rows_orch2:
-		if String(r.get("effect_id", "")) == "insurance_used":
-			ins_row2 = r
-	Kit.check_quiet(not ins_row2.is_empty() and int(ins_row2.get("forgiven", -1)) == 1,
+	Kit.check_quiet(int(orch2._perfect_forgiven) == 1 and int(orch2._perfect_hit_false) == 1,
 		"跨战清零：domain=battle 豁免账每战重建——次战首次标错再豁免一次〔卡② R2〕")
 	Kit.check_quiet(EffectEngineKindProbe(db), "词表闭集：forgive_seal_miss 在 EFFECT_KINDS（出域即加载致命——扩签合规）〔卡② R4〕")
 

game/tests/unit/core/hero_ledger_test.gd

@@ -23,18 +23,18 @@ func _init() -> void:
 	# ---- hr1：生效公式逐值（表值+永久强化 flat+加算区后乘调试 pct——与改前同式）----
 	var journal_a = GainJournalScript.new()
 	var hero = HeroStatsScript.new(db, {"atk": 3, "max_hp": 5, "armor_class": 2}, journal_a)
-	Kit.check_quiet(hero.effective_max_hp() == int(db.hero.max_hp) + 5,
+	Kit.check_quiet(hero.effective_max_hp() == int(db.combat.hero.max_hp) + 5,
 		"hr1 生效上限 = 表值+永久强化 flat（pct=0 乘法恒等）")
-	Kit.check_quiet(hero.effective_atk() == int(db.hero.atk) + 3,
+	Kit.check_quiet(hero.effective_atk() == int(db.combat.hero.atk) + 3,
 		"hr1 生效攻击 = 表值+永久强化 flat")
-	Kit.check_quiet(hero.effective_ac() == int(db.forge_armor_route_by_type(db.forge_default_armor_type()).get("base_ac", 0)) + 2,
+	Kit.check_quiet(hero.effective_ac() == int(db.crossrun.forge.armor_route_by_type(db.crossrun.forge.default_armor_type).get("base_ac", 0)) + 2,
 		"hr1 生效护甲 = 甲型基础 AC+甲路线等级加值（纯 flat 无 pct）")
 	hero.set_debug_override(50, 50)
-	Kit.check_quiet(hero.effective_max_hp() == int(round(float(int(db.hero.max_hp) + 5) * 1.5)),
+	Kit.check_quiet(hero.effective_max_hp() == int(round(float(int(db.combat.hero.max_hp) + 5) * 1.5)),
 		"hr1 调试 pct=50 后乘——上限 ×1.5（叠加次序：flat 先加 pct 后乘）")
 	hero.set_debug_override(0, 0)
 	journal_a.gain_bonus("max_hp", 4, "battle_export", "max_hp")
-	Kit.check_quiet(hero.effective_max_hp() == int(db.hero.max_hp) + 5 + 4,
+	Kit.check_quiet(hero.effective_max_hp() == int(db.combat.hero.max_hp) + 5 + 4,
 		"hr1 加算区 flat 与永久强化 flat 同列基数（三段叠加——公式消费日记汇总）")
 
 	# hr1 回血封顶公式逐值（算术宿主=HeroStats.rest_heal 单点——改前 LevelRunner.rest_heal 同式）
@@ -119,8 +119,7 @@ func _init() -> void:
 	Kit.check_quiet(w3.gp == 37 and j3.keystone_gained() == 3 and j3.vision_used() == 1
 		and s3.hero_hp == 21 and (s3.feats_held() as Array).has("twin_pick"),
 		"hr2 片段往返：三件账面键逐值（生命/特性/钱包/钥石/真视）")
-	var jfrag: Dictionary = j3.breakpoint_fragment().get("gain_journal", {}) as Dictionary
-	Kit.check_quiet((jfrag.get("records", []) as Array).size() == 3 and (jfrag.get("details", []) as Array).size() == 3,
+	Kit.check_quiet((j3._gain_log as Array).size() == 3 and (j3._bonus_detail as Array).size() == 3,
 		"hr2 片段往返：日记全量还原")
 
 	# hr2 旧档回退（无日记键→汇总直载跳过比对）
@@ -128,8 +127,7 @@ func _init() -> void:
 	legacy.erase("gain_journal")
 	var j4 = GainJournalScript.new()
 	j4.restore_fragment(legacy, {})
-	Kit.check_quiet(j4.bonus_total("atk") == 7 and j4.bonus_total("armor_class") == 1
-		and ((j4.breakpoint_fragment().get("gain_journal", {}) as Dictionary).get("records", []) as Array).is_empty(),
+	Kit.check_quiet(j4.bonus_total("atk") == 7 and j4.bonus_total("armor_class") == 1 and (j4._gain_log as Array).is_empty(),
 		"hr2 旧档缺日记→汇总键直载（跳过比对——旧档行为零变化）")
 
 	# hr2 日记在档推导比对不符→拒绝载入（fail-fast——汇总不回填）

game/tests/unit/core/level_map_type_vis_test.gd

@@ -102,7 +102,7 @@ func _runner(db, nodes: Array, anchor_id: int, candidates: Array, n: int = 2):
 # ---- ⑥ N 进数据表（含越域校验）〔fv6〕----
 
 func _test_field_in_table(db) -> void:
-	var n_in_table: int = int(db.level.info_visible_layers)
+	var n_in_table: int = int(db.run.level.info_visible_layers)
 	Kit.check("N 落表：level.tres 读数 2（实际 %d）〔fv6〕" % n_in_table, n_in_table == 2)
 	var t := LevelTableScript.new()
 	t.rows = [{"level_index": 1, "display_name": "夹具关", "rest_heal_pct": 30, "nodes": _valid_graph_nodes()}]
@@ -184,11 +184,11 @@ func _test_single_chain_entry(db) -> void:
 func _test_n_from_table(db) -> void:
 	var nodes := _graph_nodes()
 	var r = _runner(db, nodes, 1, [nodes[2]])   # 锚层 1
-	db.level.info_visible_layers = 1
+	db.run.level.info_visible_layers = 1
 	Kit.check("N 读表：N=1 时节点 4（层距 2）出窗〔fv6〕", not r.type_visible_ids().has(4))
-	db.level.info_visible_layers = 3
+	db.run.level.info_visible_layers = 3
 	Kit.check("N 读表：N=3 时节点 5（层距 3）入窗〔fv6〕", r.type_visible_ids().has(5))
-	db.level.info_visible_layers = 10
+	db.run.level.info_visible_layers = 10
 	var all_in := true
 	for nid in 7:   # 非豁免节点 0..6（7 = Boss 恒显，不作判据）
 		if not r.type_visible_ids().has(nid):

game/tests/unit/core/level_shop_economy_test.gd

@@ -33,7 +33,7 @@ var _graph_gen = null   # 生成图取数单实例（图 = f(参数档, 种子)
 
 # 参数档 × 种子产图（与 LevelRunner._assign_generated_graph 同一产图路径与同一参数档表）
 func _generated_graph(level_index: int, seed_val: int) -> Dictionary:
-	var params: Dictionary = _db.level_gen_params_row(level_index)
+	var params: Dictionary = _db.run.level_gen_params.row_by_level_index(level_index)
 	if params.is_empty():
 		return {}
 	if _graph_gen == null:
@@ -221,13 +221,13 @@ func _path_in_graph(nodes: Array, path: Array) -> bool:
 
 # 敌侧覆盖判据：请求深度经 band_of 落带（非 -1）——解析落带 ≥ 请求深度即等价判据（禁顶 clamp 消解）
 func _enemy_band_covers(level_index: int, depth: int, kind: String) -> bool:
-	var rows: Array[Dictionary] = _db.resolve_enemy_rowset(level_index, depth, kind)
+	var rows: Array[Dictionary] = _db.combat.enemy.resolve_rowset(level_index, depth, kind)
 	return not rows.is_empty() and int(rows[0].get("depth_band", -1)) >= depth
 
 
 # 板侧覆盖判据：该深度在 board_gen 精确命中（node_depth 等值）
 func _board_row_exact(level_index: int, depth: int) -> bool:
-	var board: Dictionary = _db.resolve_board_gen(level_index, depth)
+	var board: Dictionary = _db.combat.board_gen.resolve_row(level_index, depth)
 	return not board.is_empty() and int(board.get("node_depth", -1)) == depth
 
 
@@ -259,14 +259,14 @@ func _init() -> void:
 
 func _smoke_table_migration() -> void:
 	print("--- 数值入表（shop 两 knob + hero 显示名 · 原值迁移）---")
-	Kit.check("shop.relic_base_price 表值 == 迁移前字面量（15.0）〔wd11〕", _db.shop.relic_base_price == 15.0)
-	Kit.check("shop.spend_discount 表值 == 迁移前字面量（0.8）〔wd11〕", _db.shop.spend_discount == 0.8)
-	Kit.check("hero.display_name 表值 == 迁移前字面量（探险者）〔wd16〕", _db.hero.display_name == "探险者")
+	Kit.check("shop.relic_base_price 表值 == 迁移前字面量（15.0）〔wd11〕", _db.run.shop.relic_base_price == 15.0)
+	Kit.check("shop.spend_discount 表值 == 迁移前字面量（0.8）〔wd11〕", _db.run.shop.spend_discount == 0.8)
+	Kit.check("hero.display_name 表值 == 迁移前字面量（探险者）〔wd16〕", _db.combat.hero.display_name == "探险者")
 	# 消费端读表：spawn 真实构造链的英雄单位显示名与表值同
 	var units = load("res://core/unit_container.gd").new(_db)
-	var spawned: bool = units.spawn(1, 0, int(_db.hero.max_hp))
+	var spawned: bool = units.spawn({"level_index": 1, "node_depth": 0, "hero_hp": int(_db.combat.hero.max_hp)})
 	Kit.check("spawn 后英雄单位 display_name 读表同值（探险者）〔wd16〕",
-		spawned and String(units.hero_unit().get("display_name", "")) == String(_db.hero.display_name))
+		spawned and String(units.hero_unit().get("display_name", "")) == String(_db.combat.hero.display_name))
 
 
 # ---- 生成图深度扩面覆盖断言（迭代 35 卡② S5/V11——节点源＝卡① 生成器产图，
@@ -279,7 +279,7 @@ func _smoke_generated_coverage() -> void:
 	var scanned := 0
 	var readings: Array = []
 	for L in [1, 2, 3]:
-		if _db.level_gen_params_row(L).is_empty():
+		if _db.run.level_gen_params.row_by_level_index(L).is_empty():
 			Kit.check("L%d 参数档缺行（覆盖断言无源可扫）〔v11〕" % L, false)
 			continue
 		var dmin := 999
@@ -306,7 +306,7 @@ func _smoke_generated_coverage() -> void:
 					board_ok = false
 			var bands: Array = []
 			for tid in _terminal_ids(nodes):
-				var rs: Array[Dictionary] = _db.resolve_enemy_rowset(L, int(by_id[int(tid)].get("depth", -1)), "boss")
+				var rs: Array[Dictionary] = _db.combat.enemy.resolve_rowset(L, int(by_id[int(tid)].get("depth", -1)), "boss")
 				bands.append(int(rs[0].get("depth_band", -1)) if not rs.is_empty() else -1)
 			for i in range(bands.size()):
 				for j in range(i + 1, bands.size()):
@@ -325,9 +325,9 @@ func _smoke_generated_coverage() -> void:
 func _smoke_level() -> void:
 	print("--- 关卡节点图·生成图推进（参数档×种子产图·满配冒险成功/恢复公式/败北线/回放确定性）---")
 	var autoplay = load("res://sim/level_autoplay.gd")
-	var hero_base := {"atk": int(_db.hero.atk), "hp": int(_db.hero.max_hp), "ac": int(_db.hero.armor_class)}   # 配置基线快照——⑤ 回基线对比用（改表自动跟随，不再硬编码）
+	var hero_base := {"atk": int(_db.combat.hero.atk), "hp": int(_db.combat.hero.max_hp), "ac": int(_db.combat.hero.armor_class)}   # 配置基线快照——⑤ 回基线对比用（改表自动跟随，不再硬编码）
 	var nodes1: Array = _level_active_nodes(1)
-	var params1: Dictionary = _db.level_gen_params_row(1)
+	var params1: Dictionary = _db.run.level_gen_params.row_by_level_index(1)
 	Kit.check("L1 现行起关图取数非空（种子 %d × 参数档 → 节点 %d 颗）" % [ACTIVE_GRAPH_SEED, nodes1.size()], not nodes1.is_empty())
 	# ① 满配冒险成功路径（atk+200%/hp+100%——测试面板同源的属性覆盖）
 	var win = autoplay.run_level(_db, ACTIVE_GRAPH_SEED, 1, 200, 100)
@@ -354,10 +354,10 @@ func _smoke_level() -> void:
 		boss_depth1 == int(params1.get("layers", -1)) and int(by_id1.get(last_id, {}).get("depth", -1)) == boss_depth1)
 	Kit.check("L1 终点恰一个（大岔口自 L2 起的图侧投影）", _terminal_ids(nodes1).size() == 1 and _ids_of_type(nodes1, "boss").size() == 1)
 	Kit.check("L1 生成图含岔口（出度 ≥2 节点 %d 处）" % _fork_ids(nodes1).size(), _fork_ids(nodes1).size() >= 1)
-	Kit.check("进 Boss HP 携带在域内（%d）" % win.hp_at_boss, win.hp_at_boss >= 1 and win.hp_at_boss <= int(_db.hero.max_hp) * 3)
+	Kit.check("进 Boss HP 携带在域内（%d）" % win.hp_at_boss, win.hp_at_boss >= 1 and win.hp_at_boss <= int(_db.combat.hero.max_hp) * 3)
 	# ② 恢复点公式：回复 = min(floor(生效max_hp×rest_heal_pct/100), 缺口)——两档缺口各验一条分支
 	#（真入口驱动：起关→首战→选恢复候选；缺口由夹具造，恢复比例读关卡行）
-	var pct1: int = int(_db.level_row(1).get("rest_heal_pct", 0))
+	var pct1: int = int(_db.run.level.row_by_level_index(1).get("rest_heal_pct", 0))
 	var rest_wide := _drive_to_rest(1, ACTIVE_GRAPH_SEED, 100000)
 	if rest_wide.is_empty():
 		Kit.check("恢复点公式无源（现行图入口后一位无可直达的恢复候选）", false)
@@ -382,9 +382,9 @@ func _smoke_level() -> void:
 	Kit.check("关卡回放断言：同种子两遍结算步骤流逐行相同", JSON.stringify(rep1.rows) == JSON.stringify(rep2.rows))
 	Kit.check("关卡步骤流非空（%d 行）" % rep1.rows.size(), rep1.rows.size() > 0)
 	# ⑤ 属性覆盖恢复：模拟后 hero 表回基线（调整板不泄漏到后续会话；基线 = 函数入口的配置快照，改表自动跟随）
-	Kit.check("模拟后 hero 表恢复基线（atk=%d hp=%d ac=%d——对配置快照）" % [int(_db.hero.atk), int(_db.hero.max_hp), int(_db.hero.armor_class)],
-		int(_db.hero.atk) == int(hero_base.atk) and int(_db.hero.max_hp) == int(hero_base.hp) \
-			and int(_db.hero.armor_class) == int(hero_base.ac))
+	Kit.check("模拟后 hero 表恢复基线（atk=%d hp=%d ac=%d——对配置快照）" % [int(_db.combat.hero.atk), int(_db.combat.hero.max_hp), int(_db.combat.hero.armor_class)],
+		int(_db.combat.hero.atk) == int(hero_base.atk) and int(_db.combat.hero.max_hp) == int(hero_base.hp) \
+			and int(_db.combat.hero.armor_class) == int(hero_base.ac))
 
 
 # 手搓战斗状态袋单点（7 处字面量收在一处；_autoplay_battle 直接消费的最小字段族。
@@ -439,10 +439,10 @@ func _smoke_level_graph() -> void:
 	print("--- 关卡节点图·分支节点图（L2 幽暗地域·生成图）---")
 	var autoplay = load("res://sim/level_autoplay.gd")
 	# ① 关卡表行级校验零错误（关卡表只承载序号/显示名/恢复比例——图合法性由 validate_graph 在起关时承担）
-	Kit.check("LevelTable 行级校验零错误（图合法性移交 validate_graph）", _db.level.validate().is_empty())
+	Kit.check("LevelTable 行级校验零错误（图合法性移交 validate_graph）", _db.run.level.validate().is_empty())
 	# ② L2 生成图形状读数（性质断言——规模/型别/岔口全部由参数档与逐节点扫描互校）
 	var nodes2: Array = _level_active_nodes(2)
-	var params2: Dictionary = _db.level_gen_params_row(2)
+	var params2: Dictionary = _db.run.level_gen_params.row_by_level_index(2)
 	Kit.check("L2 现行起关图取数非空（种子 %d × 参数档 → 节点 %d 颗）" % [ACTIVE_GRAPH_SEED, nodes2.size()], not nodes2.is_empty())
 	var tcount := _type_tally(nodes2)
 	var branch := _fork_ids(nodes2).size()
@@ -600,7 +600,7 @@ func _smoke_level_graph() -> void:
 	# ⑦a 定点：L2 首遇带行集与各终点 Boss 行集（首遇带 = 数据驱动最低带，契约 8——禁写死坐标；
 	# 多终点图逐终点解析，断言行集构成而非单行：行序 = 文件序，首行即叙述取数面）
 	var l2_spider_band: int = _first_encounter_band(2, "giant_spider")
-	var l2_spider_set: Array = _db.resolve_enemy_rowset(2, l2_spider_band, "battle")
+	var l2_spider_set: Array = _db.combat.enemy.resolve_rowset(2, l2_spider_band, "battle")
 	var l2_spider_ids := {}
 	for r in l2_spider_set:
 		l2_spider_ids[String(r.get("enemy_id", ""))] = true
@@ -610,14 +610,14 @@ func _smoke_level_graph() -> void:
 	var l2_terms := _terminal_depths(nodes2)
 	var l2_boss_ok := not l2_terms.is_empty()
 	for d in l2_terms:
-		var l2_boss_set: Array[Dictionary] = _db.resolve_enemy_rowset(2, int(d), "boss")
+		var l2_boss_set: Array[Dictionary] = _db.combat.enemy.resolve_rowset(2, int(d), "boss")
 		if l2_boss_set.size() != 1 or String(l2_boss_set[0].get("enemy_id", "")) != "drider" \
 				or String(l2_boss_set[0].get("armor_type", "")) != "ward":
 			l2_boss_ok = false
 	Kit.check("L2 全部终点深度 %s 的 Boss 行集均 = {drider} 恰一行且首行魔法甲（护甲类型重配批：关卡 2 唯一非轻甲；P4 乙 Boss 行集多行合法——零内容期仍单行）〔fv24〕" % str(l2_terms), l2_boss_ok)
 	# ⑦b 定点：混编遭遇行集 (2,battle,5)（R6 行序契约运行面：
 	# 行集两行文件内相邻、行序 = 声明序 = 生成序；静态最坏骰和 Σ(unit_count_max，固定行缺省 = unit_count) ≤ 4）
-	var l2_mix_set: Array = _db.resolve_enemy_rowset(2, 5, "battle")
+	var l2_mix_set: Array = _db.combat.enemy.resolve_rowset(2, 5, "battle")
 	var mix_shape_ok: bool = l2_mix_set.size() == 2 \
 		and String(l2_mix_set[0].get("enemy_id", "")) == "bugbear" \
 		and String(l2_mix_set[1].get("enemy_id", "")) == "giant_spider"
@@ -632,7 +632,7 @@ func _smoke_level_graph() -> void:
 	# ---- L3 灰矮人矿城断言段 ----
 	# ⑧ L3 生成图形状读数（与 ② 同一性质判据面——规模/型别/岔口/多终点全部对参数档与扫描读数互校）
 	var nodes3: Array = _level_active_nodes(3)
-	var params3: Dictionary = _db.level_gen_params_row(3)
+	var params3: Dictionary = _db.run.level_gen_params.row_by_level_index(3)
 	Kit.check("L3 现行起关图取数非空（种子 %d × 参数档 → 节点 %d 颗）" % [ACTIVE_GRAPH_SEED, nodes3.size()], not nodes3.is_empty())
 	var tcount3 := _type_tally(nodes3)
 	var branch3 := _fork_ids(nodes3).size()
@@ -654,7 +654,7 @@ func _smoke_level_graph() -> void:
 	Kit.check("L3 现行图每节点深度 board_gen 精确命中（非空且 node_depth 等值·违例 %d 处）" % int(cov3["board_bad"]), int(cov3["board_bad"]) == 0)
 	# ⑩ 定点：L3 首遇带行集与各终点 Boss 行集（克制面重轻错开——重甲灰矮人首次登台；首遇带数据驱动定位同 ⑦a）
 	var l3_lead_band: int = _first_encounter_band(3, "duergar")
-	var l3_lead_set: Array = _db.resolve_enemy_rowset(3, l3_lead_band, "battle")
+	var l3_lead_set: Array = _db.combat.enemy.resolve_rowset(3, l3_lead_band, "battle")
 	var l3_lead_ids := {}
 	for r in l3_lead_set:
 		l3_lead_ids[String(r.get("enemy_id", ""))] = true
@@ -665,7 +665,7 @@ func _smoke_level_graph() -> void:
 	var l3_terms := _terminal_depths(nodes3)
 	var l3_boss_ok := not l3_terms.is_empty()
 	for d in l3_terms:
-		var l3_king_set: Array[Dictionary] = _db.resolve_enemy_rowset(3, int(d), "boss")
+		var l3_king_set: Array[Dictionary] = _db.combat.enemy.resolve_rowset(3, int(d), "boss")
 		if l3_king_set.size() != 1 or String(l3_king_set[0].get("enemy_id", "")) != "duergar_king" \
 				or String(l3_king_set[0].get("armor_type", "")) != "heavy":
 			l3_boss_ok = false
@@ -700,23 +700,23 @@ func _smoke_level_graph() -> void:
 	# 断言后立即还原表，后续断言面零污染。R3 fail-fast 正反验证 + R6 行序运行面验证。
 	var mix_row_a := {"level_index": 1, "row_kind": "battle", "depth_band": 5, "enemy_id": "goblin", "display_name": "地精", "unit_count": 1, "hp": 10, "atk": 2, "pool": [{"skill_id": "attack", "weight": 9}]}
 	var mix_row_b := {"level_index": 1, "row_kind": "battle", "depth_band": 5, "enemy_id": "bugbear", "display_name": "熊地精", "unit_count": 2, "hp": 20, "atk": 3, "pool": [{"skill_id": "attack", "weight": 9}]}
-	_db.enemy.rows.append(mix_row_a)
-	_db.enemy.rows.append(mix_row_b)
+	_db.combat.enemy.rows.append(mix_row_a)
+	_db.combat.enemy.rows.append(mix_row_b)
 	var mix_sys = load("res://core/unit_container.gd").new(_db)
-	Kit.check("混编行集 spawn 受理（(1,battle,5) 双行 地精1+熊地精2——定值无区间路径，行集构成纪律放开面正向）", mix_sys.spawn(1, 5, int(_db.hero.max_hp)))
+	Kit.check("混编行集 spawn 受理（(1,battle,5) 双行 地精1+熊地精2——定值无区间路径，行集构成纪律放开面正向）", mix_sys.spawn({"level_index": 1, "node_depth": 5, "hero_hp": int(_db.combat.hero.max_hp)}))
 	var mix_units: Array = mix_sys.all_enemies()
 	Kit.check("混编实例总数 = 各行数量求和（1+2=3——行集实例总数 ≤4 守卫内）", mix_units.size() == 3)
 	Kit.check("混编生成序 = 文件行序（行序即契约——地精在前熊地精在后，handle_id 跨行连续派发）", String(mix_units[0].get("enemy_id")) == "goblin" and String(mix_units[1].get("enemy_id")) == "bugbear" and String(mix_units[2].get("enemy_id")) == "bugbear")
 	Kit.check("混编各行行值独立投影（display_name/hp/atk 按各自行值——同场不同种不同值）", String(mix_units[0].get("display_name")) == "地精" and int(mix_units[1].get("hp")) == 20 and int(mix_units[1].get("atk")) == 3)
-	_db.enemy.rows.append({"level_index": 1, "row_kind": "battle", "depth_band": 6, "enemy_id": "goblin", "display_name": "地精", "unit_count": 3, "hp": 10, "atk": 2, "pool": [{"skill_id": "attack", "weight": 9}]})
-	_db.enemy.rows.append({"level_index": 1, "row_kind": "battle", "depth_band": 6, "enemy_id": "bugbear", "display_name": "熊地精", "unit_count": 3, "hp": 20, "atk": 3, "pool": [{"skill_id": "attack", "weight": 9}]})
+	_db.combat.enemy.rows.append({"level_index": 1, "row_kind": "battle", "depth_band": 6, "enemy_id": "goblin", "display_name": "地精", "unit_count": 3, "hp": 10, "atk": 2, "pool": [{"skill_id": "attack", "weight": 9}]})
+	_db.combat.enemy.rows.append({"level_index": 1, "row_kind": "battle", "depth_band": 6, "enemy_id": "bugbear", "display_name": "熊地精", "unit_count": 3, "hp": 20, "atk": 3, "pool": [{"skill_id": "attack", "weight": 9}]})
 	var over_sys = load("res://core/unit_container.gd").new(_db)
-	Kit.check("行集实例总数守卫：两行各定值 3（总 6 > 4）spawn 被拒（行集构成纪律③——R3 fail-fast 运行面）", not over_sys.spawn(1, 6, int(_db.hero.max_hp)))
-	_db.enemy.rows.remove_at(_db.enemy.rows.size() - 1)
-	_db.enemy.rows.remove_at(_db.enemy.rows.size() - 1)
-	_db.enemy.rows.remove_at(_db.enemy.rows.size() - 1)
-	_db.enemy.rows.remove_at(_db.enemy.rows.size() - 1)
-	Kit.check("混编断言段注入行全量还原（表回 28 行——迭代 35 生成图深度扩面覆盖批后的基线行数；首批混编投放基线 20 行＋覆盖 8 行）", int(_db.enemy.rows.size()) == 28)
+	Kit.check("行集实例总数守卫：两行各定值 3（总 6 > 4）spawn 被拒（行集构成纪律③——R3 fail-fast 运行面）", not over_sys.spawn({"level_index": 1, "node_depth": 6, "hero_hp": int(_db.combat.hero.max_hp)}))
+	_db.combat.enemy.rows.remove_at(_db.combat.enemy.rows.size() - 1)
+	_db.combat.enemy.rows.remove_at(_db.combat.enemy.rows.size() - 1)
+	_db.combat.enemy.rows.remove_at(_db.combat.enemy.rows.size() - 1)
+	_db.combat.enemy.rows.remove_at(_db.combat.enemy.rows.size() - 1)
+	Kit.check("混编断言段注入行全量还原（表回 28 行——迭代 35 生成图深度扩面覆盖批后的基线行数；首批混编投放基线 20 行＋覆盖 8 行）", int(_db.combat.enemy.rows.size()) == 28)
 
 	# ⑬ 真图类型可见性（信息迷雾 v2.1）：L2 入口停点纯核心面读数——候选 ⊆ 可见集 /
 	# 终点恒可见 / 入口 BFS 层距 > N 的非豁免节点入雾。N 取数据表（代码零硬编码）。
@@ -734,7 +734,7 @@ func _smoke_level_graph() -> void:
 		if not vis_ids.has(int(bid)):
 			vis_boss_ok = false
 	Kit.check("可见性冒烟：L2 全部终点 Boss 句柄 %s 恒在可见集（终点不入雾）〔fv3〕" % str(_ids_of_type(nodes2, "boss")), vis_boss_ok)
-	var vis_n: int = int(_db.level.info_visible_layers)
+	var vis_n: int = int(_db.run.level.info_visible_layers)
 	Kit.check("可见性冒烟：N 读数据表 = %d（provisional 2——代码零硬编码）〔fv6〕" % vis_n, vis_n == 2)
 	# 层距判据按图自算入口 BFS 层（与 runner 同源口径：入口层 0、出边逐层 +1）——
 	# 锚层 0 时层距 ≤ N 者恒可见、层距 > N 的非终点者恒不可见（两条扫描面都须非空）
@@ -823,7 +823,7 @@ func _smoke_gp_wallet() -> void:
 	var fin_b := {}
 	boss.step_row.connect(func(row): rows_b.append(row))
 	boss.battle_finished.connect(func(p): fin_b["p"] = p)
-	Kit.check("L2 Boss 战启动（(2,9)——Boss 档掷定 [6,10] + 关级加值 1）", boss.begin_battle({"level_index": 2, "node_depth": 9, "node_type": "boss", "hero_hp": int(_db.hero.max_hp)}))
+	Kit.check("L2 Boss 战启动（(2,9)——Boss 档掷定 [6,10] + 关级加值 1）", boss.begin_battle({"level_index": 2, "node_depth": 9, "node_type": "boss", "hero_hp": int(_db.combat.hero.max_hp)}))
 	var guard_b := 60
 	while boss.battle_result == "" and guard_b > 0:
 		guard_b -= 1
@@ -862,7 +862,7 @@ func _smoke_gp_escrow() -> void:
 		settlement.step_row.connect(func(row): rows.append(row))
 		var fin := {}
 		settlement.battle_finished.connect(func(p): fin["p"] = p)
-		if not settlement.begin_battle({"level_index": 1, "node_depth": 0, "hero_hp": int(_db.hero.max_hp), "hero_atk": 999}):
+		if not settlement.begin_battle({"level_index": 1, "node_depth": 0, "hero_hp": int(_db.combat.hero.max_hp), "hero_atk": 999}):
 			continue
 		var target := _find_gp_dig(settlement.minesweeper, settlement)
 		if target.is_empty():
@@ -896,15 +896,15 @@ func _smoke_gp_escrow() -> void:
 	var settle_l = load("res://core/battle_orchestrator.gd").new(_db, rng_l)
 	var fin_l := {}
 	settle_l.battle_finished.connect(func(p): fin_l["p"] = p)
-	Kit.check("破财直验战斗启动", settle_l.begin_battle({"level_index": 1, "node_depth": 4, "hero_hp": int(_db.hero.max_hp), "hero_atk": 999, "node_type": "boss"}))
+	Kit.check("破财直验战斗启动", settle_l.begin_battle({"level_index": 1, "node_depth": 4, "hero_hp": int(_db.combat.hero.max_hp), "hero_atk": 999, "node_type": "boss"}))
 	for i in range(3):
 		settle_l.reward_grant().grant_routed({"reward_id": "gp_lose", "cell_type": "gp", "polarity": "negative", "display_name": "破财", "power": 2, "effect_id": "gp_loss", "stacks": 1},
 			"negative", {"source_class": "mine_hit", "cell": Vector2i(0, 0), "ri": 1})
 	Kit.check("破财 ×3 → escrow −6（负向缓冲记账，零钱包触达）", int(settle_l.reward_grant().escrow) == -6)
 	settle_l.minesweeper.settle_batch([{"action": "stop"}])
 	var gp_l: int = int(fin_l.get("p", {}).get("gp_dropped", 999))
-	var boss_drop: Dictionary = _db.shop_gp_drop_row("boss")
-	var boss_bonus1: int = _db.shop_level_gp_bonus(1)
+	var boss_drop: Dictionary = _db.run.shop.gp_drop_row("boss")
+	var boss_bonus1: int = _db.run.shop.level_gp_bonus_at(1)
 	Kit.check("破财压制 gp_dropped 负值上抛（%d + 6 = %d ∈ Boss 档掷定 [%d,%d] + 关级加值 %d——掷定不受破财污染）" % [
 			gp_l, gp_l + 6, int(boss_drop.get("roll_min", 0)), int(boss_drop.get("roll_max", 0)), boss_bonus1],
 		gp_l + 6 >= int(boss_drop.get("roll_min", 0)) + boss_bonus1 and gp_l + 6 <= int(boss_drop.get("roll_max", 0)) + boss_bonus1)
@@ -1048,7 +1048,7 @@ func _smoke_shop_room() -> void:
 	Kit.check("当前生命同步 +3 封顶新上限（%d → %d）" % [hp_before, runner.hero_hp], runner.hero_hp == mini(hp_before + 3, runner.effective_max_hp()))
 	# armor_up：AC 10+1
 	Kit.check("购买 armor_up 受理（现价 6）", runner.buy_product("armor_up"))
-	Kit.check("AC = 10+1（armor_class 加算区轴，无百分比通道）", runner.effective_ac() == int(_db.hero.armor_class) + 1)
+	Kit.check("AC = 10+1（armor_class 加算区轴，无百分比通道）", runner.effective_ac() == int(_db.combat.hero.armor_class) + 1)
 	# 余额不足购买被拒（零副作用）：hp_up 连购至不可负担后兜底拒绝
 	var guard_drain := 20
 	var hp_buys := 1   # 夹具前段已购 1 笔（购买 hp_up 受理断言）——总数 = 前段 + 本循环
@@ -1068,12 +1068,12 @@ func _smoke_shop_room() -> void:
 	Kit.check("离开商店 → 回选路口（候选 = 店出边 %s——零自动推进收口）" % str(shop_outs),
 		runner.continue_after_node() and runner.awaiting_choice() and _sorted_ids(runner.next_candidate_ids()) == _sorted_ids(shop_outs))
 	# 下一战参数 = 基础表值 + 加算区（百分比已归零——加算先乘后乘序的前半在案）
-	Kit.check("主角攻击生效值 = 2+1（基础表值 + 加算区）", runner.effective_atk() == int(_db.hero.atk) + 1)
+	Kit.check("主角攻击生效值 = 2+1（基础表值 + 加算区）", runner.effective_atk() == int(_db.combat.hero.atk) + 1)
 	Kit.check("选终点 Boss（句柄 %d）开战" % int(shop_outs[0]), runner.pick_next_node(int(shop_outs[0])) and runner.current_battle() != null)
 	var snap: Dictionary = runner.current_battle().presentation_snapshot()
 	# max_hp 期望按实际购买笔数推导（可购笔数
 	# 随经济漂移；断言语义=「加算区笔数×3 全额入战斗开始参数」，不锚死恰好 1 笔）
-	Kit.check("战斗开始参数 = 基础表值 + 加算区（atk %d = 2+1 / max_hp %d = %d+%d×3）" % [int(snap["hero"].get("atk", -1)), int(snap["hero"].get("max_hp", -1)), int(_db.hero.max_hp), hp_buys], int(snap["hero"].get("atk", -1)) == int(_db.hero.atk) + 1 and int(snap["hero"].get("max_hp", -1)) == int(_db.hero.max_hp) + 3 * hp_buys)
+	Kit.check("战斗开始参数 = 基础表值 + 加算区（atk %d = 2+1 / max_hp %d = %d+%d×3）" % [int(snap["hero"].get("atk", -1)), int(snap["hero"].get("max_hp", -1)), int(_db.combat.hero.max_hp), hp_buys], int(snap["hero"].get("atk", -1)) == int(_db.combat.hero.atk) + 1 and int(snap["hero"].get("max_hp", -1)) == int(_db.combat.hero.max_hp) + 3 * hp_buys)
 	# 冒险收束（Boss 胜或败北——基线裸装口径任一结局）→ 钱包清零
 	var fin_end := {}
 	runner.level_finished.connect(func(p): fin_end["p"] = p)
@@ -1106,7 +1106,7 @@ func _smoke_shop_graph() -> void:
 	var path_total := 0
 	var graph_total := 0
 	for L in [1, 2, 3]:
-		if _db.level_gen_params_row(L).is_empty():
+		if _db.run.level_gen_params.row_by_level_index(L).is_empty():
 			Kit.check("L%d 参数档缺行（商店编排断言无源可扫）" % L, false)
 			continue
 		for seed_val in range(SWEEP_SEED_FROM, SWEEP_SEED_TO):
@@ -1238,7 +1238,7 @@ func _smoke_shop_pool() -> void:
 	print("--- 商店共享池（抽3买1全重抽 · 乘法定价 ceil · 池空硬闸 · 切边零入店）---")
 	var autoplay = load("res://sim/level_autoplay.gd")
 	var shelf_kinds: Array = []
-	for row in _db.shop_pool_rows():
+	for row in _db.run.shop.pool_rows():
 		shelf_kinds.append(String(row.get("kind_id", "")))
 	# ① 池模式场景可达（_adv_drive_to_shop 复用——L1 全程+L2 推进到商店房；pool 模式进店即抽架）
 	var scen := {}
@@ -1268,12 +1268,12 @@ func _smoke_shop_pool() -> void:
 		var r8 = scen["r"]
 		var gp0: int = int(r8.gp)
 		var cost0: int = r8.shop_refresh_cost()
-		Kit.check("刷新首价=基价（%d）" % cost0, cost0 == int(_db.adventure.shop_refresh_cost_base))
+		Kit.check("刷新首价=基价（%d）" % cost0, cost0 == int(_db.run.adventure.shop_refresh_cost_base))
 		Kit.check("基础免费 0 次（Q2——天赋增益位后续添加）", r8.shop_refresh_free_left() == 0)
 		var shelf_pre: Array = (r8.shop_shelf() as Array).duplicate(true)
 		Kit.check("GP 刷新受理（gp=%d cost=%d）" % [gp0, cost0], r8.shop_refresh())
 		Kit.check("GP 刷新扣费（%d→%d）" % [gp0, int(r8.gp)], int(r8.gp) == gp0 - cost0)
-		Kit.check("刷新爬价 ×curve（%d）" % int(r8.shop_refresh_cost()), int(r8.shop_refresh_cost()) == int(ceil(float(cost0) * float(_db.adventure.shop_refresh_cost_curve))))
+		Kit.check("刷新爬价 ×curve（%d）" % int(r8.shop_refresh_cost()), int(r8.shop_refresh_cost()) == int(ceil(float(cost0) * float(_db.run.adventure.shop_refresh_cost_curve))))
 	var same_shelf := first_shelf_a.size() == first_shelf_b.size()
 	if same_shelf:
 		for i in first_shelf_a.size():
@@ -1290,7 +1290,7 @@ func _smoke_shop_pool() -> void:
 	var l2 := int(r8.level_row.level_index)
 	# 现价等价证明（d11——消费端读表推导 vs 迁移前硬编码字面量推导：同输入逐位一致）
 	var relic_price_now: int = r8.pool_price("relic")
-	var relic_price_pre: int = int(ceil(15.0 * pow(_db.shop_price_b(), float(l2 - 1)) * 1.0))
+	var relic_price_pre: int = int(ceil(15.0 * pow(_db.run.shop.price_b, float(l2 - 1)) * 1.0))
 	Kit.check("relic 现价 = ceil(15.0×b^(关序−1))（读表与迁移前字面量逐位一致，%d）〔wd11〕" % relic_price_now, relic_price_now == relic_price_pre)
 	for c in r8.shop_shelf():
 		# T6 商店保底后 relic 卡合法入架（保底占位）——词表断言放行 relic；价格断言分叉
@@ -1300,10 +1300,10 @@ func _smoke_shop_pool() -> void:
 		Kit.check("货架 kind 在封闭词表或保底 relic 卡（%s）" % ckind, is_relic or shelf_kinds.has(ckind))
 		var expect_p: int
 		if is_relic:
-			expect_p = int(ceil(float(_db.shop.relic_base_price) * pow(_db.shop_price_b(), float(l2 - 1)) * 1.0))
+			expect_p = int(ceil(float(_db.run.shop.relic_base_price) * pow(_db.run.shop.price_b, float(l2 - 1)) * 1.0))
 		else:
-			var prow: Dictionary = _db.shop_pool_row(ckind)
-			expect_p = int(ceil(float(int(prow.get("base_price", 0))) * pow(_db.shop_price_b(), float(l2 - 1)) * 1.0))
+			var prow: Dictionary = _db.run.shop.pool_row(ckind)
+			expect_p = int(ceil(float(int(prow.get("base_price", 0))) * pow(_db.run.shop.price_b, float(l2 - 1)) * 1.0))
 		Kit.check("首购现价 = ceil(基价×b^(关序−1))（%s: %d = %d 推导）" % [ckind, int(c.get("price", -1)), expect_p], int(c.get("price", -1)) == expect_p)
 	# ③ 买 1 全重抽：出账+加算区+账本三落点 + 现价 A 链递增（买后 visit 计数=1；TP0——消费在架令牌本体）
 	var buy_c: Dictionary = {}
@@ -1321,8 +1321,8 @@ func _smoke_shop_pool() -> void:
 		var val0: int = a8.journal().bonus_total(String(val_map[kind]))
 		Kit.check("购买受理（pool 口——%s|%s）" % [kind, tier], r8.buy_pool_item(kind))
 		Kit.check("钱包扣现价（%d → %d）" % [gp0, int(r8.gp)], int(r8.gp) == gp0 - int(buy_c.get("price", 0)))
-		Kit.check("加算区 +令牌档位件值（池件=奖励件本体——%s|%s %+d）" % [kind, tier, int(_db.adventure.curio_value(kind, tier))], a8.journal().bonus_total(String(val_map[kind])) == val0 + int(_db.adventure.curio_value(kind, tier)))
-		Kit.check("共享池账本 -1（跨渠道单点——taken %d → %d）" % [taken0, int(a8.deck().taken.get(kind, 0))], int(a8.deck().taken.get(kind, 0)) == taken0 + 1)
+		Kit.check("加算区 +令牌档位件值（池件=奖励件本体——%s|%s %+d）" % [kind, tier, int(_db.run.adventure.curio_value(kind, tier))], a8.journal().bonus_total(String(val_map[kind])) == val0 + int(_db.run.adventure.curio_value(kind, tier)))
+		Kit.check("共享池账本 -1（跨渠道单点——taken %d → %d）" % [taken0, int(a8._curio.taken.get(kind, 0))], int(a8._curio.taken.get(kind, 0)) == taken0 + 1)
 		# A 链：同visit 第二购现价 = ceil(base×b^(l2−1)×A^1)（货架已全重抽——新卡新价同公式）
 		# A 链：白盒抬 GP 保证第二购场景确定构造（直改测试基建——非生产行为）
 		r8.gp = int(r8.gp) + 64
@@ -1332,8 +1332,8 @@ func _smoke_shop_pool() -> void:
 				second = c
 				break
 		if not second.is_empty():
-			var prow2: Dictionary = _db.shop_pool_row(String(second.get("kind_id", "")))
-			var expect_p2: int = int(ceil(float(int(prow2.get("base_price", 0))) * pow(_db.shop_price_b(), float(l2 - 1)) * _db.shop_price_a()))
+			var prow2: Dictionary = _db.run.shop.pool_row(String(second.get("kind_id", "")))
+			var expect_p2: int = int(ceil(float(int(prow2.get("base_price", 0))) * pow(_db.run.shop.price_b, float(l2 - 1)) * _db.run.shop.price_a))
 			Kit.check("A 链爬价 = ceil(base×b^(关序−1)×A^1)（进店第 2 购——%d）" % expect_p2, int(second.get("price", -1)) == expect_p2)
 			Kit.check("同 visit 第二购受理（A 链软闸在价不在限）", r8.buy_pool_item(String(second.get("kind_id", ""))))
 		else:
@@ -1384,8 +1384,8 @@ func _smoke_shop_pool() -> void:
 	var ps_ok := true
 	for k in ps.keys():
 		var quota := 0
-		for tier in _db.adventure.TIERS:
-			quota += int(_db.adventure.curio_quota(String(k), tier))
+		for tier in _db.run.adventure.TIERS:
+			quota += int(_db.run.adventure.curio_quota(String(k), tier))
 		if int(ps[k]) < 0 or int(ps[k]) > quota:
 			ps_ok = false
 	Kit.check("终局池余量在域 [0,配额]（%s）" % str(ps), ps_ok)
@@ -1458,7 +1458,7 @@ func _adv_st() -> Dictionary:
 # 首遇带数据驱动定位（契约 8）：该 (L, battle, enemy_id) 的最低 depth_band，禁写死坐标数字
 func _first_encounter_band(level_index: int, enemy_id: String) -> int:
 	var best := -1
-	for row in _db.enemy.rows:
+	for row in _db.combat.enemy.rows:
 		if int(row.get("level_index", -1)) != level_index:
 			continue
 		if String(row.get("row_kind", "")) != "battle" or String(row.get("enemy_id", "")) != enemy_id:

game/tests/unit/core/meta_progression_forge_test.gd

@@ -89,7 +89,7 @@ func _run_battle(L: int, D: int, axes: Dictionary = {}) -> Dictionary:
 	settlement.minesweeper.seal_judged.connect(func(evt): out.events.append(evt))
 	settlement.minesweeper.round_end_board.connect(func(p): out.events.append({"ev": "round_end_board", "path_tag": p.path_tag}))
 	settlement.action_economy.round_end_stopped.connect(func(p): out.events.append({"ev": "round_end_stopped", "path_tag": p.path_tag}))
-	var enc := {"level_index": L, "node_depth": D, "hero_hp": _db.hero.max_hp}
+	var enc := {"level_index": L, "node_depth": D, "hero_hp": _db.combat.hero.max_hp}
 	enc.merge(axes, true)   # 两根类型轴注入尾参（缺省零注入=回退面）
 	if not settlement.begin_battle(enc):
 		out.stream.append({"type": "verdict", "value": "begin_failed"})
@@ -132,22 +132,22 @@ func _meta_pricing_and_buy() -> void:
 	var sv = _meta_new_save(_META_SMOKE_PATHS[0])
 	var mp = load("res://core/meta_progression.gd").new(_db, sv)
 	# ③ 购买成功：级+1、余额−价；buy 内含写盘——reload 后持久（树全钥石单币）
-	sv.add_keystone(1000)
-	var bal0: int = sv.keystone_balance()
-	var price0: int = int(_db.tree_node("sp_hp").get("price", 0))
+	sv.meta_state._add_keystone(1000)
+	var bal0: int = sv.meta_state.keystone_balance()
+	var price0: int = int(_db.crossrun.meta_tree.row_by_id("sp_hp").get("price", 0))
 	Kit.check("树购买受理（Lv 0→1、余额 %d−%d）" % [bal0, price0],
-		mp.tree_buy("sp_hp") and sv.tree_level("sp_hp") == 1 and sv.keystone_balance() == bal0 - price0)
+		mp.tree_buy("sp_hp") and sv.meta_state.tree_state().nodes.get("sp_hp", 0) == 1 and sv.meta_state.keystone_balance() == bal0 - price0)
 	var sv_r = _meta_new_save(_META_SMOKE_PATHS[0])
 	Kit.check("购买持久（reload 后级与余额不变）",
-		sv_r.tree_level("sp_hp") == 1 and sv_r.keystone_balance() == bal0 - price0)
+		sv_r.meta_state.tree_state().nodes.get("sp_hp", 0) == 1 and sv_r.meta_state.keystone_balance() == bal0 - price0)
 	# ③ 余额不足 / 未知节点：false 零副作用
 	var sv_dry = _meta_new_save(_META_SMOKE_PATHS[1])
 	var mp_dry = load("res://core/meta_progression.gd").new(_db, sv_dry)
-	var tn_before: Dictionary = sv_dry.tree_nodes()
-	var fs_before: Dictionary = sv_dry.fork_sides()
+	var tn_before: Dictionary = sv_dry.meta_state.tree_state().nodes
+	var fs_before: Dictionary = sv_dry.meta_state.tree_state().fork_sides
 	Kit.check("余额不足 false 零副作用（0 余额购买拒绝——三域零变化〔天赋树批 V3〕）",
-		not mp_dry.tree_buy("sp_hp") and sv_dry.keystone_balance() == 0
-		and sv_dry.tree_nodes() == tn_before and sv_dry.fork_sides() == fs_before)
+		not mp_dry.tree_buy("sp_hp") and sv_dry.meta_state.keystone_balance() == 0
+		and sv_dry.meta_state.tree_state().nodes == tn_before and sv_dry.meta_state.tree_state().fork_sides == fs_before)
 	Kit.check("未知节点 false 零副作用（词表外出域）", not mp_dry.tree_buy("no_such_node"))
 
 
@@ -156,8 +156,8 @@ func _meta_settle_and_workshop() -> void:
 	print("--- 元进度·收束入账与工坊（隔离档 smoke_meta_settle/workshop/cap）---")
 	var sv = _meta_new_save(_META_SMOKE_PATHS[2])
 	var mp = load("res://core/meta_progression.gd").new(_db, sv)
-	var row1: Dictionary = _db.meta_boss_keystone_row(1)
-	var row2: Dictionary = _db.meta_boss_keystone_row(2)
+	var row1: Dictionary = _db.crossrun.meta.boss_keystone_row(1)
+	var row2: Dictionary = _db.crossrun.meta.boss_keystone_row(2)
 	# ⑥ 逐杀掉落收束入账（掉落已在冒险内逐杀入账〔summary.keystone_total 含全部〕，
 	# keystone_drops 明细随摘要归档；首杀标记仍由 apply 逐关卡完成关次置位）
 	var d1: Dictionary = mp.settle_adventure({"result": "failed", "cleared": false, "levels_cleared": 1,
@@ -171,7 +171,7 @@ func _meta_settle_and_workshop() -> void:
 	Kit.check("明细 total = keystone_total（逐杀掉落全源——无二次派生加账）",
 		int(d1.get("total", 0)) == int(row1.get("first_kill", 0)))
 	Kit.check("余额 = 累计入账（逐杀掉落合计——无重复加账）",
-		sv.keystone_balance() == int(row1.get("first_kill", 0)))
+		sv.meta_state.keystone_balance() == int(row1.get("first_kill", 0)))
 	# ⑥ 再通转复杀档（首杀标记置位后小额恒定不递减——标记面在 apply，金额面在逐杀裁决）
 	var d2: Dictionary = mp.settle_adventure({"result": "failed", "cleared": false, "levels_cleared": 1,
 		"stopped_at": 2, "keystone_total": int(row1.get("repeat_kill", 0)),
@@ -196,39 +196,39 @@ func _meta_settle_and_workshop() -> void:
 		not bool(d4["boss_drops"][0].get("first", true)) and bool(d4["boss_drops"][1].get("first", false))
 		and int(d4["boss_drops"][1].get("amount", 0)) == int(row2.get("first_kill", -1)))
 	# ⑦ 败北零关卡完成摘要：余额只增不减（零入账）、clear_counts 不变
-	var bal_before: int = sv.keystone_balance()
-	var cc1_before: int = sv.clear_count(1)
+	var bal_before: int = sv.meta_state.keystone_balance()
+	var cc1_before: int = sv.meta_state.career_state().clear_counts.get(str(1), 0)
 	var dz: Dictionary = mp.settle_adventure({"result": "failed", "cleared": false, "levels_cleared": 0,
 		"stopped_at": 1, "keystone_total": 0, "master_seed": 15})
 	Kit.check("败北零关卡完成摘要：零入账零标记（钥石只增不减——验收1；败北局 clear_counts 不变）",
-		dz["boss_drops"].is_empty() and sv.keystone_balance() == bal_before and sv.clear_count(1) == cc1_before)
+		dz["boss_drops"].is_empty() and sv.meta_state.keystone_balance() == bal_before and sv.meta_state.career_state().clear_counts.get(str(1), 0) == cc1_before)
 	# ⑧ 秘宝解锁服务（V3 钥石购买/V4 条件解锁；注入=直调解锁写口+直置存档生涯计数，
 	# 不走正常资源积累流程——卡片 7.1 测试方式）
 	var sv_u = _meta_new_save(_META_SMOKE_PATHS[11])
 	var mp_u = load("res://core/meta_progression.gd").new(_db, sv_u)
-	sv_u.add_keystone(10)
+	sv_u.meta_state._add_keystone(10)
 	Kit.check("条件件误购拒绝（购买件专属——契约 8 分配面）〔秘宝批 V3 反例〕",
-		not mp_u.buy_treasure_unlock("sky_eye") and not sv_u.item_unlocked("sky_eye")
+		not mp_u.buy_treasure_unlock("sky_eye") and not sv_u.meta_state.item_unlocked("sky_eye")
 		and not mp_u.buy_treasure_unlock("ranged_pick"))
 	Kit.check("余额不足购买拒绝且零副作用（余额 10 < 价 25）〔秘宝批 V3〕",
-		not mp_u.buy_treasure_unlock("twin_loader") and sv_u.keystone_balance() == 10)
+		not mp_u.buy_treasure_unlock("twin_loader") and sv_u.meta_state.keystone_balance() == 10)
 	Kit.check("钥石购买解锁：余额足→解锁态落档+余额扣减正确（价 10）〔秘宝批 V3〕",
-		mp_u.buy_treasure_unlock("morning_order") and sv_u.item_unlocked("morning_order")
-		and sv_u.keystone_balance() == 0)
+		mp_u.buy_treasure_unlock("morning_order") and sv_u.meta_state.item_unlocked("morning_order")
+		and sv_u.meta_state.keystone_balance() == 0)
 	Kit.check("已解锁重复购买拒绝〔秘宝批 V3〕",
 		not mp_u.buy_treasure_unlock("morning_order"))
 	Kit.check("条件未达不解锁（远程镐=冒险成功 1 次）〔秘宝批 V4〕",
-		mp_u.refresh_treasure_unlocks().is_empty() and not sv_u.item_unlocked("ranged_pick"))
+		mp_u.refresh_treasure_unlocks().is_empty() and not sv_u.meta_state.item_unlocked("ranged_pick"))
 	sv_u._data["meta"]["adventure_cleared"] = 1   # 直置存档生涯计数（调试注入口径）
 	Kit.check("远程镐=adventure_cleared≥1 达标恰解锁一次+重复刷新幂等（C6：冒险成功=打通整局冒险）〔秘宝批 V4〕",
 		(mp_u.refresh_treasure_unlocks() as Array).has("ranged_pick")
-		and sv_u.item_unlocked("ranged_pick") and mp_u.refresh_treasure_unlocks().is_empty())
+		and sv_u.meta_state.item_unlocked("ranged_pick") and mp_u.refresh_treasure_unlocks().is_empty())
 	sv_u._data["meta"]["boss_kill_count"] = 3
 	Kit.check("刷新执照=boss_kill_count≥3（阈值读 unlock_requires 行值不硬编）〔秘宝批 V4〕",
 		(mp_u.refresh_treasure_unlocks() as Array).has("refresh_license"))
 	sv_u._data["meta"]["adventure_cleared"] = 3
 	Kit.check("天眼单条件不足不解锁（AND 语义——cleared 3 达 boss 4 未达）〔秘宝批 V4〕",
-		not sv_u.item_unlocked("sky_eye"))
+		not sv_u.meta_state.item_unlocked("sky_eye"))
 	sv_u._data["meta"]["boss_kill_count"] = 4
 	Kit.check("天眼双条件 AND（冒险成功≥3 且 Boss≥4）达标解锁〔秘宝批 V4〕",
 		(mp_u.refresh_treasure_unlocks() as Array).has("sky_eye"))
@@ -240,7 +240,7 @@ func _meta_settle_and_workshop() -> void:
 		r_n += 1 if bool(st_row.get("unlocked", false)) else 0
 	Kit.check("解锁态持久投影一致（reload 面同源读数；5 件=购买 1+条件 4）〔秘宝批 V4〕", r_n == 5)
 	# ⑩ recent_summaries：元素含 boss_drops 副本、最新在前、cap 10
-	var rs: Array = sv.recent_summaries()
+	var rs: Array = sv.meta_state.career_state().recent_summaries
 	Kit.check("摘要最新在前 + 元素含掉落明细副本（复盘可归因——验收5）",
 		rs.size() >= 5 and String(rs[0].get("result", "")) != "" and rs[0].has("boss_drops")
 		and (rs[1] as Dictionary).has("keystone_drops")
@@ -251,7 +251,7 @@ func _meta_settle_and_workshop() -> void:
 		mp_c.settle_adventure({"result": "failed", "cleared": false, "levels_cleared": 0,
 			"stopped_at": 1, "keystone_total": 0, "master_seed": i})
 	Kit.check("摘要 cap 10 且最新在前（12 连 settle 截断后 seed 11 居首）",
-		sv_c.recent_summaries().size() == 10 and int(sv_c.recent_summaries()[0].get("master_seed", -1)) == 11)
+		sv_c.meta_state.career_state().recent_summaries.size() == 10 and int(sv_c.meta_state.career_state().recent_summaries[0].get("master_seed", -1)) == 11)
 	# ⑪ 同调位账本（装配持久/满位禁选/Y 升级语义；写口 = MetaProgression 同调段）
 	var sv_a = _meta_new_save(_META_SMOKE_PATHS[6])
 	var mp_a = load("res://core/meta_progression.gd").new(_db, sv_a)
@@ -259,17 +259,17 @@ func _meta_settle_and_workshop() -> void:
 		Attunement.slots(_db, sv_a) == 0 and int(mp_a.attune_camp_status()["refresh"]["charges"]) == 0)
 	Kit.check("满位禁选（Slots 0 时装配拒绝；兼未解锁拒绝前置——直置解锁后下方装配）〔秘宝批 V5〕",
 		mp_a.toggle_attunement("morning_order") == false)
-	sv_a.add_keystone(200)
-	sv_a.unlock_item("morning_order")
-	sv_a.unlock_item("twin_loader")
+	sv_a.meta_state._add_keystone(200)
+	sv_a.meta_state.unlock_item("morning_order")
+	sv_a.meta_state.unlock_item("twin_loader")
 	Kit.check("Y 升级购买入账（Lv1 → 每冒险 +1 次刷新）",
-		mp_a.buy_attune_refresh() and sv_a.attune_refresh_level() == 1
+		mp_a.buy_attune_refresh() and sv_a.meta_state.attune_state().refresh_level == 1
 		and int(mp_a.attune_camp_status()["refresh"]["charges"]) == 1)
 	mp_a.settle_adventure({"result": "failed", "cleared": false, "levels_cleared": 1,
 		"stopped_at": 2, "keystone_total": 0, "master_seed": 21})
 	Kit.check("完成 1 关 → Slots 恒 0（旧「按击杀 Boss 次数自动涨」条件已删——槽位唯一来源=树点亮）且 Boss 击杀总数=1（计数域保留）〔天赋树批 V14〕",
-		Attunement.slots(_db, sv_a) == 0 and sv_a.boss_kill_count() == 1)
-	sv_a.set_tree_level("att_socket1", 1)
+		Attunement.slots(_db, sv_a) == 0 and sv_a.meta_state.career_state().boss_kill_count == 1)
+	sv_a.meta_state.set_tree_level("att_socket1", 1)
 	Kit.check("树上点亮同调位 1 → Slots=1（槽位收编树节点——Q2 裁甲）",
 		Attunement.slots(_db, sv_a) == 1)
 	Kit.check("稀有件入普通格拒绝（件档 rank 3 > 装入位序 1——契约 2 档位格校验）〔秘宝批 V5〕",
@@ -279,7 +279,7 @@ func _meta_settle_and_workshop() -> void:
 	Kit.check("卸下恒可再装配（自卸自装——营地换装=冒险开始前合法面，装配不可变只锁运行中）〔秘宝批换主语〕",
 		mp_a.toggle_attunement("morning_order") and mp_a.toggle_attunement("morning_order"))
 	var sv_a2 = _meta_new_save(_META_SMOKE_PATHS[7])
-	sv_a2.set_attunement_equipped(["morning_order"])
+	sv_a2.meta_state.set_attunement_equipped(["morning_order"])
 	var mp_a2 = load("res://core/meta_progression.gd").new(_db, sv_a2)
 	Kit.check("装配关系读回持久（reload 后投影一致——写新件 id）〔秘宝批 V15〕",
 		(mp_a2.attune_camp_status()["equipped"] as Array).has("morning_order"))
@@ -294,20 +294,20 @@ func _meta_settle_and_workshop() -> void:
 	a12.refresh_bank()._refresh_y = 2
 	a12.stop()._pending = {"candidates": [{"kind": "gp", "tier": "common"}, {"kind": "attack", "tier": "common"}, {"kind": "max_hp", "tier": "common"}], "payload": {}}
 	Kit.check("刷新双计数器——X 优先消耗（x1y2 → x0y2）",
-		a12.stop().refresh_curio() and a12.refresh_bank().refresh_y() == 2 and a12.refresh_bank().free_left() == 2 + a12.refresh_bank().refresh_stock())
+		a12.stop().refresh_curio() and a12.refresh_bank()._refresh_x == 0 and a12.refresh_bank()._refresh_y == 2)
 	Kit.check("刷新双计数器——X 耗尽转 Y 池、池竭拒绝（x0y2 → y0 → 第四次 false 零副作用）",
-		a12.stop().refresh_curio() and a12.stop().refresh_curio() and a12.refresh_bank().refresh_y() == 0
+		a12.stop().refresh_curio() and a12.stop().refresh_curio() and a12.refresh_bank()._refresh_y == 0
 		and a12.stop().refresh_curio() == false)
 	a12.refresh_bank().reset_x()
 	Kit.check("刷新 X 每碰三选一重置（不结转；新目录无 bonus_refresh 行源——X 机制保留恒 0 空转，存量加仓走 _refresh_stock=刷新练习 V8）〔秘宝批换代〕",
-		a12.refresh_bank().free_left() == 0)
+		a12.refresh_bank()._refresh_x == 0 and a12.refresh_bank().free_left() == 0)
 	# ⑬ 主菜单开局传参面（开新/续玩两入口同调三键随开局下传防回归：真实入口曾
 	# 三键恒空（缺陷①），冒烟夹具直呼 runner 参数面拦不住——此处直呼 main.build_adventure_params
 	# 单测统一构造面（static 免实例化整菜单场景；真实两入口共用本构造），取值与营地投影同源）
 	var sv_e = _meta_new_save(_META_SMOKE_PATHS[8])
-	sv_e.set_attunement_equipped(["morning_order"])
-	sv_e.set_attune_refresh_level(2)
-	sv_e.set_fork_side("fg_posture", "a")
+	sv_e.meta_state.set_attunement_equipped(["morning_order"])
+	sv_e.meta_state.set_attune_refresh_level(2)
+	sv_e.meta_state.set_fork_side("fg_posture", "a")
 	var mp_e = load("res://core/meta_progression.gd").new(_db, sv_e)
 	var rules_e: Array = mp_e.tree_rule_keys()
 	Kit.check("开局传参夹具前置：Fork 侧 a 激活 rule 键非空 + Y=Lv2 行表值 2（防断言空转）",
@@ -315,7 +315,7 @@ func _meta_settle_and_workshop() -> void:
 	var p_new: Dictionary = load("res://presentation/main.gd").build_adventure_params(sv_e, mp_e,
 		{"treasure_unlocked": {"wide_scout_band": true}, "shop_mode": "pool"})
 	Kit.check("主菜单开新冒险参数面：同调装配 = 存档装配集（营地装了什么开局就带什么）",
-		(p_new.get("attunement", []) as Array) == (sv_e.attunement_equipped() as Array))
+		(p_new.get("attunement", []) as Array) == (sv_e.meta_state.attune_state().equipped as Array))
 	Kit.check("主菜单开新冒险参数面：Y 刷新池 = 当前等级行表值（营地升几档开局就给几次）",
 		int(p_new.get("attune_refresh_y", -1)) == mp_e.attune_refresh_charges())
 	Kit.check("主菜单开新冒险参数面：树 rule 键集 = Fork 激活侧 effects（点哪侧带哪侧）",
@@ -325,7 +325,7 @@ func _meta_settle_and_workshop() -> void:
 	var p_resume: Dictionary = load("res://presentation/main.gd").build_adventure_params(sv_e, mp_e,
 		{"treasure_unlocked": {}})
 	Kit.check("主菜单继续上局参数面：三键与开新冒险同源同值（续玩不吃白板开局）",
-		(p_resume.get("attunement", []) as Array) == (sv_e.attunement_equipped() as Array)
+		(p_resume.get("attunement", []) as Array) == (sv_e.meta_state.attune_state().equipped as Array)
 		and int(p_resume.get("attune_refresh_y", -1)) == mp_e.attune_refresh_charges()
 		and (p_resume.get("tree_rules", []) as Array) == rules_e)
 	# 续玩路径 tree_rules 受理断言：直呼 runner 续玩参数面
@@ -338,8 +338,7 @@ func _meta_settle_and_workshop() -> void:
 	Kit.check("继续上局受理面：resume_adventure 受理三键参数面（尾裁微批b 受理闭环——受理不再吃白板）",
 		adr_res.resume_adventure(bp_min, p_resume))
 	Kit.check("继续上局受理面：tree_rules 随参数面进 runner._tree_rules（消费面 set_tree_rules 下传现成）",
-		adr_res.runner() != null and adr_res.runner().pick_next_node(int(adr_res.runner().next_candidate_ids()[0]))
-		and ((adr_res.runner().current_battle().encounter.get("tree_rules", []) as Array) == rules_e))
+		(adr_res._tree_rules as Array) == rules_e)
 	_meta_smoke_cleanup()
 
 
@@ -350,9 +349,9 @@ func _meta_injection() -> void:
 	var mp = load("res://core/meta_progression.gd").new(_db, sv)
 	# 树生命淬炼注入（公式：基础值+树淬炼 flat+锻造路线加值位预留 0——2 级 = +10；
 	# 注入走调试口径直置等级〔两分法——购买链已在 _smoke_tree 覆盖，此处隔离行门槛干扰〕）
-	sv.set_tree_level("sp_hp", 2)
+	sv.meta_state.set_tree_level("sp_hp", 2)
 	Kit.check("生命淬炼 2 级 → hero_override().max_hp == Σ 节点 effects×等级（验收4 换代〔天赋树批 V12〕）",
-		int(mp.hero_override().get("max_hp", -1)) == 2 * int(_db.tree_node("sp_hp").get("effects", {}).get("max_hp", 0)))
+		int(mp.hero_override().get("max_hp", -1)) == 2 * int(_db.crossrun.meta_tree.row_by_id("sp_hp").get("effects", {}).get("max_hp", 0)))
 	Kit.check("攻/AC 树零来源（契约 9——树表零 atk/armor_class 行，override 二轴恒 0+预留位 0）",
 		int(mp.hero_override().get("atk", -1)) == 0 and int(mp.hero_override().get("armor_class", -1)) == 0)
 	Kit.check("命中线在账未注入（契约 6——override 无 hit 字段〔天赋树批 V13〕）",
@@ -363,10 +362,10 @@ func _meta_injection() -> void:
 	var r = adr.runner()
 	var ov: Dictionary = mp.hero_override()
 	Kit.check("首战 hero_atk = 表值 + 永久强化 flat（begin_battle 同表达式——下一局能用到强化）",
-		int(r.effective_atk()) == int(_db.hero.atk) + int(ov.get("atk", 0)))
+		int(r.effective_atk()) == int(_db.combat.hero.atk) + int(ov.get("atk", 0)))
 	Kit.check("首战 hero_max_hp 与开局生命账本 = 表值 + 注入档",
-		int(r.effective_max_hp()) == int(_db.hero.max_hp) + int(ov.get("max_hp", 0))
-		and int(adr.stats().hero_hp) == int(_db.hero.max_hp) + int(ov.get("max_hp", 0)))
+		int(r.effective_max_hp()) == int(_db.combat.hero.max_hp) + int(ov.get("max_hp", 0))
+		and int(adr.stats().hero_hp) == int(_db.combat.hero.max_hp) + int(ov.get("max_hp", 0)))
 	# 白板：同种子下 空参数 = 零强化参数 = 纯表值（逐位一致——注入通道默认值漏改在此转红）
 	var adr_w = load("res://core/adventure_runner.gd").new(_db, _fresh_rng(920251))
 	Kit.check("白板冒险启动（无 params 实参——B1 空参数路径）", adr_w.start_adventure(920251))
@@ -377,11 +376,11 @@ func _meta_injection() -> void:
 	var rw = adr_w.runner()
 	var rz = adr_z.runner()
 	Kit.check("白板成立：空参数 = 零强化参数 = 纯表值（atk/max_hp/ac 三轴逐位一致——验收 2/3）",
-		int(rw.effective_atk()) == int(_db.hero.atk) and int(rw.effective_max_hp()) == int(_db.hero.max_hp)
+		int(rw.effective_atk()) == int(_db.combat.hero.atk) and int(rw.effective_max_hp()) == int(_db.combat.hero.max_hp)
 		and int(rz.effective_atk()) == int(rw.effective_atk()) and int(rz.effective_max_hp()) == int(rw.effective_max_hp())
 		and int(rz.effective_ac()) == int(rw.effective_ac()))
 	Kit.check("ac 轴：白板恒表值、未换强化时注入零位移",
-		int(rw.effective_ac()) == int(_db.hero.armor_class) and int(r.effective_ac()) == int(_db.hero.armor_class))
+		int(rw.effective_ac()) == int(_db.combat.hero.armor_class) and int(r.effective_ac()) == int(_db.combat.hero.armor_class))
 	_meta_smoke_cleanup()
 
 
@@ -394,10 +393,10 @@ func _smoke_forge_axes() -> void:
 		not ("attack_type" in _db.hero) and not ("armor_type" in _db.hero))
 	# 锻造配置默认值 = normal/light（常驻持有——与柜台解锁状态解耦，未点亮也照常可读）
 	Kit.check("锻造配置默认值 attack_type=normal / armor_type=light（常驻持有）〔锻造工坊批 V5〕",
-		_db.forge_default_attack_type() == "normal" and _db.forge_default_armor_type() == "light")
+		_db.crossrun.forge.default_attack_type == "normal" and _db.crossrun.forge.default_armor_type == "light")
 	# 单位快照回退面：spawn 三参形态（零注入）= 锻造配置默认值
 	var uc = load("res://core/unit_container.gd").new(_db)
-	Kit.check("spawn 受理（三参形态——两轴缺省回退面）", uc.spawn(1, 0, int(_db.hero.max_hp)))
+	Kit.check("spawn 受理（三参形态——两轴缺省回退面）", uc.spawn({"level_index": 1, "node_depth": 0, "hero_hp": int(_db.combat.hero.max_hp)}))
 	Kit.check("主角单位快照两轴 = 锻造配置默认值 normal/light（零注入回退——行为连续）〔锻造工坊批 V5〕",
 		String(uc.hero_unit().get("attack_type", "")) == "normal"
 		and String(uc.hero_unit().get("armor_type", "")) == "light")
@@ -407,71 +406,71 @@ func _smoke_forge_axes() -> void:
 	var sv2 = _meta_new_save(_META_SMOKE_PATHS[13])
 	var mp2 = load("res://core/meta_progression.gd").new(_db, sv2)
 	# V2①：长剑首购=20（0 级位几何价）、等级 0→1、扣币即盘、reload 持久
-	sv2.add_keystone(100)
+	sv2.meta_state._add_keystone(100)
 	Kit.check("长剑锻造首购：扣 20 钥石、等级 0→1（Q1——第一级=获得装备=首个 +1）〔锻造工坊批 V2〕",
-		mp2.forge_buy_level("sword") and sv2.forge_route_level("sword") == 1
-		and sv2.keystone_balance() == 80)
+		mp2.forge_buy_level("sword") and sv2.meta_state.forge_state().levels.get("sword", 0) == 1
+		and sv2.meta_state.keystone_balance() == 80)
 	var sv2r = _meta_new_save(_META_SMOKE_PATHS[13])
 	Kit.check("购买持久（reload 后等级与余额不变——即时写盘）〔锻造工坊批 V2〕",
-		sv2r.forge_route_level("sword") == 1 and sv2r.keystone_balance() == 80)
+		sv2r.meta_state.forge_state().levels.get("sword", 0) == 1 and sv2r.meta_state.keystone_balance() == 80)
 	# V2②：二级=30（1 级位）；六路线独立（买长剑不动轻甲）
 	Kit.check("长剑二级购：扣 30、等级→2；轻甲独立零扰动（六路线各练各的）〔锻造工坊批 V2〕",
-		mp2.forge_buy_level("sword") and sv2.forge_route_level("sword") == 2
-		and sv2.keystone_balance() == 50 and sv2.forge_route_level("light") == 0)
+		mp2.forge_buy_level("sword") and sv2.meta_state.forge_state().levels.get("sword", 0) == 2
+		and sv2.meta_state.keystone_balance() == 50 and sv2.meta_state.forge_state().levels.get("light", 0) == 0)
 	# V2③：余额不足拒且零副作用（等级/选中/解锁三面零变化）
 	var sv2d = _meta_new_save(_META_SMOKE_PATHS[14])
 	var mp2d = load("res://core/meta_progression.gd").new(_db, sv2d)
-	var fr_dry: Dictionary = sv2d.forge_routes_snapshot()
+	var fr_dry: Dictionary = sv2d.meta_state.forge_state()
 	Kit.check("余额不足购买拒绝且零副作用（0 余额——三域零变化）〔锻造工坊批 V2〕",
-		not mp2d.forge_buy_level("sword") and sv2d.keystone_balance() == 0
-		and sv2d.forge_routes_snapshot() == fr_dry)
+		not mp2d.forge_buy_level("sword") and sv2d.meta_state.keystone_balance() == 0
+		and sv2d.meta_state.forge_state() == fr_dry)
 	# V2④：已满级拒购（cap 闸）；未解锁拒购
-	sv2.set_forge_route_level("sword", 5)
+	sv2.meta_state.set_forge_route_level("sword", 5)
 	Kit.check("已满级拒购/未解锁拒购（cap 闸+解锁闸——零副作用）〔锻造工坊批 V2〕",
 		not mp2.forge_buy_level("sword") and not mp2d.forge_buy_level("spear"))
 	# V3① 通道一：练满前一档（长剑 cap）→ 长枪/法杖派生解锁（零收费）；轻甲未满→甲线仍锁
 	Kit.check("通道一：长剑练满→长枪/法杖派生解锁；轻甲未练满→重甲/魔法护甲仍锁〔锻造工坊批 V3〕",
-		mp2.forge_route_unlocked("spear") and mp2.forge_route_unlocked("staff")
-		and not mp2.forge_route_unlocked("heavy") and not mp2.forge_route_unlocked("ward"))
+		mp2._forge_route_unlocked("spear") and mp2._forge_route_unlocked("staff")
+		and not mp2._forge_route_unlocked("heavy") and not mp2._forge_route_unlocked("ward"))
 	Kit.check("派生解锁后长枪可购（首购 20——余额 50−20）〔锻造工坊批 V3〕",
-		mp2.forge_buy_level("spear") and sv2.forge_route_level("spear") == 1
-		and sv2.keystone_balance() == 30)
+		mp2.forge_buy_level("spear") and sv2.meta_state.forge_state().levels.get("spear", 0) == 1
+		and sv2.meta_state.keystone_balance() == 30)
 	# V3② 通道二：一次性解锁价直购（未练满也可买——两通道互不影响）
 	var sv3 = _meta_new_save(_META_SMOKE_PATHS[15])
 	var mp3 = load("res://core/meta_progression.gd").new(_db, sv3)
-	sv3.add_keystone(500)
+	sv3.meta_state._add_keystone(500)
 	Kit.check("通道二：魔法护甲一次性解锁价 200 直购开（轻甲未练满也可买）〔锻造工坊批 V3〕",
-		not mp3.forge_route_unlocked("ward") and mp3.forge_buy_unlock("ward")
-		and sv3.keystone_balance() == 300 and mp3.forge_route_unlocked("ward"))
+		not mp3._forge_route_unlocked("ward") and mp3.forge_buy_unlock("ward")
+		and sv3.meta_state.keystone_balance() == 300 and mp3._forge_route_unlocked("ward"))
 	# V3③ 直购后练满不重复收（练满通道=派生零收费；已解锁再直购=拒绝）
-	sv3.set_forge_route_level("light", 5)
+	sv3.meta_state.set_forge_route_level("light", 5)
 	Kit.check("直购后练满不重复收（已解锁=拒绝零收费——两通道互不影响）〔锻造工坊批 V3〕",
-		mp3.forge_route_unlocked("ward") and not mp3.forge_buy_unlock("ward")
-		and sv3.keystone_balance() == 300)
+		mp3._forge_route_unlocked("ward") and not mp3.forge_buy_unlock("ward")
+		and sv3.meta_state.keystone_balance() == 300)
 	# V3④ 不设串联门槛（法杖直购开——长枪零状态不阻；dry 档充值走直购）
-	sv2d.add_keystone(500)
+	sv2d.meta_state._add_keystone(500)
 	Kit.check("不设串联门槛（法杖直购开——长枪零状态不阻）〔锻造工坊批 V3〕",
-		mp2d.forge_buy_unlock("staff") and mp2d.forge_route_unlocked("staff")
-		and sv2d.forge_route_level("spear") == 0 and not mp2d.forge_route_unlocked("spear"))
+		mp2d.forge_buy_unlock("staff") and mp2d._forge_route_unlocked("staff")
+		and sv2d.meta_state.forge_state().levels.get("spear", 0) == 0 and not mp2d._forge_route_unlocked("spear"))
 	# V4：任一购买/解锁只扣钥石——GP 侧零触碰（meta 域无 GP 键=域界扫描同款；此处钉余额差=当级价）
-	var ks4: int = sv3.keystone_balance()
+	var ks4: int = sv3.meta_state.keystone_balance()
 	Kit.check("两币分工：购买只扣钥石（余额差=当级价 20——GP 零触碰、无材料计数）〔锻造工坊批 V4〕",
-		mp3.forge_buy_level("ward") and sv3.keystone_balance() == ks4 - 20
-		and sv3.forge_route_level("ward") == 1)
+		mp3.forge_buy_level("ward") and sv3.meta_state.keystone_balance() == ks4 - 20
+		and sv3.meta_state.forge_state().levels.get("ward", 0) == 1)
 	# V6①：营地切换=写存档域+免费（余额零动）；旧路线练度保留（只不生效）
-	var ks6: int = sv3.keystone_balance()
+	var ks6: int = sv3.meta_state.keystone_balance()
 	Kit.check("选中切换免费（余额零动——写存档域即盘）〔锻造工坊批 V6〕",
-		mp3.forge_select_armor("ward") and sv3.forge_armor() == "ward"
-		and sv3.keystone_balance() == ks6)
+		mp3.forge_select("armor", "ward") and sv3.meta_state.forge_state().armor == "ward"
+		and sv3.meta_state.keystone_balance() == ks6)
 	Kit.check("切换后旧路线练度保留（轻甲 5 级不丢——回家待命只不生效）〔锻造工坊批 V6〕",
-		sv3.forge_route_level("light") == 5)
+		sv3.meta_state.forge_state().levels.get("light", 0) == 5)
 	# V6②：未解锁路线拒选零副作用（dry 档：长枪未解锁）
 	Kit.check("未解锁路线拒选零副作用〔锻造工坊批 V6〕",
-		not mp2d.forge_select_weapon("spear") and sv2d.forge_weapon() == "sword")
+		not mp2d.forge_select("weapon", "spear") and sv2d.meta_state.forge_state().weapon == "sword")
 	# V6③：类型轴读数随选中走（切换后读 ward；未解锁选中态防御回退默认值）
 	Kit.check("类型轴当前生效值随选中走（ward；未解锁档回退默认 normal/light）〔锻造工坊批 V5/V6〕",
-		mp3.hero_armor_type() == "ward" and mp2d.hero_attack_type() == "normal"
-		and mp2d.hero_armor_type() == "light")
+		mp3.hero_type_axes()["armor"] == "ward" and mp2d.hero_type_axes()["attack"] == "normal"
+		and mp2d.hero_type_axes()["armor"] == "light")
 
 	# ---- T4 注入接线（V5 后半 · V6 锁死 · V7 公式对拍 · V10 树零攻防复核）----
 	# V5：build_adventure_params 注入默认值（新档=树钥匙未点亮）+点亮后读存档选中覆盖
@@ -481,9 +480,9 @@ func _smoke_forge_axes() -> void:
 	Kit.check("build_adventure_params 注入默认值 normal/light（树钥匙未点亮——新档初始持有态）〔锻造工坊批 V5〕",
 		String(bp_params.get("attack_type", "")) == "normal"
 		and String(bp_params.get("armor_type", "")) == "light")
-	sv4.add_keystone(1000)
+	sv4.meta_state._add_keystone(1000)
 	Kit.check("长枪直购解锁+首购+选中（注入面夹具——200+20 钥石）",
-		mp4.forge_buy_unlock("spear") and mp4.forge_buy_level("spear") and mp4.forge_select_weapon("spear"))
+		mp4.forge_buy_unlock("spear") and mp4.forge_buy_level("spear") and mp4.forge_select("weapon", "spear"))
 	var bp_sel: Dictionary = load("res://presentation/main.gd").build_adventure_params(sv4, mp4)
 	Kit.check("build_adventure_params 读存档选中覆盖（选中长枪→pierce）〔锻造工坊批 V5〕",
 		String(bp_sel.get("attack_type", "")) == "pierce"
@@ -494,17 +493,17 @@ func _smoke_forge_axes() -> void:
 		and int(mp4.hero_override().get("max_hp", -1)) == 0
 		and int(mp4.hero_override().get("armor_class", -1)) == 0
 		and not mp4.hero_override().has("hit"))
-	sv4.set_forge_route_level("sword", 3)   # 长剑练度待命（未选中）
+	sv4.meta_state.set_forge_route_level("sword", 3)   # 长剑练度待命（未选中）
 	Kit.check("换当前武器→攻击加值随切换（长剑 3 级待命不生效——只认选中）〔锻造工坊批 V7〕",
 		int(mp4.hero_override().get("atk", -1)) == 1)
 	Kit.check("切回长剑→加值=3 级量（旧路线练度保留且生效）〔锻造工坊批 V7〕",
-		mp4.forge_select_weapon("sword") and int(mp4.hero_override().get("atk", -1)) == 3)
+		mp4.forge_select("weapon", "sword") and int(mp4.hero_override().get("atk", -1)) == 3)
 	# V7 三层 AC：重甲（基础 12）+路线 Lv1 加值+局内 0——经参数面起冒险断 runner 生效值
 	var sv5 = _meta_new_save(_META_SMOKE_PATHS[17])
 	var mp5 = load("res://core/meta_progression.gd").new(_db, sv5)
-	sv5.add_keystone(1000)
+	sv5.meta_state._add_keystone(1000)
 	Kit.check("重甲直购解锁+首购+选中（三层 AC 夹具）",
-		mp5.forge_buy_unlock("heavy") and mp5.forge_buy_level("heavy") and mp5.forge_select_armor("heavy"))
+		mp5.forge_buy_unlock("heavy") and mp5.forge_buy_level("heavy") and mp5.forge_select("armor", "heavy"))
 	var adr5 = load("res://core/adventure_runner.gd").new(_db, _fresh_rng(77))
 	var p5: Dictionary = load("res://presentation/main.gd").build_adventure_params(sv5, mp5)
 	Kit.check("注入参数冒险启动（两轴+override 同面）", adr5.start_adventure(77, p5))
@@ -515,7 +514,7 @@ func _smoke_forge_axes() -> void:
 		adr5.stats().attack_type == "normal" and adr5.stats().armor_type == "heavy")
 	# V6 锁死：开冒险后改存档选中→参数面/注入值不变（快照冻结；light=初始持有已解锁可切）
 	Kit.check("冒险开始后锁死：改存档选中不影响参数面快照与生效值（契约 8）〔锻造工坊批 V6〕",
-		mp5.forge_select_armor("light") and adr5.stats().armor_type == "heavy"
+		mp5.forge_select("armor", "light") and adr5.stats().armor_type == "heavy"
 		and int(r5.effective_ac()) == 12 + 1)
 	# V5/V7 末端：enc 两轴直达 spawn 英雄快照（hero_attack 行携带选中类型键）
 	var run_ax = _run_battle(1, 0, {"attack_type": "pierce", "armor_type": "ward"})
@@ -528,12 +527,12 @@ func _smoke_forge_axes() -> void:
 	# spawn 显式注入面（三参旧形态零注入已在上方覆盖——此处钉显式值）
 	var uc2 = load("res://core/unit_container.gd").new(_db)
 	Kit.check("spawn 显式两轴注入（magic/heavy 直入英雄快照）〔锻造工坊批 V5〕",
-		uc2.spawn(1, 0, int(_db.hero.max_hp), [], -1, -1, [], "magic", "heavy")
+		uc2.spawn({"level_index": 1, "node_depth": 0, "hero_hp": int(_db.combat.hero.max_hp), "hero_attack_type": "magic", "hero_armor_type": "heavy"})
 		and String(uc2.hero_unit().get("attack_type", "")) == "magic"
 		and String(uc2.hero_unit().get("armor_type", "")) == "heavy")
 	# V10 复核：树表 12 行 effects 键集无 atk/armor_class（契约 1——树零攻防来源）
 	var tree_atk_ac := false
-	for trow in _db.tree_rows():
+	for trow in _db.crossrun.meta_tree.rows:
 		var eff: Dictionary = trow.get("effects", {})
 		if eff.has("atk") or eff.has("armor_class"):
 			tree_atk_ac = true
@@ -547,11 +546,11 @@ func _smoke_tree() -> void:
 	print("--- 天赋树（12 节点 · 购买面 · Fork 双态 · 彩蛋觉醒）---")
 	# 〔V1〕结构：12 行 + schema 零违例
 	Kit.check("meta_tree 已加载（12 节点=脊柱 2〔生命/命中淬炼一线一节点 cap4〕+锻造 2〔钥匙+彩蛋——彩蛋含在锻造 2 内非第 13 行〕+钥石 2〔秘宝匣/刷新升级〕+同调 6〔socket 3+Fork 3 双态〕——v0.8 终态）〔天赋树批 V1〕",
-		_db.meta_tree != null and (_db.meta_tree.rows as Array).size() == 12)
+		_db.meta_tree != null and (_db.crossrun.meta_tree.rows as Array).size() == 12)
 	Kit.check("MetaTreeTable.validate 零违例（脉/类型/币词表出域即拒/Fork 三组每组恰一且持 a/b 双效果键/彩蛋 ≤3/effects 键封闭/零 archetype）",
-		_db.meta_tree.validate().is_empty())
+		_db.crossrun.meta_tree.validate().is_empty())
 	# 彩蛋行硬要求（契约 9 红线落点）：effects 键集 ⊆ {max_hp, hit}
-	var ley: Dictionary = _db.meta_tree.row_by_id("easter_ley")
+	var ley: Dictionary = _db.crossrun.meta_tree.row_by_id("easter_ley")
 	var ley_ok: bool = not ley.is_empty()
 	for k in (ley.get("effects", {}) as Dictionary).keys():
 		if not (String(k) == "max_hp" or String(k) == "hit"):
@@ -560,66 +559,66 @@ func _smoke_tree() -> void:
 		ley_ok)
 	# V1/V4 反例：出域行逐类构造被拒（复制行副本塞词表外值）
 	var t2 = load("res://data/schemas/meta_tree_table.gd").new()
-	var bad_vein: Dictionary = (_db.meta_tree.row_by_id("sp_hp") as Dictionary).duplicate(true)
+	var bad_vein: Dictionary = (_db.crossrun.meta_tree.row_by_id("sp_hp") as Dictionary).duplicate(true)
 	bad_vein["node_id"] = "bad_vein"
 	bad_vein["vein"] = "underworld"
 	t2.rows = [bad_vein]
 	Kit.check("schema 反例：vein 出域被拒", not t2.validate().is_empty())
-	var bad_fork: Dictionary = (_db.meta_tree.row_by_id("fork_posture") as Dictionary).duplicate(true)
+	var bad_fork: Dictionary = (_db.crossrun.meta_tree.row_by_id("fork_posture") as Dictionary).duplicate(true)
 	bad_fork["node_id"] = "bad_fork"
 	bad_fork["fork_group"] = "fg_mastery"
 	t2.rows = [bad_fork]
 	Kit.check("schema 反例：fork_group 出域（fg_mastery 已退役组）被拒", not t2.validate().is_empty())
-	var bad_arch: Dictionary = (_db.meta_tree.row_by_id("sp_hp") as Dictionary).duplicate(true)
+	var bad_arch: Dictionary = (_db.crossrun.meta_tree.row_by_id("sp_hp") as Dictionary).duplicate(true)
 	bad_arch["node_id"] = "bad_arch"
 	bad_arch["effects"] = {"archetype": 1}
 	t2.rows = [bad_arch]
 	Kit.check("schema 反例：effects.archetype 加载致命（🔴 层级纪律护栏面）〔天赋树批 V4〕",
 		not t2.validate().is_empty())
-	var bad_dangling: Dictionary = (_db.meta_tree.row_by_id("sp_hp") as Dictionary).duplicate(true)
+	var bad_dangling: Dictionary = (_db.crossrun.meta_tree.row_by_id("sp_hp") as Dictionary).duplicate(true)
 	bad_dangling["requires"] = ["ghost_node"]
 	t2.rows = [bad_dangling]
 	Kit.check("schema 反例：requires 悬空被拒", not t2.validate().is_empty())
 	# 购买面（V2 主干）
 	var sv = _meta_new_save(_META_SMOKE_PATHS[8])
 	var mp = load("res://core/meta_progression.gd").new(_db, sv)
-	sv.add_keystone(1000)
+	sv.meta_state._add_keystone(1000)
 	Kit.check("树购买受理（脊柱生命 L1——树全钥石单币）",
-		mp.tree_buy("sp_hp") and sv.tree_level("sp_hp") == 1)
+		mp.tree_buy("sp_hp") and sv.meta_state.tree_state().nodes.get("sp_hp", 0) == 1)
 	Kit.check("行门槛：第 2 级不可购（总等级 1 < 4——一线一节点主语，买第 N 级需全树总投入 ≥4×(N−1)）〔天赋树批 V2〕",
 		not mp.tree_can_buy("sp_hp"))
 	Kit.check("命中 L1/锻造钥匙（free 无前置=初始零购零币可点亮）/同调位 1（根节点无前置）受理（总等级 1→4）",
 		mp.tree_buy("sp_hit") and mp.tree_buy("forge_workshop") and mp.tree_buy("att_socket1"))
-	Kit.check("锻造工坊钥匙零币（free）", int(_db.tree_node("forge_workshop").get("price", -1)) == 0)
+	Kit.check("锻造工坊钥匙零币（free）", int(_db.crossrun.meta_tree.row_by_id("forge_workshop").get("price", -1)) == 0)
 	Kit.check("行门槛恰达开放（总等级 4 ≥ 4×1）", mp.tree_can_buy("sp_hp"))
 	Kit.check("第 2 级购买受理（门槛恰达当刻开放）",
-		mp.tree_buy("sp_hp") and sv.tree_level("sp_hp") == 2)
+		mp.tree_buy("sp_hp") and sv.meta_state.tree_state().nodes.get("sp_hp", 0) == 2)
 	# Fork 一节点双态（V9）
-	sv.add_keystone(100)
+	sv.meta_state._add_keystone(100)
 	Kit.check("Fork 购买=解锁+默认 A 态（一节点双态——单行承载）",
-		mp.tree_buy_fork("fork_posture") and sv.tree_level("fork_posture") == 1 and sv.fork_side("fg_posture") == "a")
+		mp.tree_buy_fork("fork_posture") and sv.meta_state.tree_state().nodes.get("fork_posture", 0) == 1 and sv.meta_state.tree_state().fork_sides.get("fg_posture", "") == "a")
 	Kit.check("已解锁 Fork 重复购买拒绝（cap 1）", not mp.tree_can_buy("fork_posture"))
 	Kit.check("同态重复切换零操作（false）", not mp.tree_toggle_fork("fg_posture", "a"))
 	Kit.check("未解锁 Fork 切换拒绝（解锁唯一入口=购买面）", not mp.tree_toggle_fork("fg_sense", "b"))
-	var bal_pre_toggle: int = sv.keystone_balance()
+	var bal_pre_toggle: int = sv.meta_state.keystone_balance()
 	Kit.check("零币切态 b（购买解锁后 A/B 可切）",
-		mp.tree_toggle_fork("fg_posture", "b") and sv.fork_side("fg_posture") == "b")
-	Kit.check("切态零消费（钥石余额差分不动）", int(sv.keystone_balance()) == bal_pre_toggle)
+		mp.tree_toggle_fork("fg_posture", "b") and sv.meta_state.tree_state().fork_sides.get("fg_posture", "") == "b")
+	Kit.check("切态零消费（钥石余额差分不动）", int(sv.meta_state.keystone_balance()) == bal_pre_toggle)
 	Kit.check("规则键投影=激活态效果键（B 态稳健拓荒——tree_rule_keys 随切态换键集）",
 		(mp.tree_rule_keys() as Array).has("posture_bulwark") and not (mp.tree_rule_keys() as Array).has("posture_first_strike"))
 	Kit.check("切回 A 态键集随换（六键词表在册——V11 校验面归单元段）",
 		mp.tree_toggle_fork("fg_posture", "a") and (mp.tree_rule_keys() as Array).has("posture_first_strike"))
 	# 彩蛋特化觉醒（V8）
 	Kit.check("彩蛋不经购买（手动购亮=红——觉醒唯一入口=特化判定）", not mp.tree_can_buy("easter_ley"))
-	Kit.check("觉醒前置未满足不亮（两线未拉满）", sv.tree_level("easter_ley") == 0)
-	sv.set_tree_level("sp_hp", 4)
-	sv.set_tree_level("sp_hit", 4)
-	sv.set_tree_level("att_socket2", 1)
+	Kit.check("觉醒前置未满足不亮（两线未拉满）", sv.meta_state.tree_state().nodes.get("easter_ley", 0) == 0)
+	sv.meta_state.set_tree_level("sp_hp", 4)
+	sv.meta_state.set_tree_level("sp_hit", 4)
+	sv.meta_state.set_tree_level("att_socket2", 1)
 	mp.tree_buy("att_socket3")   # 经购买口触发 _check_easter_egg
-	Kit.check("两线拉满+同调位全解锁 → 地脉共鸣自动点亮（零币特化判定）", sv.tree_level("easter_ley") == 1)
-	var bal_now: int = sv.keystone_balance()
+	Kit.check("两线拉满+同调位全解锁 → 地脉共鸣自动点亮（零币特化判定）", sv.meta_state.tree_state().nodes.get("easter_ley", 0) == 1)
+	var bal_now: int = sv.meta_state.keystone_balance()
 	mp.tree_buy("sp_hp")
-	Kit.check("觉醒零消费（钥石余额不动）", int(sv.keystone_balance()) == bal_now)
+	Kit.check("觉醒零消费（钥石余额不动）", int(sv.meta_state.keystone_balance()) == bal_now)
 	_meta_smoke_cleanup()
 
 
@@ -731,13 +730,11 @@ func _smoke_tree_rules() -> void:
 	# 财富之道·散：商品标价折价（level_runner 计价单点）
 	var lr = load("res://core/level_runner.gd").new(_db, _fresh_rng(777004),
 		{"tree_rules": []})   # 构造注入（拆件批 T3——setter 群退役）
-	Kit.check("散未激活：商品标价原价（无 economy_spend 键）",
-		int(lr.current_price({"base_price": 100, "price_increment": 0})) == 100 + int(_db.shop_price_level_bonus(0)))
+	Kit.check("散未激活：商品标价原价（无 economy_spend 键）", int(lr._spend_discounted(100)) == 100)
 	lr = load("res://core/level_runner.gd").new(_db, _fresh_rng(777005),
 		{"tree_rules": ["economy_spend"]})   # 构造注入（拆件批 T3——setter 群退役）
 	Kit.check("散激活：商品购买价 ×80%（provisional 折率——floor 偏向玩家、下限 1；刷新价不折=另一计价点零触碰）",
-		int(lr.current_price({"base_price": 100, "price_increment": 0})) == maxi(1, int(floor(float(100 + int(_db.shop_price_level_bonus(0))) * float(_db.shop.spend_discount))))
-		and int(lr.current_price({"base_price": 1, "price_increment": 0})) == maxi(1, int(floor(float(1 + int(_db.shop_price_level_bonus(0))) * float(_db.shop.spend_discount)))))
+		int(lr._spend_discounted(100)) == 80 and int(lr._spend_discounted(1)) == 1)
 	# 财富之道·聚：战斗掉落乘算·入账前（编排 _roll_gp_drop——同种子配对对拍 1.5×）
 	var orch3 = load("res://core/battle_orchestrator.gd").new(_db, _fresh_rng(777005))
 	Kit.check("聚 rig：基线编排启动（无增益侧）",

game/tests/unit/core/node_map_generator_test.gd

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

game/tests/unit/core/node_map_growth_test.gd

@@ -28,7 +28,7 @@ func _init() -> void:
 
 
 func _reading(gen, db, L: int) -> Dictionary:
-	var g: Dictionary = gen.generate(db.level_gen_params_row(L), 42)
+	var g: Dictionary = gen.generate(db.run.level_gen_params.row_by_level_index(L), 42)
 	var maxd := 0
 	for n in g["nodes"]:
 		maxd = maxi(maxd, int(n["depth"]))
@@ -62,8 +62,8 @@ func _test_growth(gen, db) -> void:
 
 func _test_fail_fast_static(gen, db) -> void:
 	Kit.check("生产三档参数档可行性判定零错误〔fv4〕",
-		NodeMapGenerator.check_params(db.level_gen_params_row(1)).is_empty()
-		and NodeMapGenerator.check_params(db.level_gen_params_row(3)).is_empty())
+		NodeMapGenerator.check_params(db.run.level_gen_params.row_by_level_index(1)).is_empty()
+		and NodeMapGenerator.check_params(db.run.level_gen_params.row_by_level_index(3)).is_empty())
 	var unsolvable := {"layers": 6, "branch_density": 0.0, "battle_ratio": 0.5, "reward_ratio": 0.2,
 		"rest_ratio": 0.2, "shop_ratio": 0.1, "entry_count": 1, "exit_count": 3, "battle_floor": 4,
 		"fork_ways_min": 2, "fork_ways_max": 3}

game/tests/unit/core/pool_case_d_test.gd

@@ -36,7 +36,7 @@ func _init() -> void:
 	var e = load("res://core/adventure_runner.gd").new(db, load("res://core/rng_service.gd").new())
 	e.start_adventure(501)
 	e.stop()._pending = {"candidates": []}
-	Kit.check_quiet(e.stop().skip_empty_curio() and (e.stop().breakpoint_fragment().get("bonus_pending", {}) as Dictionary).is_empty(),
+	Kit.check_quiet(e.stop().skip_empty_curio() and e.stop()._pending.is_empty(),
 		"空配置闸：三选一池空=停点整体跳过（skip_empty_curio 消化）〔专长批 T10〕")
 	e.stop()._pending = {"candidates": [{"kind": "gp", "tier": "common"}]}
 	Kit.check_quiet(not e.stop().skip_empty_curio(),
@@ -78,7 +78,7 @@ func check_v7(a, db) -> void:
 			continue
 		var hi := 0
 		for t in cands:
-			if db.adventure.tier_rank(String(t.get("tier", ""))) >= db.adventure.tier_rank(db.adventure.TIER_EXCELLENT):
+			if db.run.adventure.tier_rank(String(t.get("tier", ""))) >= db.run.adventure.tier_rank(db.run.adventure.TIER_EXCELLENT):
 				hi += 1
 		if hi >= 1:
 			hi_seen = true
@@ -161,21 +161,21 @@ func check_v8(c, db) -> void:
 		Kit.check_quiet(false, "V8 前置：冒险启动")
 		return
 	# 概率位与 cap 两属性独立：改 cap 不动牌库（概率位）、改牌库不动 cap 字段
-	var cap_field_before := int(db.adventure.curio_cap_gp)
-	db.adventure.curio_cap_gp = 1   # 独立设 cap（概率位=gp 令牌数不动）
+	var cap_field_before := int(db.run.adventure.cap_segment.curio_cap_gp)
+	db.run.adventure.cap_segment.curio_cap_gp = 1   # 独立设 cap（概率位=gp 令牌数不动）
 	var gp_tokens: int = c.deck().pool_stock("gp")
-	Kit.check_quiet(gp_tokens > 0 and int(db.adventure.curio_value("gp", "common")) == 20,
+	Kit.check_quiet(gp_tokens > 0 and int(db.run.adventure.curio_value("gp", "common")) == 20,
 		"改 cap 不动概率位：牌库 gp 令牌 %d 枚在库、件值字段不受影响〔专长批 V8〕" % gp_tokens)
 	# cap 只在拿了才计：刷出不计
 	c._curio.deck = [_tok("gp", "common"), _tok("attack", "common"), _tok("max_hp", "common")]
 	for i in 20:
 		c.deck().draw_candidates("reward_node")
-	Kit.check_quiet(bool(c.deck().cap_ok("gp", "")) and int(c.deck().taken.get("gp", 0)) == 0,
+	Kit.check_quiet(bool(c._curio.cap_ok("gp", "")) and int(c._curio.taken.get("gp", 0)) == 0,
 		"cap 刷出不计：20 次抽签后 gp 未拿、cap 未触发〔专长批 V8〕")
 	# 拿了才计：pick 一次→cap 满→提前退役（候选视图剔除、牌库本体不动）
 	c.stop()._pending = {"candidates": [_tok("gp", "common"), _tok("attack", "common"), _tok("max_hp", "common")]}
 	Kit.check_quiet(c.stop().pick_curio("gp", "common"), "V8 前置：兑付 gp 一枚")
-	Kit.check_quiet(not bool(c.deck().cap_ok("gp", "")), "cap 拿了才计：兑付后 cap 满（taken 1/1）〔专长批 V8〕")
+	Kit.check_quiet(not bool(c._curio.cap_ok("gp", "")), "cap 拿了才计：兑付后 cap 满（taken 1/1）〔专长批 V8〕")
 	var gp_in_deck := 0
 	for t in c._curio.deck:
 		if String((t as Dictionary).get("kind", "")) == "gp":
@@ -187,4 +187,4 @@ func check_v8(c, db) -> void:
 				gp_cand = true
 	Kit.check_quiet(gp_in_deck >= 0 and not gp_cand,
 		"提前退役：cap 满后候选视图零 gp（牌库本体张数不动=%d——概率位独立存活）〔专长批 V8〕" % gp_in_deck)
-	db.adventure.curio_cap_gp = cap_field_before   # 还原表（同进程后续套件防御）
+	db.run.adventure.cap_segment.curio_cap_gp = cap_field_before   # 还原表（同进程后续套件防御）

game/tests/unit/core/save_boot_no_activate_test.gd

@@ -23,14 +23,14 @@ func _init() -> void:
 # ① 无参实例（autoload 实例化形态）＝无激活态＋默认合法空态（sv2 类级）
 func _test_no_arg_instance_has_no_activation() -> void:
 	var sm := SaveManagerScript.new()
-	Kit.check_quiet(sm.active_slot() == 0 and not sm.has_write_target(),
+	Kit.check_quiet(sm._path == "" and sm.slots.active_slot() == 0 and not sm.slots.has_write_target(),
 		"sv2 无参实例无激活态（路径空/激活号 0/写盘目标空）〔卡① sv2〕")
-	Kit.check_quiet(sm.keystone_balance() == 0 and not sm.has_breakpoint()
-		and sm.adventure_total() == 0 and sm.adventure_cleared() == 0,
+	Kit.check_quiet(sm.meta_state.keystone_balance() == 0 and not sm.has_breakpoint()
+		and sm.meta_state.career_state().adventure_total == 0 and sm.meta_state.career_state().adventure_cleared == 0,
 		"sv2 内存=默认合法空态（钥石/断点/总局数/冒险成功数全零值——访问器 fail-safe）〔卡① sv2〕")
 	# attach_path 注入任意隔离路径＝注入即激活（契约 7 单路径语义——隔离面行为零变化）
-	sm.attach_path("user://smoke_boot_noact_iso.json")
-	Kit.check_quiet(sm.has_write_target() and sm.keystone_balance() == 0,
+	sm.slots.attach_path("user://smoke_boot_noact_iso.json")
+	Kit.check_quiet(sm.slots.has_write_target() and sm.meta_state.keystone_balance() == 0,
 		"sv2 attach_path 注入即激活（写盘目标在位、数据回默认空态）〔卡① sv2/契约7〕")
 	if FileAccess.file_exists("user://smoke_boot_noact_iso.json"):
 		DirAccess.remove_absolute("user://smoke_boot_noact_iso.json")
@@ -43,7 +43,7 @@ func _test_write_rejected_without_target() -> void:
 	var sm := SaveManagerScript.new()
 	var before := {}
 	for i in range(1, 4):
-		var p: String = sm.slot_path(i)
+		var p: String = sm.slots.slot_path(i)
 		before[i] = [FileAccess.file_exists(p),
 			FileAccess.get_file_as_bytes(p) if FileAccess.file_exists(p) else PackedByteArray(),
 			FileAccess.get_modified_time(p) if FileAccess.file_exists(p) else 0]
@@ -55,7 +55,7 @@ func _test_write_rejected_without_target() -> void:
 		"sv3 无激活写盘拒绝（write_to_disk=false）〔卡① sv3〕")
 	var unchanged := true
 	for i in range(1, 4):
-		var p: String = sm.slot_path(i)
+		var p: String = sm.slots.slot_path(i)
 		var now_state: Array = [FileAccess.file_exists(p),
 			FileAccess.get_file_as_bytes(p) if FileAccess.file_exists(p) else PackedByteArray(),
 			FileAccess.get_modified_time(p) if FileAccess.file_exists(p) else 0]
@@ -88,11 +88,11 @@ func _test_settle_chain_write_rejected() -> void:
 	for sp in ["res://.tmp", "res://.tmp.tmp"]:
 		if FileAccess.file_exists(sp):
 			DirAccess.remove_absolute(sp)
-	Kit.check_quiet(not sm.has_write_target() and not sm.write_to_disk(),
+	Kit.check_quiet(not sm.slots.has_write_target() and not sm.write_to_disk(),
 		"sv3 链前置：无激活态在位且直写被拒〔卡① sv3〕")
 	meta.settle_adventure({"result": "failed", "cleared": false, "levels_cleared": 1,
 		"stopped_at": 2, "keystone_total": 0, "master_seed": 3})
-	Kit.check_quiet(not sm.has_write_target() and sm.adventure_total() == 1,
+	Kit.check_quiet(not sm.slots.has_write_target() and sm.meta_state.career_state().adventure_total == 1,
 		"sv3 生产链：settle_adventure 落账内存（adventure_total=1）而写盘仍无目标（被拒不落盘）〔卡① sv3〕")
 	Kit.check_quiet(not FileAccess.file_exists("res://.tmp")
 		and not FileAccess.file_exists("res://.tmp.tmp"),
@@ -102,11 +102,11 @@ func _test_settle_chain_write_rejected() -> void:
 # ③ 越界槽号三原语拒绝＋窥视越界返回不可读（原语边界 fail-safe）
 func _test_out_of_range_slots_rejected() -> void:
 	var sm := SaveManagerScript.new()
-	sm.attach_slot_template("user://smoke_boot_noact_%d.json")
-	Kit.check_quiet(not sm.activate_slot(0) and not sm.activate_slot(4)
-		and not sm.create_slot(0) and not sm.create_slot(4)
-		and not sm.delete_slot(0) and not sm.delete_slot(4),
+	sm.slots.attach_slot_template("user://smoke_boot_noact_%d.json")
+	Kit.check_quiet(not sm.slots.activate_slot(0) and not sm.slots.activate_slot(4)
+		and not sm.slots.create_slot(0) and not sm.slots.create_slot(4)
+		and not sm.slots.delete_slot(0) and not sm.slots.delete_slot(4),
 		"原语边界：槽号 0/4 全拒绝（位数写死 3——契约 1）〔卡① sv1〕")
-	var out: Dictionary = sm.peek_slot_summary(4)
+	var out: Dictionary = sm.slots.peek_slot_summary(4)
 	Kit.check_quiet(not bool(out.get("readable", true)),
 		"原语边界：越界窥视返回不可读标记〔卡① sv7〕")

game/tests/unit/core/save_manager_domain_test.gd

@@ -67,55 +67,55 @@ func _smoke_save() -> void:
 
 	# ① 往返：全访问器写非默认值 → write → 新实例 load → 逐域逐值相等
 	var w = sm_script.new(paths[0])
-	w.add_keystone(7)
-	w.set_tree_level("sp_hp", 2)
-	w.set_tree_level("sp_hit", 1)
-	w.set_fork_side("fg_posture", "b")   # 树域写入
-	w.set_forge_route_level("spear", 3)   # 锻造工坊域写入（等级+直购解锁+选中标记）
-	w.add_forge_unlock("spear")
-	w.set_forge_weapon("spear")
-	w.set_forge_armor("ward")
-	w.unlock_item("probe_compass")
-	w.apply_adventure_summary({"result": "failed", "cleared": false, "levels_cleared": 2,
+	w.meta_state._add_keystone(7)
+	w.meta_state.set_tree_level("sp_hp", 2)
+	w.meta_state.set_tree_level("sp_hit", 1)
+	w.meta_state.set_fork_side("fg_posture", "b")   # 树域写入
+	w.meta_state.set_forge_route_level("spear", 3)   # 锻造工坊域写入（等级+直购解锁+选中标记）
+	w.meta_state.add_forge_unlock("spear")
+	w.meta_state.set_forge_weapon("spear")
+	w.meta_state.set_forge_armor("ward")
+	w.meta_state.unlock_item("probe_compass")
+	w.meta_state.apply_adventure_summary({"result": "failed", "cleared": false, "levels_cleared": 2,
 		"stopped_at": 3, "keystone_total": 3, "master_seed": 99})
 	Kit.check("apply 原语入账（钥石 7+3、关卡完成次数 1/1/0）",
-		w.keystone_balance() == 10 and w.clear_count(1) == 1 and w.clear_count(2) == 1 and w.clear_count(3) == 0)
+		w.meta_state.keystone_balance() == 10 and w.meta_state.career_state().clear_counts.get(str(1), 0) == 1 and w.meta_state.career_state().clear_counts.get(str(2), 0) == 1 and w.meta_state.career_state().clear_counts.get(str(3), 0) == 0)
 	Kit.check("首杀标记随关卡完成置位（1/2 有、3 无）",
-		w.boss_first_kill_marked(1) and w.boss_first_kill_marked(2) and not w.boss_first_kill_marked(3))
+		w.meta_state.career_state().boss_first_kill.has(str(1)) and w.meta_state.career_state().boss_first_kill.has(str(2)) and not w.meta_state.career_state().boss_first_kill.has(str(3)))
 	Kit.check("生涯终身计数随 apply 自增恰一（中止局：总局数 1、冒险成功局数 0——迭代 18 卡④）",
-		w.adventure_total() == 1 and w.adventure_cleared() == 0)
+		w.meta_state.career_state().adventure_total == 1 and w.meta_state.career_state().adventure_cleared == 0)
 	Kit.check("写盘成功", w.write_to_disk())
 	var r = sm_script.new(paths[0])
 	Kit.check("读回成功", r.load_from_disk())
-	Kit.check("钥石余额往返相等（10）", r.keystone_balance() == 10)
+	Kit.check("钥石余额往返相等（10）", r.meta_state.keystone_balance() == 10)
 	Kit.check("树域往返相等（tree_nodes/fork_sides——迭代 21 换代承载）",
-		r.tree_level("sp_hp") == 2 and r.tree_level("sp_hit") == 1 and r.fork_side("fg_posture") == "b")
+		r.meta_state.tree_state().nodes.get("sp_hp", 0) == 2 and r.meta_state.tree_state().nodes.get("sp_hit", 0) == 1 and r.meta_state.tree_state().fork_sides.get("fg_posture", "") == "b")
 	Kit.check("锻造工坊域往返相等（levels/unlocked/weapon/armor——迭代 23 T5）〔锻造工坊批 V8〕",
-		r.forge_route_level("spear") == 3 and r.forge_route_level("sword") == 0
-		and r.forge_unlocked_purchases() == ["spear"]
-		and r.forge_weapon() == "spear" and r.forge_armor() == "ward")
-	Kit.check("道具解锁往返相等", r.item_unlocked("probe_compass") and not r.item_unlocked("rope"))
-	Kit.check("关卡完成次数表往返相等", r.clear_count(1) == 1 and r.clear_count(2) == 1 and r.clear_count(3) == 0)
+		r.meta_state.forge_state().levels.get("spear", 0) == 3 and r.meta_state.forge_state().levels.get("sword", 0) == 0
+		and r.meta_state.forge_state().unlocked == ["spear"]
+		and r.meta_state.forge_state().weapon == "spear" and r.meta_state.forge_state().armor == "ward")
+	Kit.check("道具解锁往返相等", r.meta_state.item_unlocked("probe_compass") and not r.meta_state.item_unlocked("rope"))
+	Kit.check("关卡完成次数表往返相等", r.meta_state.career_state().clear_counts.get(str(1), 0) == 1 and r.meta_state.career_state().clear_counts.get(str(2), 0) == 1 and r.meta_state.career_state().clear_counts.get(str(3), 0) == 0)
 	Kit.check("首杀标记往返相等",
-		r.boss_first_kill_marked(1) and r.boss_first_kill_marked(2) and not r.boss_first_kill_marked(3))
-	Kit.check("生涯终身计数往返相等（1/0）", r.adventure_total() == 1 and r.adventure_cleared() == 0)
-	var s0: Dictionary = r.recent_summaries()[0]
+		r.meta_state.career_state().boss_first_kill.has(str(1)) and r.meta_state.career_state().boss_first_kill.has(str(2)) and not r.meta_state.career_state().boss_first_kill.has(str(3)))
+	Kit.check("生涯终身计数往返相等（1/0）", r.meta_state.career_state().adventure_total == 1 and r.meta_state.career_state().adventure_cleared == 0)
+	var s0: Dictionary = r.meta_state.career_state().recent_summaries[0]
 	Kit.check("冒险摘要往返相等（1 条，seed 99）",
-		r.recent_summaries().size() == 1 and int(s0.get("master_seed", -1)) == 99 and int(s0.get("keystone_total", -1)) == 3)
+		r.meta_state.career_state().recent_summaries.size() == 1 and int(s0.get("master_seed", -1)) == 99 and int(s0.get("keystone_total", -1)) == 3)
 
 	# ② 新档合法：不存在路径 load → true + 全零默认值
 	var f2 = sm_script.new(paths[1])
 	Kit.check("新档合法态（load true + 全零默认）",
-		f2.load_from_disk() and f2.keystone_balance() == 0 and f2.tree_level("sp_hp") == 0
-		and not f2.item_unlocked("anything") and f2.clear_count(1) == 0 and f2.recent_summaries().is_empty())
+		f2.load_from_disk() and f2.meta_state.keystone_balance() == 0 and f2.meta_state.tree_state().nodes.get("sp_hp", 0) == 0
+		and not f2.meta_state.item_unlocked("anything") and f2.meta_state.career_state().clear_counts.get(str(1), 0) == 0 and f2.meta_state.career_state().recent_summaries.is_empty())
 	Kit.check("新档生涯终身计数缺省全零（迭代 18 卡④两新域——白板存档完整可玩）",
-		f2.adventure_total() == 0 and f2.adventure_cleared() == 0)
+		f2.meta_state.career_state().adventure_total == 0 and f2.meta_state.career_state().adventure_cleared == 0)
 
 	# ③ spend 拒绝：余额不足 false 且零副作用（钥石只增不减——消费除外）
 	var f3 = sm_script.new(paths[2])
-	f3.add_keystone(5)
-	Kit.check("余额 5 花 8 拒绝且余额不动", not f3.spend_keystone(8) and f3.keystone_balance() == 5)
-	Kit.check("余额内消费成功（5→2）", f3.spend_keystone(3) and f3.keystone_balance() == 2)
+	f3.meta_state._add_keystone(5)
+	Kit.check("余额 5 花 8 拒绝且余额不动", not f3.meta_state.spend_keystone(8) and f3.meta_state.keystone_balance() == 5)
+	Kit.check("余额内消费成功（5→2）", f3.meta_state.spend_keystone(3) and f3.meta_state.keystone_balance() == 2)
 
 	# ⑤ 高版本拒读：load false、原文件字节不动、后续写盘拒绝且文件仍字节不动（契约 4）
 	var hv_text := "{\"version\": 99, \"meta\": {\"keystone_balance\": 1}}"
@@ -135,7 +135,7 @@ func _smoke_save() -> void:
 	fj.close()
 	var f6 = sm_script.new(paths[4])
 	Kit.check("损坏档兜底（默认数据继续）",
-		f6.load_from_disk() and f6.keystone_balance() == 0 and f6.recent_summaries().is_empty())
+		f6.load_from_disk() and f6.meta_state.keystone_balance() == 0 and f6.meta_state.career_state().recent_summaries.is_empty())
 	Kit.check("坏档备份 .corrupt.bak 存在", FileAccess.file_exists(paths[4] + ".corrupt.bak"))
 	Kit.check("备份内容 = 原坏档字节",
 		FileAccess.open(paths[4] + ".corrupt.bak", FileAccess.READ).get_as_text() == junk)
@@ -149,7 +149,7 @@ func _smoke_save() -> void:
 	fm.store_string(JSON.stringify({"version": 0, "keystone_old": 12}))
 	fm.close()
 	Kit.check("v0 旧档经迁移链入账（keystone_old 12 → 余额 12）",
-		f7.load_from_disk() and f7.keystone_balance() == 12)
+		f7.load_from_disk() and f7.meta_state.keystone_balance() == 12)
 	Kit.check("迁移链 0→1(测试钩)→7(生产) 写盘 version == 7（v7=锻造工坊域，迭代 23 T5——v6=生涯终身计数域迭代 18 卡④）",
 		f7.write_to_disk() and int(JSON.parse_string(FileAccess.open(paths[5], FileAccess.READ).get_as_text()).get("version", -1)) == 7)
 
@@ -167,9 +167,9 @@ func _smoke_save() -> void:
 	# ⑩ 摘要 cap：12 份 → 保留 10、最新在前
 	var f10 = sm_script.new(paths[7])
 	for i in range(12):
-		f10.apply_adventure_summary({"result": "completed", "cleared": true, "levels_cleared": 0,
+		f10.meta_state.apply_adventure_summary({"result": "completed", "cleared": true, "levels_cleared": 0,
 			"stopped_at": 0, "keystone_total": 0, "master_seed": i})
-	var arr: Array = f10.recent_summaries()
+	var arr: Array = f10.meta_state.career_state().recent_summaries
 	Kit.check("摘要 cap 10（12 份 → 10 条）", arr.size() == 10)
 	Kit.check("最新在前（头 seed 11 / 尾 seed 2）",
 		int(arr[0].get("master_seed", -1)) == 11 and int(arr[9].get("master_seed", -1)) == 2)
@@ -227,7 +227,7 @@ func _smoke_save() -> void:
 	fold.store_string("{\"version\": 1, \"meta\": {\"keystone_balance\": 4}}")
 	fold.close()
 	Kit.check("v1 旧档迁移 v7：断点域补空（合法空态，无断点域不炸）",
-		fo.load_from_disk() and fo.keystone_balance() == 4 and not fo.has_breakpoint())
+		fo.load_from_disk() and fo.meta_state.keystone_balance() == 4 and not fo.has_breakpoint())
 	Kit.check("v1 旧档迁移后写盘 version == 7（v1→v7 链式——锻造工坊域 2026-10-12）",
 		fo.write_to_disk() and int(JSON.parse_string(FileAccess.open(paths[9], FileAccess.READ).get_as_text()).get("version", -1)) == 7)
 
@@ -241,7 +241,7 @@ func _smoke_save() -> void:
 			"visited_ids": []}}))
 	fv2f.close()
 	Kit.check("v2 旧档迁移 v3：断点域与 meta 域原样保留（缺新附随件=合法空态）",
-		fv2.load_from_disk() and fv2.has_breakpoint() and fv2.keystone_balance() == 7)
+		fv2.load_from_disk() and fv2.has_breakpoint() and fv2.meta_state.keystone_balance() == 7)
 	Kit.check("v2 旧断点字段零丢失（向后兼容——breakpoint 内容不因 schema 升版重写）",
 		int((fv2.breakpoint_snapshot() as Dictionary).get("master_seed", 0)) == 777)
 	var adr_v2 = load("res://core/adventure_runner.gd").new(_db, _fresh_rng(777))
@@ -255,22 +255,22 @@ func _smoke_save() -> void:
 	fv5u.store_string(JSON.stringify({"version": 5, "meta": {"keystone_balance": 9}}))
 	fv5u.close()
 	Kit.check("v5 旧档升 v7：计数域缺省补零且既有余额原样（迁移只增字段不改值——v5→v6→v7 链式）",
-		f13.load_from_disk() and f13.adventure_total() == 0 and f13.adventure_cleared() == 0
-		and f13.keystone_balance() == 9)
+		f13.load_from_disk() and f13.meta_state.career_state().adventure_total == 0 and f13.meta_state.career_state().adventure_cleared == 0
+		and f13.meta_state.keystone_balance() == 9)
 	Kit.check("升档幂等：v7 档写盘再载零漂移（重复迁移零副作用——锻造工坊域同批补齐）",
 		f13.write_to_disk() and f13.load_from_disk()
 		and int(JSON.parse_string(FileAccess.open(paths[11], FileAccess.READ).get_as_text()).get("version", -1)) == 7
-		and f13.adventure_total() == 0 and f13.adventure_cleared() == 0)
+		and f13.meta_state.career_state().adventure_total == 0 and f13.meta_state.career_state().adventure_cleared == 0)
 	var f13b = sm_script.new(paths[12])
 	f13b.load_from_disk()
-	f13b.apply_adventure_summary({"result": "completed", "cleared": true, "levels_cleared": 3,
+	f13b.meta_state.apply_adventure_summary({"result": "completed", "cleared": true, "levels_cleared": 3,
 		"stopped_at": 0, "keystone_total": 0, "master_seed": 1})
 	Kit.check("收束自增恰一·冒险成功局（三关全通 cleared=true：总局数+1 且冒险成功局数+1）",
-		f13b.adventure_total() == 1 and f13b.adventure_cleared() == 1)
-	f13b.apply_adventure_summary({"result": "abandoned", "cleared": false, "levels_cleared": 1,
+		f13b.meta_state.career_state().adventure_total == 1 and f13b.meta_state.career_state().adventure_cleared == 1)
+	f13b.meta_state.apply_adventure_summary({"result": "abandoned", "cleared": false, "levels_cleared": 1,
 		"stopped_at": 2, "keystone_total": 0, "master_seed": 2})
 	Kit.check("收束自增恰一·中止局（放弃局：仅总局数+1，冒险成功局数不动）",
-		f13b.adventure_total() == 2 and f13b.adventure_cleared() == 1)
+		f13b.meta_state.career_state().adventure_total == 2 and f13b.meta_state.career_state().adventure_cleared == 1)
 
 	# ⑮ 旧档破坏性废弃（契约 4：换代前结构检测=树域废弃重置，禁迁移禁折算）〔V16〕
 	var f15 = sm_script.new(paths[13])
@@ -281,12 +281,12 @@ func _smoke_save() -> void:
 		"fork_sides": {"fg_posture": "a", "fg_mastery": "b"}}}))
 	fv16.close()
 	Kit.check("换代前结构存档：树域废弃重置（旧节点 id/fork 侧/forge_levels 旧域残留清退）、钥石余额零折算零变动",
-		f15.load_from_disk() and f15.keystone_balance() == 33
-		and f15.tree_nodes().is_empty() and f15.fork_sides().is_empty())
+		f15.load_from_disk() and f15.meta_state.keystone_balance() == 33
+		and f15.meta_state.tree_state().nodes.is_empty() and f15.meta_state.tree_state().fork_sides.is_empty())
 	var mp16 = load("res://core/meta_progression.gd").new(_db, f15)
-	f15.add_keystone(50)
+	f15.meta_state._add_keystone(50)
 	Kit.check("废弃重置后后续购买正常受理（无残留脏节点）",
-		mp16.tree_buy("sp_hp") and f15.tree_level("sp_hp") == 1)
+		mp16.tree_buy("sp_hp") and f15.meta_state.tree_state().nodes.get("sp_hp", 0) == 1)
 
 	# ⑯ 锻造工坊域 forge_routes（V8）：v6 旧档缺键补齐=初始持有态+无特效域+域界干净
 	var f16 = sm_script.new(paths[14])
@@ -295,26 +295,26 @@ func _smoke_save() -> void:
 		"tree_nodes": {"sp_hp": 1}, "tree_struct": 2, "adventure_total": 4, "adventure_cleared": 1}}))
 	fv6.close()
 	Kit.check("v6 旧档升 v7：既有域逐位不动（钥石/树/生涯计数零折算——迁移只增不改）〔锻造工坊批 V8〕",
-		f16.load_from_disk() and f16.keystone_balance() == 21
-		and f16.tree_level("sp_hp") == 1 and f16.adventure_total() == 4 and f16.adventure_cleared() == 1)
+		f16.load_from_disk() and f16.meta_state.keystone_balance() == 21
+		and f16.meta_state.tree_state().nodes.get("sp_hp", 0) == 1 and f16.meta_state.career_state().adventure_total == 4 and f16.meta_state.career_state().adventure_cleared == 1)
 	Kit.check("v6 旧档缺键补齐=初始持有态（六路线 0 级/直购清单空/选中=sword+light）〔锻造工坊批 V8〕",
-		f16.forge_route_level("sword") == 0 and f16.forge_route_level("spear") == 0
-		and f16.forge_route_level("light") == 0 and f16.forge_route_level("ward") == 0
-		and f16.forge_unlocked_purchases().is_empty()
-		and f16.forge_weapon() == "sword" and f16.forge_armor() == "light")
-	var fr_keys: Array = (f16.forge_routes_snapshot() as Dictionary).keys()
+		f16.meta_state.forge_state().levels.get("sword", 0) == 0 and f16.meta_state.forge_state().levels.get("spear", 0) == 0
+		and f16.meta_state.forge_state().levels.get("light", 0) == 0 and f16.meta_state.forge_state().levels.get("ward", 0) == 0
+		and f16.meta_state.forge_state().unlocked.is_empty()
+		and f16.meta_state.forge_state().weapon == "sword" and f16.meta_state.forge_state().armor == "light")
+	var fr_keys: Array = (f16.meta_state.forge_state() as Dictionary).keys()
 	fr_keys.sort()
 	Kit.check("forge_routes 域键集恰四项（无特效域——满级特效本期不做，契约 7）〔锻造工坊批 V8/V11〕",
 		fr_keys == ["armor", "levels", "unlocked", "weapon"])
-	var lv_keys: Array = ((f16.forge_routes_snapshot() as Dictionary).get("levels", {}) as Dictionary).keys()
+	var lv_keys: Array = ((f16.meta_state.forge_state() as Dictionary).get("levels", {}) as Dictionary).keys()
 	lv_keys.sort()
 	Kit.check("levels 六路线键集恰全（sword/spear/staff/light/heavy/ward）〔锻造工坊批 V8〕",
 		lv_keys == ["heavy", "light", "spear", "staff", "sword", "ward"])
 	# 值拷贝出户（改快照不渗档——本类契约）
-	var snap: Dictionary = f16.forge_routes_snapshot()
+	var snap: Dictionary = f16.meta_state.forge_state()
 	(snap.get("levels", {}) as Dictionary)["sword"] = 99
 	Kit.check("forge_routes_snapshot 值拷贝出户（改快照不渗档）〔锻造工坊批 V8〕",
-		f16.forge_route_level("sword") == 0)
+		f16.meta_state.forge_state().levels.get("sword", 0) == 0)
 
 	# ⑭ 收束链入账（真实收束挂点全链恰一：主流程 adventure_finished →
 	# MetaProgression.settle_adventure → apply_adventure_summary 单口；两夹具经同链入账）
@@ -322,11 +322,11 @@ func _smoke_save() -> void:
 	mp13.settle_adventure({"result": "failed", "cleared": false, "levels_cleared": 2,
 		"stopped_at": 3, "keystone_total": 0, "master_seed": 3})
 	Kit.check("收束链自增·中止局（settle_adventure 真实挂点：总局数+1、冒险成功局数不动）",
-		f13b.adventure_total() == 3 and f13b.adventure_cleared() == 1)
+		f13b.meta_state.career_state().adventure_total == 3 and f13b.meta_state.career_state().adventure_cleared == 1)
 	mp13.settle_adventure({"result": "completed", "cleared": true, "levels_cleared": 3,
 		"stopped_at": 0, "keystone_total": 0, "master_seed": 4})
 	Kit.check("收束链自增·冒险成功局（三关全通：总局数+1 且冒险成功局数+1——全链恰一）",
-		f13b.adventure_total() == 4 and f13b.adventure_cleared() == 2)
+		f13b.meta_state.career_state().adventure_total == 4 and f13b.meta_state.career_state().adventure_cleared == 2)
 
 	# 段尾清理（测试文件绝不残留）
 	for p in stale:
@@ -352,39 +352,39 @@ func _smoke_save_slots() -> void:
 			DirAccess.remove_absolute(p)
 
 	var t = sm_script.new()
-	t.attach_slot_template(slot_tpl)
+	t.slots.attach_slot_template(slot_tpl)
 
 	# ① 三槽往返×3＋位间隔离＋进档（sv1/sv5/sv10）
 	for i in range(1, 4):
-		Kit.check("sv5 进档受理·槽 %d（激活+读盘）〔卡① sv5〕" % i, t.activate_slot(i))
-		t.apply_adventure_summary({"result": "completed", "cleared": i == 1, "levels_cleared": i,
+		Kit.check("sv5 进档受理·槽 %d（激活+读盘）〔卡① sv5〕" % i, t.slots.activate_slot(i))
+		t.meta_state.apply_adventure_summary({"result": "completed", "cleared": i == 1, "levels_cleared": i,
 			"stopped_at": 0, "keystone_total": 100 * i, "master_seed": i})
 		Kit.check("sv3 激活态写盘受理·槽 %d〔卡① sv1〕" % i, t.write_to_disk())
 	var t2 = sm_script.new()
-	t2.attach_slot_template(slot_tpl)
+	t2.slots.attach_slot_template(slot_tpl)
 	for i in range(1, 4):
 		Kit.check("sv1 三槽往返一致·槽 %d（异值按位读回）〔卡① sv1〕" % i,
-			t2.activate_slot(i) and t2.keystone_balance() == 100 * i
-			and t2.adventure_total() == 1 and t2.adventure_cleared() == (1 if i == 1 else 0))
+			t2.slots.activate_slot(i) and t2.meta_state.keystone_balance() == 100 * i
+			and t2.meta_state.career_state().adventure_total == 1 and t2.meta_state.career_state().adventure_cleared == (1 if i == 1 else 0))
 	var slot2_before := FileAccess.get_file_as_bytes(slot_tpl % 2)
-	t.activate_slot(1)
-	t.add_keystone(7)
+	t.slots.activate_slot(1)
+	t.meta_state._add_keystone(7)
 	Kit.check("sv3 写盘受理·槽 1 加值后〔卡① sv1〕", t.write_to_disk())
 	Kit.check("sv1 位间隔离：改槽 1 槽 2 字节不动〔卡① sv1〕",
 		FileAccess.get_file_as_bytes(slot_tpl % 2) == slot2_before)
 
 	# ② 删档原语（sv6）：删激活槽（指针连清除）→ 删非激活槽（指针保持+他槽字节不动）
-	Kit.check("sv5 切激活至槽 3（删激活槽夹具前置）〔卡① sv5〕", t.activate_slot(3))
-	Kit.check("sv6 删档受理·激活槽 3〔卡① sv6〕", t.delete_slot(3))
+	Kit.check("sv5 切激活至槽 3（删激活槽夹具前置）〔卡① sv5〕", t.slots.activate_slot(3))
+	Kit.check("sv6 删档受理·激活槽 3〔卡① sv6〕", t.slots.delete_slot(3))
 	Kit.check("sv6 删后文件不在盘＋无 .tmp 残留〔卡① sv6〕",
 		not FileAccess.file_exists(slot_tpl % 3) and not FileAccess.file_exists(slot_tpl % 3 + ".tmp"))
 	Kit.check("sv6 删激活槽激活指针连清除（该槽不再可写）〔卡① sv6〕",
-		t.active_slot() == 0 and not t.has_write_target())
+		t.slots.active_slot() == 0 and not t.slots.has_write_target())
 	var slot1_before := FileAccess.get_file_as_bytes(slot_tpl % 1)
-	t.activate_slot(1)
-	Kit.check("sv6 删非激活槽受理·槽 2〔卡① sv6〕", t.delete_slot(2))
+	t.slots.activate_slot(1)
+	Kit.check("sv6 删非激活槽受理·槽 2〔卡① sv6〕", t.slots.delete_slot(2))
 	Kit.check("sv6 删非激活槽：文件不在盘＋激活指针保持〔卡① sv6〕",
-		not FileAccess.file_exists(slot_tpl % 2) and t.active_slot() == 1)
+		not FileAccess.file_exists(slot_tpl % 2) and t.slots.active_slot() == 1)
 	Kit.check("sv6 删槽 2 槽 1 字节不动（位间互隔离）〔卡① sv6〕",
 		FileAccess.get_file_as_bytes(slot_tpl % 1) == slot1_before)
 
@@ -394,10 +394,10 @@ func _smoke_save_slots() -> void:
 	fold.store_string(JSON.stringify({"version": 7, "meta": {"keystone_balance": 999,
 		"adventure_total": 5, "adventure_cleared": 2, "tree_nodes": {}, "fork_sides": {}, "tree_struct": 2}}))
 	fold.close()
-	Kit.check("sv4 新档受理·槽 3（创建即激活）〔卡① sv4〕", t.create_slot(3))
+	Kit.check("sv4 新档受理·槽 3（创建即激活）〔卡① sv4〕", t.slots.create_slot(3))
 	Kit.check("sv4 新档=全零可玩合法白板态（旧内容 999/5 零带入——钥石/总局数/断点全零）〔卡① sv4〕",
-		t.active_slot() == 3 and t.keystone_balance() == 0 and not t.has_breakpoint()
-		and t.adventure_total() == 0)
+		t.slots.active_slot() == 3 and t.meta_state.keystone_balance() == 0 and not t.has_breakpoint()
+		and t.meta_state.career_state().adventure_total == 0)
 	var created: Dictionary = JSON.parse_string(FileAccess.get_file_as_string(slot_tpl % 3))
 	Kit.check("sv4 新档落盘=白板内容（盘面核验非 999 旧值）〔卡① sv4〕",
 		int((created.get("meta", {}) as Dictionary).get("keystone_balance", -1)) == 0)
@@ -407,14 +407,14 @@ func _smoke_save_slots() -> void:
 	fhv.store_string(JSON.stringify({"version": 99, "meta": {}}))
 	fhv.close()
 	var hv = sm_script.new()
-	hv.attach_slot_template(slot_tpl)
+	hv.slots.attach_slot_template(slot_tpl)
 	Kit.check("sv5 进档槽 1 读回（107）〔卡① sv10〕",
-		hv.activate_slot(1) and hv.keystone_balance() == 107)
+		hv.slots.activate_slot(1) and hv.meta_state.keystone_balance() == 107)
 	var slot2_hv := FileAccess.get_file_as_bytes(slot_tpl % 2)
-	Kit.check("sv9 高版本槽进档拒绝（拒读禁写链按槽）〔卡① sv9〕", not hv.activate_slot(2))
+	Kit.check("sv9 高版本槽进档拒绝（拒读禁写链按槽）〔卡① sv9〕", not hv.slots.activate_slot(2))
 	Kit.check("sv10 激活失败恢复切换前三态（路径/激活号/数据归槽 1）〔卡① sv10〕",
-		hv.active_slot() == 1 and hv.keystone_balance() == 107)
-	hv.add_keystone(1)
+		hv.slots.active_slot() == 1 and hv.meta_state.keystone_balance() == 107)
+	hv.meta_state._add_keystone(1)
 	Kit.check("sv10 恢复后写盘落激活槽 1（高版本槽 2 零误写）〔卡① sv10〕",
 		hv.write_to_disk() and FileAccess.get_file_as_bytes(slot_tpl % 2) == slot2_hv)
 
@@ -425,14 +425,14 @@ func _smoke_save_slots() -> void:
 		fm.close()
 	for i in range(1, 4):
 		var mi = sm_script.new()
-		mi.attach_slot_template(slot_tpl)
+		mi.slots.attach_slot_template(slot_tpl)
 		Kit.check("sv9 迁移链按槽成立·槽 %d（v5→v7 各槽独立+写盘 version=7）〔卡① sv9〕" % i,
-			mi.activate_slot(i) and mi.keystone_balance() == i * 11
+			mi.slots.activate_slot(i) and mi.meta_state.keystone_balance() == i * 11
 			and mi.write_to_disk())
 
 	# ⑥ 窥视三态零副作用（sv7/sv8）：异值三槽逐槽三项＋空槽零值＋坏/高版本字节 mtime 双比对
 	var pv = sm_script.new()
-	pv.attach_slot_template(slot_tpl)
+	pv.slots.attach_slot_template(slot_tpl)
 	for i in range(1, 4):
 		var fp := FileAccess.open(slot_tpl % i, FileAccess.WRITE)
 		fp.store_string(JSON.stringify({"version": 7, "meta": {"keystone_balance": 200 * i,
@@ -440,12 +440,12 @@ func _smoke_save_slots() -> void:
 			"tree_nodes": {}, "fork_sides": {}, "tree_struct": 2}}))
 		fp.close()
 	for i in range(1, 4):
-		var ps: Dictionary = pv.peek_slot_summary(i)
+		var ps: Dictionary = pv.slots.peek_slot_summary(i)
 		Kit.check("sv7 窥视三项逐槽正确·槽 %d〔卡① sv7〕" % i,
 			bool(ps.get("readable", false)) and int(ps.get("keystone", -1)) == 200 * i
 			and int(ps.get("cleared", -1)) == i and int(ps.get("total", -1)) == 5 * i)
-	Kit.check("sv6 删槽 3 备空槽窥视〔卡① sv6〕", pv.delete_slot(3))
-	var pe: Dictionary = pv.peek_slot_summary(3)
+	Kit.check("sv6 删槽 3 备空槽窥视〔卡① sv6〕", pv.slots.delete_slot(3))
+	var pe: Dictionary = pv.slots.peek_slot_summary(3)
 	Kit.check("sv7 空槽窥视=零值合法态〔卡① sv7〕",
 		bool(pe.get("readable", false)) and int(pe.get("keystone", -1)) == 0
 		and int(pe.get("cleared", -1)) == 0 and int(pe.get("total", -1)) == 0)
@@ -454,7 +454,7 @@ func _smoke_save_slots() -> void:
 	fbad.close()
 	var bad_bytes := FileAccess.get_file_as_bytes(slot_tpl % 1)
 	var bad_mtime := FileAccess.get_modified_time(slot_tpl % 1)
-	var pb: Dictionary = pv.peek_slot_summary(1)
+	var pb: Dictionary = pv.slots.peek_slot_summary(1)
 	Kit.check("sv8 坏槽窥视=显式损坏标记〔卡① sv8〕", not bool(pb.get("readable", true)))
 	Kit.check("sv8 坏槽窥视零副作用（字节+mtime 双比对不变+零 .corrupt.bak 改名）〔卡① sv8〕",
 		FileAccess.get_file_as_bytes(slot_tpl % 1) == bad_bytes
@@ -465,7 +465,7 @@ func _smoke_save_slots() -> void:
 	fhv2.close()
 	var hv_bytes := FileAccess.get_file_as_bytes(slot_tpl % 2)
 	var hv_mtime := FileAccess.get_modified_time(slot_tpl % 2)
-	var ph: Dictionary = pv.peek_slot_summary(2)
+	var ph: Dictionary = pv.slots.peek_slot_summary(2)
 	Kit.check("sv8 高版本槽窥视=不可读标记〔卡① sv8〕", not bool(ph.get("readable", true)))
 	Kit.check("sv8 高版本窥视零副作用（字节+mtime 不变+零改名）〔卡① sv8〕",
 		FileAccess.get_file_as_bytes(slot_tpl % 2) == hv_bytes
@@ -473,7 +473,7 @@ func _smoke_save_slots() -> void:
 
 	# ⑦ 旧单档迁移（sv12）：字节搬运+源改名留痕+幂等+他槽零触碰
 	var ml = sm_script.new()
-	ml.attach_slot_template(slot_tpl)
+	ml.slots.attach_slot_template(slot_tpl)
 	var fsrc := FileAccess.open(legacy_src, FileAccess.WRITE)
 	fsrc.store_string(JSON.stringify({"version": 7, "meta": {"keystone_balance": 1234}}))
 	fsrc.close()

game/tests/unit/core/save_slot_isolation_test.gd

@@ -39,46 +39,46 @@ func _write_v7_keystone(path: String, keystone: int) -> void:
 # ① 三槽往返：各槽写异值 → 写盘 → 新实例按位读回逐域相等；改槽 1 槽 2 字节不动（sv1）
 func _test_three_slot_roundtrip_and_isolation() -> void:
 	var t := SaveManagerScript.new()
-	t.attach_slot_template(TPL)
+	t.slots.attach_slot_template(TPL)
 	for i in range(1, 4):
-		Kit.check_quiet(t.activate_slot(i), "sv5 进档受理·槽 %d〔卡① sv5〕" % i)
-		t.add_keystone(100 * i)
-		t.apply_adventure_summary({"result": "completed", "cleared": i == 1, "levels_cleared": i,
+		Kit.check_quiet(t.slots.activate_slot(i), "sv5 进档受理·槽 %d〔卡① sv5〕" % i)
+		t.meta_state._add_keystone(100 * i)
+		t.meta_state.apply_adventure_summary({"result": "completed", "cleared": i == 1, "levels_cleared": i,
 			"stopped_at": 0, "keystone_total": 0, "master_seed": i})
 		Kit.check_quiet(t.write_to_disk(), "sv3 激活态写盘受理·槽 %d〔卡① sv1〕" % i)
 	var t2 := SaveManagerScript.new()
-	t2.attach_slot_template(TPL)
+	t2.slots.attach_slot_template(TPL)
 	for i in range(1, 4):
-		Kit.check_quiet(t2.activate_slot(i) and t2.keystone_balance() == 100 * i
-			and t2.adventure_total() == 1 and t2.adventure_cleared() == (1 if i == 1 else 0),
+		Kit.check_quiet(t2.slots.activate_slot(i) and t2.meta_state.keystone_balance() == 100 * i
+			and t2.meta_state.career_state().adventure_total == 1 and t2.meta_state.career_state().adventure_cleared == (1 if i == 1 else 0),
 			"sv1 三槽往返一致·槽 %d（异值按位读回）〔卡① sv1〕" % i)
 	var slot2_before := FileAccess.get_file_as_bytes(TPL % 2)
-	t.activate_slot(1)
-	t.add_keystone(7)
+	t.slots.activate_slot(1)
+	t.meta_state._add_keystone(7)
 	Kit.check_quiet(t.write_to_disk(), "sv3 写盘受理·槽 1 加值后〔卡① sv1〕")
 	Kit.check_quiet(FileAccess.get_file_as_bytes(TPL % 2) == slot2_before,
 		"sv1 位间隔离：改槽 1 槽 2 字节不动〔卡① sv1〕")
 	# 激活号记账：activate 槽派生名后 active_slot 同步；attach_path 注入槽名亦然
-	Kit.check_quiet(t.active_slot() == 1 and t.has_write_target(),
+	Kit.check_quiet(t.slots.active_slot() == 1 and t.slots.has_write_target(),
 		"sv1 activate 后激活号同步（active_slot=1 写盘目标在位）〔卡① sv1〕")
 
 
 # ② 高版本槽进档失败：拒绝＋恢复切换前三态（路径/激活号/数据）＋拒读槽零误写（sv9/sv10）
 func _test_activate_failure_restores_previous_slot() -> void:
 	var t := SaveManagerScript.new()
-	t.attach_slot_template(TPL)
+	t.slots.attach_slot_template(TPL)
 	_write_v7_keystone(TPL % 1, 311)
 	_write_v7_keystone(TPL % 2, 422)
 	var fhv := FileAccess.open(TPL % 3, FileAccess.WRITE)
 	fhv.store_string(JSON.stringify({"version": 99, "meta": {}}))
 	fhv.close()
-	Kit.check_quiet(t.activate_slot(1) and t.keystone_balance() == 311,
+	Kit.check_quiet(t.slots.activate_slot(1) and t.meta_state.keystone_balance() == 311,
 		"sv5 进档槽 1 读回（311）〔卡① sv10〕")
 	var slot2_before := FileAccess.get_file_as_bytes(TPL % 2)
-	Kit.check_quiet(not t.activate_slot(3), "sv9 高版本槽进档拒绝（拒读链按槽）〔卡① sv9〕")
-	Kit.check_quiet(t.active_slot() == 1 and t.has_write_target() and t.keystone_balance() == 311,
+	Kit.check_quiet(not t.slots.activate_slot(3), "sv9 高版本槽进档拒绝（拒读链按槽）〔卡① sv9〕")
+	Kit.check_quiet(t.slots.active_slot() == 1 and t.slots.has_write_target() and t.meta_state.keystone_balance() == 311,
 		"sv10 激活失败恢复切换前三态（路径/激活号/数据归槽 1）〔卡① sv10〕")
-	t.add_keystone(1)
+	t.meta_state._add_keystone(1)
 	Kit.check_quiet(t.write_to_disk(), "sv3 恢复后写盘受理〔卡① sv10〕")
 	Kit.check_quiet(FileAccess.get_file_as_bytes(TPL % 2) == slot2_before,
 		"sv10 拒读槽零误写（写盘落激活槽 1，槽 2/3 字节不动）〔卡① sv10〕")
@@ -87,17 +87,17 @@ func _test_activate_failure_restores_previous_slot() -> void:
 # ③ MetaProgression 宿主链切槽：引用同一性保持＋写盘落当前槽（sv10——禁换实例先例）
 func _test_metaprogression_reference_identity() -> void:
 	var t := SaveManagerScript.new()
-	t.attach_slot_template(TPL)
+	t.slots.attach_slot_template(TPL)
 	_write_v7_keystone(TPL % 1, 533)
 	_write_v7_keystone(TPL % 2, 644)
-	Kit.check_quiet(t.activate_slot(1), "sv5 进档槽 1〔卡① sv10〕")
+	Kit.check_quiet(t.slots.activate_slot(1), "sv5 进档槽 1〔卡① sv10〕")
 	var meta := MetaProgressionScript.new(null, t)
-	Kit.check_quiet(meta.save == t and meta.keystone_balance() == 533,
+	Kit.check_quiet(meta.save == t and meta.meta_state.keystone_balance() == 533,
 		"sv10 宿主链取数走动态分发（meta.save 同一实例、读槽 1）〔卡① sv10〕")
-	Kit.check_quiet(t.activate_slot(2) and meta.save == t and meta.keystone_balance() == 644,
+	Kit.check_quiet(t.slots.activate_slot(2) and meta.save == t and meta.meta_state.keystone_balance() == 644,
 		"sv10 切槽后引用同一性保持（零换实例）且读数随槽（644）〔卡① sv10〕")
-	meta.save.add_keystone(6)
-	Kit.check_quiet(t.write_to_disk() and t.keystone_balance() == 650,
+	meta.save.meta_state._add_keystone(6)
+	Kit.check_quiet(t.write_to_disk() and t.meta_state.keystone_balance() == 650,
 		"sv10 宿主链写盘落当前槽 2（650=644+6）〔卡① sv10〕")
 	Kit.check_quiet(int((JSON.parse_string(FileAccess.get_file_as_string(TPL % 2)) as Dictionary)\
 		.get("meta", {}).get("keystone_balance", -1)) == 650,

game/tests/unit/core/save_slot_summary_test.gd

@@ -37,20 +37,20 @@ func _write_slot_json(path: String, content: String) -> void:
 # ① 三槽异值逐槽三项正确＋不激活不写内存（sv7）
 func _test_peek_three_slots_distinct_values() -> void:
 	var t := SaveManagerScript.new()
-	t.attach_slot_template(TPL)
+	t.slots.attach_slot_template(TPL)
 	for i in range(1, 4):
 		_write_slot_json(TPL % i, JSON.stringify({"version": 7, "meta": {
 			"keystone_balance": 200 * i, "adventure_total": 5 * i, "adventure_cleared": i,
 			"tree_nodes": {}, "fork_sides": {}, "tree_struct": 2}}))
 	for i in range(1, 4):
-		var ps: Dictionary = t.peek_slot_summary(i)
+		var ps: Dictionary = t.slots.peek_slot_summary(i)
 		Kit.check_quiet(bool(ps.get("readable", false)) and int(ps.get("keystone", -1)) == 200 * i
 			and int(ps.get("cleared", -1)) == i and int(ps.get("total", -1)) == 5 * i,
 			"sv7 窥视三项逐槽正确·槽 %d（钥石/冒险成功/总局）〔卡① sv7〕" % i)
-	Kit.check_quiet(t.active_slot() == 0 and not t.has_write_target() and t.keystone_balance() == 0,
+	Kit.check_quiet(t.slots.active_slot() == 0 and not t.slots.has_write_target() and t.meta_state.keystone_balance() == 0,
 		"sv7 窥视不激活不写内存（激活号 0/无写盘目标/内存余额零）〔卡① sv7〕")
 	# 路径注入口同语义（契约 7 注入面）
-	var pinj: Dictionary = t.peek_summary_at(TPL % 2)
+	var pinj: Dictionary = t.slots.peek_summary_at(TPL % 2)
 	Kit.check_quiet(bool(pinj.get("readable", false)) and int(pinj.get("keystone", -1)) == 400,
 		"sv7 peek_summary_at 注入口同语义（槽 2 钥石 400）〔卡① sv7〕")
 
@@ -58,32 +58,32 @@ func _test_peek_three_slots_distinct_values() -> void:
 # ② 空槽零值合法态＋不可读三态显式标记（sv7/契约 9）
 func _test_peek_empty_and_unreadable_states() -> void:
 	var t := SaveManagerScript.new()
-	t.attach_slot_template(TPL)
+	t.slots.attach_slot_template(TPL)
 	DirAccess.remove_absolute(TPL % 3)   # 清①段残留——空槽夹具
-	var pe: Dictionary = t.peek_slot_summary(3)   # 槽 3 无文件=空槽
+	var pe: Dictionary = t.slots.peek_slot_summary(3)   # 槽 3 无文件=空槽
 	Kit.check_quiet(bool(pe.get("readable", false)) and int(pe.get("keystone", -1)) == 0
 		and int(pe.get("cleared", -1)) == 0 and int(pe.get("total", -1)) == 0,
 		"sv7 空槽窥视=零值合法态（可读+三项全零）〔卡① sv7〕")
 	_write_slot_json(TPL % 1, "this is not json{{{")
-	Kit.check_quiet(not bool(t.peek_slot_summary(1).get("readable", true)),
+	Kit.check_quiet(not bool(t.slots.peek_slot_summary(1).get("readable", true)),
 		"sv7 坏槽窥视=显式损坏标记〔卡① sv7〕")
 	_write_slot_json(TPL % 2, JSON.stringify({"version": 99, "meta": {}}))
-	Kit.check_quiet(not bool(t.peek_slot_summary(2).get("readable", true)),
+	Kit.check_quiet(not bool(t.slots.peek_slot_summary(2).get("readable", true)),
 		"sv7 高版本槽窥视=不可读标记〔卡① sv7〕")
 	_write_slot_json(TPL % 3, JSON.stringify({"meta": {"keystone_balance": 5}}))   # 缺版本字段
-	Kit.check_quiet(not bool(t.peek_slot_summary(3).get("readable", true)),
+	Kit.check_quiet(not bool(t.slots.peek_slot_summary(3).get("readable", true)),
 		"sv7 缺版本字段槽窥视=不可读标记〔卡① sv7/契约9〕")
 
 
 # ③ 窥视零副作用：字节+mtime 双比对不变＋零 .corrupt.bak 改名（sv8——真实入口冒烟段同判据）
 func _test_peek_zero_side_effect() -> void:
 	var t := SaveManagerScript.new()
-	t.attach_slot_template(TPL)
+	t.slots.attach_slot_template(TPL)
 	_write_slot_json(TPL % 1, "corrupt bytes {{{{")
 	var bytes_before := FileAccess.get_file_as_bytes(TPL % 1)
 	var mtime_before := FileAccess.get_modified_time(TPL % 1)
-	t.peek_slot_summary(1)
-	t.peek_summary_at(TPL % 1)
+	t.slots.peek_slot_summary(1)
+	t.slots.peek_summary_at(TPL % 1)
 	Kit.check_quiet(FileAccess.get_file_as_bytes(TPL % 1) == bytes_before
 		and FileAccess.get_modified_time(TPL % 1) == mtime_before
 		and not FileAccess.file_exists(TPL % 1 + ".corrupt.bak"),
@@ -91,7 +91,7 @@ func _test_peek_zero_side_effect() -> void:
 	_write_slot_json(TPL % 2, JSON.stringify({"version": 99, "meta": {}}))
 	var hv_bytes := FileAccess.get_file_as_bytes(TPL % 2)
 	var hv_mtime := FileAccess.get_modified_time(TPL % 2)
-	t.peek_slot_summary(2)
+	t.slots.peek_slot_summary(2)
 	Kit.check_quiet(FileAccess.get_file_as_bytes(TPL % 2) == hv_bytes
 		and FileAccess.get_modified_time(TPL % 2) == hv_mtime
 		and not FileAccess.file_exists(TPL % 2 + ".corrupt.bak"),
@@ -99,7 +99,7 @@ func _test_peek_zero_side_effect() -> void:
 	# .tmp 残留按空槽处理（契约 9）
 	DirAccess.remove_absolute(TPL % 3)   # 主文件清场——只留 .tmp 残留
 	_write_slot_json(TPL % 3 + ".tmp", "{}")
-	var pt: Dictionary = t.peek_slot_summary(3)
+	var pt: Dictionary = t.slots.peek_slot_summary(3)
 	Kit.check_quiet(bool(pt.get("readable", false)) and int(pt.get("keystone", -1)) == 0,
 		"sv8 .tmp 残留按空槽处理（主文件不在=空槽零值）〔卡① sv8〕")
 	if FileAccess.file_exists(TPL % 3 + ".tmp"):

game/tests/unit/core/settle_segments_test.gd

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

game/tests/unit/core/treasure_effects_test.gd

@@ -40,7 +40,7 @@ func _init() -> void:
 	# 反例=未装配零命中
 	var rng1b = load("res://core/rng_service.gd").new(); rng1b.set_master_seed(222)
 	var ob1b = orch_s.new(db, rng1b)
-	Kit.check_quiet(ob1b.begin_battle({"level_index": 1, "node_depth": 0, "hero_hp": int(db.hero.max_hp)}) and ob1b.attune_param_sum("light_radius_bonus") == 0,
+	Kit.check_quiet(ob1b.begin_battle({"level_index": 1, "node_depth": 0, "hero_hp": int(db.combat.hero.max_hp)}) and ob1b.attune_param_sum("light_radius_bonus") == 0,
 		"空装配基线复用：未装配件参数读数 0")
 	var hits_none = ob1b.fx_host().engine.dispatch(ob1b.fx_host().counters_ctx, "round_start", {"round_index": 1})
 	Kit.check_quiet(_ap_of(hits_none) == 0, "晨操令反例：未装配首轮零命中（订阅行随装配集装载）")
@@ -48,7 +48,7 @@ func _init() -> void:
 	# ② 双管装填（前 2 轮各 +1 / 第 3 轮零）
 	var rng2 = load("res://core/rng_service.gd").new(); rng2.set_master_seed(231)
 	var ob2 = orch_s.new(db, rng2)
-	Kit.check_quiet(ob2.begin_battle({"level_index": 1, "node_depth": 0, "hero_hp": int(db.hero.max_hp), "attunement": ["twin_loader"]}),
+	Kit.check_quiet(ob2.begin_battle({"level_index": 1, "node_depth": 0, "hero_hp": int(db.combat.hero.max_hp), "attunement": ["twin_loader"]}),
 		"双管装填：装配起战")
 	Kit.check_quiet(_ap_of(ob2.fx_host().engine.dispatch(ob2.fx_host().counters_ctx, "round_start", {"round_index": 1})) == 1
 		and _ap_of(ob2.fx_host().engine.dispatch(ob2.fx_host().counters_ctx, "round_start", {"round_index": 2})) == 1,
@@ -59,7 +59,7 @@ func _init() -> void:
 	# ③ 阔视野带（参数读数=4 / 未装配=0——注入面消费在呈现桥 T4）
 	var rng3 = load("res://core/rng_service.gd").new(); rng3.set_master_seed(241)
 	var ob3 = orch_s.new(db, rng3)
-	Kit.check_quiet(ob3.begin_battle({"level_index": 1, "node_depth": 0, "hero_hp": int(db.hero.max_hp), "attunement": ["wide_scout_band"]}),
+	Kit.check_quiet(ob3.begin_battle({"level_index": 1, "node_depth": 0, "hero_hp": int(db.combat.hero.max_hp), "attunement": ["wide_scout_band"]}),
 		"阔视野带：装配起战")
 	Kit.check_quiet(ob3.attune_param_sum("light_radius_bonus") == 4,
 		"阔视野带：参数读数 4（8→12 格=+4 provisional；只扩参数不揭安危）")
@@ -69,7 +69,7 @@ func _init() -> void:
 	# ④ 试炼镐（积点受理闸：未达拒/达点兑付 AP+1/未装配拒）
 	var rng4 = load("res://core/rng_service.gd").new(); rng4.set_master_seed(251)
 	var ob4 = orch_s.new(db, rng4)
-	Kit.check_quiet(ob4.begin_battle({"level_index": 1, "node_depth": 0, "hero_hp": int(db.hero.max_hp), "attunement": ["trial_pick"]}),
+	Kit.check_quiet(ob4.begin_battle({"level_index": 1, "node_depth": 0, "hero_hp": int(db.combat.hero.max_hp), "attunement": ["trial_pick"]}),
 		"试炼镐：装配起战")
 	# 自动兑付：无玩家入口——揭示缓冲点即时计数，满 charge_n 自动
 	# grant_ap（cell_revealed 先于本格扣费→AP 归零恰逢满点时先兑再扣、轮不结束）。直调揭示处理器
@@ -88,9 +88,9 @@ func _init() -> void:
 		"试炼镐读数口：兑付后进度归零（8 取余）、阈值=charge_n、C 区浮窗数据源")
 	var rng4b = load("res://core/rng_service.gd").new(); rng4b.set_master_seed(252)
 	var ob4b = orch_s.new(db, rng4b)
-	ob4b.begin_battle({"level_index": 1, "node_depth": 0, "hero_hp": int(db.hero.max_hp)})
+	ob4b.begin_battle({"level_index": 1, "node_depth": 0, "hero_hp": int(db.combat.hero.max_hp)})
 	ob4b._on_cell_revealed({"kind": "safe", "cell": Vector2i(0, 0)})
-	var ap_base := int(db.action_economy.ap_per_round)
+	var ap_base := int(db.run.action_economy.ap_per_round)
 	Kit.check_quiet(int(ob4b.action_economy.ap) == ap_base and not bool(ob4b.attune_convert_state().get("assembled", true)),
 		"试炼镐反例：未装配零兑付零计数（AP=整轮表值、读数口 assembled=false）")
 
@@ -98,7 +98,7 @@ func _init() -> void:
 	# 展示行=C 区悬停浮窗进度唯一承载：handle=-1 非库存句柄+note 进度；空骑库存桩直构投影链）
 	var rng4c = load("res://core/rng_service.gd").new(); rng4c.set_master_seed(253)
 	var ob4c = orch_s.new(db, rng4c)
-	ob4c.begin_battle({"level_index": 1, "node_depth": 0, "hero_hp": int(db.hero.max_hp), "attunement": ["trial_pick"]})
+	ob4c.begin_battle({"level_index": 1, "node_depth": 0, "hero_hp": int(db.combat.hero.max_hp), "attunement": ["trial_pick"]})
 	var ctrl4 = load("res://presentation/treasure_interact_controller.gd").new({
 		"db": db, "meta": null, "info_panel": null, "toast": null, "board_view": null,
 		"settlement_get": func(): return ob4c, "runner_get": func(): return StubAutoInvRunner.new(),
@@ -126,19 +126,19 @@ func _init() -> void:
 
 	# ⑥ 储备罐（转存率 125=1.25:1 整除口径 / 100=1:1 逐位同旧）
 	var ae6 = load("res://core/action_economy.gd").new(db)
-	ae6.queue_ap_delta(4 - int(db.action_economy.ap_per_round))   # 排队修正到测试口径 4 AP（notify_round_start 兑现）
+	ae6.queue_ap_delta(4 - int(db.run.action_economy.ap_per_round))   # 排队修正到测试口径 4 AP（notify_round_start 兑现）
 	ae6.notify_round_start()
 	ae6.request_stop()
 	ae6.finish_round_stop(false, 100)
 	Kit.check_quiet(ae6.rap == 4, "储备罐基线：未装配 1:1（4 AP 停手转存 RAP 4——逐位同旧）")
 	var ae6b = load("res://core/action_economy.gd").new(db)
-	ae6b.queue_ap_delta(4 - int(db.action_economy.ap_per_round))
+	ae6b.queue_ap_delta(4 - int(db.run.action_economy.ap_per_round))
 	ae6b.notify_round_start()
 	ae6b.request_stop()
 	ae6b.finish_round_stop(false, 125)
 	Kit.check_quiet(ae6b.rap == 5, "储备罐正常：125% 转存（4 AP→RAP 5=1.25:1 整除口径；不碰 AP 上限）")
 	var ae6c = load("res://core/action_economy.gd").new(db)
-	ae6c.queue_ap_delta(3 - int(db.action_economy.ap_per_round))
+	ae6c.queue_ap_delta(3 - int(db.run.action_economy.ap_per_round))
 	ae6c.notify_round_start()
 	ae6c.request_stop()
 	ae6c.finish_round_stop(false, 125)
@@ -147,7 +147,7 @@ func _init() -> void:
 	# ⑦ 巢穴预告（装板后一次报数量——明细行经 step_row 信号收集）
 	var rng7 = load("res://core/rng_service.gd").new(); rng7.set_master_seed(271)
 	var ob7 = orch_s.new(db, rng7)
-	Kit.check_quiet(ob7.begin_battle({"level_index": 1, "node_depth": 0, "hero_hp": int(db.hero.max_hp), "attunement": ["nest_forecast"]}),
+	Kit.check_quiet(ob7.begin_battle({"level_index": 1, "node_depth": 0, "hero_hp": int(db.combat.hero.max_hp), "attunement": ["nest_forecast"]}),
 		"巢穴预告：装配起战（board_installed 发射）")
 	var total7: int = ob7.minesweeper.mine_total()
 	Kit.check_quiet(total7 > 0 and int(ob7.nest_preview_count) == total7,
@@ -158,7 +158,7 @@ func _init() -> void:
 	# ⑧ 线香（真视单格 cell 目标 / 每战一次战斗级限量）
 	var rng8 = load("res://core/rng_service.gd").new(); rng8.set_master_seed(281)
 	var ob8 = orch_s.new(db, rng8)
-	Kit.check_quiet(ob8.begin_battle({"level_index": 1, "node_depth": 0, "hero_hp": int(db.hero.max_hp), "attunement": ["incense_stick"]}),
+	Kit.check_quiet(ob8.begin_battle({"level_index": 1, "node_depth": 0, "hero_hp": int(db.combat.hero.max_hp), "attunement": ["incense_stick"]}),
 		"线香：装配起战（battle 级充能 1）")
 	var inv8 = load("res://core/treasure_items.gd").new(db)
 	var rec8: Dictionary = inv8.add_item("incense_stick", "attunement", Vector2i(-1, -1), 0)
@@ -177,7 +177,7 @@ func _init() -> void:
 	# ⑨ 远程镐（挖掘距离放宽 +1 / 不挖开不相邻事实）
 	var rng9 = load("res://core/rng_service.gd").new(); rng9.set_master_seed(291)
 	var ob9 = orch_s.new(db, rng9)
-	Kit.check_quiet(ob9.begin_battle({"level_index": 1, "node_depth": 0, "hero_hp": int(db.hero.max_hp), "attunement": ["ranged_pick"]}),
+	Kit.check_quiet(ob9.begin_battle({"level_index": 1, "node_depth": 0, "hero_hp": int(db.combat.hero.max_hp), "attunement": ["ranged_pick"]}),
 		"远程镐：装配起战（dig_range_bonus 注入）")
 	# 夹具：初始展开稳态下出生 d2 环全开（剃雷域收窄 r=1=出生 5×5 恰为 d≤2）——把英雄语境推进到
 	# 「已开区前沿格」（其 d2 环含未开格最多的已开格），测试直写 _hero（夹具惯例）
@@ -226,17 +226,17 @@ func _init() -> void:
 
 	# ⑩ 刷新执照（商店免费刷新 +2/店——读数叠加）
 	var lv10 = load("res://core/level_runner.gd").new(db, load("res://core/rng_service.gd").new())
-	Kit.check_quiet(int(lv10.shop_refresh_free_left()) == int(db.adventure.shop_refresh_free),
-		"刷新执照基线：未装配=表值（%d）" % int(db.adventure.shop_refresh_free))
+	Kit.check_quiet(int(lv10.shop_refresh_free_left()) == int(db.run.adventure.shop_refresh_free),
+		"刷新执照基线：未装配=表值（%d）" % int(db.run.adventure.shop_refresh_free))
 	lv10 = load("res://core/level_runner.gd").new(db, load("res://core/rng_service.gd").new(),
 		{"attunement": ["refresh_license"]})   # 构造注入（拆件批 T3——setter 群退役）
-	Kit.check_quiet(int(lv10.shop_refresh_free_left()) == int(db.adventure.shop_refresh_free) + 2,
+	Kit.check_quiet(int(lv10.shop_refresh_free_left()) == int(db.run.adventure.shop_refresh_free) + 2,
 		"刷新执照正常：免费刷新 +2/店（读数即本店可用——进店重置生命周期同 knob）")
 
 	# ⑪ 天眼（3×3 真视+安全格直开/危险格不开/封印格跳过）
 	var rng11 = load("res://core/rng_service.gd").new(); rng11.set_master_seed(301)
 	var ob11 = orch_s.new(db, rng11)
-	Kit.check_quiet(ob11.begin_battle({"level_index": 1, "node_depth": 0, "hero_hp": int(db.hero.max_hp), "attunement": ["sky_eye"]}),
+	Kit.check_quiet(ob11.begin_battle({"level_index": 1, "node_depth": 0, "hero_hp": int(db.combat.hero.max_hp), "attunement": ["sky_eye"]}),
 		"天眼：装配起战（level 级充能 1）")
 	var inv11 = load("res://core/treasure_items.gd").new(db)
 	var rec11: Dictionary = inv11.add_item("sky_eye", "attunement", Vector2i(-1, -1), 0)
@@ -265,7 +265,7 @@ func _init() -> void:
 	# ⑫ 信标网络（封印不限相邻/封印价照付）
 	var rng12 = load("res://core/rng_service.gd").new(); rng12.set_master_seed(311)
 	var ob12 = orch_s.new(db, rng12)
-	Kit.check_quiet(ob12.begin_battle({"level_index": 1, "node_depth": 0, "hero_hp": int(db.hero.max_hp), "attunement": ["beacon_network"]}),
+	Kit.check_quiet(ob12.begin_battle({"level_index": 1, "node_depth": 0, "hero_hp": int(db.combat.hero.max_hp), "attunement": ["beacon_network"]}),
 		"信标网络：装配起战（seal_range_free 注入）")
 	var far12: Vector2i = _cell_at(ob12, ob12.minesweeper.hero_pos() + Vector2i(4, 4))
 	if far12 != Vector2i(-9, -9):
@@ -277,7 +277,7 @@ func _init() -> void:
 		"信标网络正常：封印可达豁免在册（封印仍按标准动作价计费=try_spend 照走）")
 	var rng12b = load("res://core/rng_service.gd").new(); rng12b.set_master_seed(312)
 	var ob12b = orch_s.new(db, rng12b)
-	ob12b.begin_battle({"level_index": 1, "node_depth": 0, "hero_hp": int(db.hero.max_hp)})
+	ob12b.begin_battle({"level_index": 1, "node_depth": 0, "hero_hp": int(db.combat.hero.max_hp)})
 	Kit.check_quiet(ob12b.minesweeper.seal_range_free == false,
 		"信标网络反例：未装配封印可达豁免=缺省 false（零装配零扰动）")
 
@@ -285,7 +285,7 @@ func _init() -> void:
 	var rng13 = load("res://core/rng_service.gd").new(); rng13.set_master_seed(321)
 	var ob13 = orch_s.new(db, rng13)
 	var lg13 = load("res://core/gain_journal.gd").new()
-	Kit.check_quiet(ob13.begin_battle({"level_index": 1, "node_depth": 0, "hero_hp": int(db.hero.max_hp), "attunement": ["incense_stick"], "journal": lg13}),
+	Kit.check_quiet(ob13.begin_battle({"level_index": 1, "node_depth": 0, "hero_hp": int(db.combat.hero.max_hp), "attunement": ["incense_stick"], "journal": lg13}),
 		"计数链：装配起战（GainJournal 携带）")
 	var inv13 = load("res://core/treasure_items.gd").new(db)
 	var rec13: Dictionary = inv13.add_item("incense_stick", "attunement", Vector2i(-1, -1), 0)

game/tests/unit/core/tree_requires_level_test.gd

@@ -53,7 +53,7 @@ func _init() -> void:
 	var mp = load("res://core/meta_progression.gd").new(db, sv)
 	mt.rows = [base_pre.duplicate(true), base_dep.duplicate(true)]
 	db.set("meta_tree", mt)
-	sv.set_tree_level("gate_pre", 1)
+	sv.meta_state.set_tree_level("gate_pre", 1)
 	if mp.tree_can_buy("gate_dep"):
 		failures += 1
 		print("[r1] FAIL 前置 Lv1 < 阈值 2 应拒购")
@@ -62,18 +62,18 @@ func _init() -> void:
 		failures += 1
 		print("[r1] FAIL 无 requires_level 行判定不受机制位影响")
 	# ⑦ 判定面：达标开放
-	sv.set_tree_level("gate_pre", 2)
+	sv.meta_state.set_tree_level("gate_pre", 2)
 	if not mp.tree_can_buy("gate_dep"):
 		failures += 1
 		print("[r1] FAIL 前置 Lv2 达阈值应可购")
 	# ⑧ 投影：gate_text 未达标拼门槛文案、达标清空
-	sv.set_tree_level("gate_pre", 1)
-	var gate: String = mp.tree_gate_text("gate_dep")
+	sv.meta_state.set_tree_level("gate_pre", 1)
+	var gate: String = mp._tree_gate_text("gate_dep")
 	if gate != "需 门槛前置 Lv2":
 		failures += 1
 		print("[r1] FAIL 未达标 gate_text 应=「需 门槛前置 Lv2」实得「%s」" % gate)
-	sv.set_tree_level("gate_pre", 2)
-	if mp.tree_gate_text("gate_dep") != "":
+	sv.meta_state.set_tree_level("gate_pre", 2)
+	if mp._tree_gate_text("gate_dep") != "":
 		failures += 1
 		print("[r1] FAIL 达标后 gate_text 应为空串")
 	if failures == 0: