iter56-卡2：封印动作改版(迭代56卡2·受理即揭示): 规则核心(target_sealed挖封印格拒/清图口径=挖开∪封印/能清图的封最优先/notify_cleared清图收轮/sealed_identity撤出→BoardData.cell_identity——上限20用户裁)+结算面dug_under_seal删净+破封一击退役+呈现层(地板+身份字形+印记不依赖揭示态+文案四件)+探针V8-V10+sim域(标空封印剔除约束增强+错触直挖补偿注入0.10)+golden三图换代; MC同批重锚50/档=100局(2026-11-08用户批准)三方对照无结构性恶化; 高档审计通过(17行全量·审计后勘误2项闭环)

game/core/action_economy.gd

@@ -142,6 +142,15 @@ func _spend_cost_and_arbitrate(cost: int, clears_map: bool) -> bool:
 	return true
 
 
+# 封印路径清图事实上报（排雷玩法 _do_seal_place 受理后清图判定成立时调用）：
+# 轮末仲裁与 request_dig 的 cleared 语义同源——剩余 AP 当场清零作废、不进 RAP（EC7/EC10），
+# 同帧 cleared > ap_exhausted 胜出（覆盖写 _last_round_end）。封印不产挖掘计费，
+# 清图事实经独立上报口进入仲裁（硬塞 request_dig 会引入假挖掘记账）。
+func notify_cleared() -> void:
+	_ap = 0
+	_finish_round("cleared", "new_board")
+
+
 func _spend_and_arbitrate(action_kind: String, clears_map: bool) -> bool:
 	var cost := _cost(action_kind)
 	if _ap < cost:

game/core/board_data.gd

@@ -43,6 +43,14 @@ func is_safe(c: Vector2i) -> bool:
 func digit_of(c: Vector2i) -> int:
 	return digits.get(c, -1)
 
+## 格身份事实（封闭枚举）：kind = "mine"（digit 恒 -1）| "safe"（digit = 邻雷数）。
+## 封印受理即揭示的消费形态 = 呈现/测量侧按封印态（MinesweeperRules.has_seal）取本读数拼装——
+## 身份事实单点在板数据（is_mine/digit_of 同源），禁消费方各自拼 kind 枚举。
+func cell_identity(c: Vector2i) -> Dictionary:
+	if is_mine(c):
+		return {"kind": "mine", "digit": -1}
+	return {"kind": "safe", "digit": digit_of(c)}
+
 
 func variant_ids(c: Vector2i) -> Array:
 	return variants.get(c, [])

game/core/effect_engine.gd

@@ -52,12 +52,12 @@ const EFFECT_KINDS := ["add_ticket_rider", "modify_ticket", "damage_mult", "open
 
 ## fact 条件词汇（封闭枚举——payload 同名键直读面〔fact 取值序 payload
 ## 优先——effect_engine._fact_value 既有机制〕。new_resource_type=首开资源类型〔地质学家〕；
-## is_edge_cell=边缘格〔边陲矿工〕；is_blank_zero=空白连锁〔跳格采掘〕；dug_under_seal=被挖格
-## 当时有封印〔破封一击〕；ap_exhausted_last=上轮 AP 耗尽〔一滴不剩〕；hp_ratio=生命比例〔背水
+## is_edge_cell=边缘格〔边陲矿工〕；is_blank_zero=空白连锁〔跳格采掘〕；ap_exhausted_last=上轮
+## AP 耗尽〔一滴不剩〕；hp_ratio=生命比例〔背水
 ## 06 前置条兑付〕；amount=单次伤害量〔保险丝〕；ap_left=停手剩余 AP〔弃图兑换〕）
 const FACTS := ["matchup", "is_first_dig_of_battle", "terrain_kind", "target_armor_class",
 	"seals_count", "nest_count", "round_index", "counter",
-	"new_resource_type", "is_edge_cell", "is_blank_zero", "dug_under_seal",
+	"new_resource_type", "is_edge_cell", "is_blank_zero",
 	"ap_exhausted_last", "hp_ratio", "amount", "ap_left", "pct",
 	"battle_index"]   # 关卡域战斗序（1 基，enc 携带；开局姿态组「每关首轮窗」条件面）
 

game/core/minesweeper_rules.gd

@@ -8,8 +8,7 @@ extends RefCounted
 ## 揭示事实流：每格首次进入已开集恰发一次（已开格零事件）。
 ## 载荷键集（四处发射位并集）：cell: Vector2i／kind: "safe"|"mine"／digit: int（安全格邻雷数；危险格 -1）／
 ## variant_ids: Array（地形变异身份，危险格空集）／channel: "initial"|"dig"|"chain"|"fx_reveal"／
-## resource: bool（格面资源兑付资格：initial=false，其余 true）／dug_under_seal: bool（首格带封印直挖标记——
-## initial 通道不发此键）。
+## resource: bool（格面资源兑付资格：initial=false，其余 true）。
 ## 发送时点：initial=install_board 初始展开逐格；dig/chain=_do_dig 揭示闭包内（本格 AP 扣费在其后）；
 ## fx_reveal=fx_reveal 闭包内（零 AP 消耗零相位要求）。
 ## 消费方依赖：战斗结算 _on_cell_revealed 以 resource 分流缓冲（fx_reveal 由兑付点直入账，禁二次缓冲）、
@@ -94,14 +93,16 @@ func has_seal(c: Vector2i) -> bool:
 	return _seals.has(c)
 
 
+
 func revealed_cells() -> Array:
 	return _revealed.keys()
 
 
 func _safe_remaining() -> int:
+	# 清图口径 = 已挖 ∪ 已封印（封印受理即揭示改版——封掉的安全格计入完成）
 	var n := 0
 	for c in _board.safe_cells():
-		if not _revealed.has(c):
+		if not _revealed.has(c) and not _seals.has(c):
 			n += 1
 	return n
 
@@ -266,25 +267,41 @@ func settle_batch(intents: Array) -> Array:
 
 func _classify(intent: Dictionary) -> int:
 	# 0 = C_dig（执行后清图——真模拟，禁计数器捷径）；1 = C_stop；2 = C_other
+	# 清图口径 = 已挖 ∪ 已封印（封印受理即揭示改版——「能清图的挖或封」同归最先类）
 	if intent.get("action", "") == "dig":
 		var c: Vector2i = intent.get("cell", Vector2i(-9, -9))
 		if _board_face_dig(c) == "" and not _board.is_mine(c):
-			# 模拟 Chain(O, c) 后清图判定——挖封印格同口径：本格封印视为已隐式退役（其余封印照挡）
-			var sim_seals: Dictionary[Variant, Variant] = _seals.duplicate()
-			sim_seals.erase(c)
-			var chain := _chain_closure(c, sim_seals)   # 与真实执行同口径——空封印集捷径会在封印挡连锁时误判 C_dig（排雷玩法：真模拟）
+			# 模拟 Chain(O, c) 后清图判定——真模拟禁计数器捷径（连锁不越封印，真封印集口径）
+			var chain := _chain_closure(c, _seals)
 			var remaining := 0
 			for sc in _board.safe_cells():
-				if not _revealed.has(sc) and not chain.has(sc):
+				if not _revealed.has(sc) and not chain.has(sc) and not _seals.has(sc):
 					remaining += 1
 			if remaining == 0:
 				return 0
 		return 2
+	if intent.get("action", "") == "seal_place":
+		return _classify_seal(intent.get("cell", Vector2i(-9, -9)))
 	if intent.get("action", "") == "stop":
 		return 1
 	return 2
 
 
+# 封印意图的清图预判分类（批次语义序「能清图的封」取数面——受理合法性模拟与清图口径模拟）
+func _classify_seal(c: Vector2i) -> int:
+	if not _board.in_bounds(c) or is_revealed(c) or has_seal(c) or _removed.has(c):
+		return 2
+	if _board.is_mine(c):
+		return 2   # 封危险格不清图（封印受理即揭示——身份当场可见但安全格分母不减）
+	# 模拟封印受理后清图判定（换装口径：安全格完成 = 已揭示 ∪ 已封印）
+	var sim_seals: Dictionary[Variant, Variant] = _seals.duplicate()
+	sim_seals[c] = true
+	for sc in _board.safe_cells():
+		if not _revealed.has(sc) and not sim_seals.has(sc):
+			return 2
+	return 0
+
+
 func _execute(intent: Dictionary) -> Dictionary:
 	match intent.get("action", ""):
 		"dig":
@@ -305,16 +322,8 @@ func _do_dig(c: Vector2i) -> Dictionary:
 	var sub := _board_face_dig(c)
 	if sub != "":
 		return _outcome(false, "rejected", "board_face", sub)
-	# 挖封印格（封印不可逆）：本格封印事务内隐式退役——链闭包按「本格无封印、其余封印照挡」
-	# 计算（封印格为 0 时连锁照常外扩）；request_dig 被拒则封印原地保留（事务性），受理后该封印轮末不判
-	# （发射面基线 = 在场封印——标中/标空兑付让位于挖掘本体结局，四情况②④）。
-	var was_sealed := has_seal(c)
-	var eff_seals: Dictionary[Variant, Variant] = _seals
-	if was_sealed:
-		eff_seals = _seals.duplicate()
-		eff_seals.erase(c)
-	# 真模拟连锁与清图（F2/F1——单一实现两名字）
-	var chain := _chain_closure(c, eff_seals)
+	# 真模拟连锁与清图（F2/F1——单一实现两名字；连锁不越封印，挖封印格已被合法性表拒绝）
+	var chain := _chain_closure(c, _seals)
 	var clears: bool = _cleared_after(chain)
 	# F2 口径：chain_size = |O′ ∖ (O ∪ {c})|——闭包含已开集 O，只数新开格（不含首格）
 	var chain_size := 0
@@ -325,10 +334,8 @@ func _do_dig(c: Vector2i) -> Dictionary:
 	if not action_economy.request_dig(chain_size, clears):
 		return _outcome(false, "rejected", "resource_face", "")
 	# 事务内执行：首格 + 连锁新格揭示（BFS 规范序，零特判）；事件 = O′ ∖ O
-	if was_sealed:
-		_seals.erase(c)
-	var reveal_order: Array[Variant] = _chain_reveal_order(c, eff_seals)
-	_reveal_chain(c, reveal_order, was_sealed)
+	var reveal_order: Array[Variant] = _chain_reveal_order(c, _seals)
+	_reveal_chain(c, reveal_order)
 	if action_economy.phase != action_economy.PHASE_ACTIVE:
 		_emit_round_end_seals_and_payload()
 	return _outcome(true, "executed", "", "")
@@ -337,8 +344,7 @@ func _do_dig(c: Vector2i) -> Dictionary:
 ## 连锁揭示域：首格+连锁新格揭示（BFS 规范序——cell_revealed 发射序即链序，整体随段搬迁）。
 ## 格面资源资格：chain/dig 恒 true——安全格与危险格一视同仁（危险格亦携带，
 ## 负向兑付归 战斗结算 极性路由）；initial（封锁格）恒 false。资源本体与极性不在本系统。
-## dug_under_seal = 首格带封印直挖标记（战斗结算 情况④兑付改判消费；连锁格恒 false——连锁不越封印）
-func _reveal_chain(c: Vector2i, reveal_order: Array, was_sealed: bool) -> void:
+func _reveal_chain(c: Vector2i, reveal_order: Array) -> void:
 	for rc in reveal_order:
 		if _revealed.has(rc):
 			continue   # 闭包可穿过已开区——已开格零事件（cell_revealed × |O′ ∖ O|）
@@ -348,14 +354,12 @@ func _reveal_chain(c: Vector2i, reveal_order: Array, was_sealed: bool) -> void:
 			cell_revealed.emit({
 				"cell": rc, "kind": "mine", "digit": -1,
 				"variant_ids": [], "channel": channel, "resource": true,
-				"dug_under_seal": was_sealed and rc == c,
 			})
 		else:
 			_revealed[rc] = {"kind": "safe", "digit": _board.digit_of(rc)}
 			cell_revealed.emit({
 				"cell": rc, "kind": "safe", "digit": _board.digit_of(rc),
 				"variant_ids": _board.variant_ids(rc), "channel": channel, "resource": true,
-				"dug_under_seal": was_sealed and rc == c,
 			})
 
 
@@ -366,9 +370,10 @@ func _board_face_dig(c: Vector2i) -> String:
 		return "not_adjacent"
 	if is_revealed(c):
 		return "target_revealed"
+	if has_seal(c):
+		return "target_sealed"   # 封印受理即揭示、不可再挖开（封印承诺 = 对该格的最终处置——改判路径已退役）
 	if _removed.has(c):
 		return "target_removed"   # 中立移除格不可交互（拒绝先于消耗，pattern 1 board_face 腿）
-	# 封印不拦挖掘（封印不可逆）：有封印格直接挖 = 对承诺的兑现，兑付改判归 战斗结算。
 	return ""
 
 
@@ -387,17 +392,14 @@ func fx_reveal(c: Vector2i) -> bool:
 		cell_revealed.emit({
 			"cell": rc, "kind": "safe", "digit": _board.digit_of(rc),
 			"variant_ids": _board.variant_ids(rc), "channel": "fx_reveal", "resource": true,
-			"dug_under_seal": false,
 		})
 	return true
 
 
-## 挖一格→真实翻开集只读预览（sim 信息面出口——与 _classify 同口径：本格封印视为已隐式退役、
-## 其余封印照挡；复用 _chain_closure 闭包；零状态写入、零事件发射）
+## 挖一格→真实翻开集只读预览（sim 信息面出口——与 _classify 同口径：连锁不越封印、
+## 真封印集口径；复用 _chain_closure 闭包；零状态写入、零事件发射）
 func preview_reveal(c: Vector2i) -> Array[Vector2i]:
-	var sim_seals := _seals.duplicate()
-	sim_seals.erase(c)
-	var closure := _chain_closure(c, sim_seals)
+	var closure := _chain_closure(c, _seals)
 	var out: Array[Vector2i] = []
 	for cc in closure.keys():
 		if cc != c and not _revealed.has(cc):
@@ -436,34 +438,44 @@ func _chain_reveal_order(start: Vector2i, seal_set: Dictionary) -> Array:
 
 
 func _cleared_after(chain: Dictionary) -> bool:
+	# 清图口径 = 已挖 ∪ 已封印（与 _safe_remaining 同源——私有共享口径单点，禁第三处重复实现）
 	for c in _board.safe_cells():
-		if not _revealed.has(c) and not chain.has(c):
+		if not _revealed.has(c) and not chain.has(c) and not _seals.has(c):
 			return false
 	return true
 
 
 # ---- 封印 ----
 
-func _do_seal_place(c: Vector2i) -> Dictionary:
-	var sub := ""
+# 封印棋盘面合法性（board_face 拒绝情形序：目录外/不相邻/已开/已有封印/已移除——与挖掘合法性同构分域）
+func _seal_face_reject(c: Vector2i) -> String:
 	if not _board.in_bounds(c):
-		sub = "out_of_catalog"
-	elif not (seal_range_free or _adjacent_to_hero(c)):
-		sub = "not_adjacent"   # 信标网络装配时豁免（封印不限相邻——封印动作仍按标准价计费，规则放宽仅可达性）
-	elif is_revealed(c):
-		sub = "target_revealed"
-	elif has_seal(c):
-		sub = "seal_present"
-	elif _removed.has(c):
-		sub = "target_removed"   # 中立移除格不可交互
+		return "out_of_catalog"
+	if not (seal_range_free or _adjacent_to_hero(c)):
+		return "not_adjacent"   # 信标网络装配时豁免（封印不限相邻——封印动作仍按标准价计费，规则放宽仅可达性）
+	if is_revealed(c):
+		return "target_revealed"
+	if has_seal(c):
+		return "seal_present"
+	if _removed.has(c):
+		return "target_removed"   # 中立移除格不可交互
+	return ""
+
+
+func _do_seal_place(c: Vector2i) -> Dictionary:
+	var sub := _seal_face_reject(c)
 	if sub != "":
 		return _outcome(false, "rejected", "board_face", sub)
 	if not action_economy.try_spend("seal_place"):
 		return _outcome(false, "rejected", "resource_face", "")
 	_seals[c] = true   # 封印动作零格子事件外发（发射面封闭；反馈经调用返回值命令式驱动）
+	if _cleared_after({}):
+		# 封印受理即揭示改版：封掉最后安全格 = 清图完成——轮末仲裁走 cleared（行动经济
+		# notify_cleared 独立上报口，与 request_dig 的 cleared 语义同源；同帧覆盖 ap_exhausted）
+		action_economy.notify_cleared()
 	if action_economy.phase != action_economy.PHASE_ACTIVE:
 		# 封印动作花完末点 AP 同样终结轮次（行动经济 三出口——AP 用完与动作种类无关；缺漏使 round_end
-		# 永不发出、战斗结算 的 Waiting 结算点永不到达 = 整局软锁）
+		# 永不发出、战斗结算 的 Waiting 结算点永不到达 = 整局软锁）；清图收轮同此出口发判定批
 		_emit_round_end_seals_and_payload()
 	return _outcome(true, "executed", "", "")
 

game/core/reward_grant.gd

@@ -172,7 +172,7 @@ func _safe_dig_open(v: Dictionary) -> Dictionary:
 	for c_v in v.resolved:
 		var c := Vector2i(c_v)
 		if fx_host.minesweeper.has_seal(c):
-			continue
+			continue   # 封印格不代开（封印受理即揭示——天眼揭示绕开承诺格，零动作）
 		if fx_host.minesweeper.fx_reveal(c):
 			opened_any = true
 	if not opened_any:

game/core/settlement/grant_segment.gd

@@ -93,15 +93,12 @@ func _reveal_batch(ri: int) -> void:
 			_reveal_mine(evt, snap, ri)
 
 
-# safe 事件兑付（封印不可逆四情况④：插安全格再挖开 = 零惩罚零奖励——正向兑付作废〔归因行在案〕；
-# 标空判定已随封印擦除自然缺席——被挖的封印不在轮末在场基线。dig_reveal 发射+施加序：
+# safe 事件兑付（封印受理即揭示改版：挖封印格已被规则合法性表拒绝——改判路径整体退役，
+# 本函数只受理真实揭示的 safe 事件。dig_reveal 发射+施加序：
 # 乘区收集 → 正向兑付 → 施加面〔计数器/揭示入队/追加产出/奥术矢〕。
 # payload 携 is_edge_cell〔边陲矿工〕/is_blank_zero〔跳格采掘〕/
 # new_resource_type〔地质学家——快照 cell_type 首见判定，见后集登记〕）
 func _reveal_safe(evt: Dictionary, snap: Dictionary, ri: int) -> void:
-	if bool(evt.get("dug_under_seal", false)):
-		emit_row_cb.call({"type": "reward_ineffective", "source_class": "safe_cell", "origin_cell": evt.cell}, ri, "奖励作废（封印格直接挖开——零惩罚零奖励）", 0, {})
-		return
 	var board_b: BoardData = minesweeper.current_board()
 	var ctype := String(snap.get("cell_type", ""))
 	var is_new_type := fx_host.mark_new_resource_type(ctype)
@@ -145,12 +142,12 @@ func _reveal_safe_apply(dr_hits: Array, evt: Dictionary, ri: int) -> void:
 
 
 # mine 事件兑付（封印不可逆四情况②：插危险格再挖开 = 只受挖雷一层惩罚——mine_hit 照常兑付惊动巢穴，
-# 标中不发〔封印已随挖掘擦除、不入轮末判定基线〕。mine_hit 发射+施加序：施加面收集 → 减伤落快照 →
+# mine_hit 发射+施加序：施加面收集 → 减伤落快照 →
 # 计数器 → 揭示入队 → 负向兑付〔带减半系数〕→ 反打开单）
 func _reveal_mine(evt: Dictionary, snap: Dictionary, ri: int) -> void:
 	var mine_power := int(snap.get("power", 0))
 	var mh_hits := fx_host.fx_emit("mine_hit", {"cell": evt.cell, "round": ri,
-		"damage": mine_power, "dug_under_seal": bool(evt.get("dug_under_seal", false)),
+		"damage": mine_power,
 		"hp_ratio": int(round(100.0 * float(int(units.hero_unit().get("hp", 0))) / float(maxi(1, int(units.hero_unit().get("max_hp", 1))))))})
 	var applied := _reveal_mine_apply(mh_hits, snap, evt.cell, ri)
 	if int(applied["mine_reduce"]) > 0:
@@ -201,8 +198,8 @@ func _reveal_mine_apply(mh_hits: Array, snap: Dictionary, cell: Vector2i, ri: in
 
 # 地形变异 兑付批（授予段尾——触发枚举 on_open：挖开即伤、chain 通道同口径；伤害单据案C 暂存到
 # 战斗段末兑付〔案C〕；信息型 hide_number 不进结算——呈现层读取，见 board_view 数字遮蔽；
-# 危险格恒无变异——布置段排除，双层叠罚不存在；封印格直挖照吃变异伤害——地形后果同 mine_hit 口径，
-# 非奖励不作废；吞噬流资源兑付〔荆棘编织/地脉补偿〕中伤害形态行同样经案C闸暂存，非伤害形态照常当场）
+# 危险格恒无变异——布置段排除，双层叠罚不存在；封印格不可挖（封印受理即揭示——变异伤害只随
+# 真实揭示兑付）；吞噬流资源兑付〔荆棘编织/地脉补偿〕中伤害形态行同样经案C闸暂存，非伤害形态照常当场）
 func _terrain_batch(ri: int) -> void:
 	for evt in facts.reveals:
 		var vids: Array[Variant] = evt.get("variant_ids", [])

game/data/tables/feats.tres

@@ -619,30 +619,6 @@ rows = [
    }
   ]
  },
- {
-  "feat_id": "breaker_strike",
-  "display_name": "破封一击",
-  "rarity": "excellent",
-  "cap": 1,
-  "desc": "挖开带封印的危险格：+1 层（疼痛记忆同账）",
-  "triggers": [
-   {
-    "on": "mine_hit",
-    "when": [
-     {
-      "fact": "dug_under_seal",
-      "op": "eq",
-      "value": true
-     }
-    ],
-    "do": {
-     "kind": "counter_add",
-     "counter_id": "pain_layers",
-     "value": 1
-    }
-   }
-  ]
- },
  {
   "feat_id": "map_exchange",
   "display_name": "弃图兑换",

game/presentation/hud_presenter.gd

@@ -176,7 +176,8 @@ static func outcome_text(outcome: Dictionary) -> String:
 				"not_adjacent": "不能执行：目标与小人不相邻",
 				"target_revealed": "不能执行：目标已开",
 				"target_concealed": "不能移动：目标未开",
-				"seal_present": "不能封印：此格已有封印印记（封印为一次性承诺——相邻时左键直接挖开）",
+				"target_sealed": "不能挖：此格已封印（封印受理即揭示——不可再挖开）",
+				"seal_present": "不能封印：此格已有封印印记（封印受理即揭示——印记随图存续）",
 				"no_path": "不能移动：已探明区不连通",
 				"out_of_catalog": "无效目标",
 			}

game/presentation/views/board_hover.gd

@@ -108,7 +108,7 @@ func _apply_hover_visuals(c: Vector2i) -> void:
 		_show_path_preview(c)
 	elif adjacent:
 		u.face.hl_visible = true
-		u.face.hl_color = COL_HL_TARGET   # 挖掘目标格边框（相邻封印格同此——左键直接挖）
+		u.face.hl_color = COL_HL_TARGET   # 挖掘目标格边框（已封印格不入 _diggable——落下方封印禁入分支）
 		_set_cursor_shape(c, CURSOR_DIG)
 	elif seal:
 		u.face.hl_visible = true

game/presentation/views/board_view.gd

@@ -300,8 +300,8 @@ func refresh() -> void:
 	var hero: Vector2i = _minesweeper.hero_pos()
 	_diggable.clear()
 	for n in _board.neighbors8(hero):
-		if not _minesweeper.is_revealed(n) and not _minesweeper.is_removed(n):
-			_diggable[n] = true
+		if not _minesweeper.is_revealed(n) and not _minesweeper.is_removed(n) and not _minesweeper.has_seal(n):
+			_diggable[n] = true   # 已封印格不入可挖域（封印受理即揭示——挖封印格被拒）
 	_recompute_glow(hero)
 	for y in _board.height:
 		for x in _board.width:
@@ -474,14 +474,15 @@ func _on_cell_input(c: Vector2i, ev: InputEvent) -> void:
 	if ev.button_index == MOUSE_BUTTON_LEFT:
 		if _minesweeper.is_revealed(c):
 			action_requested.emit(c, "move")
+		elif _minesweeper.has_seal(c):
+			pass   # 已封印格零动作（封印受理即揭示——挖封印格被拒，左右键同零意图）
 		else:
 			action_requested.emit(c, "dig")
 		_hover_comp.detect_chord(c)
 	elif ev.button_index == MOUSE_BUTTON_RIGHT:
 		if not _minesweeper.has_seal(c):
 			action_requested.emit(c, "seal_place")
-		# 封印 = 一次性承诺：右键对封印格零动作（无撤封印）；
-		# 左键相邻封印格直接挖（规则引擎放行）。
+		# 封印 = 受理即揭示的最终承诺：右键对封印格零动作（无撤封印），左键同零动作。
 
 
 # ---- 奖励徽章（已开格身份 icon——封印之下、纹带之上、不进数字区） ----
@@ -536,20 +537,22 @@ func _paint_cell(c: Vector2i, hero: Vector2i) -> void:
 	var seal: bool = _minesweeper.has_seal(c)
 	var removed: bool = _minesweeper.is_removed(c)   # 中立移除格（退色降档）
 	var is_hero: bool = c == hero
-	# 封印印记下发（卡④ 法阵化）：封印格=未开且未移除 → CellUnit 封印子件绘制（着色器参数化）；
-	# 其余格撤子件。层序与迷雾门控在 CellUnit 侧承载（seal_mark_layer/fog_state 联动）。
-	u.seal_on = seal and not revealed
+	# 封印印记下发（卡④ 法阵化＋封印受理即揭示改版）：封印格（未移除）→ CellUnit 封印子件绘制
+	# （着色器参数化）——印记可见性不依赖揭示态（已揭示格承载=新组合态）；其余格撤子件。
+	# 层序与迷雾门控在 CellUnit 侧承载（seal_mark_layer/fog_state 联动）。
+	u.seal_on = seal
 	if removed:
 		revealed = false   # 移除格固定未开呈现基座（退色暗幕层承载；危险格本无数字，周边数字冻结）
 		seal = false
 		u.seal_on = false
 	# 绘制层五段（字形与色牌→基底瓦片→立面投影→秘宝/变异叠加→迷雾）——段间交换经单元状态面
 	#（u.base/u.face 域件与 u.glyph/u.glyph_color），唯一例外=基底色 bg 经 ink 段返回值交 base 段（无单元场域承载）
+	var shown: bool = revealed or seal   # 呈现揭示态（封印受理即揭示——地板瓦片/身份字形/迷雾开启）
 	var bg: Color = _paint_cell_ink(c, u, revealed, seal)
-	_paint_cell_base(c, u, revealed, is_hero, bg)
-	_paint_cell_facade(c, u, revealed)
+	_paint_cell_base(c, u, shown, is_hero, bg)
+	_paint_cell_facade(c, u, shown)
 	_paint_cell_overlays(c, u, revealed)
-	_paint_cell_fog(c, u, revealed, hero)
+	_paint_cell_fog(c, u, shown, hero)
 	u.face.removed_dim = removed
 	u.queue_redraw()
 
@@ -575,11 +578,19 @@ func _paint_cell_ink(c: Vector2i, u: Node2D, revealed: bool, seal: bool) -> Colo
 				else:
 					glyph = str(d)
 					digit_col = _digit_ink(d)   # 数字墨三档色温（§4.1）
+	elif seal:
+		# 封印受理即揭示：身份字形按板事实当场可见（cell_identity 单点——不用等轮末判定；
+		# 数字遮蔽不适用——遮蔽打脸受理即揭示）。
+		bg = COL_FLOOR
+		var ident: Dictionary = _board.cell_identity(c)
+		if String(ident.get("kind", "")) == "mine":
+			glyph = "危"
+			digit_col = UiKit.RED_MINE
+		elif int(ident.get("digit", 0)) > 0:
+			glyph = str(int(ident.get("digit", 0)))
+			digit_col = _digit_ink(int(ident.get("digit", 0)))
 	else:
-		if seal:
-			bg = COL_BRICK   # 封印印记由 CellUnit 封印子件绘制（卡④ 法阵化——缺图字形回退随贴图路径退役）
-		else:
-			bg = COL_BRICK
+		bg = COL_BRICK
 	u.glyph = glyph
 	u.glyph_color = digit_col
 	# 色牌后备（数字直画退牌；「危」/「?」维持牌载保读性）+ v3.4：双峰纹理板
@@ -588,7 +599,7 @@ func _paint_cell_ink(c: Vector2i, u: Node2D, revealed: bool, seal: bool) -> Colo
 	if plate_digit:
 		digit_col = COL_DIGIT   # 牌上深墨族（素牌 12:1——双峰纹理免疫）
 	u.glyph_color = digit_col
-	u.plate = revealed and (glyph == "危" or glyph == "?" or plate_digit)
+	u.plate = (revealed or seal) and (glyph == "危" or glyph == "?" or plate_digit)
 	return bg
 
 

game/presentation/views/board_zone_view.gd

@@ -77,7 +77,7 @@ func _build_board_children(board_area: Control, vb: VBoxContainer) -> void:
 	hint.size_flags_horizontal = Control.SIZE_SHRINK_CENTER
 	hint.mouse_filter = Control.MOUSE_FILTER_IGNORE
 	vb.add_child(hint)
-	var hl := UiKit.label("左键 挖掘 / 移动 · 右键 封印（不可逆） · 同格双击 快开",UiKit.FS_CAPTION, false, UiKit.WARM_FAINT)
+	var hl := UiKit.label("左键 挖掘 / 移动 · 右键 封印（受理即揭示·不可逆）",UiKit.FS_CAPTION, false, UiKit.WARM_FAINT)
 	hint.add_child(hl)
 	# 信号转发（组合根只接线一处）
 	board_view.action_requested.connect(_forward_action)

game/presentation/views/legend_overlay.gd

@@ -8,7 +8,7 @@ signal closed
 const ENTRIES := [
 	["#C9AF83", "完整覆尘地砖", "未开格——左键挖开（1AP，须相邻）· 右键封印（1AP）"],
 	["#B39A78", "碎裂裸土", "已开 0 格——可通行，左键移动（免费）"],
-	["#000000", "封印", "封印印记（呈现名·不能拔）——轮末自动判定标中；标空可左键直接挖开（安全格零奖励、危险格受挖掘惩罚）"],
+	["#000000", "封印", "封印印记（受理即揭示——落定当场可见格下身份，随图存续不能拔）——轮末自动判定标中/标空；已封印格零动作（不可再挖开）"],
 	["#2e86de", "小人", "探险者——8 向相邻未开格常驻微光 = 可挖域"],
 	["#F0A828", "金徽章", "已开格奖励身份 icon（封印之下、数值之上，不进数字区）"],
 	["#F0A828", "九徽章解码", "攻=攻击 · 守=护甲 · 爆=爆裂 · 医=回复 · 弱=削弱 · 穿=穿刺 · 魔=魔法 · 行=行动点 · 金=GP"],

game/probe/board_shot_probe.gd

@@ -142,7 +142,7 @@ func _ready() -> void:
 		# 全拒则免邻接旗标＋任意未开格重试，AP 不足先 grant_ap 兜底；拒绝全数＝取证段红）----
 		var seal_cell := Vector2i(-9, -9)
 		for c in settlement.minesweeper.current_board().safe_cells():
-			if settlement.minesweeper.has_seal(c) and not settlement.minesweeper.is_revealed(c):
+			if settlement.minesweeper.has_seal(c):   # 取证选择器换代〔封印改 V8〕——印记可见性不依赖揭示态（受理即揭示）
 				seal_cell = c
 				break
 		if seal_cell.x < 0:

game/probe/ui_click_probe.gd

@@ -20,7 +20,6 @@ var _stall_frames := 0
 var _closed_via_abandon := false   # T17——预算耗尽经放弃路径收口（断点段返回断言豁免位）
 var _done := false
 var _rand := RandomNumberGenerator.new()
-var _seals_placed: Array = []
 var _ap_spent_this_round := 0
 var _problems: Array = []          # 新增覆盖的问题收集（退出码合并判定）
 var _tested_legend := false
@@ -37,6 +36,7 @@ var _tested_map_status := false     # 地图屏角标一次性 case（选路态
 var _inter_confirms := 0           # 大奖励屏确认计数（冒险推进停点——首见确认推进 L2，再见 = L2 关卡完成收口）
 var _settlement_confirms := 0      # 卡⑥ 胜利结算框确认计数（观测面——每场普通战斗胜利恰一）
 var _route_clicks := 0             # 选路覆盖层点击计数（岔路使用率观测面）
+var _seals_placed: Array = []   # 随机封印簿记（行为①仍在役；行为②撤封印已退役——dump 读数面保留）
 var _locktest_state := 0           # T1 D1 锁期/重放断言状态机（0=待注入 1=等重放 2=完结）——每 run 一次
 var _locktest_cell := Vector2i(-9, -9)
 var _locktest_frames := 0
@@ -827,7 +827,6 @@ func _ready() -> void:
 				_done = true
 				print("[click_probe] 第二关大奖励屏（L2 关卡完成）——探针收口 · 选路口点击 %d 次" % _route_clicks)
 				break
-			_seals_placed.clear()
 			continue
 		if main.ui.modals.run.end_overlay.is_open() and main.run_scope.settlement_stop_timer.is_armed():
 			# 战斗胜利总结结算框（真实信号路径——每场普通胜利到达）：断言已拍板面后点「下一节点」
@@ -1216,8 +1215,9 @@ func _run_modal_probes_once() -> void:
 		for e in main.ui.modals.run.legend_overlay.ENTRIES:
 			if String(e[1]) == "封印":
 				legend_has_seal = true
-				# 图例封印行换代断言（迭代36 卡A wa5——真实 AP 条图例钮开层路径）
-				if not String(e[2]).contains("标空") or not String(e[2]).contains("受挖掘惩罚") 						or String(e[2]).contains("插错") or String(e[2]).contains("挖雷"):
+				# 图例封印行换代断言〔封印改 V10〕（迭代36 卡A wa5 载体——真实 AP 条图例钮开层路径）：
+				# 新口径=受理即揭示/已封印格零动作；旧「受挖掘惩罚」句随改判路径退役，雷字清零照守
+				if not String(e[2]).contains("受理即揭示") or not String(e[2]).contains("零动作") 						or String(e[2]).contains("插错") or String(e[2]).contains("挖雷") or String(e[2]).contains("雷格"):
 					_problems.append("图例封印行旧词残留（wa5——%s）" % String(e[2]).replace("
 ", "|"))
 		if not legend_has_seal:
@@ -1391,12 +1391,8 @@ func _play_one_action() -> void:
 			_seals_placed.append(target)
 			_ap_spent_this_round += 1
 			return
-	# 行为②：随机撤封印（右键已封印格），约 10% 轮次
-	if _rand.randf() < 0.1 and not _seals_placed.is_empty():
-		var fc: Vector2i = _seals_placed.pop_back()
-		if minesweeper.has_seal(fc) and not minesweeper.is_revealed(fc):
-			main.ui.battle.board_zone.board_view.click_cell(fc, MOUSE_BUTTON_RIGHT)
-			_ap_spent_this_round += 1
+	# 行为②撤封印退役〔封印改 V9 波及面——test-conventions §5.5 同生死〕：右键已封印格零动作
+	# （封印受理即揭示——撤封印路径不存在），随机撤封印行为段整体摘除；_seals_placed 簿记随段退役。
 			return
 	# 行为③：随机无效点击（非相邻格/已开格），约 8% 轮次
 	if _rand.randf() < 0.08:
@@ -1500,7 +1496,7 @@ func _locktest_tick() -> void:
 					b.width, b.height, str(settlement.minesweeper.hero_pos())])
 				_problems.append("重放断言：锁期缓存点击未受理恰一次（封印未置位——零发或双发）")
 			_locktest_state = 2
-			main.ui.battle.board_zone.board_view.click_cell(_locktest_cell, MOUSE_BUTTON_RIGHT)   # 撤封印恢复现场（尽力而为不判定）
+			# 撤封印恢复现场调用随行为②退役〔封印改 V9〕——右键已封印格零动作（改判路径不存在）
 
 
 func _locktest_pick_cell(minesweeper) -> Vector2i:

game/probe/ui_input_probe.gd

@@ -271,7 +271,7 @@ func _ready() -> void:
 	if bv.mouse_default_cursor_shape != Input.CURSOR_ARROW:
 		_problems.append("case③ 移动光标缺失（%d）" % bv.mouse_default_cursor_shape)
 	# ---- case④ 右键封印：seal_place 到达组合根 + 核心封印态落位 ----
-	# 判据出处: design/gdd/systems/排雷循环/排雷玩法.md:231 封印受理与印记随挖消失（case④/④b）
+	# 判据出处: design/gdd/systems/排雷循环/排雷玩法.md:52 封印受理即揭示、受理零兑付零事件（case④/④b——受理即揭示改版换代）
 	_push_click(_pos(bv, seal_t), MOUSE_BUTTON_RIGHT)
 	await get_tree().process_frame
 	if not _has_action(seal_t, "seal_place"):
@@ -284,6 +284,32 @@ func _ready() -> void:
 	var seal_unit = bv.cells_probe().get(seal_t)
 	if seal_unit == null or not seal_unit.seal_on:
 		_problems.append("case④b 封印印记未下发（seal_on=%s）" % ["无单元" if seal_unit == null else str(seal_unit.seal_on)])
+	# ---- case④c（V9 新增）已封印格零动作：真输入左/右键 → action_requested 零发射、光标态=禁止 ----
+	# 判据出处: design/ux/battle.md Interaction Map 已封印格行——已封印格无动作（左右键同零意图）
+	var acts_before_v9: int = _actions.size()
+	_push_motion(_pos(bv, seal_t))
+	await get_tree().process_frame
+	if bv.mouse_default_cursor_shape != Input.CURSOR_FORBIDDEN:
+		_problems.append("case④c 悬停已封印格光标非禁止（%d）〔封印改 V9〕" % bv.mouse_default_cursor_shape)
+	if bv.cells_probe()[seal_t].face.hl_color != bv.COL_SEAL:
+		_problems.append("case④c 已封印格悬停未落封印禁入框（color=%s）〔封印改 V9〕" % str(bv.cells_probe()[seal_t].face.hl_color))
+	_push_click(_pos(bv, seal_t), MOUSE_BUTTON_LEFT)
+	await get_tree().process_frame
+	_push_click(_pos(bv, seal_t), MOUSE_BUTTON_RIGHT)
+	await get_tree().process_frame
+	if _actions.size() != acts_before_v9:
+		_problems.append("case④c 已封印格左右键仍发射意图（新增 %d——应零发射）〔封印改 V9〕" % (_actions.size() - acts_before_v9))
+	if not ms.is_revealed(seal_t):
+		pass   # 封印格保持未开（零副作用同源佐证）
+	else:
+		_problems.append("case④c 已封印格被挖开（零副作用失守）〔封印改 V9〕")
+	# 悬停说明在册：图例封印行承载悬停语义说明（受理即揭示口径——ENTRIES 在册断言）
+	var legend_seal_line := ""
+	for e in main.ui.modals.run.legend_overlay.ENTRIES:
+		if String(e[1]) == "封印":
+			legend_seal_line = String(e[2])
+	if not legend_seal_line.contains("受理即揭示"):
+		_problems.append("case④c 悬停说明在册缺新口径（图例封印行=%s）〔封印改 V9〕" % legend_seal_line)
 	# ---- case⑤ 双击 chord：禁入格双左击（核心拒挖零副作用）→ chord_attempted ----
 	# 判据出处: design/gdd/systems/排雷循环/排雷玩法.md:236 拒绝三源可辨、任何拒绝零副作用（case⑤ chord）
 	_push_click(_pos(bv, forbid_t), MOUSE_BUTTON_LEFT)

game/sim/auto_player.gd

@@ -174,7 +174,10 @@ static func _constraints(minesweeper, board, mines: Dictionary) -> Array:
 		var known := 0
 		for n in board.neighbors8(c):
 			if minesweeper.has_seal(n):
-				known += 1
+				# 封印受理即揭示：封印格身份当场可查（测量侧镜像玩家可读信息——cell_identity 板事实单点）。
+				# 标中（雷）计已知雷；标空（安全格）=已完成格，剔除出约束（旧口径一律计已知雷=失真）。
+				if String(board.cell_identity(n).get("kind", "")) == "mine":
+					known += 1
 			elif not minesweeper.is_revealed(n):
 				if mines.has(n):
 					known += 1

game/sim/level_autoplay.gd

@@ -25,7 +25,8 @@ const BattleDriver := preload("res://sim/battle_driver.gd")   # 庚案收敛：
 # ── 普通档 v3 失误注入参数（踩雷期望=完美+2/板、每板少挖几个正确格）──
 # 标雷→误挖转化率：主踩雷源=卡死赌挖（不确定性概率命中），误挖只作偶发真手滑——
 # 真人几乎不挖自己封印的格（p 过高会让首轮已证封印变保底命中，非失误形态）
-const NORMAL_MINE_SLIP_P := 0.10
+const NORMAL_MISDIG_P := 0.10   # 错触直挖率（补偿注入——用户 2026-11-07 裁③：初值承旧注入 0.10，
+# 标定目标=改前锚普通档踩雷读数量级；同批同码态锚只采一次，偏差记实现决定）
 # 安全挖跳过率：每板安全格 ~70-90 × p ≈ 3-5 次漏挖（信息与推进双损失）
 const NORMAL_SKIP_DIG_P := 0.05
 # 空闲提前赌挖率：已证安全格在手时小概率先赌一格——完美系把不确定性攒到残局
@@ -471,7 +472,7 @@ static func _autoplay_battle(runner, settlement, st: Dictionary, logger) -> void
 	# 普通策略档 v3：完美策略 + 受控失误注入（标定依据=真人实证：
 	# 零加成真人首通三关踩 23 雷）。
 	# v3 语义 = 会玩的普通玩家：推理与完美档同源（subset 解算/封印/卡死刷新），失误只注入两手——
-	# 标雷误挖（NORMAL_MINE_SLIP_P）+ 安全挖跳过（NORMAL_SKIP_DIG_P）。连续拒绝 ≥3 = 编排违约防御。
+	# 错触直挖（NORMAL_MISDIG_P——标雷误挖换代名）+ 安全挖跳过（NORMAL_SKIP_DIG_P）。连续拒绝 ≥3 = 编排违约防御。
 	# 完美策略档：单步决策循环——move/dig/seal 经 排雷玩法 settle_batch 提交，
 	# refresh 经 settlement.player_request_refresh（战斗结算 核心编排：行动经济 扣 RAP + 退役 + 当场换新板），
 	# stop 出内环走统一停手提交。连续拒绝 ≥3 = 编排违约防御（fail-fast 语义，停手防死循环）。
@@ -503,9 +504,11 @@ static func _action_logger(st: Dictionary, logger) -> Callable:
 			st.refreshes = int(st.refreshes) + 1
 		elif ok and kind == "seal_place":
 			st.seal_placed = int(st.get("seal_placed", 0)) + 1   # 封印数（η 分母=全部封印数〔Q5〕；失误注入转化封印不计数=转化后实为挖）
-# 普通档 v3 失误注入：三类——
-# ①标雷误挖：把「封印已证雷」动作直接转成「挖该格」（真人手滑原型：知道是雷、位置点错，
-#   踩雷吃伤且该雷奖励报废）；期望踩雷增量 ≈ 每板已证雷数 × NORMAL_MINE_SLIP_P（目标完美+2/板）
+# 普通档 v3 失误注入：三类（封印受理即揭示改版换代——①标雷误挖退役，等价补偿注入=错触直挖，
+# 用户 2026-11-07 裁③）——
+# ①错触直挖：把「封印已证雷」动作按概率转成「挖该格」（真人错触原型：判雷正确、手指落点成挖；
+#   目标格当时未封未揭——新规则下挖未封格合法可执行，踩雷吃伤吃挖掘惩罚）；期望踩雷增量 ≈
+#   每板已证雷数 × NORMAL_MISDIG_P（初值承旧注入 0.10——标定目标=改前锚普通档踩雷读数量级）
 # ②安全挖跳过：把「挖已证安全格」动作转成本轮停手（少挖几个正确的雷——信息与推进双损失）
 # ③卡死赌挖：完美档无已证动作时刷新/停手拖轮次吃敌方垫刀（实证=完美档 41% 冒险成功；全败于慢玩
 #   垫刀非踩雷）——真人会按概率赌一个边界格（用户实证口径「有些地方因为我看不到数字,也是盲挖
@@ -516,8 +519,8 @@ static func _apply_normal_slips(act: Dictionary, settlement, st: Dictionary) ->
 	if prng == null:
 		return act
 	var kind := String(act.get("kind", "stop"))
-	if kind == "seal" and prng.randf() < NORMAL_MINE_SLIP_P:
-		st.mine_slips = int(st.get("mine_slips", 0)) + 1
+	if kind == "seal" and prng.randf() < NORMAL_MISDIG_P:
+		st.mine_slips = int(st.get("mine_slips", 0)) + 1   # 计数字段沿用 mine_slips（锚对比列对齐）
 		return {"kind": "dig", "cell": act.get("cell")}
 	if kind == "dig":
 		var roll := prng.randf()

game/tests/smoke/critical-paths.md

@@ -13,10 +13,10 @@
 ## Core Mechanic
 
 3. 挖掘：单格 1 AP、数字亮起与 8 邻雷数一致、连锁免费撕开一片
-4. 封印/撤封印/挪封印：AP 价目正确、连锁止于封印（封印挡链）属正常
+4. 封印：AP 价目正确、连锁止于封印（封印挡链）属正常；封印受理即揭示（落定当场见格下身份）、已封印格零动作（不可再挖开）
 5. 移动：已开格瞬移、**已引爆危险格可通行可读**（工程债呈现半边）
 6. 停手：RAP 1:1 转存、下轮 AP 硬重置同图继续
-7. 轮末结算：明细逐行呈现、来源标注可读（P2——"这一行是我哪步扫雷带来的"可答）
+7. 轮末结算：FX 链逐拍兑现（弹道/飘字/站桩反馈）可读（P2——"这一战果是我哪步扫雷带来的"可答；明细带逐行文字已退役）
 8. 清图：清图奖励兑付 + 完美封印高光（零误标时双份）+ 换新图；未刷新的停手轮不换图
 9. 轮内刷新（方案 A）：Active 当场换图、AP 保留、RAP 扣减、每轮 ≤2 次、跨图事实结算完整
 

game/tests/unit/battle_settlement/seal_polarity_test.gd

@@ -48,6 +48,7 @@ func _init() -> void:
 # ---- 末点 AP 封印轮末结算（playtest 缺陷②回归：末点 AP 花在封印必须终结轮次进入下一轮）----
 
 func _smoke_seal_ap_exhausted() -> void:
+# 判据出处: design/gdd/systems/战斗循环/战斗结算.md:139 封印判定批与溢价兑付链照常（保留组——封印受理即揭示改版零改动）〔封印改 V5〕
 # 判据出处: design/gdd/systems/排雷循环/行动经济.md:260 （末点 AP 耗尽即收轮组）
 	print("--- 排雷玩法·封印动作耗尽末点 AP 回归 ---")
 	var rng = load("res://core/rng_service.gd").new()
@@ -111,11 +112,11 @@ func _find_seal_target(minesweeper, want_mine: bool) -> Dictionary:
 
 
 # ---- 封印不可逆四情况冒烟（禁撤封印 + 挖封印格兑付改判）----
-# 四情况：① 插危险格不动 = 标中奖励照常；② 插危险格再挖开 = 只受挖雷一层惩罚（mine_hit 照常）标中不发；
-# ③ 插安全格不动 = 标空惩罚照常；④ 插安全格再挖开 = 零惩罚零奖励（正向兑付作废、标空不判）。
+# 四情况（封印受理即揭示改版改判〔封印改 V2〕）：① 插危险格不动 = 标中奖励照常；② 插危险格再挖开 = 挖封印格被拒（零动作零惩罚）；
+# ③ 插安全格不动 = 标空惩罚照常；④ 插安全格再挖开 = 挖封印格被拒（零动作——标空判定照发）。
 # 拒绝面：seal_pull 出目录（out_of_catalog）；重复封印仍 seal_present 拒绝。
-# 场景 A（④ + 拒绝面）：标安全格 → seal_pull 拒绝 → 重复封印拒绝 → 直接挖开 → 收轮。
-# 场景 B（②）：标危险格 → 直接挖开 → 收轮。
+# 场景 A（④ 改判〔封印改 V2〕+ 拒绝面）：标安全格 → seal_pull 拒绝 → 重复封印拒绝 → 挖封印格被拒 → 收轮（标空判定照发）。
+# 场景 B（② 改判〔封印改 V2〕）：标危险格 → 挖封印格被拒 → 收轮（标中判定照发）。
 # 场景 C（①③）：标安全格 + 标危险格 → 不挖收轮 → 标空/标中判定照常。
 
 
@@ -440,6 +441,7 @@ func _smoke_refresh_provenance_guard() -> void:
 
 
 func _smoke_polarity_routing() -> void:
+# 判据出处: design/gdd/systems/战斗循环/战斗结算.md:139 封印判定批与溢价兑付链照常（保留组——封印受理即揭示改版零改动）〔封印改 V5〕
 # 判据出处: design/gdd/systems/战斗循环/战斗结算.md:366 （极性路由：正向只兑正向、负向只兑负向组）
 # 判据出处: design/gdd/systems/战斗循环/战斗结算.md:366 （极性路由：正向只兑正向、负向只兑负向组）
 	print("--- 极性路由（挖安全格正向 / 挖危险格负向 / 标中正向 / 标空负向）---")
@@ -572,11 +574,11 @@ func _smoke_polarity_routing() -> void:
 
 
 # ---- 封印不可逆四情况冒烟（禁撤封印 + 挖封印格兑付改判）----
-# 四情况：① 插危险格不动 = 标中奖励照常；② 插危险格再挖开 = 只受挖雷一层惩罚（mine_hit 照常）标中不发；
-# ③ 插安全格不动 = 标空惩罚照常；④ 插安全格再挖开 = 零惩罚零奖励（正向兑付作废、标空不判）。
+# 四情况（封印受理即揭示改版改判〔封印改 V2〕）：① 插危险格不动 = 标中奖励照常；② 插危险格再挖开 = 挖封印格被拒（零动作零惩罚）；
+# ③ 插安全格不动 = 标空惩罚照常；④ 插安全格再挖开 = 挖封印格被拒（零动作——标空判定照发）。
 # 拒绝面：seal_pull 出目录（out_of_catalog）；重复封印仍 seal_present 拒绝。
-# 场景 A（④ + 拒绝面）：标安全格 → seal_pull 拒绝 → 重复封印拒绝 → 直接挖开 → 收轮。
-# 场景 B（②）：标危险格 → 直接挖开 → 收轮。
+# 场景 A（④ 改判〔封印改 V2〕+ 拒绝面）：标安全格 → seal_pull 拒绝 → 重复封印拒绝 → 挖封印格被拒 → 收轮（标空判定照发）。
+# 场景 B（② 改判〔封印改 V2〕）：标危险格 → 挖封印格被拒 → 收轮（标中判定照发）。
 # 场景 C（①③）：标安全格 + 标危险格 → 不挖收轮 → 标空/标中判定照常。
 func _smoke_seal_irreversible_quadrants() -> void:
 # 判据出处: design/gdd/systems/排雷循环/排雷玩法.md:231 （封印不可逆四情况组）
@@ -600,9 +602,10 @@ func _smoke_seal_irreversible_quadrants() -> void:
 		Kit.check("四情况 A：seal_pull 出目录拒绝（撤封印退役）", not pull_out.is_empty() and not bool(pull_out[0].get("accepted", true)) and String(pull_out[0].get("sub_reason", "")) == "out_of_catalog")
 		var dup_place: Array = ms_a.settle_batch([{"action": "seal_place", "cell": t_a.seal_cell}])
 		Kit.check("四情况 A：重复封印仍被拒（seal_present）", not dup_place.is_empty() and not bool(dup_place[0].get("accepted", true)) and String(dup_place[0].get("sub_reason", "")) == "seal_present")
+		# 改判〔封印改 V2〕——「挖封印格直挖受理/隐式退役」随封印受理即揭示退役：挖已封印格被拒
 		var dig_a: Array = ms_a.settle_batch([{"action": "dig", "cell": t_a.seal_cell}])
-		Kit.check("四情况 A：封印格直接挖开被受理（不再须先撤封印）", not dig_a.is_empty() and bool(dig_a[0].get("accepted", false)))
-		Kit.check("四情况 A：封印随挖掘隐式退役（has_seal = false）", not ms_a.has_seal(t_a.seal_cell))
+		Kit.check("四情况 A：挖已封印格被拒且原因可辨（target_sealed）", not dig_a.is_empty() and not bool(dig_a[0].get("accepted", true)) and String(dig_a[0].get("sub_reason", "")) == "target_sealed")
+		Kit.check("四情况 A：封印不随挖掘退役（has_seal 保持——不可再挖开）", ms_a.has_seal(t_a.seal_cell) and not ms_a.is_revealed(t_a.seal_cell))
 		ms_a.settle_batch([{"action": "stop"}])
 		var target_a: Array = [t_a.seal_cell.x, t_a.seal_cell.y]
 		var miss_a := 0
@@ -617,9 +620,11 @@ func _smoke_seal_irreversible_quadrants() -> void:
 				grant_a += 1
 			if row.get("type", "") == "reward_ineffective":
 				void_a += 1
-		Kit.check("四情况 A：标空判定零兑付（×%d——封印已擦除不入轮末基线）" % miss_a, miss_a == 0)
-		Kit.check("四情况 A：安全格正向兑付作废（×%d——零奖励）" % grant_a, grant_a == 0)
-		Kit.check("四情况 A：兑付作废归因行恰一次（×%d——零惩罚零奖励留痕）" % void_a, void_a == 1)
+		# 改判〔封印改 V2〕——封印在场入轮末基线：标空判定照发（受理即揭示不改判定批）；
+		# miss_a 口径=seal_miss 型行或来源行（判定行＋标空负向兑付行同源）
+		Kit.check("四情况 A：标空判定照发（×%d——封印在轮末基线；判定行＋负向兑付行同源）" % miss_a, miss_a >= 1)
+		Kit.check("四情况 A：安全格正向兑付为零（×%d——封印不兑付格面资源）" % grant_a, grant_a == 0)
+		Kit.check("四情况 A：零兑付作废归因行（×%d——改判路径退役无作废行）" % void_a, void_a == 0)
 	# 场景 B：危险格直挖（情况②）
 	var rng_b = load("res://core/rng_service.gd").new()
 	rng_b.set_master_seed(20260919)
@@ -634,9 +639,10 @@ func _smoke_seal_irreversible_quadrants() -> void:
 		if t_b.hero_cell != ms_b.hero_pos():
 			ms_b.settle_batch([{"action": "move", "cell": t_b.hero_cell}])
 		Kit.check("四情况 B：封印受理", ms_b.settle_batch([{"action": "seal_place", "cell": t_b.seal_cell}])[0].accepted)
+		# 改判〔封印改 V2〕——挖危险封印格同被拒（封印格拒绝挖掘不分极性）
 		var dig_b: Array = ms_b.settle_batch([{"action": "dig", "cell": t_b.seal_cell}])
-		Kit.check("四情况 B：封印危险格直接挖开被受理", not dig_b.is_empty() and bool(dig_b[0].get("accepted", false)))
-		Kit.check("四情况 B：危险格已揭示（挖雷本体照常）", ms_b.is_revealed(t_b.seal_cell) and ms_b.current_board().is_mine(t_b.seal_cell))
+		Kit.check("四情况 B：挖已封印危险格被拒（target_sealed）", not dig_b.is_empty() and not bool(dig_b[0].get("accepted", true)) and String(dig_b[0].get("sub_reason", "")) == "target_sealed")
+		Kit.check("四情况 B：危险格未揭示（封印格零动作）", not ms_b.is_revealed(t_b.seal_cell) and ms_b.current_board().is_mine(t_b.seal_cell))
 		ms_b.settle_batch([{"action": "stop"}])
 		var target_b: Array = [t_b.seal_cell.x, t_b.seal_cell.y]
 		var mine_hit_b := 0
@@ -648,8 +654,9 @@ func _smoke_seal_irreversible_quadrants() -> void:
 				mine_hit_b += 1
 			if row.get("type", "") == "seal_hit" or String(row.get("source_class", "")) == "seal_hit":
 				hit_b += 1
-		Kit.check("四情况 B：挖雷惩罚照常兑付（×%d——只受挖雷一层惩罚）" % mine_hit_b, mine_hit_b >= 1)
-		Kit.check("四情况 B：标中不发（×%d——封印已擦除不判）" % hit_b, hit_b == 0)
+		# 改判〔封印改 V2〕——封印在场入轮末基线：标中判定照发（含溢价兑付链）
+		Kit.check("四情况 B：挖雷惩罚零发生（×%d——封印格未挖）" % mine_hit_b, mine_hit_b == 0)
+		Kit.check("四情况 B：标中判定照发（×%d——封印在轮末基线）" % hit_b, hit_b >= 1)
 	# 场景 C：不挖收轮（①③判定照常）
 	var rng_c = load("res://core/rng_service.gd").new()
 	rng_c.set_master_seed(20260919)

game/tests/unit/battle_settlement/settlement_wiring_snapshot_test.gd

@@ -420,6 +420,8 @@ var _db
 
 func _init() -> void:
 # 判据出处: design/gdd/systems/战斗循环/战斗结算.md:362 （结算接线同种子逐项 golden 对拍组）
+# 判据出处: design/gdd/systems/战斗循环/战斗结算.md:134 受理零兑付、改判路径死——流水零「奖励作废（封印格直接挖开）」行、
+# 同种子驱动序 golden 实测零漂移零重录（挖封印格被拒——驱动序不含该路径）〔封印改 V6〕
 	_db = ConfigDBScript.new()
 	var load_ok: bool = _db.load_tables("res://data/tables", true)
 	Kit.check("前置：表加载零 error", load_ok and _db.diagnostics_count("error") == 0)

game/tests/unit/core/adventure_feats_test.gd

@@ -147,9 +147,11 @@ func _smoke_adventure() -> void:
 	Kit.check("生成图每个战斗/Boss 节点经解析链命中敌行集与棋盘行（扫描 %d 节点，缺失 %d）〔fv24〕" % [cov_scan, cov_miss],
 		cov_scan > 0 and cov_miss == 0)
 	# ② 满配冒险成功 + ④ 三层奖励兑付（三选一恰 2 次 · 回血封顶 · 钥石逐杀 · 候选零重复）
-	var st: Dictionary = autoplay.run_adventure(_db, 42, 900, 400)
+	# 种子换代〔退役改 V7 波及面——test-conventions §5.5 同生死〕：feats.tres 删破封一击行使
+	# RNG 流消费序列变，42 路线漂移为 timeout（43 实跑 completed——钉值随表行集换代）
+	var st: Dictionary = autoplay.run_adventure(_db, 43, 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("满配冒险成功（43 / 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.run.level.rows.size()) + 1):
@@ -157,7 +159,7 @@ func _smoke_adventure() -> void:
 	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)
-	Kit.check("摘要携带主种子（42）", int(sum.get("master_seed", -1)) == 42)
+	Kit.check("摘要携带主种子（43）", int(sum.get("master_seed", -1)) == 43)
 	var picks: Array = []
 	var resolves: Array = []
 	var node_picks := 0
@@ -274,7 +276,7 @@ func _smoke_adventure() -> void:
 			seq_ok = false
 	Kit.check("各战上限入参 ∈ [基础, 基础+3×件值+购血余量]（覆盖值通道——双渠道共享上限 3；模拟档贪心购血合法叠加〔数值修复批 v3.4〕；首战=基础 %d）" % exp_base, seq_ok)
 	# ③ 种子域可复现（同种子两局：summary + 上限序列 + 行进序列 + 三选一停点载荷逐位一致）
-	var st2: Dictionary = autoplay.run_adventure(_db, 42, 900, 400)
+	var st2: Dictionary = autoplay.run_adventure(_db, 43, 900, 400)
 	Kit.check("同种子两局逐位可复现（summary/上限序列/行进序列/三选一载荷——reward_pick 封闭流）",
 		st2["summary"] == sum and st2["encounter_max_hp_seq"] == seq
 		and st2["visited_ids"] == st["visited_ids"] and st2["reward_events"] == st["reward_events"])
@@ -465,8 +467,8 @@ func _smoke_adventure() -> void:
 func _smoke_feats() -> void:
 # 判据出处: design/gdd/systems/冒险循环/奇物.md:465 （奇物授予与凭证保底组）
 	print("--- 专长重设计实装（feat_table 四级 · 专长带池接线 · 订阅面逐件）---")
-	# ① 现行表牌库构成：37 件全量入池——102 数值令牌+37 relic 令牌（四级 rarity 直映射）
-	Kit.check("feat_table 已加载（37 件=基础 27+迁入 2+完美保险 1+迭代 46 换图系七件——换代）", _db.crossrun.feats != null and (_db.crossrun.feats.rows as Array).size() == 37)
+	# ① 现行表牌库构成：36 件全量入池（破封一击随封印受理即揭示退役〔退役改 V7〕）——102 数值令牌+36 relic 令牌（四级 rarity 直映射）
+	Kit.check("feat_table 已加载（36 件=基础 27+迁入 2+完美保险 1+迭代 46 换图系七件−破封一击退役〔退役改 V7〕——换代）", _db.crossrun.feats != null and (_db.crossrun.feats.rows as Array).size() == 36)
 	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))
@@ -477,7 +479,7 @@ 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("专长带入池：37 件四级直映射（普通 14/优秀 13/稀有 10/传说 0）——牌库 102+37=139〔专长批 V2＋迭代 46 换图系七件换代〕", feat_tokens == 37 and int(tier_counts.get("common", 0)) == 14 and int(tier_counts.get("excellent", 0)) == 13 and int(tier_counts.get("rare", 0)) == 10 and a_r0.deck().deck.size() == 139)
+	Kit.check("专长带入池：36 件四级直映射（普通 14/优秀 12/稀有 10/传说 0）——牌库 102+36=138〔专长批 V2＋迭代 46 换图系七件换代−破封一击退役〕", feat_tokens == 36 and int(tier_counts.get("common", 0)) == 14 and int(tier_counts.get("excellent", 0)) == 12 and int(tier_counts.get("rare", 0)) == 10 and a_r0.deck().deck.size() == 138)
 	# ② 旧 27 件零残留钉面（V2——arcane_ember 系旧件表首行；全仓 grep 零残留归静态核查）
 	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())
@@ -717,11 +719,7 @@ func _smoke_feats() -> void:
 	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())
-	# 跨族桥
-	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())
+	# 跨族桥（破封一击随封印受理即揭示改版退役——dug_under_seal 事实词除名，改判路径不存在〔封印改 V7〕）
 	# 节奏系
 	fx.rebuild(["map_exchange"], [], {})
 	var me_hits: Array = fx.dispatch(orch.fx_host().counters_ctx, "dig_stop", {"ap_left": 4})

game/tests/unit/core/effect_words_t1_test.gd

@@ -21,10 +21,12 @@ func _init() -> void:
 	Kit.check_quiet(EffectEngineScript.EFFECT_KINDS.has("grant_reserve_ap") and EffectEngineScript.EFFECT_KINDS.has("apply_discount"),
 		"换图系新效果在册：grant_reserve_ap/apply_discount〔换图系批 V1〕")
 	Kit.check_quiet(EffectEngineScript.FACTS.has("hp_ratio") and EffectEngineScript.FACTS.has("is_edge_cell")
-		and EffectEngineScript.FACTS.has("new_resource_type") and EffectEngineScript.FACTS.has("dug_under_seal")
+		and EffectEngineScript.FACTS.has("new_resource_type")
 		and EffectEngineScript.FACTS.has("ap_exhausted_last") and EffectEngineScript.FACTS.has("ap_left")
 		and EffectEngineScript.FACTS.has("is_blank_zero") and EffectEngineScript.FACTS.has("amount"),
-		"新事实在册：hp_ratio/is_edge_cell/new_resource_type/dug_under_seal/ap_exhausted_last/ap_left/is_blank_zero/amount〔专长批 V1〕")
+		"新事实在册：hp_ratio/is_edge_cell/new_resource_type/ap_exhausted_last/ap_left/is_blank_zero/amount〔专长批 V1——dug_under_seal 随破封一击退役除名，退役改 V7〕")
+	Kit.check_quiet(not EffectEngineScript.FACTS.has("dug_under_seal"),
+		"退役事实词出册：dug_under_seal（改判路径退役——词表除名防回潮）〔退役改 V7〕")
 	Kit.check_quiet(EffectEngineScript.EFFECT_KINDS.has("heal") and EffectEngineScript.EFFECT_KINDS.has("ac_bonus")
 		and EffectEngineScript.EFFECT_KINDS.has("damage_reduce") and EffectEngineScript.EFFECT_KINDS.has("bonus_delta")
 		and EffectEngineScript.EFFECT_KINDS.has("blast_scaled") and EffectEngineScript.EFFECT_KINDS.has("preview_area")

game/tests/unit/core/minesweeper_rules_test.gd

@@ -42,6 +42,10 @@ func _init() -> void:
 	_test_seal_place()
 	_test_reject_out_of_catalog()
 	_test_preview_reveal_readonly()
+	_test_seal_reveal_identity()
+	_test_dig_sealed_rejected()
+	_test_clear_by_seal()
+	_test_classify_seal_clears()
 	quit(Kit.finish("minesweeper_rules_test"))
 
 
@@ -133,12 +137,15 @@ func _test_preview_reveal_readonly() -> void:
 	Kit.check("V14 形态A：preview 返回集（真板形态——%d 格）" % prev_a.size(), prev_a.size() >= 0)
 	Kit.check("V14 形态A：调用前后零状态写入（revealed/seal 计数零变化）〔架构整改 V14〕",
 		_rules.revealed_cells().size() == before_revealed and _rules.seal_count() == before_seals)
-	# 形态 B：挖封印格——本格封印隐式退役只入模拟集，真实封印计数不动
+	# 形态 B（改判〔封印改 V14B〕——挖封印格隐式退役前提随「封印受理即揭示」退役）：
+	# preview(封印格) 连锁不越封印——封印格自身零外扩返回空集，真实封印计数不动
 	var seal_c := _unrevealed_safe()
 	_rules.settle_batch([{"action": "seal_place", "cell": seal_c}])
 	var sealed_before := _rules.seal_count()
 	var prev_b: Array = _rules.preview_reveal(seal_c)
-	Kit.check("V14 形态B：preview(封印格) 零状态写入（seal_count 不变——隐式退役只入模拟集）〔架构整改 V14〕",
+	Kit.check("V14 形态B：preview(封印格) 零外扩（连锁不越封印——返回空集 %d 格）〔封印改 V14B〕" % prev_b.size(),
+		prev_b.is_empty())
+	Kit.check("V14 形态B：preview(封印格) 零状态写入（seal_count 不变）〔封印改 V14B〕",
 		_rules.seal_count() == sealed_before)
 	# 同口径对照：preview(c) = settle_batch(dig c) 后 revealed 差集 ∖ {c}（F2——不含首格与已开格）
 	var dig_c := _unrevealed_safe()
@@ -159,3 +166,163 @@ func _test_preview_reveal_readonly() -> void:
 	var _pc: Array = _rules.preview_reveal(_unrevealed_safe())
 	Kit.check("V14 零事件：preview 全程 cell_revealed 零发射（前后增量 0——实测 %d→%d）〔架构整改 V14〕" % [events_before_previews, events],
 		events == events_before_previews)
+
+# 未完成安全格集（清图口径=已挖∪已封印——未揭且未封；V3 阶段c/V4 夹具扫描口）
+func _incomplete_cells() -> Array:
+	var out: Array = []
+	for c in _board.safe_cells():
+		if not _rules.is_revealed(c) and not _rules.has_seal(c):
+			out.append(c)
+	return out
+
+
+# 新板重装夹具（V3 阶段c/V4 干净局面——IDLE 装板→round_start 进 ACTIVE；封印/揭示随装板重置）
+func _fresh_board(seed_v: int) -> void:
+	_ae._phase = 0   # Phase.IDLE——夹具直置（前置相位可能处 ACTIVE：fx_reveal 不经行动经济不收轮；notify_combat_end 相位守卫拒 ACTIVE）
+	var rng := RngServiceScript.new()
+	rng.set_master_seed(seed_v)
+	rng.new_adventure(seed_v)
+	_board = BoardGeneratorScript.new().generate(1, 0, rng.open_stream("board_gen"), _db)
+	_rules.install_board(_board)
+	_ae.notify_round_start()
+
+
+# ---- 封印受理即揭示改版（迭代 56 封印动作改版批 V1–V4——身份可查/挖封印格被拒/清图口径/批次语义序）----
+
+# 未揭示且未封印的安全格（V1-V4 夹具对象选择口——排除已封印格）
+func _unrevealed_unsealed_safe() -> Vector2i:
+	for c in _board.safe_cells():
+		if not _rules.is_revealed(c) and not _rules.has_seal(c):
+			return c as Vector2i
+	return Vector2i(-1, -1)
+
+
+# V1 封印受理即揭示：身份当场可查（sealed_identity 与板事实逐位一致）、受理零事件零兑付
+func _test_seal_reveal_identity() -> void:
+# 判据出处: design/gdd/systems/排雷循环/排雷玩法.md:52 封印受理那一刻身份当场可见、受理当场零兑付零事件
+	_ae.grant_ap(20)
+	_rules.seal_range_free = true
+	var safe_c := _unrevealed_unsealed_safe()
+	var events := 0
+	_rules.cell_revealed.connect(func(_evt): events += 1)   # 受理零事件哨兵
+	var events_before := events
+	_rules.settle_batch([{"action": "seal_place", "cell": safe_c}])
+	Kit.check("V1 前提：安全格封印受理", _rules.has_seal(safe_c))
+	# 身份揭示拼装（用户裁 2026-11-08 上限保持 20——sealed_identity 撤出 rules，
+	# 身份事实=BoardData.cell_identity、封印态=has_seal，两段各归其主）
+	Kit.check("V1 安全格封印身份 kind=safe 且 digit=板数字逐位一致（%s vs %d）〔封印改 V1〕" % [str(_board.cell_identity(safe_c).get("kind", "")), _board.digit_of(safe_c)],
+		_rules.has_seal(safe_c) and String(_board.cell_identity(safe_c).get("kind", "")) == "safe"
+		and int(_board.cell_identity(safe_c).get("digit", -9)) == _board.digit_of(safe_c))
+	Kit.check("V1 受理零事件：cell_revealed 零发射（%d→%d）〔封印改 V1〕" % [events_before, events],
+		events == events_before)
+	# 危险格封印身份：找未开危险格封印 → kind=mine
+	var mine_c := Vector2i(-1, -1)
+	for c in _board.all_cells():
+		if _board.is_mine(c) and not _rules.is_revealed(c) and not _rules.has_seal(c):
+			mine_c = c
+			break
+	if mine_c != Vector2i(-1, -1):
+		_rules.settle_batch([{"action": "seal_place", "cell": mine_c}])
+		Kit.check("V1 危险格封印身份 kind=mine〔封印改 V1〕",
+			_rules.has_seal(mine_c) and String(_board.cell_identity(mine_c).get("kind", "")) == "mine")
+	Kit.check("V1 身份事实与揭示态独立：未封印格 has_seal=false 但身份可查（板事实恒在）〔封印改 V1〕",
+		not _rules.has_seal(_unrevealed_unsealed_safe())
+		and not _board.cell_identity(_unrevealed_unsealed_safe()).is_empty())
+
+
+# V2 挖已封印格被拒：原因可辨 target_sealed、封印/揭示/AP 三态零变化
+func _test_dig_sealed_rejected() -> void:
+# 判据出处: design/gdd/systems/排雷循环/排雷玩法.md:56 动作合法性表——挖的拒绝情形含已封印
+	var sealed_c := Vector2i(-1, -1)
+	for c in _board.all_cells():
+		if _rules.has_seal(c) and not _rules.is_revealed(c):
+			sealed_c = c
+			break
+	Kit.check("V2 前提：已封印未开格在板", _rules.has_seal(sealed_c) and not _rules.is_revealed(sealed_c))
+	_rules.dig_range_bonus = 99   # 夹具免邻接（公开属性直置——seal_range_free 先例同款；挖掘射程非判据面）
+	_ae.grant_ap(20)
+	var ap_before: int = _ae._ap
+	var out: Array = _rules.settle_batch([{"action": "dig", "cell": sealed_c}])
+	var o: Dictionary = (out[0] as Dictionary) if not out.is_empty() else {}
+	Kit.check("V2 挖封印格被拒且原因可辨（sub_reason=target_sealed——实测 %s）〔封印改 V2〕" % String(o.get("sub_reason", "")),
+		String(o.get("outcome", "")) == "rejected" and String(o.get("sub_reason", "")) == "target_sealed")
+	Kit.check("V2 拒绝零副作用：封印态/揭示态/AP 三态零变化〔封印改 V2〕",
+		_rules.has_seal(sealed_c) and not _rules.is_revealed(sealed_c) and _ae._ap == ap_before)
+	_rules.dig_range_bonus = 0   # 还原射程（后续夹具不吃豁免）
+
+
+# V3 清图口径换代：封印可完成清图（封掉最后安全格→cleared 收束）；非末封印不清图
+func _test_clear_by_seal() -> void:
+# 判据出处: design/gdd/systems/排雷循环/排雷玩法.md:139 清图=全部安全格完成，完成=挖开或封印
+	_ae.grant_ap(20)
+	_rules.seal_range_free = true
+	# 阶段 a：封一张非末安全格 → clear_map_cleared 仍 false（封印计入完成但未清完）
+	var seal_c := _unrevealed_unsealed_safe()
+	_rules.settle_batch([{"action": "seal_place", "cell": seal_c}])
+	Kit.check("V3 阶段a 前提：封印受理", _rules.has_seal(seal_c))
+	Kit.check("V3 阶段a：非末封印后清图未达成（clear_map_cleared=false）〔封印改 V3〕",
+		not _rules.clear_map_cleared())
+	# 阶段 b：fx_reveal 除 seal_c 外全部未完成安全格 → 唯一未完成格=已封印的 seal_c → 封印计入完成
+	for c in _board.safe_cells():
+		if c != seal_c and not _rules.is_revealed(c) and not _rules.has_seal(c):
+			_rules.fx_reveal(c)
+	Kit.check("V3 阶段b：唯一未完成格=已封印格 → clear_map_cleared=true〔封印改 V3〕",
+		_rules.clear_map_cleared())
+	# 阶段 c：另起干净新板——逐格封至清图（每封一批次真实入口）：非末封零 round_end、
+	# 末封恰发一条 path_tag=cleared 的轮末事件（封印后清图判定触发——轮末事件 carry 清图）
+	_fresh_board(81003)
+	_ae.grant_ap(60)
+	_rules.seal_range_free = true
+	var end_seen: Array = []
+	_rules.round_end_board.connect(func(p): end_seen.append(String(p.get("path_tag", ""))))
+	var guard := 0
+	while not _rules.clear_map_cleared() and guard < 200:
+		guard += 1
+		var t: Vector2i = _incomplete_cells()[0] if not _incomplete_cells().is_empty() else Vector2i(-1, -1)
+		if t == Vector2i(-1, -1):
+			break
+		_rules.settle_batch([{"action": "seal_place", "cell": t}])
+	Kit.check("V3 阶段c：逐格封至清图达成（%d 封——封印可完成清图）〔封印改 V3〕" % guard,
+		_rules.clear_map_cleared())
+	Kit.check("V3 阶段c：清图收束恰一次且 path_tag=cleared（round_end 序列=%s）〔封印改 V3〕" % str(end_seen),
+		end_seen.size() == 1 and String(end_seen[0]) == "cleared")
+
+
+# V4 批次语义序：同批「停手 + 能清图的封」提交 → 赢家=清图收束而非停手
+func _test_classify_seal_clears() -> void:
+# 判据出处: design/gdd/systems/排雷循环/排雷玩法.md:167 最先=能清图的挖或封——防耗尽优先把清图高光结算成最差结局
+	# 收敛未完成格到恰 1 格（封它即清图；fx_reveal 连锁不可控——逐格揭至剩 1，连锁越格则换种子重试）
+	var left: Array = []
+	var last_c := Vector2i(-1, -1)
+	for seed_i in range(3):
+		_fresh_board(81004 + seed_i)
+		_ae.grant_ap(60)
+		_rules.seal_range_free = true
+		left = _incomplete_cells()
+		var guard2 := 0
+		while left.size() > 1 and guard2 < 400:
+			_rules.fx_reveal(left[0])
+			left = _incomplete_cells()
+			guard2 += 1
+		if left.size() == 1:
+			last_c = left[0]
+			break
+	Kit.check("V4 前提：未完成格收敛到恰 1 格（实测 %d——封它即清图）" % left.size(),
+		left.size() == 1)
+	if left.size() != 1:
+		quit(Kit.finish("minesweeper_rules_test"))
+		return
+	var intents: Array = [{"action": "stop"}, {"action": "seal_place", "cell": last_c}]
+	# 同批「停手＋能清图的封」：末格封 cls 0 最先执行→cleared 收轮；stop cls 1 voided
+	var end_seen: Array = []
+	_rules.round_end_board.connect(func(p): end_seen.append(String(p.get("path_tag", ""))))   # append 捕获引用（lambda 内重绑定不回写）
+	var outcomes: Array = _rules.settle_batch(intents)
+	Kit.check("V4 赢家=清图封：round_end path_tag=cleared 而非 stopped（round_end 序列=%s）〔封印改 V4〕" % str(end_seen),
+		end_seen.size() == 1 and String(end_seen[0]) == "cleared")
+	Kit.check("V4 清图封印受理（末格 %s 在封印态）〔封印改 V4〕" % str(last_c), _rules.has_seal(last_c))
+	# outcomes 按执行序承载（cls 升序）——赢家=cls 0 的清图封居首；stop 与非末封在其后 voided
+	var o_winner: Dictionary = (outcomes[0] as Dictionary) if not outcomes.is_empty() else {}
+	Kit.check("V4 末格封意图受理（batch 赢家=清图封居执行序首——实测 %s）〔封印改 V4〕" % String(o_winner.get("outcome", "")),
+		String(o_winner.get("outcome", "")) == "executed")
+	Kit.check("V4 其余意图 voided（清图收轮后批次余项作废）〔封印改 V4〕",
+		outcomes.size() >= 2 and String((outcomes[outcomes.size() - 1] as Dictionary).get("outcome", "")) == "voided")

game/tests/unit/presentation/battle_log_zero_text_test.gd

@@ -18,6 +18,11 @@ func check(cond: bool, msg: String) -> void:
 
 
 func _init() -> void:
+# 判据出处: design/engineering/test-conventions.md:56 （判定上报通道——验证函数组）
+	_smoke_settle_zero_rows()
+
+
+func _smoke_settle_zero_rows() -> void:
 # 判据出处: design/gdd/08-Alpha版本标准.md:154 战斗演出链（弹道 / 受击 / 血条 / 灰化）在役；
 # 逐行结算排播行已随 v1.29 退役——结算期 B 区零逐行文字、FX 排播链保持
 	var main: Node = load("res://presentation/main.tscn").instantiate()

game/tests/unit/presentation/hud_presenter_test.gd

@@ -27,7 +27,8 @@ func _test_reject_text_by_reason() -> void:
 	var cases := {
 		"not_adjacent": "不能执行：目标与小人不相邻",
 		"target_revealed": "不能执行：目标已开",
-		"seal_present": "不能封印：此格已有封印印记（封印为一次性承诺——相邻时左键直接挖开）",
+		"seal_present": "不能封印：此格已有封印印记（封印受理即揭示——印记随图存续）",
+		"target_sealed": "不能挖：此格已封印（封印受理即揭示——不可再挖开）",
 	}
 	var bad: Array[String] = []
 	for sub in cases:

game/tests/unit/presentation/player_copy_sweep_test.gd

@@ -76,7 +76,10 @@ func _sweep_legend() -> void:
 			seal_row = e
 			break
 	Kit.check("图例封印行含「标空」（u4——与「标中」成对）〔wa5〕", String(seal_row[2] if seal_row.size() > 2 else "").contains("标空"))
-	Kit.check("图例封印行含「受挖掘惩罚」（u4 雷字清零换代）〔wa5〕", String(seal_row[2] if seal_row.size() > 2 else "").contains("受挖掘惩罚"))
+	# 文案换代〔封印改 V10〕——图例封印行新口径：受理即揭示、已封印格零动作（旧「受挖掘惩罚」句随改判路径退役）
+	Kit.check("图例封印行含「受理即揭示」且零雷字（u4 清零换代〔封印改 V10〕）〔wa5〕",
+		String(seal_row[2] if seal_row.size() > 2 else "").contains("受理即揭示")
+		and not String(seal_row[2] if seal_row.size() > 2 else "").contains("雷"))
 	for w in ["插错", "挖雷"]:
 		Kit.check("图例封印行零「%s」〔wa5〕" % w,
 			not String(seal_row[2] if seal_row.size() > 2 else "").contains(w))

game/tests/unit/presentation/seal_mark_params_test.gd

@@ -14,6 +14,7 @@ func _init() -> void:
 	_test_param_values()
 	_test_shader_uniforms()
 	_test_fog_gate()
+	_test_seal_on_revealed_visible()
 	quit(Kit.finish("seal_mark_params_test"))
 
 
@@ -54,3 +55,16 @@ func _test_fog_gate() -> void:
 	u.seal_on = false
 	Kit.check("撤 seal_on 即撤子件〔seal批 V4〕", u._seal_layer == null)
 	u.free()
+
+
+# R8 新组合态：seal_on 与已揭示同真时印记子件仍可见（封印受理即揭示改版——印记可见性不依赖
+# 揭示态；内部字段直查=受控例外同 _test_fog_gate——子件可见性无公开可观测面，对照表随行申报）
+func _test_seal_on_revealed_visible() -> void:
+# 判据出处: design/ux/battle.md「封印格呈现预览」受理即揭示——印记承载面换代（已揭示格承载合法）
+	var u: Node2D = CELL_UNIT.new()
+	u.seal_on = true
+	Kit.check("R8 前提：seal_on 挂封印子件〔封印改 V8〕", u._seal_layer != null)
+	u.fog_state = 0
+	Kit.check("R8 新组合态：seal_on 与揭示同真印记仍可见（非雾态——承载面不因揭示态撤印）〔封印改 V8〕",
+		u._seal_layer != null and u._seal_layer.visible == true)
+	u.free()