专长迁移完成：27 行 triggers 订阅形态全量生效+旧 23 挂点枚举消亡+消费点拆除+断言面随迁（T3——内容数据驱动扩展批）

接手前任中断的 T3 半成品（脏文件三件：battle_orchestrator/effects engine/feats.tres），方向核实无误后续做收口；
承接修正四处随本提交留痕：①perfect_defense 的 when 用了 fact 封闭 9 项外的 flags_hit_all（装载校验必红）——
改 flags_count gte 1 保守判定，全中闸=flag_settle 发射点施加面承载（载荷字段仅供观测）；②has 算子语义与行
不匹配（数组包含对 String 恒假）——落非空在场判定（value 缺省）+数组包含（value 给定），查询面落法=代拍板
白名单；③前任漏写 _harmful_adjacent 助手（flag_hit 发射点调用必炸）；④counter_add set 键语义 bool() 吞 0
（清零行 set:0 被当 false 走加零通道）——改 has(set) 置值模式，四处施加点同修。

本提交主干（专长族全量迁移——任务书 §六 T3）：
- damage_controller：feat_flags 旗面整体退役，五事件施加面接线——attack_commit 命中随单据 context 携带
  （发射点=开单入口，任务书 §3.1 定稿位；主角攻击单恒段内首单，开单现场=结账现场），rider/改写/加值/
  段数/状态五族按迁移前算序施加（重锤两拍/专注/spike 恒全额/猎弱移档/魔网湛蓝猎手克制直调/整备每层
  +1/厚积满层倍乘/奥术+猎巢+执拗 rider 合计后档位暴击）；armor_roll 免掷恒折扣、clamp_check 双面
  （hero+board_typed）delta 窗口、kill 溢出弹射（landed×value%）、damage_taken shield 加法族合计。
  _feat_clamp_bonus/13 处旗消费点拆除。
- battle_orchestrator：_combat_segment 换代（dig_streak/charge_layers 注伤害控制器运行态；连珠矢段数
  施加位紧随主角攻击单开立=迁移前开单位，flush 兑现序逐位一致）；round_start 发射位前移至行动经济轮
  切换前（树规则 grant_ap queue 当轮入队当轮兑现——先手压制首轮语义锚）；深挖快照滚动拆除（计数器
  reset_at 声明承载）；熔火/连击旧计数变量退役。
- action_economy：feat_ap_carry/feat_dig_extra/deep_paid_count 旧注入旗拆除；dig_paid 施加面落地
  （counter_spend 对价：AP 富余付全价积计数、不足 fallback 只付基础 1——2026-10-04 降级口径逐位保留）。
- feat_table schema：HOOKS 23 挂点枚举/MINE_HOOKS/EFFECT_KEYS/hook+effects 双形态校验全删——triggers
  订阅形态唯一合法行形（行键白名单收口 feat_id/display_name/rarity/archetype/triggers/desc/note）。
- feats_engine：hooks_for 挂点投影退役（订阅装载序=feats 表序，由效果引擎 rebuild 承载）。
- battle_narrator：专长卡片文案表值化（summaries 硬编码映射拆除，读行 desc——27 件措辞逐字迁移）。
- smoke 断言面随迁（任务书 v1.1 补列项）：构造表 5 行换代 triggers 形态；挂点投影断言换代订阅装载面；
  ④-⑧ 求值断言（_feat_flags_for 直呼+旗读数）全量改写为 rebuild+dispatch 命中面（27 件逐事件覆盖）；
  深挖钻头付费开掘回归闸改 counter_spend 计数器面；特性卡 desc 直读断言新增。

映射表对拍注记（行为等价优先，.tres 尾注同步留痕）：猎巢人/矿工的执拗映射表标 modify_ticket/attack_bonus，
现行为必中附加通道（hero_rider 后置于乘区与下限）——落 add_ticket_rider（per 取数载荷）；整备军备现行为
双效果（轮末转蓄力+每层首段攻 +1）——两行订阅；深挖钻头 per-round 计数器对（paid/given）复刻旧 v2
跨轮不对称语义（given 不随轮重置）。

验证：冒烟 800 项 0 失败（三闸过）· 单元 17 套全绿 · S1 魔法流对拍预检=MC formed/off 两态与 T0 pre 锚
（83000 种子段）同种子逐位一致（2×5 局，三档只测不判）——14 件迁移行实战斗承载零分岔。

设计权威：design/research/研究-内容数据驱动扩展架构-2026-10-06.md（案乙）。
任务书：design/research/任务书-内容数据驱动扩展批-2026-10-06.md §六 T3、§五映射表、§七契约 2/4。

game/core/action_economy.gd

@@ -35,19 +35,12 @@ var last_round_end: Dictionary:
 var _settlement_consumed := false            # AC-14 门：notify_settlement_done 消费后才受理 round_start
 var _next_round_mode := ""                   # 调试观测量（同板续轮 / 换新图）
 var _pending_ap_delta := 0                   # 下轮行动点修正排队（格面资源八型批 2026-09-20——action 型 ±1 排队，轮开始兑现后清零）
-# 蓄力流运行态（迭代 12 T5——relic 件注入面；false=关着零扰动）：
-# feat_ap_carry=整备军备（轮末剩余 AP 转蓄力层替代 RAP 转存——cleared 作废口径改写的停手侧承载）；
-# feat_dig_extra=深挖钻头付费开掘对价（R4 甲非信息税形态；2026-10-04 试玩缺陷修复——对价挂付费
-# 开掘侧：AP 富余时挖掘付全价 1+extra 积付费计数、AP 不足时降级只付基础 1 照常开格不积计数——
-# 原「持有期所有挖掘无条件 +1」实现把对价错挂成普通挖掘税，AP=1 锁死开格）；charge_layers=蓄力层账本。
-var feat_ap_carry := false
-var feat_dig_extra := 0
+# 蓄力流运行态（迭代 12 T5 → 内容数据驱动扩展批 T3 换代：旧 feat_ap_carry/feat_dig_extra 注入旗
+# 退役——转蓄力=round_end grant_ap(mode:transfer) 订阅（finish_round_stop 定夺）、深挖对价=dig_paid
+# counter_spend 订阅（request_dig 施加面）；charge_layers=蓄力层账本）
 var _charge_layers := 0
 var charge_layers: int:
 	get: return _charge_layers
-var _deep_paid_count := 0
-var deep_paid_count: int:
-	get: return _deep_paid_count
 # 效果引擎（内容数据驱动扩展批 T1——dig_paid/charge_full 发射面；round_end 转存决策面）
 var _fx: EffectEngine = null
 var _last_stop_ap := 0   # 停手侧剩余 AP 记账（转存决策移至 round_end 发射点——grant_ap(transfer) 订阅定夺）
@@ -94,21 +87,25 @@ func try_spend(action_kind: String) -> bool:
 
 
 # 排雷玩法 挖掘专用：chain_size = 连锁附加格数（不含首格）；clears_map = 本次动作后全图安全格开完。
-# 深挖钻头付费开掘（2026-10-04 缺陷修复——对价挂付费侧）：AP 富余（≥基础+extra）时本动作付全价
-# 并积付费开掘计数（orchestrator 深层产出配额取数面）；AP 不足全价时**降级只付基础 1 照常开格**、
-# 不积计数——持有钻头永不锁死普通挖格（散件保底 B-2）。
+# 深挖钻头付费开掘（内容数据驱动扩展批 T3——dig_paid counter_spend 订阅施加面，2026-10-04 缺陷
+# 修复口径不变）：按序消耗族——AP 富余（≥基础+对价）时本动作付全价并积本轮付费计数（效果引擎
+# 计数器=授予段追加产出配额取数面）；AP 不足全价时 fallback 降级只付基础 1 照常开格、不积计数
+# ——持有钻头永不锁死普通挖格（散件保底 B-2）。
 func request_dig(chain_size: int, clears_map: bool) -> bool:
 	if _phase != Phase.ACTIVE:
 		_reject("phase")
 		return false
 	var cost := _cost("dig")
-	if feat_dig_extra > 0 and _ap >= cost + feat_dig_extra:
-		cost += feat_dig_extra
-		_deep_paid_count += 1
-	# dig_paid 发射点（内容数据驱动扩展批 T1——付费开掘发起、动作经济闸收对价前；
-	# 深挖钻头 counter_spend 对价订阅面。双轨期对价仍走 feat_dig_extra 旧面）
+	# dig_paid 发射+施加（内容数据驱动扩展批 T3——付费开掘发起、动作经济闸收对价前：
+	# counter_spend 命中=尝试加收对价并积计数；资源不足走 fallback/耗尽即止=只付常规基础对价）
 	if _fx != null:
-		_fx.dispatch("dig_paid", {"ap_cost": cost, "ap_surplus": _ap - cost})
+		for h in _fx.dispatch("dig_paid", {"ap_cost": cost, "ap_surplus": _ap - cost}):
+			if String(h.get("kind", "")) != "counter_spend":
+				continue
+			var extra := int(h.get("value", 1))
+			if _ap >= cost + extra:
+				cost += extra
+				_fx.counter_add(String(h.get("counter_id", "")), 1)
 	if _ap < cost:
 		_reject("resource_face")
 		return false

game/core/battle_orchestrator.gd

@@ -77,15 +77,11 @@ var attunement: Array = []                 # 装备中同调件 item_id 集
 var _attune_charges_ref: Dictionary = {}   # 充能账本共享引用（迭代 11 第①批 T6——use_treasure 消费直改）
 var _attune_bank := 0                      # 掘进蓄能积点（battle 域——每 charge_n 安全格 +1 点）
 var _attune_safe_seen := 0                 # 掘进蓄能 battle 域安全开格计数
-# 特性运行态（迭代 12 T2——relic 持有集经 enc.feats 注入；求值旗注 damage_controller.feat_flags；
-# 魔矢每战首次计数 battle 域。空集=零扰动）
+# 特性运行态（内容数据驱动扩展批 T3——relic 持有集经 enc.feats 注入：效果行为=数据行 triggers 经
+# 效果引擎分发；魔矢每战首次计数 battle 域。空集=零扰动）
 var _feat_first_dig_used := false
-var _feat_combo := 0        # 矿脉直觉连击计数（battle 域——safe +1/mine 清零）
-var _feat_deep_given := 0        # 深挖钻头本轮已追加份数（battle 域——v2 本格双份制：safe 事件按付费数上限）
-var _feat_paid_at_round_start := 0  # 轮初付费计数快照（v2——本轮付费次数=当前值−快照）
-var _feat_magma_layers := 0 # 熔火之躯积层（battle 域——受地形伤 +1，轮末反打清零）
 # 效果引擎（内容数据驱动扩展批 T1——发布订阅解释器；begin_battle 从持有集/装备集重建订阅。
-# 双轨过渡期：发射点 dispatch 仅观测命中（施加面仍走 feat_flags 旧消费点），T3 起逐点切换）
+# T3 起施加面全量切换：发射点 dispatch 返回命中，发射点按组合规则施加——旧 feat_flags 旗注入消亡）
 var _fx: EffectEngine
 
 
@@ -96,6 +92,14 @@ func _fx_emit(event: String, payload: Dictionary) -> Array:
 	return _fx.dispatch(event, payload, Callable(self, "_fx_fact"))
 
 
+# round_start 发射+施加（内容数据驱动扩展批 T3——grant_ap mode:queue=当轮入队，行动经济轮切换
+# 即兑现；计数器 round_start 重置点在 dispatch 内生效。调用点两处：begin_battle 首轮 / 轮始段续轮）
+func _emit_round_start() -> void:
+	for h in _fx_emit("round_start", {"round": round_index}):
+		if String(h.get("kind", "")) == "grant_ap" and String(h.get("mode", "")) == "queue":
+			action_economy.queue_ap_delta(int(h.get("value", 0)))
+
+
 # 补充事实面（fact 取值第二优先源——payload 未携带的运行态读数）
 func _fx_fact(fact: String):
 	match fact:
@@ -131,89 +135,9 @@ func _attune_mag(item_id: String) -> int:
 	return int(_attune_row(item_id).get("magnitude", 0))
 
 
-# 特性求值（迭代 12 T2——持有集 × feat_table → damage_controller.feat_flags 注入面）：
-# rider_flat = Σ rider 件 value（奥术余烬 +1 / 魔能共鸣 +2）；magic 档一（≥2 件）rider +1、
-# 档二（≥4 件）rider 可暴击；clamp 两件直调键；first_dig_spell 旗（魔能共鸣第二效果——魔矢值
-# = 件 effects.value）。空集/空表 = 零旗零扰动。
-func _feat_flags_for(feat_ids: Array) -> void:
-	var flags: Dictionary = {}
-	if not feat_ids.is_empty() and db.feats != null and not db.feats.rows.is_empty():
-		var hooks := FeatsEngine.hooks_for(feat_ids, db.feats)
-		var tiers := FeatsEngine.tiers_for(feat_ids, db.feats)
-		for h in hooks:
-			var hook: String = String(h.get("hook", ""))
-			var fx: Dictionary = h.get("effects", {}) as Dictionary
-			match hook:
-				"hero_attack_rider":
-					flags["rider_flat"] = int(flags.get("rider_flat", 0)) + int(fx.get("value", 0))
-				"clamp_modifier":
-					# clamp 方向按件 note 词分流（魔网=magic-vs-magic 罚修正 / 湛蓝=magic-vs-heavy 加成）
-					if String(fx.get("polarity", "")) == "magic_vs_magic":
-						flags["clamp_magic_magic"] = int(flags.get("clamp_magic_magic", 0)) + int(fx.get("value", 0))
-					elif String(fx.get("polarity", "")) == "magic_vs_heavy":
-						flags["clamp_magic_heavy"] = int(flags.get("clamp_magic_heavy", 0)) + int(fx.get("value", 0))
-					elif String(fx.get("polarity", "")) == "pierce_vs_light":
-						flags["clamp_pierce_light"] = int(flags.get("clamp_pierce_light", 0)) + int(fx.get("value", 0))
-				"first_dig_spell":
-					flags["first_dig_spell"] = true
-					flags["spell_value"] = int(fx.get("value", 0))
-				"flag_resource":
-					flags["flag_resource_extra"] = int(fx.get("value", 0))
-				"nest_aura":
-					flags["nest_aura_value"] = int(fx.get("value", 0))
-				"flag_all_hit":
-					flags["flag_all_hit_mult"] = int(fx.get("value", 0))
-				"flag_strike":
-					flags["flag_strike_value"] = int(fx.get("value", 0))
-				"kill_overflow":
-					flags["kill_overflow"] = true
-				"dig_count_segments":
-					flags["chain_value"] = int(fx.get("value", 0))
-					flags["chain_cap"] = int(fx.get("cap", 2))
-				"roll_discount":
-					flags["discount_shift"] = int(fx.get("value", 0))
-				"round_dig_bonus":
-					flags["round_dig_value"] = int(fx.get("value", 0))
-					flags["round_dig_cap"] = int(fx.get("cap", 5))
-				"hit_trade":
-					flags["hit_trade_atk"] = int(fx.get("trade_atk", 0))
-					flags["hit_trade_hit"] = int(fx.get("trade_hit", 0))
-				"armor_roll_rewrite":
-					flags["armor_roll_rewrite"] = int(fx.get("value", 0))
-				"heavy_debuff":
-					flags["crack_value"] = int(fx.get("value", 0))
-				"dig_yield_mult":
-					# 开格产出乘区族（贪婪矿灯/矿脉直觉/赌徒的血签——正负双向，同 hook 累加）
-					flags["dig_yield_pos_mult"] = int(flags.get("dig_yield_pos_mult", 0)) + int(fx.get("mult", 0))
-					flags["dig_yield_neg_mult"] = int(flags.get("dig_yield_neg_mult", 0)) + int(fx.get("cost_mult", 0))
-					if int(fx.get("cap", 0)) > 0:
-						flags["combo_cap"] = int(fx.get("cap", 0))   # 矿脉直觉连击上限
-				"deep_dig":
-					flags["deep_dig_cost"] = int(fx.get("ap_cost", 0))
-					flags["deep_dig_cap"] = int(fx.get("cap", 4))
-				"ap_carry":
-					flags["ap_carry_value"] = int(fx.get("value", 0))
-				"charge_shield":
-					flags["shield_per_layer"] = int(fx.get("shield_per_layer", 0))
-				"charge_spike":
-					flags["spike_mult"] = int(fx.get("value", 0))
-				"terrain_refund":
-					flags["terrain_refund"] = int(fx.get("value", 0))
-				"terrain_dig_double":
-					flags["terrain_dig_double"] = int(fx.get("value", 0))
-				"flag_neutralize":
-					flags["flag_neutralize"] = int(fx.get("value", 0))
-				"variant_counter":
-					flags["variant_counter_value"] = int(fx.get("value", 0))
-		var mt := int(tiers.get("magic", 0))
-		if mt >= 1:
-			flags["rider_flat"] = int(flags.get("rider_flat", 0)) + 1   # 档一质变（≥2 件）：rider +1（provisional）
-		if mt >= 2:
-			flags["rider_crit"] = true   # 档二质变（≥4 件）：rider 可暴击（crit 时乘暴击倍率）
-	_damage.feat_flags = flags
-	# 蓄力流/深挖钻头 action_economy 注入（求值即注入——冒烟直呼 _feat_flags_for 同面生效）
-	action_economy.feat_ap_carry = int(flags.get("ap_carry_value", 0)) > 0
-	action_economy.feat_dig_extra = int(flags.get("deep_dig_cost", 0))
+# 特性求值（内容数据驱动扩展批 T3——_feat_flags_for 挂点求值退役：效果行为=数据行 triggers 订阅，
+# 效果引擎 dispatch 分发；旧 23 hook 枚举与旗注入消亡。流派档位质变=FeatsEngine 纯函数求值
+# （档位机制本身系引擎基建非内容效果），两运行态注伤害控制器：档一 rider+1 / 档二 rider 可暴击）
 var _flag_miss_seen := {}                  # 标旗未中行去重（每安全格实例一次）
 var _perfect_hit_true := 0                 # 板级完美排雷计数（install 重置）
 var _perfect_hit_false := 0
@@ -288,24 +212,25 @@ func begin_battle(enc: Dictionary) -> bool:
 	_attune_safe_seen = 0
 	_damage.attune_venom = _attune_mag("venom_edge") if _attune_has("venom_edge") else 0
 	_reward_economy.luck_bias = _attune_mag("luck_coin") if _attune_has("luck_coin") else 0
-	# 特性运行态注入（迭代 12 T2 魔法流——enc.feats 携带持有集；FeatsEngine 求值后注伤害控制器
-	# feat_flags；空集/空表=零扰动。魔矢每战首次开格计数同步归零）
-	_feat_flags_for((enc.get("feats", []) as Array))
+	# 特性运行态（内容数据驱动扩展批 T3——enc.feats 携带持有集：效果行为=数据行 triggers 经效果
+	# 引擎分发；流派档位=FeatsEngine 纯函数求值两运行态注伤害控制器。魔矢每战首次开格计数同步归零）
+	var feat_ids: Array = enc.get("feats", []) as Array
+	if not feat_ids.is_empty() and db.feats != null:
+		var tiers: Dictionary = FeatsEngine.tiers_for(feat_ids, db.feats)
+		var mt := int(tiers.get("magic", 0))
+		_damage.rider_tier_bonus = 1 if mt >= 1 else 0
+		_damage.rider_tier_crit = mt >= 2
+	else:
+		_damage.rider_tier_bonus = 0
+		_damage.rider_tier_crit = false
 	_feat_first_dig_used = false
-	_feat_combo = 0
-	_feat_deep_given = 0
-	_feat_paid_at_round_start = 0
-	_feat_magma_layers = 0
-	# 树 rule 键消费（迭代 12 T10——Fork 激活侧 effects；真实接线首期两键：先手压制=战斗首轮
-	# AP+1（queue_ap_delta——先手压制语义）/稳健拓荒=敌方攻击减 1（伤害控制器 flags bulwark）；
-	# 其余 rule 键=stat 面投影不入战斗（T8 表内容 provisional 口径披露））
+	# 树 rule 键消费（迭代 12 T10 → 内容数据驱动扩展批 T3 换代：Fork 激活侧效果=效果引擎合成
+	# 订阅（rebuild 注入——round_start 首轮 AP+1 / damage_taken 减伤+1），旧直调拆除。其余 rule 键
+	# =stat 面投影不入战斗（T8 表内容 provisional 口径披露））
 	var tree_rules: Array = enc.get("tree_rules", []) as Array
-	if tree_rules.has("posture_first_strike"):
-		action_economy.queue_ap_delta(1)
-	_damage.feat_flags["bulwark"] = 1 if tree_rules.has("posture_bulwark") else 0
 	# 效果引擎订阅重建（内容数据驱动扩展批 T1——每战从持有集/装备集重建，中途获得下一战生效；
 	# 树规则合成订阅同面装载。装载序=feats 表序→treasure 表序→树规则，写死保种子复放）
-	_fx.rebuild((enc.get("feats", []) as Array), attunement, tree_rules)
+	_fx.rebuild(feat_ids, attunement, tree_rules)
 	# 迭代 10 奖励重构批——跨冒险行动点加成轴（统一冒险加算区第四轴）：经排队修正通道兑现
 	# 「每场战斗开始首轮 AP +加成值」（queue_ap_delta = 下轮开轮基线加算、notify_round_start 兑现后
 	# 清零——首轮即消费，后续轮次不重复兑现；语义锚 = 行动经济 GDD「跨冒险行动点加成轴」节）
@@ -315,12 +240,15 @@ func begin_battle(enc: Dictionary) -> bool:
 	# 工兵晨令（迭代 11 同调批 T5——前 effective_rounds 轮每轮 +1 AP；首轮在此入队，后续轮在轮始段续队）
 	if _attune_has("dawn_order"):
 		action_economy.queue_ap_delta(_attune_mag("dawn_order"))
+	# round_start 发射+施加（内容数据驱动扩展批 T3——发射位先于行动经济轮切换：树规则 grant_ap
+	# mode:queue 当轮入队、notify_round_start 即兑现（先手压制=首轮 AP+1 语义锚，与迁移前
+	# begin_battle 直调 queue_ap_delta 逐位一致）；计数器 round_start 重置点同点生效）
+	round_index = 1
+	_emit_round_start()
 	if not action_economy.notify_round_start():
 		_fatal("行动经济 首轮 notify_round_start 被拒")
 		return false
-	round_index = 1
 	_roll_round_actions()   # 开轮摇号（敌人技能池批——首轮同样摇；先于 round_started，挖掘期动画位可读）
-	_fx_emit("round_start", {"round": round_index})
 	round_started.emit(round_index)
 	return true
 
@@ -511,49 +439,68 @@ func _settle() -> void:
 				# 作废（归因行在案）；标空判定已随旗擦除自然缺席（被挖的旗不在轮末在场基线）。
 				_emit_row("reward_ineffective", "safe_cell", evt.cell, ri, "奖励作废（插旗格直接挖开——零惩罚零奖励）", 0, {}, "")
 				continue
-			# dig_reveal 发射点（内容数据驱动扩展批 T1——安全开格结算完成；载荷含首格事实与变异类型）
-			_fx_emit("dig_reveal", {"cell": evt.cell, "round": ri,
+			# dig_reveal 发射+施加（内容数据驱动扩展批 T3——桶序固定承载等价：
+			# 乘区收集 → 正向兑付 → 计数器 → 追加产出（深挖）→ 奥术矢）
+			var dr_hits := _fx_emit("dig_reveal", {"cell": evt.cell, "round": ri,
 				"is_first_dig_of_battle": not _feat_first_dig_used,
-				"terrain_kind": (evt.get("variant_ids", []) as Array)})
-			_grant_routed(_feat_yield_adjust(snap, true), "positive", "safe_cell", evt.cell, ri, "")
-			# 开格流连击/深层产出（迭代 12 T5）：矿脉直觉连击 = safe +1（mine 清零在负向分支）；
-			# 深挖钻头深层产出 = 每 cap 格额外 grant 一份（收益面补偿额外 AP 成本——R4 甲非信息税对价）
-			_feat_combo += 1
-			# 深挖钻头 v2（2026-10-04 二次修正——用户实测「付 2AP 无可见提升纯挨打」：v1 配额制
-			# 4 次付费 8AP 换 1 份随机资源=净负期望+收益埋明细带不可感知）：改**本格双份**——
-			# 付费挖掘的本格资源直接双份（多花 1AP 买多一份同格产出，账目直白期望微正）。
-			# 本轮付费次数 N=deep_paid_count−轮初快照；safe 事件按 N 上限逐格追加第二份（「深挖」）。
-			var dd_cost := int(_damage.feat_flags.get("deep_dig_cost", 0))
-			if dd_cost > 0:
-				var paid_this_round := int(action_economy.deep_paid_count) - _feat_paid_at_round_start
-				if paid_this_round > 0 and _feat_deep_given < paid_this_round:
-					_feat_deep_given += 1
+				"terrain_kind": _harmful_variants(evt.get("variant_ids", []) as Array)})
+			var pos_m := 0
+			var neg_m := 0
+			var combo_cap := -1
+			for h in dr_hits:
+				if String(h.get("kind", "")) != "yield_mult":
+					continue
+				pos_m += int(h.get("mult", 0))
+				neg_m += int(h.get("cost_mult", 0))
+				if int(h.get("cap", 0)) > 0:
+					combo_cap = int(h.cap)   # 矿脉直觉连击上限
+			_grant_routed(_feat_yield_adjust(snap, true, pos_m, neg_m, combo_cap), "positive", "safe_cell", evt.cell, ri, "")
+			# 计数器执行（连击计数——加法族，乘区收集后执行=本格兑付用旧值，与迁移前逐位一致）
+			for h in dr_hits:
+				if String(h.get("kind", "")) == "counter_add":
+					var set_v = h.get("set", null)
+					_fx.counter_add(String(h.get("counter_id", "")), int(h.get("value", 0)) if set_v == null else int(set_v), set_v != null)
+			# 追加产出（深挖钻头 v2——本格双份制：grant_material 命中=配额内追加第二份；标签随行）
+			for h in dr_hits:
+				if String(h.get("kind", "")) == "grant_material":
 					var dd_snap = _reward_economy.grant(evt.cell)
 					if dd_snap is Dictionary:
-						_grant_routed(dd_snap, "positive", "safe_cell", evt.cell, ri, "", "（深挖）")
-			# 魔能共鸣·每战首次开安全格追加魔法矢（迭代 12 T2——relic 件「每关首次开格必出魔法矢」
-			# 落地为每战首次〔战斗域单事务无跨战状态——「每关」字面改「每战」台账披露待追认〕；
-			# board_typed magic 必中，扫雷结算触发点=relic 挂 first_dig_spell 承载红线①）
-			if bool(_damage.feat_flags.get("first_dig_spell", false)) and not _feat_first_dig_used:
+						_grant_routed(dd_snap, "positive", "safe_cell", evt.cell, ri, "", String(h.get("label", "")))
+			# 奥术矢（魔能共鸣——每战首次开安全格追加魔法矢；任意真族单次生效）
+			var spell_hits: Array = _hits_of(dr_hits, "spawn_spell")
+			if not spell_hits.is_empty() and not _feat_first_dig_used:
 				_feat_first_dig_used = true
 				var spell_t := _damage.open_ticket(DamageController.KIND_BOARD_TYPED, "feat_first_dig_spell",
-					"奥术矢", "board", int(_damage.feat_flags.get("spell_value", 0)),
+					"奥术矢", "board", int((spell_hits[0] as Dictionary).get("value", 0)),
 					DamageController.TARGET_FRONT_ALIVE, ri, evt.cell, "magic")
 				_submit(spell_t, false)
-		# 掘进蓄能计数（迭代 11 同调批 T6——battle 域安全开格计数，每 charge_n 格积 1 点）
-		if _attune_has("dig_charge"):
-			_attune_safe_seen += 1
-			var cn_b: int = int(db.treasure_item_row("dig_charge").get("charge_n", 999))
-			if cn_b > 0 and _attune_safe_seen % cn_b == 0:
-				_attune_bank += 1
+			# 掘进蓄能计数（迭代 11 同调批 T6——battle 域安全开格计数，每 charge_n 格积 1 点）
+			if _attune_has("dig_charge"):
+				_attune_safe_seen += 1
+				var cn_b: int = int(db.treasure_item_row("dig_charge").get("charge_n", 999))
+				if cn_b > 0 and _attune_safe_seen % cn_b == 0:
+					_attune_bank += 1
 		elif evt.kind == "mine":
 			# 插旗不可逆四情况②：插雷格再挖开 = 只受挖雷一层惩罚（mine_hit 照常兑付——惊动巢穴），
 			# 标中不发（旗已随挖掘擦除、不入轮末判定基线）。
-			# mine_hit 发射点（内容数据驱动扩展批 T1——踩雷时；减半/反打/连击清零订阅面）
-			_fx_emit("mine_hit", {"cell": evt.cell, "round": ri,
+			# mine_hit 发射+施加（内容数据驱动扩展批 T3——桶序固定承载等价：
+			# 减半收集 → 负向兑付〔带减半系数〕→ 反打开单 → 连击清零计数器）
+			var mh_hits := _fx_emit("mine_hit", {"cell": evt.cell, "round": ri,
 				"damage": int((snap as Dictionary).get("power", 0))})
-			_grant_routed(_feat_yield_adjust(snap, false), "negative", "mine_hit", evt.cell, ri, "")
-			_feat_combo = 0   # 矿脉直觉连击清零（踩雷断连——「推理密度直接奖励」的对侧）
+			var halve_pct := 0
+			for h in mh_hits:
+				if String(h.get("kind", "")) == "damage_mult":
+					halve_pct += int(h.get("value", 0))
+			for h in mh_hits:
+				if String(h.get("kind", "")) == "counter_add":
+					var set_v = h.get("set", null)
+					_fx.counter_add(String(h.get("counter_id", "")), int(h.get("value", 0)) if set_v == null else int(set_v), set_v != null)
+			_grant_routed(_feat_yield_adjust(snap, false, 0, 0, -1), "negative", "mine_hit", evt.cell, ri, "", "", halve_pct)
+			for h in mh_hits:
+				if String(h.get("kind", "")) == "open_ticket" and String(h.get("channel", "")) == "reflect":
+					var nct := _damage.open_ticket(DamageController.KIND_BOARD_BLAST, "attune_nest_counter", "惊巢反制·反弹", "board",
+						int(h.get("value", 0)), DamageController.TARGET_ALL_ALIVE, ri, evt.cell, "", 0, "", {})
+					_submit(nct, false)
 	# 地形变异 兑付段（授予段尾——触发枚举 on_open：挖开即伤、chain 通道同口径；伤害单据案C 暂存到
 	# 战斗段末兑付〔2026-10-06 用户裁〕；信息型 hide_number 不进结算——呈现层读取，见 board_view 数字遮蔽；
 	# 雷格恒无变异——布置段排除，双层叠罚不存在；插旗格直挖照吃变异伤害——地形后果同 mine_hit 口径，
@@ -568,30 +515,27 @@ func _settle() -> void:
 			var vt := _damage.open_ticket(DamageController.KIND_BOARD_FLAT_HERO, "地形变异", String(vrow.get("display_name", vid)), "board", \
 				int(vrow.get("effect_value", 0)), DamageController.TARGET_HERO, ri, evt.cell, "", 0, "", {"variant_id": String(vid)})
 			_submit(vt, false)
-			# damage_taken 发射点（内容数据驱动扩展批 T1——kind=terrain；荆棘/地脉/熔火订阅面）
-			_fx_emit("damage_taken", {"kind": "terrain", "amount": int(vrow.get("effect_value", 0)),
-				"source": String(vid), "cell": evt.cell, "round": ri})
-			# 吞噬流四面（迭代 12 T6——地形从纯税到第三资源带；伤害仍发生=乙稿判据 3 承载）：
-			# ①荆棘编织者=挖开伤害型地形格额外掉落一次格面资源（主动吃地形换资源）
-			if int(_damage.feat_flags.get("terrain_dig_double", 0)) > 0:
-				var tw_snap = _reward_economy.grant(evt.cell)
-				if tw_snap is Dictionary:
-					_grant_routed(tw_snap, "positive", "safe_cell", evt.cell, ri, "", "（荆棘编织）")
-			# ②地脉采撷=受地形伤掉落小额资源补偿（薄矿化——每次受伤兑一份）
-			if int(_damage.feat_flags.get("terrain_refund", 0)) > 0:
-				var lh_snap = _reward_economy.grant(evt.cell)
-				if lh_snap is Dictionary:
-					_grant_routed(lh_snap, "positive", "safe_cell", evt.cell, ri, "", "（地脉补偿）")
-			# ③熔火之躯=受地形伤积层（触发键=「受地形伤」通用不按种类特化——定稿红线承载）
-			if int(_damage.feat_flags.get("variant_counter_value", 0)) > 0:
-				_feat_magma_layers += 1
+			# damage_taken(kind=terrain) 发射+施加（内容数据驱动扩展批 T3——荆棘/地脉 grant_material
+			# 即时执行 + 熔火积层 counter_add；行序随订阅声明序〔ley 表序在 thorn 前〕，兑付值逐位一致）
+			var dt_hits := _fx_emit("damage_taken", {"kind": "terrain", "amount": int(vrow.get("effect_value", 0)),
+				"source": String(vid), "cell": evt.cell, "round": ri, "terrain_kind": String(vid)})
+			for h in dt_hits:
+				match String(h.get("kind", "")):
+					"grant_material":
+						var tw_snap = _reward_economy.grant(evt.cell)
+						if tw_snap is Dictionary:
+							_grant_routed(tw_snap, "positive", "safe_cell", evt.cell, ri, "", String(h.get("label", "")))
+					"counter_add":
+						var set_v = h.get("set", null)
+						_fx.counter_add(String(h.get("counter_id", "")), int(h.get("value", 0)) if set_v == null else int(set_v), set_v != null)
 	for evt in _facts_flags:
 		_judge_flag(evt, ri)
 	# 战旗军规开单段（迭代 12 T3 标旗流——flag_judged 批后统一开单：轮末每面标中旗对最前存活敌
 	# 结算 board_typed 必中伤害〔复用零新配方；「旗所在巢穴敌」简化为 default_target 最前存活敌——
 	# 台账披露待追认〕；完美布防=本轮旗批全中（hit>0 且 miss==0）时旗伤 ×mult——全对推理奖励）。
-	# 扫雷结算触发点=flag_strike/flag_all_hit/nest_aura 挂点承载红线①；伤害单据案C 暂存战斗段末兑付。
-	# flag_settle 发射点（内容数据驱动扩展批 T1——轮末旗伤结算；战旗开单/完美布防订阅面）
+	# 伤害单据案C 暂存战斗段末兑付。
+	# flag_settle 发射+施加（内容数据驱动扩展批 T3——战旗 open_ticket + 完美布防 modify_ticket
+	# 改写窗口：旗伤基值×完美倍率后逐旗开单，与迁移前算序一致）
 	var fs_hits := 0
 	var fs_misses := 0
 	for fevt in _facts_flags:
@@ -599,44 +543,45 @@ func _settle() -> void:
 			fs_hits += 1
 		else:
 			fs_misses += 1
-	_fx_emit("flag_settle", {"flags_hit_all": fs_hits > 0 and fs_misses == 0,
+	var fs_fx := _fx_emit("flag_settle", {"flags_hit_all": fs_hits > 0 and fs_misses == 0,
 		"flags_count": fs_hits, "round": ri})
-	if int(_damage.feat_flags.get("flag_strike_value", 0)) > 0:
-		var hits := 0
-		var misses := 0
+	var banner_hits: Array = []
+	for h in fs_fx:
+		if String(h.get("kind", "")) == "open_ticket" and String(h.get("channel", "")) == "attack":
+			banner_hits.append(h)
+	if not banner_hits.is_empty():
+		var strike_value := int((banner_hits[0] as Dictionary).get("value", 0))
+		var flag_mult := 1
+		for h in fs_fx:
+			if String(h.get("kind", "")) == "modify_ticket" and String(h.get("mode", "")) == "flag_mult":
+				flag_mult *= maxi(1, int(h.get("value", 1)))
+		if fs_misses == 0 and fs_hits > 0 and flag_mult > 1:
+			strike_value *= flag_mult   # 完美布防：同轮全中旗伤倍增（全对推理奖励）
 		for fevt in _facts_flags:
-			if bool(fevt.get("hit", false)):
-				hits += 1
-			else:
-				misses += 1
-		if hits > 0:
-			var mult := int(_damage.feat_flags.get("flag_all_hit_mult", 1))
-			var strike_value := int(_damage.feat_flags.get("flag_strike_value", 0))
-			if misses == 0 and mult > 1:
-				strike_value *= mult   # 完美布防：同轮全中旗伤倍增（全对推理奖励）
-			for fevt in _facts_flags:
-				if not bool(fevt.get("hit", false)):
-					continue
-				var st_t := _damage.open_ticket(DamageController.KIND_BOARD_TYPED, "feat_flag_strike",
-					"战旗军规", "board", strike_value, DamageController.TARGET_FRONT_ALIVE, ri,
-					fevt.cell, "normal")
-				_submit(st_t, false)
-	# 熔火之躯轮末反打（迭代 12 T6 吞噬流——受地形伤积层，对全体敌 ~1 必中反伤；
-	# 触发键=「受地形伤」通用不按地形种类特化——定稿红线承载；反打后清零；单据案C 暂存战斗段末）
-	var magma := int(_damage.feat_flags.get("variant_counter_value", 0))
-	if magma > 0 and _feat_magma_layers > 0:
-		var mg_t := _damage.open_ticket(DamageController.KIND_BOARD_BLAST, "feat_magma_body",
-			"熔火反噬 ×%d" % _feat_magma_layers, "board", magma * _feat_magma_layers,
-			DamageController.TARGET_ALL_ALIVE, ri, minesweeper.hero_pos(), "", 0, "", {})
-		_submit(mg_t, false)
-		_feat_magma_layers = 0
-	# round_end 发射点（内容数据驱动扩展批 T1——每轮结算收口；熔火反打/整备转蓄力订阅面。
-	# 转蓄力等价说明：停手侧 AP 已在 request_stop 记账（last_stop_ap），转存决策在本点由
-	# grant_ap(mode:transfer) 订阅定夺——双轨期旧旗 feat_ap_carry 并行生效，无订阅走 RAP
-	# 转存缺省，行为与迁移前逐位一致）
-	_fx_emit("round_end", {"round": ri})
-	action_economy.finish_round_stop(action_economy.feat_ap_carry
-		or (_fx != null and _fx.has_effect_on("round_end", "grant_ap", "transfer")))
+			if not bool(fevt.get("hit", false)):
+				continue
+			var st_t := _damage.open_ticket(DamageController.KIND_BOARD_TYPED, "feat_flag_strike",
+				"战旗军规", "board", strike_value, DamageController.TARGET_FRONT_ALIVE, ri,
+				fevt.cell, "normal")
+			_submit(st_t, false)
+	# round_end 发射+施加（内容数据驱动扩展批 T3——每轮结算收口：熔火之躯反打单开立〔open_ticket
+	# 即时执行〕+积层清零〔counter_add set〕；整备转蓄力由 finish_round_stop 承载——停手侧 AP 已在
+	# request_stop 记账，转存决策=grant_ap(mode:transfer) 订阅定夺，无订阅走 RAP 转存缺省）
+	var re_fx := _fx_emit("round_end", {"round": ri})
+	for h in re_fx:
+		if String(h.get("kind", "")) == "open_ticket" and String(h.get("channel", "")) == "blast":
+			var mg_layers := _fx.counter(String(h.get("per", "")))
+			var mg_total := int(h.get("value", 0)) * mg_layers
+			if mg_total > 0:
+				var mg_t := _damage.open_ticket(DamageController.KIND_BOARD_BLAST, "feat_magma_body",
+					"熔火反噬 ×%d" % mg_layers, "board", mg_total,
+					DamageController.TARGET_ALL_ALIVE, ri, minesweeper.hero_pos(), "", 0, "", {})
+				_submit(mg_t, false)
+	for h in re_fx:
+		if String(h.get("kind", "")) == "counter_add":
+			var set_v = h.get("set", null)
+			_fx.counter_add(String(h.get("counter_id", "")), int(h.get("value", 0)) if set_v == null else int(set_v), set_v != null)
+	action_economy.finish_round_stop(_fx != null and _fx.has_effect_on("round_end", "grant_ap", "transfer"))
 	if _facts_path == "cleared":
 		_grant_clear_reward(ri)
 	_damage.flush()   # 授予段界结账（案C 后本段伤害单据全数暂存，此处对空队 no-op——保留作防御性段界）
@@ -665,31 +610,62 @@ func _settle() -> void:
 		return
 	_emit_row("verdict", "", Vector2i(-1, -1), ri, "下一轮次", 0, {}, "")
 	_exit_distribution()
-	# 深挖钻头 v2 轮初快照滚动（本轮付费次数已消费——下一轮 N=当前值−新快照）
-	_feat_paid_at_round_start = int(action_economy.deep_paid_count)
 	_settling = false
 
 
 # ---- 授予段 helpers（极性路由）----
 
-# 开格产出乘区（迭代 12 T5 开格流——贪婪矿灯/矿脉直觉/赌徒的血签；duplicate 隔离不回写快照）：
+# 开格产出乘区（内容数据驱动扩展批 T3 参数化——贪婪矿灯/矿脉直觉/赌徒的血签事件收集器注入）：
 # positive=power ×(1+静态 mult% + 矿脉直觉连击加成 min(cap,combo)×10%)；negative=power ×(1+cost%)。
-# 零旗=原快照原样返回（零扰动）。
-func _feat_yield_adjust(snap: Dictionary, positive: bool) -> Dictionary:
-	var pos_m := int(_damage.feat_flags.get("dig_yield_pos_mult", 0))
-	var neg_m := int(_damage.feat_flags.get("dig_yield_neg_mult", 0))
-	if positive and pos_m <= 0 and not _damage.feat_flags.has("combo_cap"):
+# 全零收集器=原快照原样返回（零扰动）。combo 读数=效果引擎 dig_combo 计数器（safe+1/mine 清零，
+# 跨轮累计——与迁移前 _feat_combo 逐位一致）。
+func _feat_yield_adjust(snap: Dictionary, positive: bool, pos_m: int, neg_m: int, combo_cap: int) -> Dictionary:
+	var combo_val := _fx.counter("dig_combo") if _fx != null else 0
+	if positive and pos_m <= 0 and combo_cap <= 0:
 		return snap
 	if not positive and neg_m <= 0:
 		return snap
 	var out: Dictionary = snap.duplicate()
 	var power := int(out.get("power", int(_reward_economy.polarity_row(String(out.get("cell_type", "")), "positive" if positive else "negative").power)))
 	var pct := pos_m if positive else neg_m
-	if positive and _damage.feat_flags.has("combo_cap"):
-		pct += mini(int(_damage.feat_flags.get("combo_cap", 5)), _feat_combo) * 10
+	if positive and combo_cap > 0:
+		pct += mini(combo_cap, combo_val) * 10
 	out["power"] = maxi(1, int(round(float(power) * (1.0 + float(pct) / 100.0))))
 	return out
 
+
+# 伤害型变异过滤（terrain_kind fact 取数面——variation 表 effect=flat_damage 判据；
+# 🔴 R4 甲永不对冲边界=仅限伤害型，信息型（hide_number 族）永不出现在本集）
+func _harmful_variants(vids: Array) -> Array:
+	var out: Array = []
+	for vid_v in vids:
+		var vid := String(vid_v)
+		var vrow: Dictionary = db.variation.row_by_id(vid)
+		if String(vrow.get("effect", "")) == "flat_damage":
+			out.append(vid)
+	return out
+
+
+# 邻接伤害型变异收集（terrain_kind fact 取数面——flag_hit 发射点用：标中旗相邻八格的伤害型变异集；
+# 🔴 R4 甲永不对冲边界=仅限伤害型，信息型〔hide_number 族〕不入集）
+func _harmful_adjacent(cell: Vector2i) -> Array:
+	var out: Array = []
+	var board: BoardData = minesweeper.current_board()
+	if board == null:
+		return out
+	for n in board.neighbors8(cell):
+		out.append_array(_harmful_variants(board.variant_ids(n)))
+	return out
+
+
+# 效果命中过滤（按效果类型取命中子集——发射点分桶施加面）
+func _hits_of(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
+
 # 「动作 × 格型」矩阵的执行面：snap = 缓冲期冻结身份快照（cell_type = 该格装板期摇定的类型身份），
 # polarity 由动作决定（开安全格/标中旗 = positive，开雷格/标错旗 = negative），
 # 兑付行 = 奖励字典（类型, 极性）行。返回 true = percent 行实际生效（flat 行恒 false——兑付结果由行协议承载）。
@@ -754,7 +730,7 @@ func set_treasure_unlocked(ids: Dictionary) -> void:
 	_reward_economy.set_treasure_unlocked(ids)
 
 
-func _grant_routed(snap: Dictionary, polarity: String, source_class: String, cell: Vector2i, ri: int, highlight: String = "", label_suffix: String = "") -> bool:
+func _grant_routed(snap: Dictionary, polarity: String, source_class: String, cell: Vector2i, ri: int, highlight: String = "", label_suffix: String = "", halve_pct: int = 0) -> bool:
 	# 迭代 11 第①批 T7——aux 授予分支随掉落/停点渠道退役拆除（reward 词表第十型 treasure_item 保留但零投放：
 	# 无 aux 行入池、CURIO_KINDS 词表已除名）；剩余类型走极性字典路由。
 	var row: Dictionary = _reward_economy.polarity_row(String(snap.get("cell_type", "")), polarity)
@@ -909,9 +885,10 @@ func _judge_flag(evt: Dictionary, ri: int) -> void:
 			return   # 去重跳过（资格以雷格实例为键——排雷玩法 诚实重复上报的对侧）；零明细行
 		_flag_consumed[cell] = true
 		_perfect_hit_true += 1
-		# flag_hit 发射点（内容数据驱动扩展批 T1——标中雷兑付时；殉爆/中和/图谱订阅面）
-		_fx_emit("flag_hit", {"cell": cell, "round": ri,
-			"adjacent_terrain": (minesweeper.current_board().variant_ids(cell) if minesweeper.current_board() != null else [])})
+		# flag_hit 发射+施加（内容数据驱动扩展批 T3——桶序固定承载等价：殉爆〔T4 秘宝面〕→
+		# 净化改写 → 图谱额外资源 → 基线兑付）
+		var fh_hits := _fx_emit("flag_hit", {"cell": cell, "round": ri,
+			"terrain_kind": _harmful_adjacent(cell)})
 		# 标中殉爆（迭代 11 同调批 T5——底稿 §3：每标中一面旗，全体存活敌吃 N 群伤；无类型走 blast 通道）
 		if _attune_has("flag_burst"):
 			var fbt := _damage.open_ticket(DamageController.KIND_BOARD_BLAST, "attune_flag_burst", "标中殉爆", "board",
@@ -920,7 +897,7 @@ func _judge_flag(evt: Dictionary, ri: int) -> void:
 		# 净化工兵（迭代 12 T6 吞噬流——标中旗中和相邻伤害型地形格）：🔴 R4 甲永不对冲边界=
 		# **仅限伤害型**（thorn/magma/rockfall——variation 表 effect=flat_damage 判据），信息型
 		# （hide_number 族）永不清除（红线①看门税不可对冲）；中和=变普通格（BoardData.clear_variants）。
-		if int(_damage.feat_flags.get("flag_neutralize", 0)) > 0:
+		if not _hits_of(fh_hits, "rewrite_board").is_empty():
 			var board: BoardData = minesweeper.current_board()
 			for n in board.neighbors8(cell):
 				var vids_n: Array = board.variant_ids(n)
@@ -935,10 +912,11 @@ func _judge_flag(evt: Dictionary, ri: int) -> void:
 					_emit_row("terrain_neutralized", "feat_purge_sapper", n, ri, "净化工兵·地形中和", 0, {}, "")
 		# 雷区图谱（迭代 12 T3 标旗流——标中雷额外获得一份格面资源：插旗开始产出对标开格；
 		# 复用 grant 单点，额外兑付走同一 _grant_routed 正向路由）
-		if int(_damage.feat_flags.get("flag_resource_extra", 0)) > 0:
-			var extra_snap = _reward_economy.grant(cell)
-			if extra_snap is Dictionary:
-				_grant_routed(extra_snap, "positive", "flag_hit", cell, ri, "", "（雷区图谱）")
+		for h in fh_hits:
+			if String(h.get("kind", "")) == "grant_material":
+				var extra_snap = _reward_economy.grant(cell)
+				if extra_snap is Dictionary:
+					_grant_routed(extra_snap, "positive", "flag_hit", cell, ri, "", String(h.get("label", "")))
 		var snap = _reward_economy.grant(cell)
 		if not (snap is Dictionary):
 			return
@@ -1050,10 +1028,10 @@ func _combat_segment(ri: int) -> void:
 			round_safe += 1
 		elif evt.kind == "mine":
 			round_mine = true
-	_damage.feat_flags["dig_streak"] = 0 if round_mine else round_safe
-	# 蓄力层注入（迭代 12 T5——整备军备「每层下轮首段 +1」/厚积薄发满层 spike/铁壁整备减伤——
-	# 三件同读 action_economy.charge_layers；battle 域每轮刷新）
-	_damage.feat_flags["charge_layers"] = action_economy.charge_layers
+	_damage.dig_streak = 0 if round_mine else round_safe
+	# 蓄力层注入（内容数据驱动扩展批 T3——整备军备「每层下轮首段 +1」/厚积薄发满层 spike/铁壁整备
+	# 减伤——三件 fact charge_layers 同读 action_economy；battle 域每轮刷新）
+	_damage.charge_layers = action_economy.charge_layers
 	# ⓪ 主角先手攻击（基础攻击恒存在——2026-09-11 用户裁决；先于敌方行动。案C 后授予段不再产出伤害，
 	# 主角进入战斗段时恒存活——先手必兑，除非场上无敌）。
 	# 单分量伤害构成（2026-09-19 充能退役批·用户拍板）：主角攻击 = 唯一基础分量（atk，吃掷点含暴击；
@@ -1068,14 +1046,14 @@ func _combat_segment(ri: int) -> void:
 		var ht := _damage.open_ticket(DamageController.KIND_HERO_ATTACK, "hero_attack", "主角攻击", "combat", _hero_atk, \
 			DamageController.TARGET_FRONT_ALIVE, ri, Vector2i(-1, -1), String(_enemy_system.hero_unit().get("attack_type", "normal")))
 		_damage.submit(ht)
-		# 连珠矢（迭代 12 T4 穿刺流——开格节奏变攻击段数）：本轮每开 ~3 安全格 +1 段穿刺附加
-		# （上限 cap；段值 provisional 固定值不乘 atk——台账披露）。扫描雷结算触发点=dig_count_segments。
-		var chain_value := int(_damage.feat_flags.get("chain_value", 0))
-		if chain_value > 0:
-			var segments := mini(int(_damage.feat_flags.get("chain_cap", 2)), int(_damage.feat_flags.get("dig_streak", 0)) / 3)
+		# 连珠矢（内容数据驱动扩展批 T3——attack_commit 订阅施加面：开格节奏变攻击段数，本轮每开
+		# ~3 安全格 +1 段穿刺附加（上限 cap；段值 provisional 固定值不乘 atk——台账披露）。施加位
+		# 紧随主角攻击单开立=迁移前开单位（先于敌方行动单入队——flush 兑现序逐位一致）
+		for h in _hits_of(ht.context.get("fx_attack_hits", []) as Array, "attack_segments"):
+			var segments := mini(int(h.get("cap", 2)), _damage.dig_streak / maxi(1, int(h.get("divisor", 3))))
 			for s in segments:
 				var ct := _damage.open_ticket(DamageController.KIND_BOARD_TYPED, "feat_chain_arrows",
-					"连珠矢", "board", chain_value, DamageController.TARGET_FRONT_ALIVE, ri,
+					"连珠矢", "board", int(h.get("value", 0)), DamageController.TARGET_FRONT_ALIVE, ri,
 					minesweeper.hero_pos(), "pierce")
 				_damage.submit(ct)
 	# 敌方行动（敌人技能池批——本拍动作开轮已摇定，此处按技能行兑现；行序 = 生成序）。
@@ -1208,12 +1186,13 @@ func _exit_distribution() -> void:
 	if _attune_has("dawn_order") and round_index + 1 <= int(db.treasure_item_row("dawn_order").get("effective_rounds", 0)):
 		action_economy.queue_ap_delta(_attune_mag("dawn_order"))
 	action_economy.notify_settlement_done(mode)
+	# round_start 发射先于行动经济轮切换（queue 型 grant_ap 当轮入队当轮兑现——与首轮同口径）
+	round_index += 1
+	_emit_round_start()
 	action_economy.notify_round_start()
 	_reset_round_facts()
 	_refresh_used_this_round = 0
-	round_index += 1
 	_roll_round_actions()   # 开轮摇号——每轮恰摇一次（轮内刷新换图不重摇：refresh 不走本通道）
-	_fx_emit("round_start", {"round": round_index})
 	round_started.emit(round_index)
 
 

game/core/damage_controller.gd

@@ -60,13 +60,16 @@ var _outcomes := {}              # ticket_id → "redeemed"/"zero"/"voided"（
 var _seq := 0                    # 流水号
 var _halted := false             # 主角倒下终止旗（死亡事件置位——flush 余单作废）
 var _hero_ac_override := -1      # 主角护甲等级合流入参（begin_battle 显式设定——-1 = 表值兜底，口径同战斗编排器）
-# 效果引擎（内容数据驱动扩展批 T1——attack_commit/clamp_check/armor_roll/kill/damage_taken 发射面；
-# 双轨过渡期仅观测命中，施加面仍走 feat_flags 旧消费点）
+# 效果引擎（内容数据驱动扩展批 T1/T3——attack_commit/clamp_check/armor_roll/kill/damage_taken
+# 发射+施加面：dispatch 返回命中，本类按组合规则施加——T3 起旧 feat_flags 旗消费点全部拆除）
 var _fx: EffectEngine = null
-# 特性求值旗（迭代 12 T2——begin_battle 编排器经 FeatsEngine 求值后注入；空字典=零扰动。
-# rider_flat=英雄侧必中附加值〔奥术余烬族〕/rider_crit=档二 rider 可暴击/first_dig_spell=每战首次
-# 开安全格追加魔法矢〔消费在编排器授予段〕/clamp_magic_light·clamp_magic_heavy=克制点直调）
-var feat_flags: Dictionary = {}
+# 战斗段运行态事实（编排器每轮刷新——fact 取数面：attack_commit 载荷 dig_streak /
+# charge_layers facts〔猎巢人 per/整备 attack_bonus per/厚积薄发 when/铁壁 shield per〕；
+# 流派档位两运行态〔magic 档一 rider+1 / 档二 rider 可暴击〕）
+var dig_streak := 0
+var charge_layers := 0
+var rider_tier_bonus := 0
+var rider_tier_crit := false
 
 
 func _init(db_ref, rng_ref, units_ref, effects_ref) -> void:
@@ -87,10 +90,38 @@ func set_fx(fx: EffectEngine) -> void:
 	_fx = fx
 
 
-# 事件发射薄面（发射点统一入口——订阅空=零循环零扰动）
+# 事件发射薄面（发射+命中收集统一入口——订阅空=零循环零扰动；命中由各施加面按组合规则施加）
+func _fx_hits(event: String, payload: Dictionary) -> Array:
+	if _fx == null:
+		return []
+	return _fx.dispatch(event, payload, Callable(self, "_fx_fact"))
+
+
+# 事件发射薄面（免施加观测位——enemy_hp_threshold 等现无订阅者的事件保留零扰动面）
 func _fx_dispatch(event: String, payload: Dictionary) -> void:
-	if _fx != null:
-		_fx.dispatch(event, payload)
+	_fx_hits(event, payload)
+
+
+# 补充事实面（fact 取值第二优先源——payload 未携带的运行态读数：charge_layers 编排器每轮注入）
+func _fx_fact(fact: String):
+	match fact:
+		"charge_layers":
+			return charge_layers
+		"dig_streak":
+			return dig_streak
+	return null
+
+
+# per 取数（per 字段解析——载荷同名字段优先，回落补充事实面；add_ticket_rider/attack_bonus/
+# shield/open_ticket 的倍数承载：贡献值 = value × per 读数，cap 对乘积封顶）
+func _per_value(name: String, payload: Dictionary) -> int:
+	if name == "":
+		return 1
+	if payload.has(name):
+		return int(payload[name])
+	if _fx_fact(name) != null:
+		return int(_fx_fact(name))
+	return 0
 
 
 # 巢穴控制数（fact nest_count 取数面——敌方 weaken 实例数，猎巢人订阅面）
@@ -104,12 +135,28 @@ func _nest_count() -> int:
 
 # ---- 开单面（流程调用——编排器六调用点的唯一形态）----
 
+# 开单：A 模式当场结账；B 模式入队待 flush。返回流水号（outcome() 查询键）。
+func submit(t: Dictionary) -> int:
+	_seq += 1
+	t["ticket_id"] = _seq
+	_outcomes[_seq] = "pending"
+	if policy == POLICY_IMMEDIATE:
+		_resolve(t)
+	else:
+		_queue.append(t)
+	return _seq
+
+
 # 单据构造（缺省填齐——调用点只写差异栏；context = kind 专用：enemy_skill 带 skill_id/baseline，
-# board_flat_hero 的键并入行载荷，board_blast/board_typed 带 batch_key 供未生效行归因）
+# board_flat_hero 的键并入行载荷，board_blast/board_typed 带 batch_key 供未生效行归因）。
+# attack_commit 发射点（内容数据驱动扩展批 T3——我方伤害单据开立入口，任务书 §3.1 定稿位；
+# 命中挂单据 context 随行——施加面在 _resolve_hero_attack 管线算术前逐族施加，开单时点=主角攻击
+# 单恒为段内首单（结账现场与开单现场一致）。载荷 atk/target/matchup + 挖掘 streak 事实〔连珠矢/
+# 执拗订阅面〕+巢穴控制数〔猎巢人〕）
 func open_ticket(kind: String, source_class: String, display: String, channel: String, base_value: int,
 		target_rule: String, ri: int, origin_cell: Vector2i = Vector2i(-1, -1), attack_type: String = "",
 		rider: int = 0, highlight: String = "", context: Dictionary = {}) -> Dictionary:
-	return {
+	var t := {
 		"kind": kind,
 		"source_class": source_class,
 		"origin_cell": origin_cell,
@@ -125,18 +172,16 @@ func open_ticket(kind: String, source_class: String, display: String, channel: S
 		"requires": -1,          # 前置单据 id（-1 = 无依赖）
 		"source_unit": {},       # enemy_skill 专用——来源敌句柄（作废判定 + commit）
 	}
-
-
-# 开单：A 模式当场结账；B 模式入队待 flush。返回流水号（outcome() 查询键）。
-func submit(t: Dictionary) -> int:
-	_seq += 1
-	t["ticket_id"] = _seq
-	_outcomes[_seq] = "pending"
-	if policy == POLICY_IMMEDIATE:
-		_resolve(t)
-	else:
-		_queue.append(t)
-	return _seq
+	if kind == KIND_HERO_ATTACK:
+		var tgt = _target_for(target_rule)
+		var armor_b: String = String(tgt.get("armor_type", "light")) if tgt != null else "light"
+		var matchup_o: String = (attack_type + "_vs_" + armor_b) if attack_type != "" else ""
+		var ac_payload := {"atk": int(base_value),
+			"target": String(tgt.get("display_name", "")) if tgt != null else "",
+			"matchup": matchup_o, "dig_streak": dig_streak, "nest_count": _nest_count()}
+		t.context["fx_attack_hits"] = _fx_hits("attack_commit", ac_payload)
+		t.context["fx_attack_payload"] = ac_payload
+	return t
 
 
 # 同步开单（清图批专用——完美第二份与高光份数的流程依赖需要同步读数，开单权归流程 用户裁决③）：
@@ -212,6 +257,8 @@ func _resolve(t: Dictionary) -> void:
 
 
 # 主角先手攻击：掷点 → 折扣/暴击 → 克制点数 → hero_offense×enemy_defense 池乘区 → 下限 → 交付
+# （内容数据驱动扩展批 T3——attack_commit/clamp_check/armor_roll 订阅施加面：命中=开单入口随单
+# context 携带，本函数按迁移前算序逐族施加——命中序=数据表声明序，确定性）
 func _resolve_hero_attack(t: Dictionary) -> void:
 	var target = _target_for(String(t.target_rule))
 	if target == null:
@@ -220,56 +267,70 @@ func _resolve_hero_attack(t: Dictionary) -> void:
 	var armor: String = String(target.get("armor_type", "light"))
 	var atk_type: String = String(t.attack_type)
 	var matchup := (atk_type + "_vs_" + armor) if atk_type != "" else ""
-	# attack_commit 发射点（内容数据驱动扩展批 T1——我方伤害单据开立、管线算术前；载荷 atk/target/
-	# matchup + 挖掘 streak 事实〔连珠矢/执拗订阅面〕+巢穴控制数〔猎巢人〕）
-	_fx_dispatch("attack_commit", {"atk": int(t.base_value), "target": String(target.display_name),
-		"matchup": matchup, "dig_streak": int(feat_flags.get("dig_streak", 0)), "nest_count": _nest_count()})
+	var ac_hits: Array = (t.context.get("fx_attack_hits", []) as Array)
+	var ac_payload: Dictionary = (t.context.get("fx_attack_payload", {}) as Dictionary)
 	var roll_read: Dictionary = _armor_roll()
 	var threshold: int = defender_ac(target) + int(db.settlement.attack_bonus)
 	# armor_roll 发射点（内容数据驱动扩展批 T1——敌护甲掷骰判定；免掷恒折扣订阅面）
-	_fx_dispatch("armor_roll", {"target_ac": threshold, "roll": int(roll_read.roll)})
-	# 矿工重锤·命中交换（迭代 12 T4 普攻流——正负双修原生形态：命中判定减成 trade_hit 点
-	# 〔更易命中〕换攻击增伤 trade_atk%——高 AC 负期望/低 AC 正期望）
-	var trade_hit := int(feat_flags.get("hit_trade_hit", 0))
+	var ar_hits := _fx_hits("armor_roll", {"target_ac": threshold, "roll": int(roll_read.roll)})
+	# 按序改写族第一拍：矿工重锤命中交换（正负双修原生形态：命中判定减成 trade_hit 点〔更易命中〕
+	# 换攻击增伤 trade_atk%——高 AC 负期望/低 AC 正期望；改写位先于掷点折扣读数，与迁移前一致）
+	var trade_hit := 0
+	for h in ac_hits:
+		if String(h.get("kind", "")) == "modify_ticket" and int(h.get("trade_hit", 0)) > 0:
+			trade_hit += int(h.trade_hit)
 	if trade_hit > 0:
 		threshold = maxi(1, threshold - trade_hit)
 	var crit: bool = bool(roll_read.crit)
 	var discount: int = _roll_discount(int(roll_read.roll), threshold)
-	# 专注（迭代 12 T4 普攻流——免掷骰恒定折扣：方差买断成期望——稳定器人格；roll 记 0 归因）
-	var rewrite := int(feat_flags.get("armor_roll_rewrite", 0))
-	if rewrite > 0:
-		discount = rewrite
-		crit = false
-		roll_read["roll"] = 0
-	# 厚积薄发满层必中（迭代 12 T5 蓄力流——spike ready 时 discount 恒全额、暴击面走倍乘不加掷）
-	if int(feat_flags.get("spike_mult", 0)) > 0 and int(feat_flags.get("charge_layers", 0)) >= 3:
-		discount = 100
-	# 猎弱本能（迭代 12 T4 穿刺流——对轻甲敌折扣档改善 value 档：对冲 pierce 列 L1 −1 开局罚；
+	# 按序改写族第二拍：专注免掷骰恒定折扣（方差买断成期望——稳定器人格；roll 记 0 归因）
+	for h in ar_hits:
+		if String(h.get("kind", "")) == "modify_ticket" and String(h.get("mode", "")) == "armor_rewrite":
+			discount = int(h.get("value", 0))
+			crit = false
+			roll_read["roll"] = 0
+	# 按序改写族第三拍：厚积薄发满层必中（spike ready 时 discount 恒全额、暴击面走倍乘不加掷；
+	# when charge_layers≥3 在 dispatch 判定——满层持续状态口径）
+	var spike_ready := false
+	for h in ac_hits:
+		if String(h.get("kind", "")) == "modify_ticket" and String(h.get("mode", "")) == "spike":
+			spike_ready = true
+			discount = 100
+	# 按序改写族第四拍：猎弱本能对轻甲敌折扣档改善 value 档（对冲 pierce 列 L1 −1 开局罚；
 	# 改善 = 折扣表向全额方向移档，nat 最大面/已全额不重复）
-	var shift := int(feat_flags.get("discount_shift", 0))
+	var shift := 0
+	var clamp_hits := _fx_hits("clamp_check", {"matchup": matchup})
+	for h in clamp_hits:
+		if String(h.get("kind", "")) != "modify_ticket":
+			continue
+		if String(h.get("mode", "")) == "discount_shift":
+			shift += int(h.get("value", 0))
 	if shift > 0 and armor == "light" and discount < 100:
 		discount = _discount_shift_up(discount, shift)
-	# clamp_check 发射点（内容数据驱动扩展批 T1——克制关系判定修正点；魔网/湛蓝/猎手订阅面）
-	if atk_type != "":
-		_fx_dispatch("clamp_check", {"matchup": matchup})
-	var cdelta: int = _counter_delta(atk_type, armor) + _feat_clamp_bonus(atk_type, armor)
+	# 克制点数读值+订阅改写（魔网织者/湛蓝誓约/猎手刺剑 clamp_check modify delta——克制矩阵查表值
+	# 后的直调；hero_attack 与 board_typed 两消费面同享）
+	var cdelta: int = _counter_delta(atk_type, armor)
+	for h in clamp_hits:
+		if String(h.get("kind", "")) == "modify_ticket" and h.has("delta"):
+			cdelta += int(h.delta)
 	# 淬毒刃纹（迭代 11 同调批 T5——底稿 §3：对被克制敌人的穿刺/魔法直伤 +N；条件 = 克制成立 ×
 	# 攻击类型限定，主角攻击面专属——棋盘克制直伤走 _resolve_board_typed 不吃本加成）
 	if attune_venom > 0 and (atk_type == "pierce" or atk_type == "magic") and cdelta > 0:
 		cdelta += attune_venom
 	var base_value := float(t.base_value)
-	var trade_atk := int(feat_flags.get("hit_trade_atk", 0))
-	if trade_atk > 0:
-		base_value *= 1.0 + float(trade_atk) / 100.0   # 重锤增伤面（交换的正向侧）
-	# 蓄力流（迭代 12 T5）：整备军备「每层下轮首段 +1」（层数×value 加算）+厚积薄发满层（≥3）
-	# spike 倍乘+强制必中（discount 100/crit 关闭掷骰面——方差买断的爆发出口）
-	var charge_layers := int(feat_flags.get("charge_layers", 0))
-	if charge_layers > 0:
-		base_value += float(charge_layers * int(feat_flags.get("ap_carry_value", 0)))
-	var spike_mult := int(feat_flags.get("spike_mult", 0))
-	var spike_ready := spike_mult > 0 and charge_layers >= 3
+	# 按序改写族第五拍：矿工重锤增伤面（交换的正向侧）
+	for h in ac_hits:
+		if String(h.get("kind", "")) == "modify_ticket" and int(h.get("trade_atk", 0)) > 0:
+			base_value *= 1.0 + float(int(h.trade_atk)) / 100.0
+	# 加法族：整备军备「每层下轮首段 +1」（层数×value 加算）——attack_bonus per charge_layers
+	for h in ac_hits:
+		if String(h.get("kind", "")) == "attack_bonus":
+			base_value += float(int(h.get("value", 0)) * _per_value(String(h.get("per", "")), ac_payload))
+	# 任意真族：厚积薄发满层 spike 倍乘（≥3 层——强制必中已在折扣拍承载）
 	if spike_ready:
-		base_value *= float(spike_mult)
+		for h in ac_hits:
+			if String(h.get("kind", "")) == "modify_ticket" and String(h.get("mode", "")) == "spike":
+				base_value *= float(int(h.get("value", 1)))
 	var rolled: int = DamageMath.rolled_component(base_value, discount, crit, int(db.settlement.crit_multiplier), cdelta)
 	var payload: Dictionary = {"target": String(target.display_name)}
 	payload[atk_type] = rolled   # 分量键 = 实际攻击类型（归因字段，单分量模型）
@@ -280,56 +341,49 @@ func _resolve_hero_attack(t: Dictionary) -> void:
 		payload["crit"] = true
 	var pooled: int = DamageMath.pool_damage(rolled, clamped_pool("hero_offense"), clamped_pool("enemy_defense"))
 	var landed: int = maxi(int(db.settlement.damage_floor), pooled)
-	# 英雄侧 rider（迭代 12 T2 魔法流——enemy_skill rider 对称位补齐）：后置必中附加，独立于掷点
-	# 与乘区（奥术余烬「普攻命中后恒定结算」语义）；档二（magic 4 件）rider 可暴击=当次 crit 时
-	# rider 值乘暴击倍率。rider 不改变下限语义（landed 含 rider 后不再过 floor）。
-	var hero_rider := int(feat_flags.get("rider_flat", 0))
-	# 猎巢人（迭代 12 T3 标旗流——巢穴控制数转伤害光环）：控制数 = 敌方 weaken（削弱）实例数
-	# 〔八型批 side-wide 状态行——标中旗控制巢穴的既有承载；原设计「对其中敌伤害」简化为全体
-	# 先手攻击附加值——台账披露待追认〕，每控制 1 巢 rider +Z。
-	var nest_aura := int(feat_flags.get("nest_aura_value", 0))
-	if nest_aura > 0:
-		for eff in effects.query_active("enemy"):
-			if String(eff.effect_id) == "weaken":
-				hero_rider += nest_aura
-	# 矿工的执拗（迭代 12 T4 普攻流——「排雷排得多好，打得就有多疼」）：本轮安全开格 streak
-	# 〔编排器授予段实时写入 feat_flags.dig_streak；踩雷清零〕×value，上限 cap。
-	var rdig := int(feat_flags.get("round_dig_value", 0))
-	if rdig > 0:
-		hero_rider += mini(int(feat_flags.get("round_dig_cap", 5)), int(feat_flags.get("dig_streak", 0)) * rdig)
+	# 加法族：英雄侧 rider（enemy_skill rider 对称位补齐口径）——后置必中附加，独立于掷点与乘区
+	# （奥术余烬「普攻命中后恒定结算」语义）；猎巢人巢控光环（per nest_count）/矿工的执拗开格加成
+	# （per dig_streak、cap 封顶）同通道合计；档一质变 rider+1 / 档二（crit 时）rider 乘暴击倍率。
+	# rider 不改变下限语义（landed 含 rider 后不再过 floor）。
+	var hero_rider := rider_tier_bonus
+	for h in ac_hits:
+		if String(h.get("kind", "")) == "add_ticket_rider":
+			var contrib := int(h.get("value", 0)) * _per_value(String(h.get("per", "")), ac_payload)
+			if h.has("cap"):
+				contrib = mini(int(h.cap), contrib)
+			hero_rider += contrib
 	if hero_rider > 0:
-		if crit and bool(feat_flags.get("rider_crit", false)):
+		if crit and rider_tier_crit:
 			hero_rider = int(round(float(hero_rider) * float(db.settlement.crit_multiplier)))
 		landed += hero_rider
 		payload["hero_rider"] = hero_rider
 	units.apply_damage(target, landed)
 	payload["killed"] = not target.alive   # 击杀标记在扣血后取（原语义不变）
-	# kill 发射点（内容数据驱动扩展批 T1——敌人死亡确认；贯穿射击 overflow 订阅面）
+	# kill 发射+施加（内容数据驱动扩展批 T3——敌人死亡确认；贯穿射击溢出弹射订阅面：对下一存活敌
+	# 以穿刺类型弹射本体 value%〔无次敌=弹射落空〕。B 模式入队段尾 flush 兑现；A 模式递归 resolve）
 	if bool(payload.get("killed", false)):
-		_fx_dispatch("kill", {"target": String(target.display_name), "overflow": landed})
-	# 碎甲震击（迭代 12 T4 普攻流——命中重甲附加「护甲裂解」）：复用 off_guard（enemy percent
-	# +25 受伤加深——零新状态行）；apply_effect 域闭/重复授予由状态容器自行守卫。
-	var crack := int(feat_flags.get("crack_value", 0))
-	if crack > 0 and armor == "heavy":
-		effects.apply_effect("off_guard", {"source_class": "feat_armor_crack"}, -1)
-		payload["cracked"] = true
+		for h in _fx_hits("kill", {"target": String(target.display_name), "overflow": landed}):
+			if String(h.get("kind", "")) != "overflow":
+				continue
+			var next_target = units.default_target()
+			if next_target != null:
+				var of_t := open_ticket(DamageController.KIND_BOARD_TYPED, "feat_pierce_shot",
+					"贯穿射击", "board", maxi(int(db.settlement.damage_floor), int(landed * int(h.get("value", 50)) / 100)),
+					DamageController.TARGET_FRONT_ALIVE, int(t.round_index), t.origin_cell, "pierce")
+				if policy == POLICY_SEGMENT:
+					_queue.append(of_t)
+				else:
+					_resolve(of_t)
+	# 即时执行族：碎甲震击打重甲附加「护甲裂解」（复用 off_guard——零新状态行；apply_effect 域闭/
+	# 重复授予由状态容器自行守卫）
+	for h in ac_hits:
+		if String(h.get("kind", "")) == "apply_status":
+			effects.apply_effect(String(h.get("status_id", "")), {"source_class": "feat_armor_crack"}, -1)
+			payload["cracked"] = true
 	var label := _attack_label(String(t.display), crit, discount)
 	if hero_rider > 0:
 		label += "＋奥术%d（必中）" % hero_rider
 	emit_row_cb.call("damage", String(t.source_class), t.origin_cell, int(t.round_index), label, landed, payload, String(t.highlight))
-	# 贯穿射击（迭代 12 T4 穿刺流——击杀溢出弹射）：击杀时对下一存活敌以穿刺类型弹射
-	# 本体半额〔原设计「溢出伤害」追踪在单分量模型不可行——半额弹射 provisional 裁定披露待追认；
-	# 无次敌=弹射落空〕。B 模式入队段尾 flush 兑现；A 模式递归 resolve（目标存活守卫内建）。
-	if bool(payload.get("killed", false)) and int(feat_flags.get("kill_overflow", 0)) > 0:
-		var next_target = units.default_target()
-		if next_target != null:
-			var of_t := open_ticket(DamageController.KIND_BOARD_TYPED, "feat_pierce_shot",
-				"贯穿射击", "board", maxi(int(db.settlement.damage_floor), int(landed / 2)),
-				DamageController.TARGET_FRONT_ALIVE, int(t.round_index), t.origin_cell, "pierce")
-			if policy == POLICY_SEGMENT:
-				_queue.append(of_t)
-			else:
-				_resolve(of_t)
 	_outcomes[int(t.ticket_id)] = "redeemed"
 
 
@@ -344,14 +398,14 @@ func _resolve_enemy_skill(t: Dictionary) -> void:
 	var rolled: int = DamageMath.rolled_component(float(t.base_value), discount, crit, int(db.settlement.crit_multiplier), 0)
 	var pooled: int = DamageMath.pool_damage(rolled, clamped_pool("hero_defense"), clamped_pool("enemy_output"))
 	var total: int = maxi(int(db.settlement.damage_floor), pooled) + int(t.rider)   # rider 后置于伤害下限——独立必中加项，不进乘区
-	# damage_taken 发射点（内容数据驱动扩展批 T1——kind=enemy_skill；铁壁减伤订阅面）
-	_fx_dispatch("damage_taken", {"kind": "enemy_skill", "amount": total,
-		"source": String(t.context.get("skill_id", "")), "round": int(t.round_index)})
-	# 铁壁整备（迭代 12 T5 蓄力流——每层下轮开场 S 点减伤；减后过下限保底）
-	var shield := int(feat_flags.get("shield_per_layer", 0)) * int(feat_flags.get("charge_layers", 0))
-	# 稳健拓荒（迭代 12 T10——Fork posture B 侧 rule 键：受击减 1；两侧对称弱值=「不同强非强弱」）
-	if int(feat_flags.get("bulwark", 0)) > 0:
-		shield += 1
+	# damage_taken 发射+施加（内容数据驱动扩展批 T3——kind=enemy_skill；铁壁整备减伤订阅面：
+	# shield 加法族合计 value×per(charge_layers)，稳健拓荒树规则同面（rebuild 合成订阅）；
+	# 减后过下限保底）
+	var shield := 0
+	for h in _fx_hits("damage_taken", {"kind": "enemy_skill", "amount": total,
+		"source": String(t.context.get("skill_id", "")), "round": int(t.round_index)}):
+		if String(h.get("kind", "")) == "shield":
+			shield += int(h.get("value", 0)) * _per_value(String(h.get("per", "")), {})
 	if shield > 0:
 		total = maxi(int(db.settlement.damage_floor), total - shield)
 	units.apply_damage(hero, total)
@@ -378,14 +432,17 @@ func _resolve_board_typed(t: Dictionary) -> void:
 		return
 	var armor_b: String = String(target.get("armor_type", "light"))
 	var atk_b: String = String(t.attack_type)
-	# clamp_check 发射点（内容数据驱动扩展批 T1——克制判定修正点棋盘面；与 hero_attack 同表同点）
+	# clamp_check 发射+施加（内容数据驱动扩展批 T3——克制判定修正点棋盘面；与 hero_attack 同表同点：
+	# modify delta 订阅改写合计进克制点数；discount_shift 档位面属主角攻击专享，本面不施加）
+	var cdelta: int = _counter_delta(atk_b, armor_b)
 	if atk_b != "":
-		_fx_dispatch("clamp_check", {"matchup": atk_b + "_vs_" + armor_b})
-	var delta: int = _counter_delta(atk_b, armor_b) + _feat_clamp_bonus(atk_b, armor_b)
-	var dealt: int = DamageMath.counter_component(int(t.base_value), delta, int(db.settlement.damage_floor))
+		for h in _fx_hits("clamp_check", {"matchup": atk_b + "_vs_" + armor_b}):
+			if String(h.get("kind", "")) == "modify_ticket" and h.has("delta"):
+				cdelta += int(h.delta)
+	var dealt: int = DamageMath.counter_component(int(t.base_value), cdelta, int(db.settlement.damage_floor))
 	units.apply_damage(target, dealt)
 	emit_row_cb.call("damage", String(t.source_class), t.origin_cell, int(t.round_index), "%s → %s" % [String(t.display), String(target.display_name)], dealt,
-		{"target": String(target.display_name), "attack_type": String(t.attack_type), "effectiveness": delta}, String(t.highlight))
+		{"target": String(target.display_name), "attack_type": String(t.attack_type), "effectiveness": cdelta}, String(t.highlight))
 	_outcomes[int(t.ticket_id)] = "redeemed"
 
 
@@ -462,23 +519,6 @@ func _counter_delta(attack_type: String, armor: String) -> int:
 	return int(row.get(armor, 0))
 
 
-# 克制点直调（迭代 12 T2 魔法流/T4 穿刺流 clamp_modifier 件——克制矩阵查表值后的特性调整；
-# 空旗=0 零扰动）：魔网织者=magic vs magic（矩阵罚 −1 → 0/正）；湛蓝誓约=magic vs heavy（+1 → +2）；
-# 猎手刺剑=pierce vs light（+1——对轻甲敌穿刺提升，对重甲无增益=正负双修）。hero_attack 与
-# board_typed 两消费面同享。
-func _feat_clamp_bonus(attack_type: String, armor: String) -> int:
-	var bonus := 0
-	if attack_type == "magic":
-		if armor == "magic":
-			bonus += int(feat_flags.get("clamp_magic_magic", 0))
-		elif armor == "heavy":
-			bonus += int(feat_flags.get("clamp_magic_heavy", 0))
-	elif attack_type == "pierce":
-		if armor == "light":
-			bonus += int(feat_flags.get("clamp_pierce_light", 0))
-	return bonus
-
-
 # 折扣档改善（迭代 12 T4 猎弱本能——折扣表向全额方向移 value 档；查不到当前档 = 不动防御口径）
 func _discount_shift_up(discount: int, shift: int) -> int:
 	var tbl: Array = db.settlement.roll_tier_discounts

game/core/effect_engine.gd

@@ -50,8 +50,8 @@ const WHEN_KEYS := ["fact", "op", "value", "id", "ref", "value_from"]
 
 ## do 效果键白名单（trigger 行 do 字典键——零裸 flat 同族护栏：kind 外键全部参数引用面）
 const DO_KEYS := ["kind", "value", "value_from", "delta", "delta_from", "mult", "mult_from",
-	"cap", "cap_from", "per", "divisor", "dtype", "mode", "channel", "counter_id", "reset_at",
-	"set", "status_id", "label", "fallback", "target_kinds"]
+	"cap", "cap_from", "cost_mult", "per", "divisor", "dtype", "mode", "channel", "counter_id",
+	"reset_at", "set", "status_id", "label", "fallback", "target_kinds", "trade_atk", "trade_hit"]
 
 ## 主动件分发通道（不经事件订阅——刷新/显影/移除是玩家主动动作；use_treasure 按 kind 分发）
 const ACTIVE_KINDS := ["reveal_tiles", "preview", "grant_ap", "remove_mines", "refresh_pick"]
@@ -80,14 +80,14 @@ func rebuild(feat_ids: Array, item_ids: Array, tree_rules: Array = []) -> void:
 			if not feat_ids.has(fid):
 				continue
 			for tr in (row.get("triggers", []) as Array):
-				_push_trigger("feat", fid, tr)
+				_push_trigger("feat", fid, tr, row)
 	if db != null:
 		for row in db.treasure_attunement_rows():
 			var iid := String(row.get("item_id", ""))
 			if not item_ids.has(iid):
 				continue
 			for tr in (row.get("triggers", []) as Array):
-				_push_trigger("attune", iid, tr)
+				_push_trigger("attune", iid, tr, row)
 	# 树规则合成订阅（T5——规则键效果走同面：非数据行，词表同闭集）
 	for key_v in tree_rules:
 		var rk := String(key_v)
@@ -95,21 +95,26 @@ func rebuild(feat_ids: Array, item_ids: Array, tree_rules: Array = []) -> void:
 			"posture_first_strike":
 				_push_trigger("tree", rk, {"on": "round_start",
 					"when": [{"fact": "round_index", "op": "eq", "value": 1}],
-					"do": {"kind": "grant_ap", "mode": "queue", "value": 1}})
+					"do": {"kind": "grant_ap", "mode": "queue", "value": 1}}, {})
 			"posture_bulwark":
 				_push_trigger("tree", rk, {"on": "damage_taken",
-					"do": {"kind": "shield", "value": 1}})
+					"do": {"kind": "shield", "value": 1}}, {})
 
 
-func _push_trigger(source: String, id: String, tr: Dictionary) -> void:
+func _push_trigger(source: String, id: String, tr: Dictionary, row: Dictionary) -> void:
 	var on := String(tr.get("on", ""))
 	assert(EVENTS.has(on), "[效果引擎] 订阅事件出域: %s（%s %s）" % [on, source, id])
+	var do_d: Dictionary = (tr.get("do", {}) as Dictionary).duplicate(true)
+	# *_from 解析（rebuild 时把行字段引用定影为值——value_from:"magnitude" → value=行 magnitude）
+	for pair in [["value_from", "value"], ["delta_from", "delta"], ["mult_from", "mult"], ["cap_from", "cap"]]:
+		if do_d.has(pair[0]):
+			do_d[pair[1]] = int(row.get(String(do_d[pair[0]]), 0))
+			do_d.erase(pair[0])
 	var t := {"source": source, "id": id, "on": on,
 		"when": (tr.get("when", []) as Array).duplicate(true),
-		"do": (tr.get("do", {}) as Dictionary).duplicate(true)}
+		"do": do_d}
 	_triggers.append(t)
 	# 计数器重置点收集（counter_add/counter_spend 行声明 reset_at）
-	var do_d: Dictionary = t.do
 	if do_d.has("counter_id") and String(do_d.get("reset_at", "")) == "round_start":
 		var cid := String(do_d.counter_id)
 		if not _reset_on_round_start.has(cid):
@@ -203,9 +208,16 @@ func _cond_ok(c: Dictionary, payload: Dictionary, facts: Callable) -> bool:
 				return false
 			return String(actual).ends_with(String(val))
 		"has":
+			# 在场判定（fact 查询面落法——代拍板白名单，commit 留痕）：value 缺省=非空判定
+			# （terrain_kind fact：伤害型变异集非空=挖开伤害型地形格/邻格有伤害型地形/地形伤种类在场）；
+			# value 给定=数组包含判定（保留泛用面）。
+			if c.has("value"):
+				if actual is Array:
+					return (actual as Array).has(val)
+				return false
 			if actual is Array:
-				return (actual as Array).has(val)
-			return false
+				return not (actual as Array).is_empty()
+			return String(actual) != ""
 		"mod_zero":
 			var m := int(val)
 			return m > 0 and int(actual) % m == 0

game/core/feats_engine.gd

@@ -30,21 +30,8 @@ static func tiers_for(feat_ids: Array, table: FeatTable) -> Dictionary:
 	return out
 
 
-## 挂点投影：持有集 → [{feat_id, hook, archetype, tier, effects}]（表序稳定——同集合同投影，
-## MC 逐位可复放承载）
-static func hooks_for(feat_ids: Array, table: FeatTable) -> Array:
-	var out: Array = []
-	for rid in feat_ids:
-		var row: Dictionary = table.row_by_id(String(rid)) if table != null else {}
-		if row.is_empty():
-			continue
-		out.append({
-			"feat_id": String(row.get("feat_id", "")),
-			"hook": String(row.get("hook", "")),
-			"archetype": String(row.get("archetype", "")),
-			"effects": (row.get("effects", {}) as Dictionary).duplicate(true),
-		})
-	return out
+## 挂点投影随 T3 退役（内容数据驱动扩展批——hook 词族消亡：订阅投影=效果引擎 rebuild 装载序
+## （feats 表序），投影稳定性由 EffectEngine._triggers 声明序承载）
 
 
 ## 成型判读（读数面口径）：流派 tier ≥1 = 成型（档一即判——任务书完成定义「标签+档位激活引擎可判成型」）

game/data/schemas/feat_table.gd

@@ -1,7 +1,8 @@
 # VERTICAL SLICE - NOT FOR PRODUCTION
 # Validation Question: 七核心流派各 ≥3 件入局内随机渠道后，标签+档位激活引擎能否机械判「成型」、
 # 专长带能否挂进令牌池稀有/罕见档随机投放（P0——迭代 12 双层 BD 实施批 T1）
-# Date: 2026-10-04（双层 BD 实施批 T1——任务书五裁定稿；设计权威 双层BD体系-整合定稿-2026-10-03 v3）
+# Date: 2026-10-06（内容数据驱动扩展批 T3——行换代：hook/effects 挂点形态退役，triggers 事件订阅形态
+#   唯一合法行形——旧 23 挂点枚举消亡：事件名+效果类型取代，任务书 R4 裁决）
 # 概念指路：本表的专长，与 adventure.tres 的属性值提升、资源，同属一个对象——
 #   「奇物」（一次冒险内各渠道给予玩家的增益总称）。定义见 design/gdd/systems/冒险循环/奇物.md。
 #   它们是它分类轴上的枚举（专长 / 属性值提升 / 资源），不是三套系统；本表承载「专长」（专长 Feat）的逐项定义。
@@ -11,16 +12,15 @@
 # 数据配置 FeatTable schema（奇物·专长定义表；行 = Dictionary 键 feat_id，Rule 4 豁免
 # 定义表——TreasureItemTable 先例）。
 # 行字段：feat_id 主键 / display_name / rarity ∈ {common, rare, rarest}（对齐令牌池三档命名——
-#   投放档映射：common/rare→稀有令牌档、rarest→罕见令牌档；relic 令牌永不入普通档=「挂稀有/罕见档」
-#   追认 b 接线口径）/ archetype ∈ ARCHETYPES 七流派标签 / hook ∈ HOOKS 挂点枚举（结算段槽——整合定稿
-#   §2.1 哈迪斯恩赐槽同构）/ effects Dictionary（hook 消费参数，provisional 投值）。
-# 正负双修（整合定稿 B2 判据）：effects 允许负向键（cost_* 族）——纯增益件须专项论证（反例 B-3），加载期
-#   仅校验键域不禁纯增益（专项论证件以 positive_only 批注登记，人工清单呈报）。
+#   投放档映射：common/rare→稀有令牌档、rarest→罕见令牌档；relic 令牌永不入普通档）/ 
+# archetype ∈ ARCHETYPES 七流派标签 / desc 效果说明（文案表值化——呈现层读行，零硬编码）/
+# triggers 订阅行数组（订阅哪个事件 on / 什么条件 when / 什么效果 do——效果引擎 EffectEngine
+# 统一解释执行；四词表封闭校验=EffectEngine.validate_trigger_row 单一事实源）。
 # 档位激活（整合定稿 设计工具 1——以撒套装/小骨铭文）：同标签计数 ≥2→档一（流派核心规则）/≥4→档二
 #   （完全体）；散件单体保底=每件效果独立生效，档位只做质变（反例 B-2）——引擎纯函数 FeatsEngine。
 # 🔴 层级纪律（任务书红线 2）：专长只走局内随机渠道（三选一/商店/格面）——本表行永不入同调位
-#   （treasure_items 表）/局外树（T8 节点表）；扫雷触发点铁律：每流派 ≥1 行 hook ∈ MINE_HOOKS（加载校验，
-#   违反=红线①触碰面）。
+#   （treasure_items 表）/局外树（T8 节点表）；扫雷触发点铁律：每流派 ≥1 行订阅扫雷侧事件
+#   （EffectEngine.MINE_EVENTS——加载校验，违反=红线①触碰面）。
 class_name FeatTable
 extends Resource
 
@@ -32,70 +32,19 @@ const ARCHETYPES := ["magic", "pierce", "normal", "dig", "flag", "charge", "devo
 ## 稀有度词表（对齐令牌池三档；投放档映射 relic→rare / rarest→rarest）
 const RARITIES := ["common", "rare", "rarest"]
 
-## 挂点枚举（结算段槽——首批 23 点位；每 hook 恰一流派域消费，T2-T6 接线）
-## 内容数据驱动扩展批 T2 挂账：hook 词族随 T3 专长迁移退役（triggers 事件订阅形态取代——
-## 旧字段校验保留共存至迁移完成，过渡期两形态同行校验）。
-const HOOKS := [
-	# 魔法流
-	"hero_attack_rider",       # 普攻命中后追加必中魔法伤（奥术余烬/魔能共鸣）
-	"clamp_modifier",          # 克制点直调（魔网织者/湛蓝誓约/猎手刺剑）
-	"first_dig_spell",         # 每关首次开格必出魔法矢（魔能共鸣第二效果）
-	# 穿刺流
-	"kill_overflow",           # 击杀溢出弹射（贯穿射击）
-	"dig_count_segments",      # 开格计数转攻击段数（连珠矢）
-	"roll_discount",           # 折扣档改写（猎弱本能前移一档）
-	# 普攻流
-	"round_dig_bonus",         # 轮内安全开格数转攻击加成（矿工的执拗；踩雷清零=mine_hit 监听同口）
-	"hit_trade",               # 命中交换（矿工重锤——正负双修原生形态）
-	"armor_roll_rewrite",      # 免掷骰恒折扣（专注）
-	"heavy_debuff",            # 命中重甲附加护甲裂解（碎甲震击）
-	# 开格流
-	"dig_yield_mult",          # 开格产出乘区（贪婪矿灯/矿脉直觉/赌徒的血签——正负双向）
-	"deep_dig",                # 深层资源掘取（深挖钻头——R4 甲非信息税形态：开掘额外 AP 代价）
-	# 标旗流
-	"flag_resource",           # 标中雷获格面资源（雷区图谱）
-	"nest_aura",               # 控制巢穴数转伤害光环（猎巢人）
-	"flag_all_hit",            # 同轮全中旗伤倍增（完美布防）
-	"flag_strike",             # 轮末旗伤开单（战旗军规——复用 board_typed）
-	# 蓄力流
-	"ap_carry",                # 轮末 AP 结转蓄力（整备军备——改写 cleared 作废口径）
-	"charge_shield",           # 蓄力层转减伤（铁壁整备）
-	"charge_spike",            # 满层 spike（厚积薄发）
-	# 吞噬流
-	"terrain_refund",          # 受地形伤掉落资源补偿（地脉采撷——伤害仍发生）
-	"terrain_dig_double",      # 挖开伤害型地形格双产出（荆棘编织者）
-	"flag_neutralize",         # 标中旗中和相邻伤害型地形格（净化工兵——🔴 R4 甲仅限伤害型）
-	"variant_counter",         # 受地形伤积层轮末反打（熔火之躯——触发键不按地形种类特化）
-]
+## 行键白名单（🔴 零裸 flat 同族护栏——键出域=加载致命；triggers/desc=T3 换代新形态）
+const ROW_KEYS := ["feat_id", "display_name", "rarity", "archetype", "triggers", "desc", "note"]
 
-## 扫雷结算触发点 hook 集（🔴 红线①承载：每流派 ≥1 行 hook 命中本集——加载校验）
-const MINE_HOOKS := ["first_dig_spell", "dig_count_segments", "round_dig_bonus", "dig_yield_mult",
-	"deep_dig", "flag_resource", "nest_aura", "flag_all_hit", "flag_strike", "ap_carry",
-	"terrain_refund", "terrain_dig_double", "flag_neutralize", "variant_counter"]
-
-## effects 键白名单（🔴 零裸 flat 同族护栏——机制轴禁无条件属性加项；键出域=加载致命）
-## 全部条件触发/机制修正参数；cost_* 族=正负双修负向面
-const EFFECT_KEYS := ["value", "value2", "tier_value", "per_stack", "cap", "ap_cost", "chance",
-	"mult", "cost_mult", "cost_flat", "polarity", "spell_kind", "segment_cap", "discount_shift",
-	"trade_atk", "trade_hit", "shield_per_layer", "spike_mult", "layers_to_shield",
-	"neutralize_range", "counter_damage", "resource_kind", "rider_kind", "note"]
-
-## ---- 内容数据驱动扩展批 T2 新形态词汇（triggers 事件订阅行）----
-## 行字段换代目标：hook/effects → triggers: [{on, when?, do}]——订阅哪个事件/什么条件/什么效果。
-## 事件/效果/fact/算子四词表全部引用 EffectEngine 闭集常量（单一事实源，禁本表复抄）。
+## trigger 行键（订阅行三字段：on/when?/do）
 const TRIGGER_KEYS := ["on", "when", "do"]
 
 
-func _validate_triggers(rid: String, row: Dictionary, triggers: Array, errs: Array) -> bool:
-	return EffectEngine.validate_trigger_row(rid, row, triggers, errs)
-
-
 func validate() -> Array:
 	var errs: Array = []
 	if rows.is_empty():
-		return errs   # 空表合法态（T1 基建先行——T2 起逐流派填行）
+		return errs   # 空表合法态（T1 基建先行——逐流派填行）
 	var seen := {}
-	# 流派扫雷覆盖聚合（🔴 红线①铁律——两形态共存判定：triggers 行按扫雷侧事件、hook 行按 MINE_HOOKS）
+	# 流派扫雷覆盖聚合（🔴 红线①铁律——每流派 ≥1 行订阅扫雷侧事件）
 	var arch_mine := {}   # archetype → bool
 	for row in rows:
 		var rid: String = row.get("feat_id", "")
@@ -113,33 +62,17 @@ func validate() -> Array:
 		var arch := String(row.get("archetype", ""))
 		if not ARCHETYPES.has(arch):
 			errs.append({"category": "enum", "message": "%s archetype 出域 %s" % [rid, str(ARCHETYPES)]})
-		var has_triggers: bool = row.has("triggers")
-		var has_hook: bool = row.has("hook")
-		if has_triggers:
-			if String(row.get("hook", "")) != "":
-				errs.append({"category": "domain", "message": "%s triggers 与 hook 并存（换代单形态——迁移期禁双挂）" % rid})
-			if _validate_triggers(rid, row, row.get("triggers", []) as Array, errs):
-				arch_mine[arch] = true
-		elif has_hook:
-			var hook := String(row.get("hook", ""))
-			if not HOOKS.has(hook):
-				errs.append({"category": "enum", "message": "%s hook 出域（挂点枚举封闭）: %s" % [rid, hook]})
-			if MINE_HOOKS.has(hook):
-				arch_mine[arch] = true
-		else:
-			errs.append({"category": "domain", "message": "%s 缺 triggers/hook（换代后行必须声明订阅）" % rid})
+		if not row.has("triggers"):
+			errs.append({"category": "domain", "message": "%s 缺 triggers（订阅形态唯一合法行形）" % rid})
+		elif EffectEngine.validate_trigger_row(rid, row, row.get("triggers", []) as Array, errs):
+			arch_mine[arch] = true
 		for k in row.keys():
-			if not ["feat_id", "display_name", "rarity", "archetype", "hook", "effects", "triggers", "desc", "note"].has(String(k)):
+			if not ROW_KEYS.has(String(k)):
 				errs.append({"category": "zero_flat", "message": "%s 行键出白名单: %s" % [rid, String(k)]})
-		var fx: Dictionary = row.get("effects", {}) as Dictionary
-		for ek in fx.keys():
-			if not EFFECT_KEYS.has(String(ek)):
-				errs.append({"category": "zero_flat", "message": "%s effects 键出白名单: %s（机制轴禁无条件属性加项）" % [rid, String(ek)]})
-	# 🔴 红线① 扫雷触发点铁律：**有行的流派**各 ≥1 行订阅扫雷侧事件（triggers 新形态）或
-	# hook ∈ MINE_HOOKS（旧形态过渡）
+	# 🔴 红线① 扫雷触发点铁律：**有行的流派**各 ≥1 行订阅扫雷侧事件（MINE_EVENTS 同义校验）
 	for arch in archs_with_rows():
 		if not bool(arch_mine.get(arch, false)):
-			errs.append({"category": "load_bearing", "message": "流派 %s 无扫雷结算触发点行（🔴 红线①铁律——每流派 ≥1 件挂扫雷端）" % String(arch)})
+			errs.append({"category": "load_bearing", "message": "流派 %s 无扫雷结算触发点行（🔴 红线①铁律——每流派 ≥1 件订阅扫雷侧事件）" % String(arch)})
 	return errs
 
 

game/data/tables/feats.tres

@@ -9,266 +9,564 @@ rows = [{
 "display_name": "奥术余烬",
 "rarity": "common",
 "archetype": "magic",
-"hook": "hero_attack_rider",
-"effects": {
+"desc": "普攻附加必中伤害",
+"triggers": [{
+"on": "attack_commit",
+"do": {
+"kind": "add_ticket_rider",
 "value": 1
 }
+}]
 }, {
 "feat_id": "mana_weaver",
 "display_name": "魔网织者",
 "rarity": "rare",
 "archetype": "magic",
-"hook": "clamp_modifier",
-"effects": {
-"value": 1,
-"polarity": "magic_vs_magic"
+"desc": "克制面强化",
+"triggers": [{
+"on": "clamp_check",
+"when": [{
+"fact": "matchup",
+"op": "eq",
+"value": "magic_vs_magic"
+}],
+"do": {
+"kind": "modify_ticket",
+"delta": 1
 }
+}]
 }, {
 "feat_id": "azure_oath",
 "display_name": "湛蓝誓约",
 "rarity": "rare",
 "archetype": "magic",
-"hook": "clamp_modifier",
-"effects": {
-"value": 1,
-"polarity": "magic_vs_heavy"
+"desc": "克制面强化",
+"triggers": [{
+"on": "clamp_check",
+"when": [{
+"fact": "matchup",
+"op": "eq",
+"value": "magic_vs_heavy"
+}],
+"do": {
+"kind": "modify_ticket",
+"delta": 1
 }
+}]
 }, {
 "feat_id": "mana_resonance",
 "display_name": "魔能共鸣",
 "rarity": "rarest",
 "archetype": "magic",
-"hook": "first_dig_spell",
-"effects": {
+"desc": "首格追加奥术矢",
+"triggers": [{
+"on": "dig_reveal",
+"when": [{
+"fact": "is_first_dig_of_battle",
+"op": "eq",
+"value": true
+}],
+"do": {
+"kind": "spawn_spell",
 "value": 2
 }
+}]
 }, {
 "feat_id": "mine_atlas",
 "display_name": "雷区图谱",
 "rarity": "common",
 "archetype": "flag",
-"hook": "flag_resource",
-"effects": {
-"value": 1
+"desc": "标中雷额外得资源",
+"triggers": [{
+"on": "flag_hit",
+"do": {
+"kind": "grant_material",
+"value": 1,
+"label": "（雷区图谱）"
 }
+}]
 }, {
 "feat_id": "nest_hunter",
 "display_name": "猎巢人",
 "rarity": "rare",
 "archetype": "flag",
-"hook": "nest_aura",
-"effects": {
-"value": 1
+"desc": "控巢攻击光环",
+"triggers": [{
+"on": "attack_commit",
+"do": {
+"kind": "add_ticket_rider",
+"value": 1,
+"per": "nest_count"
 }
+}]
 }, {
 "feat_id": "perfect_defense",
 "display_name": "完美布防",
 "rarity": "rare",
 "archetype": "flag",
-"hook": "flag_all_hit",
-"effects": {
-"value": 2
+"desc": "全中标旗伤加倍",
+"triggers": [{
+"on": "flag_settle",
+"when": [{
+"fact": "flags_count",
+"op": "gte",
+"value": 1
+}],
+"do": {
+"kind": "modify_ticket",
+"value": 2,
+"mode": "flag_mult"
 }
+}]
 }, {
 "feat_id": "war_banner",
 "display_name": "战旗军规",
 "rarity": "rarest",
 "archetype": "flag",
-"hook": "flag_strike",
-"effects": {
-"value": 2
+"desc": "标中旗必中打敌",
+"triggers": [{
+"on": "flag_settle",
+"when": [{
+"fact": "flags_count",
+"op": "gte",
+"value": 1
+}],
+"do": {
+"kind": "open_ticket",
+"value": 2,
+"channel": "attack"
 }
+}]
 }, {
 "feat_id": "pierce_shot",
 "display_name": "贯穿射击",
 "rarity": "rarest",
 "archetype": "pierce",
-"hook": "kill_overflow",
-"effects": {
-"value": 1
+"desc": "击杀半额弹射",
+"triggers": [{
+"on": "kill",
+"do": {
+"kind": "overflow",
+"value": 50
 }
+}]
 }, {
 "feat_id": "chain_arrows",
 "display_name": "连珠矢",
 "rarity": "rare",
 "archetype": "pierce",
-"hook": "dig_count_segments",
-"effects": {
-"value": 2,
-"cap": 2
+"desc": "开格积穿刺矢",
+"triggers": [{
+"on": "dig_reveal",
+"do": {
+"kind": "counter_add",
+"counter_id": "chain_digs",
+"value": 1,
+"reset_at": "round_start"
 }
 }, {
+"on": "attack_commit",
+"do": {
+"kind": "attack_segments",
+"value": 2,
+"cap": 2,
+"per": "dig_streak",
+"divisor": 3
+}
+}]
+}, {
 "feat_id": "weak_instinct",
 "display_name": "猎弱本能",
 "rarity": "rare",
 "archetype": "pierce",
-"hook": "roll_discount",
-"effects": {
-"value": 1
+"desc": "打轻甲更易命中",
+"triggers": [{
+"on": "clamp_check",
+"when": [{
+"fact": "matchup",
+"op": "ends_with",
+"value": "vs_light"
+}],
+"do": {
+"kind": "modify_ticket",
+"value": 1,
+"mode": "discount_shift"
 }
+}]
 }, {
 "feat_id": "hunter_rapier",
 "display_name": "猎手刺剑",
 "rarity": "common",
 "archetype": "pierce",
-"hook": "clamp_modifier",
-"effects": {
-"value": 1,
-"polarity": "pierce_vs_light"
+"desc": "克制面强化",
+"triggers": [{
+"on": "clamp_check",
+"when": [{
+"fact": "matchup",
+"op": "eq",
+"value": "pierce_vs_light"
+}],
+"do": {
+"kind": "modify_ticket",
+"delta": 1
 }
+}]
 }, {
 "feat_id": "miner_stubborn",
 "display_name": "矿工的执拗",
 "rarity": "common",
 "archetype": "normal",
-"hook": "round_dig_bonus",
-"effects": {
+"desc": "开格越多打得越疼",
+"triggers": [{
+"on": "dig_reveal",
+"do": {
+"kind": "counter_add",
+"counter_id": "stubborn_digs",
 "value": 1,
-"cap": 5
+"reset_at": "round_start"
 }
 }, {
+"on": "mine_hit",
+"do": {
+"kind": "counter_add",
+"counter_id": "stubborn_digs",
+"set": 0
+}
+}, {
+"on": "attack_commit",
+"do": {
+"kind": "add_ticket_rider",
+"value": 1,
+"cap": 5,
+"per": "dig_streak"
+}
+}]
+}, {
 "feat_id": "miner_hammer",
 "display_name": "矿工重锤",
 "rarity": "common",
 "archetype": "normal",
-"hook": "hit_trade",
-"effects": {
+"desc": "加伤换命中",
+"triggers": [{
+"on": "attack_commit",
+"do": {
+"kind": "modify_ticket",
 "trade_atk": 25,
 "trade_hit": 2
 }
+}]
 }, {
 "feat_id": "focus_mind",
 "display_name": "专注",
 "rarity": "rare",
 "archetype": "normal",
-"hook": "armor_roll_rewrite",
-"effects": {
-"value": 75
+"desc": "攻击恒75%折扣",
+"triggers": [{
+"on": "armor_roll",
+"do": {
+"kind": "modify_ticket",
+"value": 75,
+"mode": "armor_rewrite"
 }
+}]
 }, {
 "feat_id": "armor_crack",
 "display_name": "碎甲震击",
 "rarity": "rare",
 "archetype": "normal",
-"hook": "heavy_debuff",
-"effects": {
-"value": 25
+"desc": "打重甲附加破防",
+"triggers": [{
+"on": "attack_commit",
+"when": [{
+"fact": "matchup",
+"op": "ends_with",
+"value": "vs_heavy"
+}],
+"do": {
+"kind": "apply_status",
+"status_id": "off_guard"
 }
+}]
 }, {
 "feat_id": "greedy_lantern",
 "display_name": "贪婪矿灯",
 "rarity": "common",
 "archetype": "dig",
-"hook": "dig_yield_mult",
-"effects": {
+"desc": "开格产出放大",
+"triggers": [{
+"on": "dig_reveal",
+"do": {
+"kind": "yield_mult",
 "mult": 25,
 "cost_mult": 25
 }
+}]
 }, {
 "feat_id": "vein_intuition",
 "display_name": "矿脉直觉",
 "rarity": "rare",
 "archetype": "dig",
-"hook": "dig_yield_mult",
-"effects": {
+"desc": "开格产出放大",
+"triggers": [{
+"on": "dig_reveal",
+"do": {
+"kind": "counter_add",
+"counter_id": "dig_combo",
+"value": 1
+}
+}, {
+"on": "mine_hit",
+"do": {
+"kind": "counter_add",
+"counter_id": "dig_combo",
+"set": 0
+}
+}, {
+"on": "dig_reveal",
+"do": {
+"kind": "yield_mult",
 "mult": 10,
 "cap": 5
 }
+}]
 }, {
 "feat_id": "gambler_pact",
 "display_name": "赌徒的血签",
 "rarity": "rarest",
 "archetype": "dig",
-"hook": "dig_yield_mult",
-"effects": {
+"desc": "开格产出放大",
+"triggers": [{
+"on": "dig_reveal",
+"do": {
+"kind": "yield_mult",
 "mult": 50,
 "cost_mult": 100
 }
+}]
 }, {
 "feat_id": "deep_drill",
 "display_name": "深挖钻头",
 "rarity": "rare",
 "archetype": "dig",
-"hook": "deep_dig",
-"effects": {
-"ap_cost": 1,
-"cap": 4
+"desc": "开格2AP·产出双份",
+"triggers": [{
+"on": "dig_paid",
+"do": {
+"kind": "counter_spend",
+"counter_id": "deep_paid_round",
+"value": 1,
+"reset_at": "round_start",
+"fallback": 1
 }
 }, {
+"on": "dig_reveal",
+"when": [{
+"fact": "counter",
+"id": "deep_paid_round",
+"op": "gte",
+"value": 1
+}, {
+"fact": "counter",
+"id": "deep_given_round",
+"op": "lt_ref",
+"ref": "deep_paid_round"
+}],
+"do": {
+"kind": "grant_material",
+"label": "（深挖）"
+}
+}, {
+"on": "dig_reveal",
+"when": [{
+"fact": "counter",
+"id": "deep_paid_round",
+"op": "gte",
+"value": 1
+}, {
+"fact": "counter",
+"id": "deep_given_round",
+"op": "lt_ref",
+"ref": "deep_paid_round"
+}],
+"do": {
+"kind": "counter_add",
+"counter_id": "deep_given_round",
+"value": 1
+}
+}]
+}, {
 "feat_id": "armory_prep",
 "display_name": "整备军备",
 "rarity": "rarest",
 "archetype": "charge",
-"hook": "ap_carry",
-"effects": {
-"value": 1,
-"cap": 3
+"desc": "剩AP转下轮攻击",
+"triggers": [{
+"on": "round_end",
+"do": {
+"kind": "grant_ap",
+"mode": "transfer"
 }
 }, {
+"on": "attack_commit",
+"do": {
+"kind": "attack_bonus",
+"value": 1,
+"per": "charge_layers"
+}
+}]
+}, {
 "feat_id": "iron_wall",
 "display_name": "铁壁整备",
 "rarity": "rare",
 "archetype": "charge",
-"hook": "charge_shield",
-"effects": {
-"shield_per_layer": 1
+"desc": "蓄力转减伤",
+"triggers": [{
+"on": "damage_taken",
+"do": {
+"kind": "shield",
+"value": 1,
+"per": "charge_layers"
 }
+}]
 }, {
 "feat_id": "patient_burst",
 "display_name": "厚积薄发",
 "rarity": "rare",
 "archetype": "charge",
-"hook": "charge_spike",
-"effects": {
-"value": 2
+"desc": "蓄满下轮爆发",
+"triggers": [{
+"on": "attack_commit",
+"when": [{
+"fact": "charge_layers",
+"op": "gte",
+"value": 3
+}],
+"do": {
+"kind": "modify_ticket",
+"value": 2,
+"mode": "spike"
 }
+}]
 }, {
 "feat_id": "ley_harvest",
 "display_name": "地脉采撷",
 "rarity": "common",
 "archetype": "devour",
-"hook": "terrain_refund",
-"effects": {
-"value": 1
+"desc": "吃地形伤返资源",
+"triggers": [{
+"on": "damage_taken",
+"when": [{
+"fact": "terrain_kind",
+"op": "has"
+}],
+"do": {
+"kind": "grant_material",
+"label": "（地脉补偿）"
 }
+}]
 }, {
 "feat_id": "thorn_weaver",
 "display_name": "荆棘编织者",
 "rarity": "rare",
 "archetype": "devour",
-"hook": "terrain_dig_double",
-"effects": {
-"value": 1
+"desc": "挖伤害格双产出",
+"triggers": [{
+"on": "damage_taken",
+"when": [{
+"fact": "terrain_kind",
+"op": "has"
+}],
+"do": {
+"kind": "grant_material",
+"label": "（荆棘编织）"
 }
+}]
 }, {
 "feat_id": "purge_sapper",
 "display_name": "净化工兵",
 "rarity": "rare",
 "archetype": "devour",
-"hook": "flag_neutralize",
-"effects": {
-"value": 1
+"desc": "标旗中和伤害格",
+"triggers": [{
+"on": "flag_hit",
+"when": [{
+"fact": "terrain_kind",
+"op": "has"
+}],
+"do": {
+"kind": "rewrite_board"
 }
+}]
 }, {
 "feat_id": "magma_body",
 "display_name": "熔火之躯",
 "rarity": "rarest",
 "archetype": "devour",
-"hook": "variant_counter",
-"effects": {
+"desc": "吃地形伤反打全体",
+"triggers": [{
+"on": "damage_taken",
+"when": [{
+"fact": "terrain_kind",
+"op": "has"
+}],
+"do": {
+"kind": "counter_add",
+"counter_id": "magma_layers",
 "value": 1
 }
+}, {
+"on": "round_end",
+"when": [{
+"fact": "counter",
+"id": "magma_layers",
+"op": "gte",
+"value": 1
+}],
+"do": {
+"kind": "open_ticket",
+"value": 1,
+"per": "magma_layers",
+"channel": "blast"
+}
+}, {
+"on": "round_end",
+"when": [{
+"fact": "counter",
+"id": "magma_layers",
+"op": "gte",
+"value": 1
+}],
+"do": {
+"kind": "counter_add",
+"counter_id": "magma_layers",
+"set": 0
+}
+}]
 }]
 
-; 双层 BD 实施批（2026-10-04）：规则改写型特性表——行 = 特性定义
-; （feat_id/display_name/rarity/archetype/hook/effects）。
-; T2 魔法流四件（整合定稿 §2.3 S1）：奥术余烬〔普通·rider+1 必中附加〕/魔网织者〔稀有·magic vs
-; magic 克制罚修正〕/湛蓝誓约〔稀有·magic vs heavy 克制加成〕/魔能共鸣〔罕见锚点·rider+2+每战首次
-; 开格奥术矢——「每关首次」字面落地为「每战首次」台账披露待追认〕；magic 档一（≥2 件）rider+1 /
-; 档二（≥4 件）rider 可暴击——引擎 tiers_for 承载。T3-T6 逐流派续填（flag 4/pierce 4/normal 4/
-; dig 4/charge 3/devour 4——整合定稿 §2.3 七流派的件面）。
-; 稀有度→投放档映射：common/rare → 稀有令牌档、rarest → 罕见令牌档（relic 永不入普通令牌档
-; ——「规则改写型特性带挂稀有/罕见档」追认 b 接线口径，普通档 70 张纯数值维持）。
-; 🔴 层级纪律：本表行永不入同调位（treasure_items）/局外树（T8 节点表）——规则改写型特性只走局内随机渠道。
-; 数值全 provisional 归 M-4 数值批；effects 键白名单封闭（零裸 flat 同族护栏）。
-
+; 内容数据驱动扩展批（2026-10-06 T3）：专长表换代——行 = triggers 事件订阅形态
+; （feat_id/display_name/rarity/archetype/desc/triggers——订阅哪个事件 on / 什么条件 when / 什么效果 do）。
+; 旧 hook/effects 挂点形态随本批退役（挂点枚举消亡：事件名+效果类型取代——任务书 R4 裁决）。
+; 23 挂点逐行移植映射=任务书 §五（等价性对拍底单）；desc=文案表值化（呈现层读行，零硬编码）。
+; 效果参数值直接写 do 字典（数值单一事实源=本表；效果引擎 DO_KEYS 白名单封闭）。
+; 🔴 护栏全部保留：事件/效果/fact/算子四词表封闭（EffectEngine 常量）、行键白名单、悬空引用
+; 致命、零裸 flat 禁令、流派扫雷触发铁律（每流派 ≥1 行订阅扫雷侧事件——MINE_EVENTS 同义校验）。
+; 映射表对拍注记（T3 落地语义修正，行为等价优先——commit 留痕）：
+; - terrain_dig_double（荆棘编织者）：映射表标 yield_mult(×2)，现行为=第二份同格产出兑付
+;   （grant_material），×2 乘区对 percent 行不等价——落 grant_material。
+; - flag_all_hit（完美布防）：映射表标 yield_mult(旗伤乘区)，现行为=旗伤单值倍增（战旗单据
+;   数值改写）——落 modify_ticket(mode:flag_mult)。
+; - 连珠矢/矿工的执拗 streak 取数：映射表 on:dig_reveal counter_add 形态与现行为「轮内踩雷全轮
+;   清零」不等价（逐格清零后重积≠全轮判定）——计数器行保留（扫雷铁律承载），等价执行读
+;   attack_commit 载荷 dig_streak（战斗段全轮推导，与迁移前逐位一致）。
+; - 厚积薄发：映射表 on:charge_full(满层沿)→spike，现行为=满层持续状态（层数无消耗点，沿触发
+;   一次≠持续增强）——落 on:attack_commit + when(charge_layers ≥3) → modify_ticket(mode:spike)，
+;   charge_full 事件仍埋点（R6 框架先行）。
+; - 完美布防：「全中」条件装不进 fact 封闭 9 项（需 hits>0 且 misses==0 双读数）——when 落
+;   flags_count ≥1（可命中保守判定），全中闸=flag_settle 发射点施加面承载（载荷 flags_hit_all
+;   仅供观测）——禁私开 fact（停机点纪律），查询面落法=代拍板白名单。
+; - 猎巢人/矿工的执拗：映射表标 modify_ticket/attack_bonus，现行为=必中附加通道（伤害控制器
+;   hero_rider 后置于乘区与下限）——落 add_ticket_rider（per 取数载荷），乘区外恒定兑付逐位一致。
+; - 整备军备：现行为双效果（轮末 AP 转蓄力层 + 每层下轮首段攻 +1）——两行订阅：
+;   round_end grant_ap(mode:transfer) + attack_commit attack_bonus(per:charge_layers)。
+; 数值全 provisional 归 M-4 数值批；desc 文案=旧 summaries 表迁移（措辞零变化）。

game/presentation/battle_narrator.gd

@@ -131,40 +131,16 @@ static func bonus_result_text(result: Dictionary) -> String:
 	return "已选择：%s\n其余选项已丢弃（不可反悔）" % name
 
 
-# 特性卡片文案（迭代 12 T1；2026-10-04 呈现补强——第三行=hook 效果摘要，用户反馈「不知道件是
-# 干嘛的」缺口承载；摘要=静态映射表 provisional 文案归代拍板白名单「件文案微调」）
+# 特性卡片文案（迭代 12 T1；2026-10-04 呈现补强——第三行=效果摘要，用户反馈「不知道件是
+# 干嘛的」缺口承载。内容数据驱动扩展批 T3 文案表值化：摘要=数据行 desc 字段，零硬编码映射——
+# 新件写行即有名有姓，措辞与旧 summaries 表逐字一致）
 static func feat_card_text(row: Dictionary) -> String:
 	if row.is_empty() or String(row.get("feat_id", "")) == "":
 		return "特性\n???"
 	var arch_names := {"magic": "魔法", "pierce": "穿刺", "normal": "普攻", "dig": "开格",
 		"flag": "标旗", "charge": "蓄力", "devour": "吞噬"}
 	var arch := String(arch_names.get(String(row.get("archetype", "")), "流派"))
-	var summaries := {
-		"hero_attack_rider": "普攻附加必中伤害",
-		"clamp_modifier": "克制面强化",
-		"first_dig_spell": "首格追加奥术矢",
-		"kill_overflow": "击杀半额弹射",
-		"dig_count_segments": "开格积穿刺矢",
-		"roll_discount": "打轻甲更易命中",
-		"round_dig_bonus": "开格越多打得越疼",
-		"hit_trade": "加伤换命中",
-		"armor_roll_rewrite": "攻击恒75%折扣",
-		"heavy_debuff": "打重甲附加破防",
-		"dig_yield_mult": "开格产出放大",
-		"deep_dig": "开格2AP·产出双份",
-		"flag_resource": "标中雷额外得资源",
-		"nest_aura": "控巢攻击光环",
-		"flag_all_hit": "全中标旗伤加倍",
-		"flag_strike": "标中旗必中打敌",
-		"ap_carry": "剩AP转下轮攻击",
-		"charge_shield": "蓄力转减伤",
-		"charge_spike": "蓄满下轮爆发",
-		"terrain_refund": "吃地形伤返资源",
-		"terrain_dig_double": "挖伤害格双产出",
-		"flag_neutralize": "标旗中和伤害格",
-		"variant_counter": "吃地形伤反打全体",
-	}
-	var summary := String(summaries.get(String(row.get("hook", "")), ""))
+	var summary := String(row.get("desc", ""))
 	if summary != "":
 		return "%s · %s\n%s" % [String(row.get("display_name", row.get("feat_id", ""))), arch, summary]
 	return "特性 · %s\n%s" % [arch, String(row.get("display_name", row.get("feat_id", "")))]

game/smoke/smoke_all.gd

@@ -619,17 +619,23 @@ func _smoke_feats() -> void:
 				rarest_tokens += 1
 	check(feat_tokens == 27 and rarest_tokens == 6 and a_r0._curio_deck.size() == 125,
 		"规则改写型特性带入池：27 件（rare 档 21 + rarest 锚点 6）——牌库 98+27=125")
-	check(_db.feats.validate().is_empty(), "feat_table.validate 零违例（有行流派扫雷端铁律——magic first_dig_spell 在案）")
-	# ② 档位激活引擎（纯函数直测——构造表 4 件 magic + 1 件 flag + 1 件 rarest 锚点）
+	check(_db.feats.validate().is_empty(), "feat_table.validate 零违例（有行流派扫雷端铁律——magic 魔能共鸣 dig_reveal 订阅在案）")
+	# ② 档位激活引擎（纯函数直测——构造表 4 件 magic + 1 件 flag；内容数据驱动扩展批 T3 断言面随迁：
+	# 行=triggers 事件订阅形态，挂点投影断言换代=效果引擎订阅装载序〔feats 表序〕）
 	var rt := FeatTable.new()
 	rt.rows = [
-		{"feat_id": "m1", "display_name": "魔一", "rarity": "common", "archetype": "magic", "hook": "hero_attack_rider", "effects": {"value": 1}},
-		{"feat_id": "m2", "display_name": "魔二", "rarity": "common", "archetype": "magic", "hook": "first_dig_spell", "effects": {"value": 1}},
-		{"feat_id": "m3", "display_name": "魔三", "rarity": "rare", "archetype": "magic", "hook": "clamp_modifier", "effects": {"value": 1}},
-		{"feat_id": "m4", "display_name": "魔四", "rarity": "rare", "archetype": "magic", "hook": "hero_attack_rider", "effects": {"tier_value": 2}},
-		{"feat_id": "f1", "display_name": "旗一", "rarity": "common", "archetype": "flag", "hook": "flag_resource", "effects": {"value": 1}},
+		{"feat_id": "m1", "display_name": "魔一", "rarity": "common", "archetype": "magic", "desc": "测试 rider",
+			"triggers": [{"on": "attack_commit", "do": {"kind": "add_ticket_rider", "value": 1}}]},
+		{"feat_id": "m2", "display_name": "魔二", "rarity": "common", "archetype": "magic", "desc": "测试奥术矢",
+			"triggers": [{"on": "dig_reveal", "do": {"kind": "spawn_spell", "value": 1}}]},
+		{"feat_id": "m3", "display_name": "魔三", "rarity": "rare", "archetype": "magic", "desc": "测试克制",
+			"triggers": [{"on": "clamp_check", "when": [{"fact": "matchup", "op": "eq", "value": "magic_vs_magic"}], "do": {"kind": "modify_ticket", "delta": 1}}]},
+		{"feat_id": "m4", "display_name": "魔四", "rarity": "rare", "archetype": "magic", "desc": "测试加值",
+			"triggers": [{"on": "attack_commit", "do": {"kind": "attack_bonus", "value": 2}}]},
+		{"feat_id": "f1", "display_name": "旗一", "rarity": "common", "archetype": "flag", "desc": "测试图谱",
+			"triggers": [{"on": "flag_hit", "do": {"kind": "grant_material", "value": 1}}]},
 	]
-	check(rt.validate().is_empty(), "构造 relic 表 validate 零违例（magic 4 件含 first_dig_spell 扫雷端——红线①铁律过）")
+	check(rt.validate().is_empty(), "构造 relic 表 validate 零违例（magic 4 件含 dig_reveal 扫雷端订阅——红线①铁律过）")
 	var tiers := FeatsEngine.tiers_for(["m1", "m2", "m3", "m4", "f1"], rt)
 	check(int(tiers.get("magic", -1)) == 2 and int(tiers.get("flag", -1)) == 0,
 		"档位激活：magic 4 件→档二 · flag 1 件→散件档 0（集 2 档一/4 档二——以撒套装/小骨铭文先例）")
@@ -637,9 +643,6 @@ func _smoke_feats() -> void:
 		"成型判读：magic 成型（tier≥1）· flag 未成型（散件单体保底——档位只质变不启动）")
 	var t2 := FeatsEngine.tiers_for(["m1", "m2"], rt)
 	check(int(t2.get("magic", -1)) == 1, "档位激活：2 件→档一（同集合同档位确定性——MC 逐位可复放承载）")
-	var hooks := FeatsEngine.hooks_for(["m1", "f1"], rt)
-	check(hooks.size() == 2 and String(hooks[0].get("hook", "")) == "hero_attack_rider",
-		"挂点投影：表序稳定（同集合→同投影）")
 	# ③ 规则改写型特性带接线（临时表注入——relic 令牌入牌库/兑付入持有集/踢池/断点往返；测试尾还原现行表）
 	var live_rows: FeatTable = _db.feats
 	_db.feats = rt
@@ -721,56 +724,121 @@ func _smoke_feats() -> void:
 	check(bp_deck_m3 == 0, "断点余库：已兑付 relic 令牌逐枚还原（m3 零残留——续玩不重复获得）")
 	sm_r.clear_breakpoint()
 	_db.feats = live_rows   # 还原现行表（共享 _db 防污染——后续冒烟段零感知）
-	# ④ T2 魔法流求值面（现行表 magic 四件——flags 组装直测；rider 落地行为=伤害控制器消费面，
-	# 既有战斗冒烟全绿=feat_flags 空 dict 零扰动实证；全链分岔读数归 T7 MC）
+	# ④ 魔法流订阅面（内容数据驱动扩展批 T3 断言面随迁——_feat_flags_for 挂点求值退役：
+	# 求值断言=效果引擎 rebuild+dispatch 命中面；落地行为=发射点施加面（本段下方各事件直测），
+	# 全链分岔读数归 T6 MC 对拍）
 	var orch = load("res://core/battle_orchestrator.gd").new(_db, _fresh_rng(73))
-	orch._feat_flags_for(["arcane_ember", "mana_weaver", "azure_oath", "mana_resonance"])
-	var rf: Dictionary = orch._damage.feat_flags
-	check(int(rf.get("rider_flat", -1)) == 2 and bool(rf.get("rider_crit", false)),
-		"魔法流求值：rider_flat=余烬1+档一(4件)+1=2 · 档二 rider 可暴击（共鸣 rider 提升以奥术矢+档位承载——锚点双效果 provisional 披露）")
-	check(int(rf.get("clamp_magic_magic", -1)) == 1 and int(rf.get("clamp_magic_heavy", -1)) == 1
-		and bool(rf.get("first_dig_spell", false)) and int(rf.get("spell_value", -1)) == 2,
-		"魔法流求值：魔网织者 magic-vs-magic 罚修正 +1 · 湛蓝誓约 magic-vs-heavy +1 · 魔能共鸣奥术矢 value 2")
-	# ⑤ T3 标旗流求值面（现行表 magic 4+flag 4——混合持有：flag 档一 4 件成型）
-	orch._feat_flags_for(["arcane_ember", "mana_weaver", "azure_oath", "mana_resonance",
-		"mine_atlas", "nest_hunter", "perfect_defense", "war_banner"])
-	var rf8: Dictionary = orch._damage.feat_flags
-	check(int(rf8.get("flag_resource_extra", -1)) == 1 and int(rf8.get("nest_aura_value", -1)) == 1
-		and int(rf8.get("flag_all_hit_mult", -1)) == 2 and int(rf8.get("flag_strike_value", -1)) == 2,
-		"标旗流求值：雷区图谱额外资源 1 · 猎巢人光环 +1/巢 · 完美布防 ×2 · 战旗军规旗伤 2（复用 board_typed 零新配方）")
-	# ⑥ T4 穿刺/普攻流求值面（全 16 件持有——四流派档位成型）
-	orch._feat_flags_for(["arcane_ember", "mana_weaver", "azure_oath", "mana_resonance",
-		"mine_atlas", "nest_hunter", "perfect_defense", "war_banner",
+	var magic4: Array = ["arcane_ember", "mana_weaver", "azure_oath", "mana_resonance"]
+	orch._fx.rebuild(magic4, [], [])
+	var ac4: Array = orch._fx_emit("attack_commit", {"atk": 10, "target": "敌", "matchup": "magic_vs_magic", "dig_streak": 0, "nest_count": 0})
+	check(orch._hits_of(ac4, "add_ticket_rider").size() == 1
+		and int((orch._hits_of(ac4, "add_ticket_rider")[0] as Dictionary).get("value", -1)) == 1,
+		"魔法流订阅：奥术余烬 attack_commit→add_ticket_rider value 1（必中附加通道）")
+	check(int((orch._hits_of(orch._fx_emit("clamp_check", {"matchup": "magic_vs_magic"}), "modify_ticket")[0] as Dictionary).get("delta", -1)) == 1
+		and int((orch._hits_of(orch._fx_emit("clamp_check", {"matchup": "magic_vs_heavy"}), "modify_ticket")[0] as Dictionary).get("delta", -1)) == 1,
+		"魔法流订阅：魔网织者 magic-vs-magic +1 · 湛蓝誓约 magic-vs-heavy +1（clamp_check modify 窗口）")
+	var spell4: Array = orch._fx_emit("dig_reveal", {"cell": Vector2i(1, 1), "round": 1, "is_first_dig_of_battle": true, "terrain_kind": []})
+	check(orch._hits_of(spell4, "spawn_spell").size() == 1
+		and int((orch._hits_of(spell4, "spawn_spell")[0] as Dictionary).get("value", -1)) == 2,
+		"魔法流订阅：魔能共鸣每战首次开格→spawn_spell value 2（奥术矢）")
+	check(int(FeatsEngine.tiers_for(magic4, _db.feats).get("magic", -1)) == 2,
+		"魔法流档位：magic 4 件→档二（rider 可暴击——begin_battle 注伤害控制器两运行态）")
+	# ⑤ 标旗流订阅面（magic 4+flag 4——混合持有：flag 档一成型）
+	orch._fx.rebuild(magic4 + ["mine_atlas", "nest_hunter", "perfect_defense", "war_banner"], [], [])
+	check(orch._hits_of(orch._fx_emit("flag_hit", {"cell": Vector2i(1, 1), "round": 1, "terrain_kind": []}), "grant_material").size() == 1,
+		"标旗流订阅：雷区图谱 flag_hit→grant_material（标中雷额外资源）")
+	var nh5: Array = orch._fx_emit("attack_commit", {"atk": 10, "target": "敌", "matchup": "", "dig_streak": 0, "nest_count": 3})
+	var nh_hits: Array = orch._hits_of(nh5, "add_ticket_rider")
+	check(nh_hits.size() == 2 and String((nh_hits[1] as Dictionary).get("per", "")) == "nest_count",
+		"标旗流订阅：猎巢人 attack_commit→add_ticket_rider per nest_count（控巢光环 rider 通道）")
+	var fs5: Array = orch._fx_emit("flag_settle", {"flags_hit_all": true, "flags_count": 2, "round": 1})
+	check(orch._hits_of(fs5, "open_ticket").size() == 1
+		and int((orch._hits_of(fs5, "open_ticket")[0] as Dictionary).get("value", -1)) == 2
+		and orch._hits_of(fs5, "modify_ticket").size() == 1,
+		"标旗流订阅：战旗军规 flag_settle→open_ticket value 2（attack 通道自开单）· 完美布防 flag_mult ×2")
+	check(orch._fx_emit("flag_settle", {"flags_hit_all": false, "flags_count": 0, "round": 1}).is_empty(),
+		"标旗流订阅：零标中旗→战旗/完美布防零命中（when flags_count 封闭判定）")
+	# ⑥ 穿刺/普攻流订阅面（16 件持有——四流派档位成型）
+	var ids16: Array = magic4 + ["mine_atlas", "nest_hunter", "perfect_defense", "war_banner",
 		"pierce_shot", "chain_arrows", "weak_instinct", "hunter_rapier",
-		"miner_stubborn", "miner_hammer", "focus_mind", "armor_crack"])
-	var rf16: Dictionary = orch._damage.feat_flags
-	check(bool(rf16.get("kill_overflow", false)) and int(rf16.get("chain_value", -1)) == 2
-		and int(rf16.get("discount_shift", -1)) == 1 and int(rf16.get("clamp_pierce_light", -1)) == 1,
-		"穿刺流求值：贯穿射击弹射旗 · 连珠矢段值 2 上限 2 · 猎弱本能折扣改善 1 档 · 猎手刺剑 pierce-vs-light +1")
-	check(int(rf16.get("round_dig_value", -1)) == 1 and int(rf16.get("hit_trade_atk", -1)) == 25
-		and int(rf16.get("hit_trade_hit", -1)) == 2 and int(rf16.get("armor_roll_rewrite", -1)) == 75
-		and int(rf16.get("crack_value", -1)) == 25,
-		"普攻流求值：执拗 +1/格上限 5 · 重锤交换 +25%/−2AC · 专注恒 75% 免掷骰 · 碎甲震击 off_guard 授予旗")
-	check(bool(rf16.get("rider_crit", false)) and bool(rf16.get("rider_crit", false)),
+		"miner_stubborn", "miner_hammer", "focus_mind", "armor_crack"]
+	orch._fx.rebuild(ids16, [], [])
+	check(orch._hits_of(orch._fx_emit("kill", {"target": "敌", "overflow": 10}), "overflow").size() == 1,
+		"穿刺流订阅：贯穿射击 kill→overflow（击杀弹射旗）")
+	var dr6: Array = orch._fx_emit("dig_reveal", {"cell": Vector2i(1, 1), "round": 1, "is_first_dig_of_battle": false, "terrain_kind": []})
+	check(orch._hits_of(dr6, "counter_add").size() == 2,
+		"穿刺/普攻流订阅：连珠矢+执拗 dig_reveal→counter_add（扫雷侧事件铁律承载——chain_digs/stubborn_digs）")
+	var ac6: Array = orch._fx_emit("attack_commit", {"atk": 10, "target": "敌", "matchup": "pierce_vs_light", "dig_streak": 9, "nest_count": 0})
+	var seg6: Array = orch._hits_of(ac6, "attack_segments")
+	check(seg6.size() == 1 and int((seg6[0] as Dictionary).get("value", -1)) == 2
+		and int((seg6[0] as Dictionary).get("cap", -1)) == 2 and int((seg6[0] as Dictionary).get("divisor", -1)) == 3,
+		"穿刺流订阅：连珠矢 attack_commit→attack_segments（段值 2 上限 2 每 3 格 +1 段）")
+	var clamp6: Array = orch._fx_emit("clamp_check", {"matchup": "pierce_vs_light"})
+	check(orch._hits_of(clamp6, "modify_ticket").size() == 2,
+		"穿刺流订阅：猎弱本能 ends_with vs_light→discount_shift · 猎手刺剑 pierce_vs_light→delta +1（同一事件双订阅按声明序）")
+	check(orch._hits_of(orch._fx_emit("armor_roll", {"target_ac": 5, "roll": 3}), "modify_ticket").size() == 1,
+		"普攻流订阅：专注 armor_roll→modify armor_rewrite 75（免掷恒折扣）")
+	var ac6n: Array = orch._fx_emit("attack_commit", {"atk": 10, "target": "敌", "matchup": "normal_vs_heavy", "dig_streak": 0, "nest_count": 0})
+	check(orch._hits_of(ac6n, "apply_status").size() == 1
+		and String((orch._hits_of(ac6n, "apply_status")[0] as Dictionary).get("status_id", "")) == "off_guard",
+		"普攻流订阅：碎甲震击 ends_with vs_heavy→apply_status off_guard（复用零新状态行）")
+	var ham6: Array = orch._hits_of(ac6, "modify_ticket")
+	var has_trade := false
+	for h in ham6:
+		if int((h as Dictionary).get("trade_atk", 0)) == 25 and int((h as Dictionary).get("trade_hit", 0)) == 2:
+			has_trade = true
+	check(has_trade, "普攻流订阅：矿工重锤 attack_commit→modify trade_atk 25/trade_hit 2（命中交换）")
+	check(int(FeatsEngine.tiers_for(ids16, _db.feats).get("pierce", -1)) == 2
+		and int(FeatsEngine.tiers_for(ids16, _db.feats).get("normal", -1)) == 2,
 		"档位质变：magic/pierce/normal/flag 四流派档二（16 件混合——同标签 ≥4 判档二确定性）")
-	# ⑦ T5 开格/蓄力流求值面（追加七件）
-	var ids23: Array = ["arcane_ember", "mana_weaver", "azure_oath", "mana_resonance",
-		"mine_atlas", "nest_hunter", "perfect_defense", "war_banner",
-		"pierce_shot", "chain_arrows", "weak_instinct", "hunter_rapier",
-		"miner_stubborn", "miner_hammer", "focus_mind", "armor_crack",
-		"greedy_lantern", "vein_intuition", "gambler_pact", "deep_drill",
-		"armory_prep", "iron_wall", "patient_burst"]
-	orch._feat_flags_for(ids23)
-	var rf23: Dictionary = orch._damage.feat_flags
-	check(int(rf23.get("dig_yield_pos_mult", -1)) == 85 and int(rf23.get("dig_yield_neg_mult", -1)) == 125
-		and int(rf23.get("combo_cap", -1)) == 5,
-		"开格流求值：正向乘区 25+10+50=85% · 负向加重 25+100=125% · 直觉连击上限 5（同 hook 累加——三件同持）")
-	check(int(rf23.get("deep_dig_cost", -1)) == 1 and int(rf23.get("deep_dig_cap", -1)) == 4
-		and int(rf23.get("ap_carry_value", -1)) == 1 and int(rf23.get("shield_per_layer", -1)) == 1
-		and int(rf23.get("spike_mult", -1)) == 2,
-		"深挖钻头=开掘 +1 AP/每 4 格深层产出（R4 甲非信息税对价）· 蓄力三件=层值 1/减伤 1/层/满层 ×2")
-	check(orch.action_economy.feat_ap_carry and orch.action_economy.feat_dig_extra == 1,
-		"蓄力/钻头 action_economy 注入（ap_carry 改写停手转存 + 付费开掘对价注入——关着 false/0 零扰动）")
+	# ⑦ 开格/蓄力流订阅面（追加七件）
+	var ids23: Array = ids16.duplicate()
+	ids23.append_array(["greedy_lantern", "vein_intuition", "gambler_pact", "deep_drill",
+		"armory_prep", "iron_wall", "patient_burst"])
+	orch._fx.rebuild(ids23, [], [])
+	var pos_m := 0
+	var neg_m := 0
+	var combo_cap := -1
+	for h in orch._fx_emit("dig_reveal", {"cell": Vector2i(1, 1), "round": 1, "is_first_dig_of_battle": false, "terrain_kind": []}):
+		if String(h.get("kind", "")) != "yield_mult":
+			continue
+		pos_m += int(h.get("mult", 0))
+		neg_m += int(h.get("cost_mult", 0))
+		if int(h.get("cap", 0)) > 0:
+			combo_cap = int(h.cap)
+	check(pos_m == 85 and neg_m == 125 and combo_cap == 5,
+		"开格流订阅：正向乘区 25+10+50=85% · 负向加重 25+100=125% · 直觉连击上限 5（dig_reveal yield_mult 乘法族三件同持收集）")
+	var dd7: Array = orch._fx_emit("dig_paid", {"ap_cost": 1, "ap_surplus": 1})
+	check(orch._hits_of(dd7, "counter_spend").size() == 1
+		and bool((orch._hits_of(dd7, "counter_spend")[0] as Dictionary).has("fallback")),
+		"开格流订阅：深挖钻头 dig_paid→counter_spend 对价（fallback 降级声明——AP 不足只付基础 1）")
+	var re7: Array = orch._fx_emit("round_end", {"round": 1})
+	check(orch._hits_of(re7, "grant_ap").size() == 1
+		and String((orch._hits_of(re7, "grant_ap")[0] as Dictionary).get("mode", "")) == "transfer",
+		"蓄力流订阅：整备军备 round_end→grant_ap transfer（剩 AP 转蓄力层——finish_round_stop 定夺）")
+	var ab7: Array = orch._hits_of(orch._fx_emit("attack_commit", {"atk": 10, "target": "敌", "matchup": "", "dig_streak": 0, "nest_count": 0}), "attack_bonus")
+	check(ab7.size() == 1 and String((ab7[0] as Dictionary).get("per", "")) == "charge_layers",
+		"蓄力流订阅：整备军备 attack_commit→attack_bonus per charge_layers（每层下轮首段 +1）")
+	orch.action_economy._charge_layers = 2
+	var sp7: Array = orch._fx_emit("attack_commit", {"atk": 10, "target": "敌", "matchup": "normal_vs_light", "dig_streak": 0, "nest_count": 0})
+	var spike7_off: Array = orch._hits_of(sp7, "modify_ticket")
+	var spike_off_n := 0
+	for h in spike7_off:
+		if String((h as Dictionary).get("mode", "")) == "spike":
+			spike_off_n += 1
+	check(spike_off_n == 0,
+		"蓄力流订阅：厚积薄发未满层（charge_layers 2<3）→零命中（when 封闭判定——满层持续状态口径）")
+	orch.action_economy._charge_layers = 3
+	var sp7b: Array = orch._fx_emit("attack_commit", {"atk": 10, "target": "敌", "matchup": "normal_vs_light", "dig_streak": 0, "nest_count": 0})
+	var spike7: Array = []
+	for h in orch._hits_of(sp7b, "modify_ticket"):
+		if String((h as Dictionary).get("mode", "")) == "spike":
+			spike7.append(h)
+	check(spike7.size() == 1 and int((spike7[0] as Dictionary).get("value", -1)) == 2,
+		"蓄力流订阅：厚积薄发满层→modify spike ×2（discount 恒全额+基值倍乘）")
+	orch.action_economy._charge_layers = 0
+	check(orch._hits_of(orch._fx_emit("damage_taken", {"kind": "enemy_skill", "amount": 5, "source": "s", "round": 1}), "shield").size() == 1,
+		"蓄力流订阅：铁壁整备 damage_taken→shield per charge_layers（蓄力转减伤）")
 	# ⑦c 特性持有呈现段（2026-10-04 用户反馈补齐——C 区「特性」节：聚合行+成型档位；空态隐藏）
 	var panel = load("res://presentation/views/hero_info_panel_view.gd").new()
 	panel.set_feat_holdings([])
@@ -778,30 +846,46 @@ func _smoke_feats() -> void:
 	panel.set_feat_holdings(["魔法 ×2 · 档一", "开格 ×1 · 散件"])
 	check(panel._feat_section.visible and panel._feat_list.get_child_count() == 2,
 		"特性段持有呈现（聚合行+成型档位常驻可读——「局内奖励选了什么看不到」缺口承载）")
-	# ⑦b 深挖钻头付费开掘回归（2026-10-04 试玩缺陷修复——对价挂付费侧）：AP=1 降级照常开格
-	# （用户实测「AP=1 无法开格只能标旗」的回归闸）；AP=2 付全价积付费计数（深层产出配额取数面）。
+	check(String(load("res://presentation/battle_narrator.gd").feat_card_text({"feat_id": "arcane_ember", "display_name": "奥术余烬", "archetype": "magic", "desc": "普攻附加必中伤害"})).contains("普攻附加必中伤害"),
+		"特性卡文案表值化：desc 行字段直读（T3 文案入表——零硬编码映射）")
+	# ⑦b 深挖钻头付费开掘回归（2026-10-04 试玩缺陷修复口径，T3 对价面换代=dig_paid 订阅施加）：
+	# AP=1 降级照常开格（fallback 只付基础 1 不积计数）；AP=2 付全价积付费计数（深层产出配额取数面）。
 	var ae_dd = load("res://core/action_economy.gd").new(_db)
-	ae_dd.feat_dig_extra = 1
+	var fx_dd = EffectEngine.new(_db)
+	fx_dd.rebuild(["deep_drill"], [], [])
+	ae_dd.set_fx(fx_dd)
 	ae_dd._phase = 1 if ae_dd.Phase.ACTIVE == 1 else ae_dd.Phase.ACTIVE   # white-box 相位（冒烟专用）
 	ae_dd._ap = 1
-	check(ae_dd.request_dig(0, false) and ae_dd.deep_paid_count == 0,
-		"钻头降级：AP=1 照常开格（只付基础 1 不积付费——持有钻头永不锁死挖格，散件保底 B-2）")
+	check(ae_dd.request_dig(0, false) and fx_dd.counter("deep_paid_round") == 0,
+		"钻头降级：AP=1 照常开格（fallback 只付基础 1 不积付费——持有钻头永不锁死挖格，散件保底 B-2）")
 	ae_dd._ap = 2
 	ae_dd._phase = ae_dd.Phase.ACTIVE   # 首挖 AP 归 0 已翻轮（ap_exhausted 仲裁）——白盒复位续测
-	check(ae_dd.request_dig(0, false) and ae_dd.deep_paid_count == 1,
-		"钻头付费开掘：AP=2 付全价（基础 1+对价 1——deep_paid_count 积数=深层产出配额取数面）")
-	# ⑧ T6 吞噬流求值面（27 件全量——七流派档位成型）
+	check(ae_dd.request_dig(0, false) and fx_dd.counter("deep_paid_round") == 1,
+		"钻头付费开掘：AP=2 付全价（基础 1+对价 1——deep_paid_round 计数器=授予段追加产出配额取数面）")
+	# ⑧ 吞噬流订阅面（27 件全量——七流派档位成型）
 	var ids27: Array = ids23.duplicate()
 	ids27.append_array(["ley_harvest", "thorn_weaver", "purge_sapper", "magma_body"])
-	orch._feat_flags_for(ids27)
-	var rf27: Dictionary = orch._damage.feat_flags
-	check(int(rf27.get("terrain_refund", -1)) == 1 and int(rf27.get("terrain_dig_double", -1)) == 1
-		and int(rf27.get("flag_neutralize", -1)) == 1 and int(rf27.get("variant_counter_value", -1)) == 1,
-		"吞噬流求值：地脉采撷补偿 1 · 荆棘编织双产出 · 净化工兵中和旗（🔴 仅伤害型——过滤在消费面）· 熔火反噬 1/层")
+	orch._fx.rebuild(ids27, [], [])
+	var dt8: Array = orch._fx_emit("damage_taken", {"kind": "terrain", "amount": 3, "source": "thorn_field", "round": 1, "terrain_kind": "thorn_field"})
+	check(orch._hits_of(dt8, "grant_material").size() == 2 and orch._hits_of(dt8, "counter_add").size() == 1,
+		"吞噬流订阅：地脉采撷+荆棘编织 damage_taken(地形伤)→grant_material ×2 · 熔火之躯→counter_add 积层")
+	check(orch._hits_of(orch._fx_emit("flag_hit", {"cell": Vector2i(1, 1), "round": 1, "terrain_kind": ["thorn_field"]}), "rewrite_board").size() == 1
+		and orch._hits_of(orch._fx_emit("flag_hit", {"cell": Vector2i(1, 1), "round": 1, "terrain_kind": []}), "rewrite_board").is_empty(),
+		"吞噬流订阅：净化工兵 flag_hit 邻伤害型地形→rewrite_board · 无伤害型邻格零命中（🔴 仅伤害型——terrain_kind has 在场判定）")
+	orch._fx.counter_add("magma_layers", 2, false)
+	var re8: Array = orch._fx_emit("round_end", {"round": 1})
+	check(orch._hits_of(re8, "open_ticket").size() == 1
+		and int((orch._hits_of(re8, "open_ticket")[0] as Dictionary).get("value", -1)) == 1
+		and String((orch._hits_of(re8, "open_ticket")[0] as Dictionary).get("per", "")) == "magma_layers",
+		"吞噬流订阅：熔火之躯 round_end→open_ticket per magma_layers（受地形伤积层轮末反打）")
+	check(orch._hits_of(re8, "counter_add").size() == 1
+		and (orch._hits_of(re8, "counter_add")[0] as Dictionary).has("set"),
+		"吞噬流订阅：熔火之躯反打后积层清零（counter_add set——即时执行族按声明序）")
 	var orch0 = load("res://core/battle_orchestrator.gd").new(_db, _fresh_rng(74))
-	orch0._feat_flags_for([])
-	check((orch0._damage.feat_flags as Dictionary).is_empty(),
-		"零持有求值=零旗（relic 关着零扰动——伤害管线既有行为逐位不变）")
+	orch0._fx.rebuild([], [], [])
+	check(orch0._fx_emit("attack_commit", {"atk": 10, "target": "敌", "matchup": "", "dig_streak": 0, "nest_count": 0}).is_empty()
+		and orch0._fx_emit("dig_reveal", {"cell": Vector2i(1, 1), "round": 1, "is_first_dig_of_battle": true, "terrain_kind": []}).is_empty(),
+		"零持有订阅=零命中（relic 关着零扰动——伤害管线既有行为逐位不变）")
 
 
 # 手工场景驱动：L1 全程 + L2 推进到商店房（_drive_level 复用 + 兑付确认/选路/大奖励确认手工编排）