Merge branch 'master' into iter38

# Conflicts:
#	game/README.md
#	game/tests/验证集清单.md

game/tests/unit/core/adventure_feats_test.gd

@@ -99,11 +99,11 @@ func _api_mark_node(_node: Dictionary, _info: Dictionary, seq: Array) -> void:
 	seq.append("node_entered")
 
 
-# ③ 冒险验收断言（映射 冒险结构.md 验收标准——表覆盖/满配通关/种子复现/大奖励/败北线/
+# ③ 冒险验收断言（映射 冒险结构.md 验收标准——表覆盖/满配冒险成功/种子复现/大奖励/败北线/
 # 重复拒绝/GP 跨关延续/加算区同账/恢复数学/放弃）
 
 
-# ③ 冒险验收断言（映射 冒险结构.md 验收标准——表覆盖/满配通关/种子复现/大奖励/败北线/
+# ③ 冒险验收断言（映射 冒险结构.md 验收标准——表覆盖/满配冒险成功/种子复现/大奖励/败北线/
 # 重复拒绝/GP 跨关延续/加算区同账/恢复数学/放弃）
 func _smoke_adventure() -> void:
 	print("--- 冒险结构验收（三关序列 · 大奖励 · 摘要五件事 · 账本封闭）---")
@@ -129,11 +129,11 @@ func _smoke_adventure() -> void:
 			cov_miss += 1
 	Kit.check("生成图每个战斗/Boss 节点经解析链命中敌行集与棋盘行（扫描 %d 节点，缺失 %d）〔fv24〕" % [cov_scan, cov_miss],
 		cov_scan > 0 and cov_miss == 0)
-	# ② 满配通关 + ④ 三层奖励兑付（三选一恰 2 次 · 回血封顶 · 钥石逐杀 · 候选零重复）
+	# ② 满配冒险成功 + ④ 三层奖励兑付（三选一恰 2 次 · 回血封顶 · 钥石逐杀 · 候选零重复）
 	var st: Dictionary = autoplay.run_adventure(_db, 42, 900, 400)
 	var sum: Dictionary = st["summary"]
-	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)
+	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))
@@ -151,7 +151,7 @@ func _smoke_adventure() -> void:
 			node_picks += 1   # 奖励节点三选一（每关奖励节点各 1 次）
 		elif (ev as Dictionary).has("curio_resolved"):
 			resolves.append((ev as Dictionary)["curio_resolved"])
-	Kit.check("通关三选一恰呈现 2 次、恰兑付 2 次（L1/L2 后——末关不发；resolves 含节点回执另计）", picks.size() == 2 and resolves.size() == 2 + node_picks)
+	Kit.check("关卡完成三选一恰呈现 2 次、恰兑付 2 次（L1/L2 后——末关不发；resolves 含节点回执另计）", picks.size() == 2 and resolves.size() == 2 + node_picks)
 	# 奖励节点在生成图里是可选路位（旧单链模板的「L1 必经 1 个」形状前提随模板消亡）——
 	# 接线证明拆两半：图侧每关含 ≥1 奖励节点，行进侧种子扫描内确有经停（扫描零经停=三选一接线不可达）
 	var reward_levels := 0
@@ -242,7 +242,7 @@ func _smoke_adventure() -> void:
 			if rk == "max_hp":
 				hp_acc += int(r.get("value", max_flat))
 	Kit.check("三选一候选 2–3 枚且零重复（令牌洗牌不放回——kind+tier 复合身份）", cand_ok)
-	Kit.check("通关部分回血封顶（floor(观测上限×比例) 封顶——购血观测值精确断言，核代码增补）", heal_ok)
+	Kit.check("关卡完成部分回血封顶（floor(观测上限×比例) 封顶——购血观测值精确断言，核代码增补）", heal_ok)
 	Kit.check("钥石逐杀入账（首杀档位 + 累计逐位）", ks_gain_ok)
 	Kit.check("点选恰兑付选中一件（值=令牌档位表值；未选项零生效）", resolve_ok)
 	var seq: Array = st["encounter_max_hp_seq"]
@@ -271,7 +271,7 @@ func _smoke_adventure() -> void:
 	Kit.check("零配 L1 败北种子可达（seed=%s）" % str(lose.get("s", -1)), not lose.is_empty())
 	if not lose.is_empty():
 		var sl: Dictionary = lose["st"]["summary"]
-		Kit.check("L1 败北摘要：未打穿 · 通关 0 关 · 钥石 0 · 止步第 1 层",
+		Kit.check("L1 败北摘要：未打穿 · 完成 0 关 · 钥石 0 · 止步第 1 层",
 		not bool(sl["cleared"]) and int(sl["levels_cleared"]) == 0 \
 				and int(sl["keystone_total"]) == 0 and int(sl["stopped_at"]) == 1)
 		var dl: Dictionary = sl.get("defeat", {})
@@ -351,8 +351,8 @@ func _smoke_adventure() -> void:
 		var acc_shop := int(a8.run_ledger.bonus.get("max_hp", -1))   # L1 三选一后 + 商店 3（首件随种子）
 		Kit.check("统一冒险加算区含商店值（max_hp=%d ≥ 商店 3——L1 三选一件值另计）" % acc_shop, acc_shop >= 3)
 		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 通关三选一停点在案（直调兑付前——零自动推进）", not a8._curio_pending.is_empty())
+			"node_id": r8.current_node_id(), "node_type": "shop"})   # 模拟 L2 关卡完成（victory 载荷直调——非末关）
+		Kit.check("L2 关卡完成三选一停点在案（直调兑付前——零自动推进）", not a8._curio_pending.is_empty())
 		Kit.check("未兑付推进拒绝（选择停点零自动推进契约）", not a8.continue_to_next_level())
 		var l2_cands: Array = a8._curio_pending["candidates"]
 		var l2_pick: Dictionary = l2_cands[0]
@@ -361,7 +361,7 @@ func _smoke_adventure() -> void:
 		var expect_acc: int = acc_shop + (int(a8._curio_result.get("value", 0)) if picked2 == "max_hp" else 0)
 		Kit.check("三选一属性件与商店购买同账累加（max_hp=%d = %d + 三选一%s）" % [int(a8.run_ledger.bonus.get("max_hp", -1)), acc_shop, picked2], int(a8.run_ledger.bonus.get("max_hp", -1)) == expect_acc)
 		var max_eff8: int = a8.effective_max_hp()   # 账本生效上限含调试浮窗 pct（a8 已 set 400）
-		Kit.check("通关部分回血封顶（hp %d ≤ 生效上限 %d——血回满语义退役）" % [int(a8.ledger["hero_hp"]), max_eff8], int(a8.ledger["hero_hp"]) <= max_eff8)
+		Kit.check("关卡完成部分回血封顶（hp %d ≤ 生效上限 %d——血回满语义退役）" % [int(a8.ledger["hero_hp"]), max_eff8], int(a8.ledger["hero_hp"]) <= max_eff8)
 		Kit.check("兑付后推进受理（下一关开始）", a8.continue_to_next_level())
 	# ⑨ 恢复点数学（接口③封顶公式三读数 + 同式两落点一致）
 	var a9 = load("res://core/adventure_runner.gd").new(_db, _fresh_rng(99))
@@ -406,7 +406,7 @@ func _smoke_adventure() -> void:
 				treasure_seen = true
 				break
 	Kit.check("池收缩——40 次重抽零 aux 候选（停点渠道 aux 卡退役，迭代 11 第①批 T7）", not treasure_seen)
-	# 满血回 0 合法（通关回血封顶口径）
+	# 满血回 0 合法（关卡完成回血封顶口径）
 	var a12 = load("res://core/adventure_runner.gd").new(_db, _fresh_rng(12))
 	a12.start_adventure(12)
 	var cap := {"payload": {}}
@@ -414,7 +414,7 @@ func _smoke_adventure() -> void:
 	var max_full := int(_db.hero.max_hp) + int(a12._base_override.get("max_hp", 0))
 	a12.ledger["hero_hp"] = max_full
 	a12._on_level_finished({"result": "victory", "hp": max_full, "node_index": 1, "node_id": 1, "node_type": "shop"})
-	Kit.check("满血通关回血 0 合法（封顶口径——heal_gained=0 非负溢出）", int(cap["payload"].get("heal_gained", -1)) == 0)
+	Kit.check("满血关卡完成回血 0 合法（封顶口径——heal_gained=0 非负溢出）", int(cap["payload"].get("heal_gained", -1)) == 0)
 	# ⑬ 奖励节点共享池（同库同池同摘牌；TP0：attack 令牌耗尽后节点域同样零出现）
 	var a13 = load("res://core/adventure_runner.gd").new(_db, _fresh_rng(13))
 	Kit.check("节点共享池场景：冒险启动（seed 13）", a13.start_adventure(13, {"treasure_unlocked": {"wide_scout_band": true}}))
@@ -509,7 +509,7 @@ func _smoke_feats() -> void:
 		if String((t as Dictionary).get("kind", "")) == "relic":
 			deck_relic += 1
 	Kit.check("专长带入池：5 行 relic 每件 1 张（四级 rarity 直映射）——牌库 102+5=107", deck_relic == 5 and a_r._curio_deck.size() == 107)
-	# 渠道白名单断言（渠道轴定位：通关渠道只出专长/节点渠道零专长）
+	# 渠道白名单断言（渠道轴定位：关卡完成渠道只出专长/节点渠道零专长）
 	var feat_seen: Dictionary = {}
 	var node_relic_seen := false
 	for i in 60:
@@ -519,7 +519,7 @@ func _smoke_feats() -> void:
 		for t in a_r._draw_curio_candidates("reward_node"):
 			if String((t as Dictionary).get("kind", "")) == "relic":
 				node_relic_seen = true
-	Kit.check("通关渠道只出专长（60 次重抽 ≥2 种不同 relic——身份键 feat_id 同档可多件）", feat_seen.size() >= 2)
+	Kit.check("关卡完成渠道只出专长（60 次重抽 ≥2 种不同 relic——身份键 feat_id 同档可多件）", feat_seen.size() >= 2)
 	Kit.check("节点渠道零专长（60 次重抽零 relic——专长在非 Boss 渠道只以专长凭证形态出现）", not node_relic_seen)
 	# T5 专长凭证行为断言（A5 拿到即开 / A6 保底计数——契约④四口径；独立 runner 防污染 a_r 牌库）
 	var a_t = load("res://core/adventure_runner.gd").new(_db, _fresh_rng(91))

game/tests/unit/core/breakpoint_resume_test.gd

@@ -96,7 +96,7 @@ func _init() -> void:
 	adr_e._curio_taken["attack"] = 1   # 白盒预置计数（断点附随件往返的判据面——计数不可由加算区反推）
 	adr_e._on_level_finished({"result": "victory", "hp": 30, "node_index": 1, "node_id": 1, "node_type": "shop"})
 	var cands_e: Array = (adr_e._curio_pending.get("candidates", []) as Array).duplicate()
-	Kit.check_quiet(not cands_e.is_empty(), "P5 非末关通关三选一停点在案（直调 victory——L1 非末关）")
+	Kit.check_quiet(not cands_e.is_empty(), "P5 非末关的关卡完成三选一停点在案（直调 victory——L1 非末关）")
 	var sm_f = SaveManagerScript.new(_bp_path)
 	Kit.check_quiet(sm_f.load_from_disk() and sm_f.has_breakpoint(), "P5 选择停点断点在档（选择停点可中断契约）")
 	var bp_f: Dictionary = sm_f.breakpoint_snapshot()

game/tests/unit/core/curio_refresh_paid_test.gd

@@ -23,9 +23,9 @@ func _init() -> void:
 	Kit.check_quiet(adr.curio_stop_pending() == false, "无停点=在途谓词 false")
 	Kit.check_quiet(adr.refresh_curio() == false and adr.refresh_curio_paid() == false, "无停点：免费/付费刷新皆拒绝零副作用")
 
-	# ---- ② 免费位优先序 X→Y（白盒造通关停点——smoke_all ⑫ 同构）----
+	# ---- ② 免费位优先序 X→Y（白盒造关卡完成停点——smoke_all ⑫ 同构）----
 	adr._curio_pending = {"candidates": _cands(), "payload": {}}
-	Kit.check_quiet(adr.curio_stop_pending() == true, "通关停点在途=谓词 true")
+	Kit.check_quiet(adr.curio_stop_pending() == true, "关卡完成停点在途=谓词 true")
 	adr._attune_refresh_x = 1
 	adr._attune_refresh_y = 2
 	Kit.check_quiet(adr.refresh_curio() and adr._attune_refresh_x == 0 and adr._attune_refresh_y == 2, "X 优先消耗（x1y2→x0y2）")

game/tests/unit/core/level_shop_economy_test.gd

@@ -1,6 +1,6 @@
 # tests/unit/core/level_shop_economy_test.gd — 关卡图与 GP 商店单元测试宿主
 # 断言面 = 七套（批 B 断言迁移自 smoke_all.gd，G8 施工组）：
-#   关卡节点图·生成图推进（满配通关/恢复点公式/败北线/回放确定性/属性覆盖恢复）
+#   关卡节点图·生成图推进（满配冒险成功/恢复点公式/败北线/回放确定性/属性覆盖恢复）
 #   分支节点图（图校验正反/L2·L3 行进与行集定点/混编运行面/真图类型可见性）
 #   GP 冒险钱包·到账（掷定窗口/关级加值）
 #   escrow 隔离（格面兑付入缓冲/破财直验/钱包钳制不透支）
@@ -323,15 +323,15 @@ func _smoke_generated_coverage() -> void:
 # ---- 关卡节点图·生成图推进冒烟（图 = 该关参数档 × 种子）----
 
 func _smoke_level() -> void:
-	print("--- 关卡节点图·生成图推进（参数档×种子产图·满配通关/恢复公式/败北线/回放确定性）---")
+	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 nodes1: Array = _level_active_nodes(1)
 	var params1: Dictionary = _db.level_gen_params_row(1)
 	Kit.check("L1 现行起关图取数非空（种子 %d × 参数档 → 节点 %d 颗）" % [ACTIVE_GRAPH_SEED, nodes1.size()], not nodes1.is_empty())
-	# ① 满配通关路径（atk+200%/hp+100%——测试面板同源的属性覆盖）
+	# ① 满配冒险成功路径（atk+200%/hp+100%——测试面板同源的属性覆盖）
 	var win = autoplay.run_level(_db, ACTIVE_GRAPH_SEED, 1, 200, 100)
-	Kit.check("关卡·满配（atk+200/hp+100）通关（实测：%s @节点 %d）" % [win.result, win.defeat_node_index], win.result == "victory")
+	Kit.check("关卡·满配（atk+200/hp+100）完成（实测：%s @节点 %d）" % [win.result, win.defeat_node_index], win.result == "victory")
 	# 行进面读数与图读数自洽：路径逐跳为图出边，路径上战斗/Boss 计数 = battles 读数
 	var by_id1 := _nodes_by_id(nodes1)
 	var path_battles := 0
@@ -339,10 +339,10 @@ func _smoke_level() -> void:
 		var vkind := String(by_id1.get(int(vid), {}).get("type", ""))
 		if vkind == "battle" or vkind == "boss":
 			path_battles += 1
-	Kit.check("L1 通关路径逐跳为图出边（入口起步·末节点无出边——句柄轴行进自洽）", _path_in_graph(nodes1, win.visited_ids))
-	Kit.check("L1 通关路径战斗/Boss 节点数 = 行进 battles 读数（路径 %d 节点·战斗 %d 颗·battles %d）" % [win.visited_ids.size(), path_battles, int(win.battles)],
+	Kit.check("L1 关卡完成路径逐跳为图出边（入口起步·末节点无出边——句柄轴行进自洽）", _path_in_graph(nodes1, win.visited_ids))
+	Kit.check("L1 关卡完成路径战斗/Boss 节点数 = 行进 battles 读数（路径 %d 节点·战斗 %d 颗·battles %d）" % [win.visited_ids.size(), path_battles, int(win.battles)],
 		path_battles == int(win.battles) and path_battles >= 2)
-	# 终点恒落最长路径步数：Boss 深度 = 参数档层高，且通关路径末节点即该终点
+	# 终点恒落最长路径步数：Boss 深度 = 参数档层高，且关卡完成路径末节点即该终点
 	var boss_depth1 := -1
 	for n in nodes1:
 		if String(n.get("type", "")) == "boss":
@@ -350,7 +350,7 @@ func _smoke_level() -> void:
 	var last_id := -1
 	if win.visited_ids.size() > 0:
 		last_id = int(win.visited_ids[win.visited_ids.size() - 1])
-	Kit.check("L1 终点 Boss 深度 = 参数档层高 %d 且通关路径末节点落该深度（实测终点深度 %d·末句柄 %d）" % [int(params1.get("layers", -1)), boss_depth1, last_id],
+	Kit.check("L1 终点 Boss 深度 = 参数档层高 %d 且关卡完成路径末节点落该深度（实测终点深度 %d·末句柄 %d）" % [int(params1.get("layers", -1)), boss_depth1, last_id],
 		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)
@@ -371,7 +371,7 @@ func _smoke_level() -> void:
 		else:
 			Kit.check("恢复点公式·缺口不足档：回复封顶到缺口 2（实测 %d，比例项 %d）" % [int(rest_narrow["healed"]), expect_pct],
 				int(rest_narrow["healed"]) == mini(expect_pct, 2) and expect_pct > 2)
-	# ③ 裸装败北路径（atk1/hp10——Roguelike 基线应难以通关）
+	# ③ 裸装败北路径（atk1/hp10——Roguelike 基线应难以完成）
 	var lose = autoplay.run_level(_db, ACTIVE_GRAPH_SEED, 1, -80, -80)
 	Kit.check("关卡·裸装（atk≈1/hp≈10）败北路径可达（实测：%s）" % lose.result, lose.result == "defeat")
 	Kit.check("败北节点记录在域内（节点 %d，图节点数 %d）" % [lose.defeat_node_index, nodes1.size()],
@@ -488,7 +488,7 @@ func _smoke_level_graph() -> void:
 	Kit.check("图校验拒绝：非 Boss 终点（终点恒为 Boss）〔v1〕", _has_err_category(LT.validate_graph(orphan), "structural"))
 	# ④ L2 选路推进：min / max 双路径全通（确定性路径轴——同种子同图，方向轴只换候选取值）
 	var win_min: Dictionary = autoplay.run_level(_db, ACTIVE_GRAPH_SEED, 2, 200, 100, false, null, "normal", "min")
-	Kit.check("L2·满配 min 路径通关（实测：%s）" % win_min.result, win_min.result == "victory")
+	Kit.check("L2·满配 min 路径完成（实测：%s）" % win_min.result, win_min.result == "victory")
 	var n2_last := -1
 	if win_min.visited_ids.size() > 0:
 		n2_last = int(win_min.visited_ids[win_min.visited_ids.size() - 1])
@@ -501,7 +501,7 @@ func _smoke_level_graph() -> void:
 		_path_shop_count(nodes2, win_min.visited_ids) == 1)
 	Kit.check("选路口发生 %d 次（每节点兑付后——零自动推进）" % win_min.choices, win_min.choices >= 3)
 	var win_max: Dictionary = autoplay.run_level(_db, ACTIVE_GRAPH_SEED, 2, 200, 100, false, null, "normal", "max")
-	Kit.check("L2·满配 max 路径（候选取最大句柄）通关（实测：%s·路径 %s）" % [win_max.result, str(win_max.visited_ids)], win_max.result == "victory")
+	Kit.check("L2·满配 max 路径（候选取最大句柄）完成（实测：%s·路径 %s）" % [win_max.result, str(win_max.visited_ids)], win_max.result == "victory")
 	var n2_last_max := -1
 	if win_max.visited_ids.size() > 0:
 		n2_last_max = int(win_max.visited_ids[win_max.visited_ids.size() - 1])
@@ -973,7 +973,7 @@ func _smoke_shop_room() -> void:
 	var shop_run := {}
 	for s in range(42, 92):
 		var r0 = load("res://core/level_runner.gd").new(_db, _fresh_rng(s))
-		r0.set_hero_override(900, 400)   # 行进段快速通关档（购买断言与百分比轴正交——加算区单独断言）
+		r0.set_hero_override(900, 400)   # 行进段快速完成档（购买断言与百分比轴正交——加算区单独断言）
 		r0.start_level(2, s)
 		var st := _battle_st("normal")
 		var guard := 60

game/tests/unit/core/meta_progression_forge_test.gd

@@ -159,7 +159,7 @@ func _meta_settle_and_workshop() -> void:
 	var row1: Dictionary = _db.meta_boss_keystone_row(1)
 	var row2: Dictionary = _db.meta_boss_keystone_row(2)
 	# ⑥ 逐杀掉落收束入账（掉落已在冒险内逐杀入账〔summary.keystone_total 含全部〕，
-	# keystone_drops 明细随摘要归档；首杀标记仍由 apply 逐通关关次置位）
+	# keystone_drops 明细随摘要归档；首杀标记仍由 apply 逐关卡完成关次置位）
 	var d1: Dictionary = mp.settle_adventure({"result": "failed", "cleared": false, "levels_cleared": 1,
 		"stopped_at": 2, "keystone_total": int(row1.get("first_kill", 0)),
 		"keystone_drops": [{"level": 1, "first": true, "amount": int(row1.get("first_kill", 0))}],
@@ -186,21 +186,21 @@ func _meta_settle_and_workshop() -> void:
 		"master_seed": 13})
 	Kit.check("重复杀第三轮恒定不递减（验收5——无衰减曲线）",
 		not bool(d3["boss_drops"][0].get("first", true)) and int(d3["boss_drops"][0].get("amount", 0)) == int(row1.get("repeat_kill", -1)))
-	# 混合归因：通关两关 → L1 重复 + L2 首杀（明细随摘要逐笔归档）
+	# 混合归因：完成两关 → L1 重复 + L2 首杀（明细随摘要逐笔归档）
 	var d4: Dictionary = mp.settle_adventure({"result": "failed", "cleared": false, "levels_cleared": 2,
 		"stopped_at": 0, "keystone_total": int(row1.get("repeat_kill", 0)) + int(row2.get("first_kill", 0)),
 		"keystone_drops": [{"level": 1, "first": false, "amount": int(row1.get("repeat_kill", 0))},
 			{"level": 2, "first": true, "amount": int(row2.get("first_kill", 0))}],
 		"master_seed": 14})
-	Kit.check("两关通关逐关归因：L1 重复档 + L2 首杀档（first_kill 金额）",
+	Kit.check("两关完成逐关归因：L1 重复档 + L2 首杀档（first_kill 金额）",
 		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 不变
+	# ⑦ 败北零关卡完成摘要：余额只增不减（零入账）、clear_counts 不变
 	var bal_before: int = sv.keystone_balance()
 	var cc1_before: int = sv.clear_count(1)
 	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 不变）",
+	Kit.check("败北零关卡完成摘要：零入账零标记（钥石只增不减——验收1；败北局 clear_counts 不变）",
 		dz["boss_drops"].is_empty() and sv.keystone_balance() == bal_before and sv.clear_count(1) == cc1_before)
 	# ⑧ 秘宝解锁服务（V3 钥石购买/V4 条件解锁；注入=直调解锁写口+直置存档生涯计数，
 	# 不走正常资源积累流程——卡片 7.1 测试方式）
@@ -217,10 +217,10 @@ func _meta_settle_and_workshop() -> void:
 		and sv_u.keystone_balance() == 0)
 	Kit.check("已解锁重复购买拒绝〔秘宝批 V3〕",
 		not mp_u.buy_treasure_unlock("morning_order"))
-	Kit.check("条件未达不解锁（远程镐=通关 1 次）〔秘宝批 V4〕",
+	Kit.check("条件未达不解锁（远程镐=冒险成功 1 次）〔秘宝批 V4〕",
 		mp_u.refresh_treasure_unlocks().is_empty() and not sv_u.item_unlocked("ranged_pick"))
 	sv_u._data["meta"]["adventure_cleared"] = 1   # 直置存档生涯计数（调试注入口径）
-	Kit.check("远程镐=adventure_cleared≥1 达标恰解锁一次+重复刷新幂等（C6：通关=打通整局冒险）〔秘宝批 V4〕",
+	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())
 	sv_u._data["meta"]["boss_kill_count"] = 3
@@ -230,7 +230,7 @@ func _meta_settle_and_workshop() -> void:
 	Kit.check("天眼单条件不足不解锁（AND 语义——cleared 3 达 boss 4 未达）〔秘宝批 V4〕",
 		not sv_u.item_unlocked("sky_eye"))
 	sv_u._data["meta"]["boss_kill_count"] = 4
-	Kit.check("天眼双条件 AND（通关≥3 且 Boss≥4）达标解锁〔秘宝批 V4〕",
+	Kit.check("天眼双条件 AND（冒险成功≥3 且 Boss≥4）达标解锁〔秘宝批 V4〕",
 		(mp_u.refresh_treasure_unlocks() as Array).has("sky_eye"))
 	sv_u._data["meta"]["vision_used"] = 10
 	Kit.check("信标网络=真视类工具累计使用≥10（行为计数新域——use_treasure 受理成功累计）〔秘宝批 V4〕",
@@ -267,7 +267,7 @@ func _meta_settle_and_workshop() -> void:
 		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〕",
+	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)
 	Kit.check("树上点亮同调位 1 → Slots=1（槽位收编树节点——Q2 裁甲）",

game/tests/unit/core/save_boot_no_activate_test.gd

@@ -27,7 +27,7 @@ func _test_no_arg_instance_has_no_activation() -> void:
 		"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,
-		"sv2 内存=默认合法空态（钥石/断点/总局数/通关数全零值——访问器 fail-safe）〔卡① sv2〕")
+		"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,

game/tests/unit/core/save_manager_domain_test.gd

@@ -78,11 +78,11 @@ func _smoke_save() -> void:
 	w.unlock_item("probe_compass")
 	w.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）",
+	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)
-	Kit.check("首杀标记随通关关卡置位（1/2 有、3 无）",
+	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))
-	Kit.check("生涯终身计数随 apply 自增恰一（中止局：总局数 1、通关局数 0——迭代 18 卡④）",
+	Kit.check("生涯终身计数随 apply 自增恰一（中止局：总局数 1、冒险成功局数 0——迭代 18 卡④）",
 		w.adventure_total() == 1 and w.adventure_cleared() == 0)
 	Kit.check("写盘成功", w.write_to_disk())
 	var r = sm_script.new(paths[0])
@@ -95,7 +95,7 @@ func _smoke_save() -> void:
 		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)
+	Kit.check("关卡完成次数表往返相等", r.clear_count(1) == 1 and r.clear_count(2) == 1 and r.clear_count(3) == 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)
@@ -265,11 +265,11 @@ func _smoke_save() -> void:
 	f13b.load_from_disk()
 	f13b.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）",
+	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,
 		"stopped_at": 2, "keystone_total": 0, "master_seed": 2})
-	Kit.check("收束自增恰一·中止局（放弃局：仅总局数+1，通关局数不动）",
+	Kit.check("收束自增恰一·中止局（放弃局：仅总局数+1，冒险成功局数不动）",
 		f13b.adventure_total() == 2 and f13b.adventure_cleared() == 1)
 
 	# ⑮ 旧档破坏性废弃（契约 4：换代前结构检测=树域废弃重置，禁迁移禁折算）〔V16〕
@@ -321,11 +321,11 @@ func _smoke_save() -> void:
 	var mp13 = load("res://core/meta_progression.gd").new(_db, f13b)
 	mp13.settle_adventure({"result": "failed", "cleared": false, "levels_cleared": 2,
 		"stopped_at": 3, "keystone_total": 0, "master_seed": 3})
-	Kit.check("收束链自增·中止局（settle_adventure 真实挂点：总局数+1、通关局数不动）",
+	Kit.check("收束链自增·中止局（settle_adventure 真实挂点：总局数+1、冒险成功局数不动）",
 		f13b.adventure_total() == 3 and f13b.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——全链恰一）",
+	Kit.check("收束链自增·冒险成功局（三关全通：总局数+1 且冒险成功局数+1——全链恰一）",
 		f13b.adventure_total() == 4 and f13b.adventure_cleared() == 2)
 
 	# 段尾清理（测试文件绝不残留）

game/tests/unit/core/save_slot_summary_test.gd

@@ -46,7 +46,7 @@ func _test_peek_three_slots_distinct_values() -> void:
 		var ps: Dictionary = t.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)
+			"sv7 窥视三项逐槽正确·槽 %d（钥石/冒险成功/总局）〔卡① sv7〕" % i)
 	Kit.check_quiet(t.active_slot() == 0 and not t.has_write_target() and t.keystone_balance() == 0,
 		"sv7 窥视不激活不写内存（激活号 0/无写盘目标/内存余额零）〔卡① sv7〕")
 	# 路径注入口同语义（契约 7 注入面）