refactor(迭代35卡②T2·二口＋T3 S1/S2/S6/S8): 消费侧切源落定＋断言面换代主体——① level_runner 图源换代（_generator 取代模板解析，_assign_generated_graph 读 level_gen_params 参数档产图并过 LevelTable.validate_graph，违规起关拒绝零兜底）＋_entry_nodes 多入口首跳＋_node_id 句柄单空间＋enc node_depth 取节点 depth 值；② adventure_runner/main/save_manager 模板链路退役（first_script 参数与 template_pick 计算全删，断点 template_pick 键换生成图代差标记键 graph_gen_v2，缺键旧断点 resume 显式拒绝禁静默回放）；③ level.tres 三行 templates 键清出（15 张模板数据出表，行级字段留，表尾注释改指参数档＋生成器）；④ sim/probe 随动（run_level/run_adventure 尾参退役、MC 出数字段 level_templates→level_maps 值＝关卡#主种子、探针注释性质化、boss_depth 取节点 depth 键）；⑤ 断言面换代：node_map_templates 宿主整段重写为生成图确定性套（纯函数复现/换种子变图/零计数器号位依赖/单一图源/种子 42 两开局同图/断点重生成同图/缺代差键拒绝/表无 templates/收束置位三条保留），breakpoint_resume 新增 P7 六断言（快照无已抽模板键、代差标记、停点句柄与已到序往返、续玩同图、旧断点拒绝、同种子重开局同图），S8 单测随动 first_script 键清退＋断点夹具换代＋meta 参数面 extra 键样换 treasure_unlocked（语义保持），S2 生成图取数面三宿主替换（level_active_nodes 走参数档＋种子 42，消费点深度键换 depth，round_flow 死件 _boss_depth 随删），adventure_feats 覆盖义务段改真实解析链判据（敌侧落带≥请求深度＋板侧命中＋非空扫描面）、奖励节点段换「图侧含件＋真实选路点选呈停兑付」双断言（旧单链必经形状前提随模板消亡，非放宽：经停即呈候选由真实 pick_next_node 入口证明）、商店余额段按每关恰一店投影改三关读数

game/core/adventure_runner.gd

@@ -42,7 +42,7 @@ var _pending_next_level := false          # 大奖励已兑付、等 continue_to
 var _last_level_payload := {}             # 最近一次关卡结束载荷（失败结算的败退节点明细来源——数值验证取数面）
 var _override := [0, 0]                   # 调试浮窗百分比通道 [atk_pct, hp_pct]（每关新 runner 都要应用）
 var _base_override := {"atk": 0, "max_hp": 0, "armor_class": 0}
-var _first_script := false                # 首次脚本模式（关卡节点图生成 v0.4——true = 全关零抽签取池内模板 0；测量夹具恒 false）   # 永久强化 flat 注入（冒险开始参数面 params.hero_override 存入，共享给 LevelRunner；全零 = 白板）
+# 永久强化 flat 注入（冒险开始参数面 params.hero_override 存入，共享给 LevelRunner；全零 = 白板）
 var _last_treasure_cleared := 0                 # additive（最近一次关卡末清空计数，summary 取数面）
 var _treasure_unlocked := {}                   # aux 解锁门控集（params.treasure_unlocked 接收面）
 var _attunement: Array[Variant] = []               # 同调装配集（params.attunement 接收面，start_level 外下传 LevelRunner）
@@ -99,7 +99,6 @@ func start_adventure(seed_val: int, params: Dictionary = {}) -> bool:
 	_base_override = _normalize_override(params.get("hero_override", {}))
 	hero_attack_type = String(params.get("attack_type", ""))   # 两根类型轴快照（契约 8 锁死：开局后不随存档选中变化）
 	hero_armor_type = String(params.get("armor_type", ""))
-	_first_script = bool(params.get("first_script", false))   # 缺省 = 非首次（抽签路径；真实侧由呈现层读存档布尔位传入）
 	_shop_mode = "pool" if String(params.get("shop_mode", "legacy")) == "pool" else "legacy"   # 缺省 legacy（off 对照零扰动）
 	_treasure_unlocked = params.get("treasure_unlocked", {}) if params.get("treasure_unlocked", {}) is Dictionary else {}
 	_attunement = params.get("attunement", []) if params.get("attunement", []) is Array else []   # additive
@@ -144,6 +143,11 @@ func resume_adventure(bp: Dictionary, params: Dictionary = {}) -> bool:
 	if bp.is_empty():
 		push_error("[冒险结构] resume_adventure 拒绝——空断点快照")
 		return false
+	if int(bp.get("graph_gen_v2", 0)) != 1:
+		# 旧代差断点（模板池时代的 node_id 与生成图句柄空间可碰撞错位）——显式拒绝，
+		# 禁按新语义静默回放；旧模板图已随模板池退役，无迁移动作可做（凭空捏图＝兜底图红线）。
+		push_error("[冒险结构] resume_adventure 拒绝——断点缺生成图代差标记（graph_gen_v2），属换代前旧断点")
+		return false
 	master_seed = int(bp.get("master_seed", 0))
 	rng.restore_adventure(master_seed, int(bp.get("rng_counter", 0)))
 	ledger = {"hero_hp": int(bp.get("hero_hp", 0)), "gp": int(bp.get("gp", 0))}
@@ -191,7 +195,6 @@ func resume_adventure(bp: Dictionary, params: Dictionary = {}) -> bool:
 	# 钳制用 flat 已含的保守口径即可，加算区恢复后其余战斗照常）。
 	ledger["hero_hp"] = mini(int(ledger.get("hero_hp", 0)), maxi(1,
 		int(round(float(int(db.hero.max_hp) + int(_base_override.get("max_hp", 0))) * (100.0 + float(_override[1])) / 100.0))))
-	_first_script = false   # 续玩模板已随快照强制（已抽模板零重抽）——脚本模式不重放
 	_shop_mode = "pool" if String(params.get("shop_mode", "legacy")) == "pool" else "legacy"   # 续玩参数面同 start_adventure（缺省 legacy）
 	_treasure_unlocked = params.get("treasure_unlocked", {}) if params.get("treasure_unlocked", {}) is Dictionary else {}
 	_attunement = params.get("attunement", []) if params.get("attunement", []) is Array else []   # additive
@@ -844,14 +847,12 @@ func _start_current_level() -> bool:
 	_runner.wallet_changed.connect(_forward_wallet_changed)
 	_runner.level_finished.connect(_on_level_finished)
 	_runner.set_hero_override(int(_override[0]), int(_override[1]))
-	# 断点续玩分支：模板随快照强制（已抽模板零重抽零 RNG）、resume_state 带
-	# 停点节点与已到序——重建到停点后经 present_resumed_choice 呈现（信号顺序契约同入口）。
+	# 断点续玩分支：图由主种子＋参数档重生成同图（产图与计数器号位无关，停点零重抽语义随之消解），
+	# resume_state 带停点句柄与已到序——重建到停点后经 present_resumed_choice 呈现（信号顺序契约同入口）。
 	var resume_state: Dictionary[Variant, Variant] = {}
-	var template_pick: int = 0 if _first_script else -1   # 首次脚本 = 每关固定模板 0 零抽签；否则逐关抽签
 	if not _resume_bp.is_empty():
 		resume_state = {"node_id": int(_resume_bp.get("node_id", -1)),
 			"visited_ids": _resume_bp.get("visited_ids", []) as Array}
-		template_pick = int(_resume_bp.get("template_pick", -1))
 	# 接口①开始关卡：生命经共享账本交接（账本当前值即开局生命——冒险开始置满 / 大奖励回满已写好）；
 	# _base_override 共享引用随载荷传入（永久强化 flat——LevelRunner.effective_* 叠加序第二项）。
 	# defer_entry=true 起每关（含首关）——先 emit level_started（呈现层在
@@ -860,7 +861,7 @@ func _start_current_level() -> bool:
 	_runner.set_run_ledger(run_ledger)   # 共享四账单类下传（run_ledger=四账类，ledger=关卡账）
 	_runner.sync_attune_inventory()   # 能力件骑库存面注入（随账下传同拍）
 	var ok: bool = _runner.start_level_external(level_index, ledger, purchased,
-		apply_rest, _base_override, true, template_pick, resume_state)
+		apply_rest, _base_override, true, resume_state)
 	if ok:
 		_runner.set_attunement(_attunement)   # 同调装配下传（enc 携带进战斗结算）
 		_runner.set_feats(_feats)   # 特性持有集下传（begin_battle enc.feats 求值面）
@@ -1010,7 +1011,7 @@ func _snapshot_breakpoint() -> void:
 		"shop_shelf": _runner.shop_bp_shelf() if _runner != null else [],          # 货架入断点（离开店/非店停点 = 空架合法态）
 		"shop_visit_buys": _runner.shop_bp_visit_buys() if _runner != null else 0, # 本次进店已购次数（A 链定价输入）
 		"attunement_charges": run_ledger.attune_charges.duplicate(true),   # 同调主动件充能余量随断点（save v4 域）
-		"template_pick": _runner.active_template_index if _runner != null else -1,
+		"graph_gen_v2": 1,   # 生成图换代代差标记（缺键 = 换代前旧断点 → resume 显式拒绝）
 		"master_seed": master_seed,
 		"rng_counter": rng.counter(),
 		"keystone": keystone,

game/core/level_runner.gd

@@ -64,7 +64,7 @@ var _phase: int = Phase.IDLE
 var level_result := ""                    # "" / "victory" / "defeat"（外部契约面）
 var _candidates: Array[Dictionary] = []               # 当前选路候选（节点引用数组）
 var visited: Array[Dictionary] = []                   # 已兑付/到达节点序列（呈现层图条数据源；含当前节点）
-var _graph_mode := false                  # 图形态缓存（行集任一节点带 next；单链 = false）
+var _generator   # 参数化长图生成器（惰性建——NodeMapGenerator 持注入的 RngService）
 
 
 func _init(db_ref: ConfigDb, rng_ref: RngServiceCore) -> void:
@@ -127,7 +127,7 @@ func restore_hero_base() -> void:
 
 # ---- 关卡生命周期 ----
 
-func start_level(level_index: int, seed_val: int, base_override_in: Dictionary = {}, template_pick: int = -1) -> bool:
+func start_level(level_index: int, seed_val: int, base_override_in: Dictionary = {}) -> bool:
 	# 单关测试模式：私有账本、内置恢复数学、自调 new_adventure（漂移①
 	# 单关=冒险的历史简化在测试模式保留；正式种子域归 AdventureRunner.start_adventure）
 	# base_override_in = 永久强化 flat 注入尾参（缺省 {} 全零白板，
@@ -146,34 +146,31 @@ func start_level(level_index: int, seed_val: int, base_override_in: Dictionary =
 	_phase = Phase.IDLE
 	_candidates = []
 	visited = []
-	_graph_mode = false
 	gp = 0                                   # 冒险钱包清零开局（局内货币生命周期起点）
 	run_ledger.bonus = {"atk": 0, "max_hp": 0, "armor_class": 0}   # 加算区冒险开始全 0（单关入口零元进度——注入面见上）
 	base_override = {"atk": 0, "max_hp": 0, "armor_class": 0}   # 永久强化 flat：缺省全零白板（单关入口零元进度——注入面见上）
 	_shop_purchased = {}                     # 已购档数清零（跨冒险不延续——递增定价按冒险内累计）
 	for k in base_override.keys():
 		base_override[k] = maxi(0, int(base_override_in.get(k, 0)))   # 注入规范化（契约同冒险开始参数面）
-	for node in nodes():
-		if node.has("next"):
-			_graph_mode = true
-			break
 	hero_hp = effective_max_hp()
 	rng.new_adventure(seed_val)            # 关卡起点 = 冒险起点（切片口径；跨关接续归 冒险结构）
-	level_row.assign(_resolve_template_row(row, template_pick))   # 池解析在播种后（node_map 抽签须已播种——EC7）
-	_phase = Phase.RUNNING
-	var entry := _entry_node()
-	if entry.is_empty():
-		push_error("[关卡节点地图] 入口节点缺失（无入边唯一节点——图合法性校验应已拦截）")
+	if not _assign_generated_graph(row, seed_val):
 		_phase = Phase.ENDED
 		return false
-	return _enter_node(entry)
+	_phase = Phase.RUNNING
+	var entries := _entry_nodes()
+	if entries.is_empty():
+		push_error("[关卡节点地图] 入口节点缺失（无入边节点集为空——validate_graph 应已拦）")
+		_phase = Phase.ENDED
+		return false
+	return _enter_node(entries[0])
 
 
 # 冒险结构接口①：开始关卡（载荷 = 关卡序号 + 当前生命 + 生效上限——生命经共享账本交接；
 # 种子域归冒险结构：本路径不重播种；账本归冒险结构：本路径不重置 gp/bonus/_shop_purchased，
 # 也不重置 hero_hp——账本当前值即开局生命，AdventureRunner 已在 ledger 写好）。
 # base_override = 永久强化 flat 共享引用（缺省 {} 全零白板，与 B1 空参数路径同值）。
-# 流程与 start_level 同款（_find_level_row → 状态初始化 → _graph_mode 探测 → _enter_node(entry)），
+# 流程与 start_level 同款（_find_level_row → 生成图装配 → 状态初始化 → _enter_node(入口)），
 # 差异仅在账本/加算区/已购档/恢复执行体的注入与零重置。
 # defer_entry 尾参（缺省 false = 直接进节点）——true 时不自动
 # _enter_node(entry)，改置选路态（awaiting_choice + 单候选 = 入口节点），由 AdventureRunner 在
@@ -183,7 +180,7 @@ func start_level(level_index: int, seed_val: int, base_override_in: Dictionary =
 # _enter_node(entry)——测量面零漂移红线。
 func start_level_external(level_index: int, ledger: Dictionary,
 		purchased_ref: Dictionary, rest_handler: Callable, base_override_ref: Dictionary = {},
-		defer_entry: bool = false, template_pick: int = -1, resume_state: Dictionary = {}) -> bool:
+		defer_entry: bool = false, resume_state: Dictionary = {}) -> bool:
 	var row := _find_level_row(level_index)
 	if row.is_empty():
 		push_error("[关卡节点地图] level_index %d 在 LevelTable 无行" % level_index)
@@ -193,34 +190,30 @@ func start_level_external(level_index: int, ledger: Dictionary,
 	base_override = base_override_ref
 	_shop_purchased = purchased_ref
 	_rest_handler = rest_handler
-	level_row.assign(_resolve_template_row(row, template_pick))
+	if not _assign_generated_graph(row, rng.master_seed):
+		return false
 	node_index = -1
 	level_result = ""
 	_phase = Phase.IDLE
 	_candidates = []
 	visited = []
-	_graph_mode = false
-	for node in nodes():
-		if node.has("next"):
-			_graph_mode = true
-			break
 	_phase = Phase.RUNNING
 	# 断点续玩路径（defer_entry 之外的第三种停点入口）：直接重建到停点所在节点，
-	# 零 RNG 消耗（模板已随 template_pick 强制、节点状态纯重建不 _enter_node——当场战斗从头打）。
+	# 零 RNG 消耗（图由主种子＋参数档重生成同图、节点状态纯重建不 _enter_node——当场战斗从头打）。
 	# resume_state = {"node_id": int（-1 = 入口停点）, "visited_ids": Array[int]}；空字典 = 既有路径逐位不变。
 	if not resume_state.is_empty():
 		return _restore_to_stop(int(resume_state.get("node_id", -1)),
 			resume_state.get("visited_ids", []) as Array)
-	var entry := _entry_node()
-	if entry.is_empty():
-		push_error("[关卡节点地图] 入口节点缺失（无入边唯一节点——图合法性校验应已拦截）")
+	var entries := _entry_nodes()
+	if entries.is_empty():
+		push_error("[关卡节点地图] 入口节点缺失（无入边节点集为空——validate_graph 应已拦）")
 		_phase = Phase.ENDED
 		return false
 	if defer_entry:
-		_phase = Phase.AWAITING_CHOICE    # 入口停点（node_index 保持 -1——进节点前无 current_node）
-		_candidates = [entry]
+		_phase = Phase.AWAITING_CHOICE    # 入口停点（node_index 保持 -1）——候选＝全部入口（多入口首跳即选路）
+		_candidates = entries
 		return true
-	return _enter_node(entry)
+	return _enter_node(entries[0])
 
 
 # 入口停点呈现（defer_entry=true 的第二步）：发出入口候选供呈现层弹
@@ -240,14 +233,14 @@ func present_entry_choice() -> bool:
 # 候选 = 停点节点出边（与 choices_presented 停点语义逐位一致）。
 func _restore_to_stop(node_id: int, visited_ids: Array) -> bool:
 	if node_id < 0:
-		# 入口停点：与 defer_entry 同款形态（node_index 保持 -1，单候选 = 入口节点）
-		var entry := _entry_node()
-		if entry.is_empty():
+		# 入口停点：与 defer_entry 同款形态（node_index 保持 -1，候选 = 全部入口）
+		var entries := _entry_nodes()
+		if entries.is_empty():
 			push_error("[关卡节点地图] 断点恢复失败——入口节点缺失")
 			_phase = Phase.ENDED
 			return false
 		_phase = Phase.AWAITING_CHOICE
-		_candidates = [entry]
+		_candidates = entries
 		return true
 	var stop: Dictionary[Variant, Variant] = {}
 	for node in nodes():
@@ -296,32 +289,31 @@ func _find_level_row(level_index: int) -> Dictionary:
 	return db.level_row(level_index)   # 表访问收口（行集直扫归 LevelTable/ConfigDB 访问器）
 
 
-# ---- 模板池解析（关卡节点图生成 v0.4——M-3）----
-# row.templates 非空 = 池形态：template_pick >= 0 = 强制取该模板（首次脚本模式/冒烟固定图，零 RNG 消费）；
-# -1 = 抽签（node_map 用途标签恰一 scope，均匀取模）。空池 = 旧单图形态原样返回（向后兼容零迁移）。
-# 解析产物 = row 副本换 nodes（下游 nodes()/校验/呈现全透明）；active_template_name 供 MC 分层出数；
-# active_template_index 供断点快照备案（已抽模板续玩零重抽零 RNG 消耗）。
-var active_template_name := ""
-var active_template_index := -1   # -1 = 非池形态（旧单图）/未解析
-
-func _resolve_template_row(row: Dictionary, template_pick: int) -> Dictionary:
-	var templates: Array[Variant] = row.get("templates", [])
-	active_template_name = ""
-	active_template_index = -1
-	if templates.is_empty():
-		return row
-	var idx := 0
-	if template_pick >= 0:
-		idx = clampi(template_pick, 0, templates.size() - 1)
-	else:
-		var stream: RandomNumberGenerator = rng.open_stream("node_map")
-		idx = stream.randi_range(0, templates.size() - 1)
-	var tpl: Dictionary[Variant, Variant] = templates[idx]
-	active_template_name = String(tpl.get("display_name", ""))
-	active_template_index = idx
-	var out := row.duplicate(true)
-	out["nodes"] = tpl.get("nodes", [])
-	return out
+# ---- 图源装配（关卡节点图生成 v1.1——图 = f(参数档, 种子) 纯函数；无模板池、无兜底图）----
+# 参数档按关卡序号解析（消费侧职责——生成器不认关卡号），种子取本局口径：单关模式用传入种子、
+# 冒险模式用主种子（产图与全局计数器号位无关，断点在停点重生成同图）。产图先过消费侧独立校验
+# LevelTable.validate_graph（与产出侧自证同源规格、分工不重叠）；违规＝起关拒绝，不降级不回退。
+func _assign_generated_graph(row: Dictionary, seed_val: int) -> bool:
+	var level_index: int = int(row.get("level_index", 0))
+	var params: Dictionary = db.level_gen_params_row(level_index)
+	if params.is_empty():
+		push_error("[关卡节点地图] level %d 无参数档行（level_gen_params 缺行——配置错误）" % level_index)
+		return false
+	if _generator == null:
+		_generator = NodeMapGenerator.new(rng)
+	var graph: Dictionary = _generator.generate(params, seed_val)
+	if graph.is_empty() or _generator.is_fatal():
+		push_error("[关卡节点地图] level %d 生成图失败（参数无解或产出不合格——无兜底图）" % level_index)
+		return false
+	var bad := LevelTable.validate_graph(graph["nodes"] as Array)
+	if not bad.is_empty():
+		for e in bad:
+			push_error("[关卡节点地图] level %d 生成图违规: %s" % [level_index, String(e["message"])])
+		return false
+	var merged := row.duplicate(true)
+	merged["nodes"] = graph["nodes"]
+	level_row.assign(merged)
+	return true
 
 
 func nodes() -> Array:
@@ -334,37 +326,30 @@ func current_node() -> Dictionary:
 	return nodes()[node_index]
 
 
-# ---- 图版行进面（v1.0：出边表选路 · 零自动推进 · 单链 = 隐式出边退化形态）----
-# 编号空间（与 LevelTable 校验器同一解析）：图形态 = node_depth（全节点编号化）；单链 = 数组下标。
-# 混用两空间会在单链上碰撞（如 reward 下标 2 vs 战斗 node_depth 2）——节点寻址一律经 _node_id。
+# ---- 图版行进面（生成图恒带显式出边；单链退化形态 = 出度 ≤1 的图，无数组序隐式边）----
+# 节点身份＝生成图句柄 id（图内唯一）。定位信息另算（enc 携带关卡序号 + 节点深度），
+# 禁再以深度当身份（句柄/位置两轴语义单一）。
 
 func _node_id(node: Dictionary) -> int:
-	if _graph_mode:
-		return int(node.get("node_depth", -1))
-	return nodes().find(node)
+	return int(node.get("id", -1))
 
 
-# 入口节点 = 无入边唯一节点（图合法性校验保证恰一）
-func _entry_node() -> Dictionary:
+# 入口节点集 = 全部无入边节点（个数＝参数档 entry_count；多入口时首跳即选路）
+func _entry_nodes() -> Array[Dictionary]:
 	var inbound := {}
 	for node in nodes():
 		for tid in _out_ids(node):
-			inbound[tid] = true
+			inbound[int(tid)] = true
+	var out: Array[Dictionary] = []
 	for node in nodes():
 		if not inbound.has(_node_id(node)):
-			return node
-	return {}
+			out.append(node)
+	return out
 
 
-# 出边编号表：显式 next 优先；单链（无 next 键）= 数组顺序下一项（退化形态）
+# 出边句柄表（生成图恒显式 next）
 func _out_ids(node: Dictionary) -> Array:
-	if node.has("next"):
-		return node.get("next", [])
-	var nodes: Array[Variant] = nodes()
-	var i := nodes.find(node)
-	if i >= 0 and i < nodes.size() - 1:
-		return [i + 1]
-	return []
+	return node.get("next", [])
 
 
 # 出边候选（节点引用数组——选路口/呈现层共用读面）
@@ -442,11 +427,13 @@ func type_visible_ids() -> Array[int]:
 # 不可达节点不落表（加载期孤儿校验应已拦截）。
 func _bfs_layers() -> Dictionary:
 	var layers := {}
-	var entry := _entry_node()
-	if entry.is_empty():
+	var entries := _entry_nodes()
+	if entries.is_empty():
 		return layers
-	var queue: Array[Dictionary] = [entry]
-	layers[_node_id(entry)] = 0
+	var queue: Array[Dictionary] = []
+	for entry in entries:
+		layers[_node_id(entry)] = 0
+		queue.append(entry)
 	var i := 0
 	while i < queue.size():
 		var cur: Dictionary[Variant, Variant] = queue[i]
@@ -510,7 +497,7 @@ func _start_battle(node: Dictionary) -> bool:
 	# node_entered 先于 begin_battle：呈现层须先拿到 settlement 引用，才能响应 begin 期间发出的
 	# board_changed（首板安装）并重建棋盘——后发会导致首战棋盘不渲染
 	node_entered.emit(node, {})
-	if not _settlement.begin_battle({"level_index": int(level_row.level_index), "node_depth": int(node.get("node_depth", 0)),
+	if not _settlement.begin_battle({"level_index": int(level_row.level_index), "node_depth": int(node.get("depth", 0)),
 			"hero_hp": hero_hp, "hero_atk": effective_atk(), "hero_max_hp": effective_max_hp(),
 			"hero_armor_class": effective_ac(), "hero_ap_bonus": effective_ap_bonus(),
 			"attack_type": _hero_attack_type, "armor_type": _hero_armor_type,   # 两根类型轴（spawn 英雄快照；空串=锻造配置默认值回退）
@@ -523,7 +510,7 @@ func _start_battle(node: Dictionary) -> bool:
 			"voucher_rap": _voucher_rap,
 			"voucher_time_sand": _voucher_time_sand,
 			"node_type": String(node.get("type", ""))}):
-		push_error("[关卡节点地图] 战斗启动失败（depth %s）" % str(node.get("node_depth", -1)))
+		push_error("[关卡节点地图] 战斗启动失败（depth %s）" % str(node.get("depth", -1)))
 		return false
 	_voucher_rap = 0   # 节点级一次性：注入即消费（战斗未启动则保留至下次注入前不清）
 	_voucher_time_sand = 0
@@ -535,7 +522,7 @@ func _forward_step_row(row: Dictionary) -> void:
 
 
 # battle_index=第几场战斗（关卡域 1 基序——visited 已含当前节点〔_enter_node :437 先追加后启动〕；
-# 按已到节点 type=battle 计数，与图形态 node_depth/单链数组下标两编号空间解耦〔混编碰撞免疫〕；
+# 按已到节点 type=battle 计数，与句柄 id / 节点深度两轴解耦〔身份与位置互不兼任〕；
 # 开局姿态组「每关首轮窗」条件面）
 func _battle_index() -> int:
 	var n := 0

game/data/tables/level.tres

@@ -6,20 +6,11 @@
 script = ExtResource("1")
 info_visible_layers = 2
 rows = [
-{"level_index": 1, "display_name": "第一层 · 地精洞窟", "rest_heal_pct": 30, "templates": [{"display_name": "地精洞窟·主线洞道（现行）", "nodes": [{"node_depth": 0, "type": "battle"}, {"node_depth": 1, "type": "battle"}, {"node_depth": 2, "type": "battle"}, {"node_depth": 3, "type": "battle"}, {"type": "reward"}, {"type": "rest"}, {"node_depth": 4, "type": "boss"}]}, {"display_name": "地精洞窟·先赏后整", "nodes": [{"node_depth": 0, "type": "battle"}, {"node_depth": 1, "type": "battle"}, {"node_depth": 2, "type": "battle"}, {"type": "reward"}, {"type": "rest"}, {"node_depth": 3, "type": "battle"}, {"node_depth": 4, "type": "boss"}]}, {"display_name": "地精洞窟·先整后赏", "nodes": [{"node_depth": 0, "type": "battle"}, {"node_depth": 1, "type": "battle"}, {"node_depth": 2, "type": "battle"}, {"type": "rest"}, {"type": "reward"}, {"node_depth": 3, "type": "battle"}, {"node_depth": 4, "type": "boss"}]}, {"display_name": "地精洞窟·赏战整", "nodes": [{"node_depth": 0, "type": "battle"}, {"node_depth": 1, "type": "battle"}, {"node_depth": 2, "type": "battle"}, {"type": "reward"}, {"node_depth": 3, "type": "battle"}, {"type": "rest"}, {"node_depth": 4, "type": "boss"}]}, {"display_name": "地精洞窟·整战赏", "nodes": [{"node_depth": 0, "type": "battle"}, {"node_depth": 1, "type": "battle"}, {"node_depth": 2, "type": "battle"}, {"type": "rest"}, {"node_depth": 3, "type": "battle"}, {"type": "reward"}, {"node_depth": 4, "type": "boss"}]}]},
-{"level_index": 2, "display_name": "第二层 · 幽暗地域", "rest_heal_pct": 30, "templates": [{"display_name": "宽廊双干（现行）", "nodes": [{"node_depth": 0, "type": "battle", "next": [1, 2]}, {"node_depth": 1, "type": "battle", "next": [3, 4]}, {"node_depth": 2, "type": "reward", "next": [5, 6]}, {"node_depth": 3, "type": "rest", "next": [7]}, {"node_depth": 4, "type": "battle", "next": [7]}, {"node_depth": 5, "type": "battle", "next": [7]}, {"node_depth": 6, "type": "battle", "next": [7]}, {"node_depth": 7, "type": "battle", "next": [8]}, {"node_depth": 8, "type": "shop", "next": [9]}, {"node_depth": 9, "type": "boss", "next": []}]}, {"display_name": "三干中廊", "nodes": [{"node_depth": 0, "type": "battle", "next": [1, 2]}, {"node_depth": 1, "type": "battle", "next": [3, 5]}, {"node_depth": 2, "type": "reward", "next": [4, 5]}, {"node_depth": 3, "type": "rest", "next": [6]}, {"node_depth": 4, "type": "battle", "next": [6, 7]}, {"node_depth": 5, "type": "battle", "next": [7]}, {"node_depth": 6, "type": "battle", "next": [8]}, {"node_depth": 7, "type": "battle", "next": [8]}, {"node_depth": 8, "type": "shop", "next": [9]}, {"node_depth": 9, "type": "boss", "next": []}]}, {"display_name": "宽廊斜岔", "nodes": [{"node_depth": 0, "type": "battle", "next": [1, 2]}, {"node_depth": 1, "type": "battle", "next": [3, 5]}, {"node_depth": 2, "type": "reward", "next": [4, 6]}, {"node_depth": 3, "type": "rest", "next": [7]}, {"node_depth": 4, "type": "battle", "next": [7]}, {"node_depth": 5, "type": "battle", "next": [7]}, {"node_depth": 6, "type": "battle", "next": [7]}, {"node_depth": 7, "type": "battle", "next": [8]}, {"node_depth": 8, "type": "shop", "next": [9]}, {"node_depth": 9, "type": "boss", "next": []}]}, {"display_name": "三干宽门", "nodes": [{"node_depth": 0, "type": "battle", "next": [1, 2]}, {"node_depth": 1, "type": "battle", "next": [3, 4]}, {"node_depth": 2, "type": "reward", "next": [4, 5]}, {"node_depth": 3, "type": "rest", "next": [6, 7]}, {"node_depth": 4, "type": "battle", "next": [7]}, {"node_depth": 5, "type": "battle", "next": [7]}, {"node_depth": 6, "type": "battle", "next": [8]}, {"node_depth": 7, "type": "battle", "next": [8]}, {"node_depth": 8, "type": "shop", "next": [9]}, {"node_depth": 9, "type": "boss", "next": []}]}, {"display_name": "窄廊短支", "nodes": [{"node_depth": 0, "type": "battle", "next": [1, 2]}, {"node_depth": 1, "type": "battle", "next": [3, 4]}, {"node_depth": 2, "type": "reward", "next": [5]}, {"node_depth": 3, "type": "rest", "next": [5, 6]}, {"node_depth": 4, "type": "battle", "next": [6]}, {"node_depth": 5, "type": "battle", "next": [7]}, {"node_depth": 6, "type": "battle", "next": [7]}, {"node_depth": 7, "type": "battle", "next": [8]}, {"node_depth": 8, "type": "shop", "next": [9]}, {"node_depth": 9, "type": "boss", "next": []}]}]},
-{"level_index": 3, "display_name": "第三层 · 灰矮人矿城", "rest_heal_pct": 30, "templates": [{"display_name": "宽廊双干（现行）", "nodes": [{"node_depth": 0, "type": "battle", "next": [1, 2]}, {"node_depth": 1, "type": "battle", "next": [3, 4]}, {"node_depth": 2, "type": "reward", "next": [5, 6]}, {"node_depth": 3, "type": "rest", "next": [7]}, {"node_depth": 4, "type": "battle", "next": [7]}, {"node_depth": 5, "type": "battle", "next": [7]}, {"node_depth": 6, "type": "battle", "next": [7]}, {"node_depth": 7, "type": "battle", "next": [8]}, {"node_depth": 8, "type": "shop", "next": [9]}, {"node_depth": 9, "type": "boss", "next": []}]}, {"display_name": "三干中廊", "nodes": [{"node_depth": 0, "type": "battle", "next": [1, 2]}, {"node_depth": 1, "type": "battle", "next": [3, 5]}, {"node_depth": 2, "type": "reward", "next": [4, 5]}, {"node_depth": 3, "type": "rest", "next": [6]}, {"node_depth": 4, "type": "battle", "next": [6, 7]}, {"node_depth": 5, "type": "battle", "next": [7]}, {"node_depth": 6, "type": "battle", "next": [8]}, {"node_depth": 7, "type": "battle", "next": [8]}, {"node_depth": 8, "type": "shop", "next": [9]}, {"node_depth": 9, "type": "boss", "next": []}]}, {"display_name": "宽廊斜岔", "nodes": [{"node_depth": 0, "type": "battle", "next": [1, 2]}, {"node_depth": 1, "type": "battle", "next": [3, 5]}, {"node_depth": 2, "type": "reward", "next": [4, 6]}, {"node_depth": 3, "type": "rest", "next": [7]}, {"node_depth": 4, "type": "battle", "next": [7]}, {"node_depth": 5, "type": "battle", "next": [7]}, {"node_depth": 6, "type": "battle", "next": [7]}, {"node_depth": 7, "type": "battle", "next": [8]}, {"node_depth": 8, "type": "shop", "next": [9]}, {"node_depth": 9, "type": "boss", "next": []}]}, {"display_name": "三干宽门", "nodes": [{"node_depth": 0, "type": "battle", "next": [1, 2]}, {"node_depth": 1, "type": "battle", "next": [3, 4]}, {"node_depth": 2, "type": "reward", "next": [4, 5]}, {"node_depth": 3, "type": "rest", "next": [6, 7]}, {"node_depth": 4, "type": "battle", "next": [7]}, {"node_depth": 5, "type": "battle", "next": [7]}, {"node_depth": 6, "type": "battle", "next": [8]}, {"node_depth": 7, "type": "battle", "next": [8]}, {"node_depth": 8, "type": "shop", "next": [9]}, {"node_depth": 9, "type": "boss", "next": []}]}, {"display_name": "窄廊短支", "nodes": [{"node_depth": 0, "type": "battle", "next": [1, 2]}, {"node_depth": 1, "type": "battle", "next": [3, 4]}, {"node_depth": 2, "type": "reward", "next": [5]}, {"node_depth": 3, "type": "rest", "next": [5, 6]}, {"node_depth": 4, "type": "battle", "next": [6]}, {"node_depth": 5, "type": "battle", "next": [7]}, {"node_depth": 6, "type": "battle", "next": [7]}, {"node_depth": 7, "type": "battle", "next": [8]}, {"node_depth": 8, "type": "shop", "next": [9]}, {"node_depth": 9, "type": "boss", "next": []}]}]}
+{"level_index": 1, "display_name": "第一层 · 地精洞窟", "rest_heal_pct": 30},
+{"level_index": 2, "display_name": "第二层 · 幽暗地域", "rest_heal_pct": 30},
+{"level_index": 3, "display_name": "第三层 · 灰矮人矿城", "rest_heal_pct": 30}
 ]
 
-; 关卡节点图生成 v0.4 台阶一内容批（M-3 迭代 5 T5，2026-09-28——15 张骨架 = 3 关 × 5，拍板点④）：
-; L2/L3 网状图约束（承袭）：战斗节点编号恒 ∈ 遭遇表行集 {0,1,4,5,6,7}、Boss 9 最大编号、
-; 商店房 8→Boss 必经位承袭；遭遇表按编号共用——零新增敌人数值。L1 五模板 = 单链排列变体
-; （战斗深度序单调保难度坡，变化面 = 奖励/恢复位次）。
-; 池内全模板加载期校验（level_table.gd validate + config_db 跨表校验模板感知）；
-; 行为读 LevelRunner._resolve_template_row（node_map 标签恰一 scope 抽签 / template_pick 强制）。
-; 生成器 = tools/t5_build_templates.py（生成前自校验，一次性内容批工具随批入库留档）。
-; U2 目检返工（M-3 迭代 5 返工批，2026-09-29——U2 目检 15/15 不过两规则缺口，全池重生成）：
-; ① L1 奖励/休整禁入前三位（用户目检裁决）——五链全部前三位纯战斗，位 4-6 = {战斗3,奖励,休整} 排列；
-; ② L2/L3 BFS 同深度层上限 5 且应用足（每张最大层宽 4-5，旧池层宽最大 3 被否）；模板 0 一并重排
-; （待批点甲按推荐=随新规则重生成——首次冒险/钉固断言期望随新图更新；模板 0 名保持「（现行）」后缀=新现行图锚）。
-; 加载校验两规则同落 level_table.gd validate（单链前三纯战斗/图形态层宽 ≤5）。
+; 节点图源已换代为参数化生成器（关卡节点图生成 v1.1）——本表逐关行只承载关卡序号/显示名/恢复比例，
+; 不再携带节点数据；图 = f(参数档, 种子)，参数档见 level_gen_params.tres 三行（消费侧按 level_index 解析后交 generate）。
+; 旧 15 张模板池（3 关 × 5）随迭代 35 卡② 清出，历史查 git 提交史与 tools/t5_build_templates.py、t17_fanout2_rebuild.py 留档。

game/presentation/main.gd

@@ -589,11 +589,9 @@ func _start_adventure() -> void:
 	logger.start_session(seed_val)
 	run_scope.adventure.set_hero_override(debug_overlay.atk_pct(), debug_overlay.hp_pct())
 	# 永久强化注入：冒险开始参数面——meta 现算 override 显式传参（全零 = 白板）
-	# 首次冒险脚本（关卡节点图生成 v0.4）：存档布尔位 false = 全关固定模板 0（教学重放）；置位后逐关抽签
-	# 同调三键随开局下传（build_adventure_params 统一构造，与营地投影同源）
-	var first_script: bool = not save_manager.is_first_adventure_done()
+	# 开局参数面（同调三键同源构造——确定性承载＝固定种子＋参数档，首局教学图由种子域三分判定给 42）
 	if not run_scope.adventure.start_adventure(seed_val, build_adventure_params(save_manager, meta,
-		{"first_script": first_script, "treasure_unlocked": _treasure_ui.unlocked_set(), "shop_mode": "pool"})):
+		{"treasure_unlocked": _treasure_ui.unlocked_set(), "shop_mode": "pool"})):
 		_fatal_screen("冒险启动失败——见输出日志")
 		return
 

game/probe/shot_probe.gd

@@ -10,7 +10,7 @@
 # 每屏双帧 + frame_post_draw 同步后抓 get_viewport().get_texture()，PNG 落输出目录；
 # 最小自检 = 七件存在且非零字节（像素方差断言归 tools/shot_checker.py——B 档骨架分工）。
 # 商店房不纳屏（真实路径口径）：真实路径必经 L1 打穿→L2 商店节点
-# 选路（商店层在 L2 Boss 前必经位）——探针现行驱动只进首战节点，低代价确定性
+# 选路（商店按摆放约束恒在终点前一位，每局必经恰一店）——探针现行驱动只进首战节点，低代价确定性
 # 到达不成立；合成投喂（ui_struct_probe 同款）破坏本探针真实路径口径 → 不纳屏。
 extends Node
 

game/probe/ui_click_probe.gd

@@ -370,7 +370,7 @@ func _ready() -> void:
 			_seals_placed.clear()
 			continue
 		if main.shop_overlay.visible:
-			# 商店房覆盖层（L2 商店为 Boss 前必经位）：零购离开（真实 leave 信号路径）放行选路。
+			# 商店房覆盖层（摆放约束：每终点前一位恰一店，真实路径恒必经一店）：零购离开（真实 leave 信号路径）放行选路。
 			# 分派链序：商店层=选路页上的模态覆盖（停点呈现为
 			# level_screen+shop 双 visible）——必须先于 level_screen 分派，否则下层候选点击
 			# 空转烧尽预算（实证：lv2 商店停点双 visible 循环 12000 帧 done=false）。

game/sim/adventure_monte_carlo.gd

@@ -136,7 +136,7 @@ func _initialize() -> void:
 				"encounter_max_hp_seq": st["encounter_max_hp_seq"],
 				"reward_events": st["reward_events"],
 				"shop_gp_seq": st["shop_gp_seq"],
-				"level_templates": st.get("level_templates", []),
+				"level_maps": st.get("level_maps", []),
 				"wallet_count": (st["wallet_events"] as Array).size(),
 			}
 			if shop_mode == "on":

game/sim/level_autoplay.gd

@@ -9,7 +9,7 @@
 # 策略档 policy："normal"（默认）/ "perfect"（零盲挖/全封印/卡死刷新——上界测量仪，求解器与
 # 动作语义见 auto_player.gd 完美策略档节）。
 # 选路驱动（零自动推进）：兑付确认/战斗胜利后 runner 进选路态，驱动循环按 route 策略显式
-# pick_next_node；route = "min"/"max"（候选节点编号最小/最大——确定性路径轴，零随机流自开；默认 "min"）。
+# pick_next_node；route = "min"/"max"（候选节点句柄最小/最大——确定性路径轴，零随机流自开；默认 "min"）。
 # run_adventure 三关连探驱动（AdventureRunner——主种子恰一次、通关兑付停点确认、adventure_finished
 # 置 result/summary；外层每关重取 runner 实例经 _drive_level 复用单关驱动）。
 # 大奖励停点 = 三选一驱动（候选取首件/替换放弃新件）。
@@ -34,7 +34,7 @@ const NORMAL_SKIP_DIG_P := 0.05
 const NORMAL_IDLE_GAMBLE_P := 0.10
 
 
-static func run_level(db, seed_val: int, level_index: int, atk_pct: int, hp_pct: int, collect_rows: bool = false, logger = null, policy: String = "normal", route: String = "min", template_pick: int = -1) -> Dictionary:
+static func run_level(db, seed_val: int, level_index: int, atk_pct: int, hp_pct: int, collect_rows: bool = false, logger = null, policy: String = "normal", route: String = "min") -> Dictionary:
 	var own_session := logger == null
 	if own_session:
 		logger = load("res://presentation/playtest_logger.gd").new()
@@ -60,7 +60,7 @@ static func run_level(db, seed_val: int, level_index: int, atk_pct: int, hp_pct:
 	runner.node_entered.connect(_on_node_entered.bind(runner, st, logger))
 	runner.level_finished.connect(_on_level_finished.bind(st, logger))
 	runner.set_hero_override(atk_pct, hp_pct)
-	if not runner.start_level(level_index, seed_val, {}, template_pick):
+	if not runner.start_level(level_index, seed_val, {}):
 		st.result = "start_failed"
 		runner.restore_hero_base()
 		if own_session:
@@ -138,7 +138,7 @@ static func run_adventure(db, seed_val: int, atk_pct: int, hp_pct: int, collect_
 		"prng": _policy_rng(seed_val), "mine_slips": 0, "skip_digs": 0, "shop_buys": 0,
 		"adv": true,   # v3 档位行为开关（选路评分/失误注入/商店购买只挂冒险测量面——单关夹具语义不变）
 
-		"level_templates": [],   # 逐关图模板名（关卡节点图生成 v0.4 分层出数）
+		"level_maps": [],   # 逐关节点图标识（生成图 = 关卡序号＋本局主种子——MC 分层出数）
 	}
 	adr.step_row.connect(_on_step_row.bind(adr, st, collect_rows))
 	adr.node_entered.connect(_on_adventure_node_entered.bind(adr, st, logger))
@@ -150,7 +150,7 @@ static func run_adventure(db, seed_val: int, atk_pct: int, hp_pct: int, collect_
 	adr.adventure_finished.connect(_on_adventure_finished.bind(st, logger))
 	adr.set_hero_override(atk_pct, hp_pct)
 	# 同调分层注入（缺省 {} 与既有调用方逐位一致零行为变更）
-	var adv_params := {"hero_override": hero_override, "first_script": false}
+	var adv_params := {"hero_override": hero_override}
 	if not attune.is_empty():
 		adv_params["attunement"] = attune.get("equipped", [])
 		adv_params["attune_refresh_y"] = int(attune.get("refresh_y", 0))
@@ -197,9 +197,9 @@ static func _on_adventure_node_entered(node: Dictionary, info: Dictionary, adr,
 	var r = adr.runner()
 	var t := String(node.get("type", ""))
 	st.visited_ids.append(int(r.node_id_of(node)))
-	if not st.has("level_templates"):
-		st["level_templates"] = []
-	st["level_templates"].append(r.active_template_name)   # MC 分层出数（关卡×图模板——v0.4 测量对账条款）
+	if not st.has("level_maps"):
+		st["level_maps"] = []
+	st["level_maps"].append("%d#%d" % [int(r.level_row.get("level_index", 0)), int(adr.master_seed)])   # MC 分层出数（关卡×生成图标识）
 
 	if t == "battle" or t == "boss":
 		st.battles += 1
@@ -208,7 +208,7 @@ static func _on_adventure_node_entered(node: Dictionary, info: Dictionary, adr,
 		if logger != null and r.current_battle() != null:
 			logger.attach_battle(r.current_battle())
 		if t == "boss":
-			st.boss_depth = int(node.get("node_depth", -1))
+			st.boss_depth = int(node.get("depth", -1))
 			st.hp_at_boss = int(adr.ledger["hero_hp"])
 	elif t == "reward":
 		# 奖励节点三选一（共享池确定性策略；TP0 起 316-f 判读：1 级最稀有、
@@ -376,7 +376,7 @@ static func _policy_rng(seed_val: int) -> RandomNumberGenerator:
 
 
 # 路径轴选路（目标价值评分制）：候选按节点类型评分取最高，
-# 同分 tie-break 沿 route 方向（min=小编号/max=大编号——verifier 双窗轴保持）。
+# 同分 tie-break 沿 route 方向（min=小句柄/max=大句柄——verifier 双窗轴保持）。
 # 评分语义（确定性，零随机流）：rest=伤重高值（缺口比例×100）/shop=买得起高值（GP 局内死钱，
 # 真人实证两店全购）/reward=占位低值（MC 夹具解锁空集=零兑付直通）/boss=缓冲低值（有店有_rest
 # 先补给再打）/battle=基线。编号取 runner.next_candidate_ids()（编号空间解析单一出口）。
@@ -478,7 +478,7 @@ static func _on_node_entered(node: Dictionary, info: Dictionary, runner, st: Dic
 		if logger != null and runner.current_battle() != null:
 			logger.attach_battle(runner.current_battle())
 		if t == "boss":
-			st.boss_depth = int(node.get("node_depth", -1))
+			st.boss_depth = int(node.get("depth", -1))
 			st.hp_at_boss = runner.hero_hp
 	elif t == "reward":
 		runner.continue_after_node()   # 奖励点 = 内容未定直通节点

game/tests/integration/cross_system_flow_test.gd

@@ -76,7 +76,7 @@ func _feats_breakpoint_roundtrip() -> void:
 	var live_rows: FeatTable = _db.feats
 	_db.feats = rt
 	var a_r = load("res://core/adventure_runner.gd").new(_db, _fresh_rng(72))
-	a_r.start_adventure(72, {"first_script": true})   # 源 :723（受理断言留单元宿主）
+	a_r.start_adventure(72)   # 源 :723（受理断言留单元宿主）
 	a_r._curio_pending = {"candidates": [{"kind": "relic", "tier": "rare", "feat_id": "x3"}, {"kind": "gp", "tier": "common"}], "payload": {}}
 	a_r.pick_curio("relic", "rare", "x3")   # 源 :781（兑付断言留单元宿主）
 	# 断点往返（持有集+余库 feat_id 随行）

game/tests/integration/node_map_templates_test.gd

@@ -1,18 +1,21 @@
-# tests/integration/node_map_templates_test.gd — L2 集成用例：关卡节点图生成·模板池
-# 断言面 = 模板池套（批 B 断言迁移自 smoke_all.gd `_smoke_node_map_templates`，G12 施工组；
+# tests/integration/node_map_templates_test.gd — L2 集成用例：关卡节点图生成·确定性承载
+# 断言面 = 生成图确定性套（批 B 断言迁移自 smoke_all.gd，G12 施工组；
 # 主会话裁决六整套集成不拆——跨四系统且走落盘）。
-# 跨系统面 = RngService（node_map 用途标签/抽签确定性/零消耗计账）×
-#            LevelRunner（start_level_external 受理/模板 0 回滚档）×
-#            AdventureRunner（first_script 全关零抽签/逐关恰一抽签）×
+# 跨系统面 = RngService（纯派生流零计数器占用）×
+#            LevelRunner（start_level/start_level_external 受理·生成图装配·单一图源）×
+#            AdventureRunner（开局种子承载·断点写读后同图）×
 #            SaveManager＋MetaProgression（首次冒险布尔位收束置位落盘——真实档写盘）。
 # 与单元侧同入口同协议：extends SceneTree＋Kit.check 主通道；--script 模式无 autoload，
-# ConfigDB 显式实例化构造注入；表加载失败不中止（沿被迁断言面的源语义——诊断展开，红由断言落）。
+# ConfigDB 显式实例化构造注入；表加载失败不中止（沿被迁断言面的源语义——诊断展开，红由具体断言落）。
 # 运行：godot --headless --path game --script res://tests/integration/node_map_templates_test.gd
 extends SceneTree
 
 const Kit := preload("res://tests/unit/test_kit.gd")
+const SaveManagerScript := preload("res://core/save_manager.gd")
+const AdventureRunnerScript := preload("res://core/adventure_runner.gd")
 
 var _db
+var _bp_path := "user://smoke_node_map_save.json"
 
 
 func _init() -> void:
@@ -24,84 +27,115 @@ func _init() -> void:
 		for d in _db.diagnostics():
 			if d.severity == "error" or d.severity == "fatal":
 				push_error("  [%s] %s: %s" % [d.severity, d.category, d.message])
-	_smoke_node_map_templates()
+	_smoke_generated_map_determinism()
 	quit(Kit.finish("node_map_templates_test"))
 
 
-# ---- 关卡节点图生成·模板池冒烟（v0.4 §P0.6 断言面）----
-func _smoke_node_map_templates() -> void:
-	# ① 扩签：node_map 入用途标签封闭词表（派生零改动——标签只进事件日志）
-	var svc = load("res://core/rng_service.gd").new()
-	Kit.check("node_map 标签入 rng_service 封闭词表（扩签通道=改代码+冒烟守卫）",
-		(svc.PURPOSE_TAGS as Array).has("node_map"))
-	# ② 池参数：三关各 5 模板、模板 0 存在（回滚档成员）
-	for li in range(1, 4):
-		var row := {}
-		for r in _db.level.rows:
-			if int(r.level_index) == li:
-				row = r
-		var tpls: Array = row.get("templates", [])
-		Kit.check("L%d 模板池 = 5 张（拍板点④——首版池规模）" % li, tpls.size() == 5)
-		Kit.check("L%d 模板 0 = 现行固定图（回滚档成员）" % li,
-			not tpls.is_empty() and String(tpls[0].get("display_name", "")).ends_with("（现行）"))
-	# ③ 强制取 0 = 模板 0 节点表逐位相等 + 零 scope 消费
-	var rng0 = load("res://core/rng_service.gd").new()
-	rng0.new_adventure(910001)
-	var runner0 = load("res://core/level_runner.gd").new(_db, rng0)
-	var c_before: int = rng0.counter()
-	Kit.check("强制 template_pick=0 起关受理", runner0.start_level_external(2, {"hero_hp": 20, "gp": 0}, {},   # start_level_external 签名收口（bonus 参数由 RunLedger 单类下传）
-		Callable(self, "_smoke_rest_stub"), {}, true, 0))
-	Kit.check("强制取模板零 RNG 消耗（零抽签——首次脚本语义）", rng0.counter() == c_before)
-	var tpl0: Dictionary = {}
-	for r in _db.level.rows:
-		if int(r.level_index) == 2:
-			tpl0 = r.get("templates", [])[0]
-	Kit.check("强制 0 的生效节点表 = 模板 0 逐位相等（回滚档成立）",
-		runner0.level_row.get("nodes", []) == tpl0.get("nodes", []))
-	# ④ 抽签确定性：同种子两实例同模板（同种子同操作序列 → 逐位同图）
-	var names := []
-	for i in range(2):
-		var rg = load("res://core/rng_service.gd").new()
-		rg.new_adventure(910002)
-		var rn = load("res://core/level_runner.gd").new(_db, rg)
-		rn.start_level_external(2, {"hero_hp": 20, "gp": 0}, {},
-			Callable(self, "_smoke_rest_stub"), {}, true, -1)
-		names.append(rn.active_template_name)
-	Kit.check("抽签确定性：同种子逐位同图（实测 %s）" % String(names[0]),
-		names[0] == names[1] and String(names[0]) != "")
-	# ⑤ N=1 池与现行固定图等价：单模板行过图校验（抽签取模 1 恒 0 = 回滚档）
-	var lt = load("res://data/schemas/level_table.gd").new()
-	lt.rows.assign([{"level_index": 9, "display_name": "t", "rest_heal_pct": 30,
-		"templates": [tpl0]}])
-	Kit.check("N=1 池表通过图校验（回滚档形态合法）", lt.validate().is_empty())
-	# ⑥ 首次脚本分支：first_script=true 全关模板 0；false = 抽签（scope 恰一差异）
-	var rngF = load("res://core/rng_service.gd").new()
-	rngF.new_adventure(910003)
-	var adrF = load("res://core/adventure_runner.gd").new(_db, rngF)
-	adrF.start_adventure(910003, {"first_script": true})
-	Kit.check("首次脚本模式：L1 取模板 0（全关零抽签——存档布尔位 false 语义）",
-		String(adrF.runner().active_template_name).ends_with("（现行）"))
-	var cF: int = rngF.counter()
-	var rngT = load("res://core/rng_service.gd").new()
-	rngT.new_adventure(910003)
-	var adrT = load("res://core/adventure_runner.gd").new(_db, rngT)
-	adrT.start_adventure(910003, {"first_script": false})
-	Kit.check("抽签模式恰多消费 1 scope（node_map 逐关恰一——L1 起关抽签）", rngT.counter() == cF + 1)
-	Kit.check("抽签模式 active_template_name 有值（MC 分层出数取数面在位）",
-		String(adrT.runner().active_template_name) != "")
+# ---- 关卡节点图生成·确定性承载断言面 ----
+func _smoke_generated_map_determinism() -> void:
+	# ① 纯函数复现：图 = f(参数档, 种子)——同档同种子两次产图逐位同图，换种子必变图
+	var gen = NodeMapGenerator.new(_fresh_rng(910001))
+	var params2: Dictionary = _db.level_gen_params_row(2)
+	var g_a: Dictionary = gen.generate(params2, 910002)
+	var g_b: Dictionary = gen.generate(params2, 910002)
+	var g_c: Dictionary = gen.generate(params2, 910003)
+	var nodes_a: Array = g_a.get("nodes", [])
+	Kit.check("同参数档同种子两次产图逐位同图（D2 执行边界）",
+		nodes_a == (g_b.get("nodes", []) as Array))
+	Kit.check("同参数档换种子即变图（图确为种子函数，非恒定输出）",
+		nodes_a != (g_c.get("nodes", []) as Array))
+	Kit.check("产图节点携图内唯一句柄 id 与自入口 depth（消费侧寻址面）",
+		_not_empty_graph(nodes_a) and _handles_unique(nodes_a))
+	# ② 消费侧单一图源：起关装配的图与生成器直取逐位一致（runner 内不存第二份图数据）
+	var runner1 = load("res://core/level_runner.gd").new(_db, _fresh_rng(910004))
+	Kit.check("单关起关受理（种子 910004——生成图直供，无兜底图）",
+		runner1.start_level(2, 910004))
+	Kit.check("起关生效图 = 生成器同档同种子直取逐位一致（消费侧无第二图源）",
+		runner1.level_row.get("nodes", []) == (gen.generate(params2, 910004) as Dictionary).get("nodes", []))
+	# ③ 产图零统一流消费（纯派生流不占计数器号位——断点在任意号位重生成同图的机制承载）
+	var rng_c = _fresh_rng(910005)
+	var counter_before: int = rng_c.counter()
+	var runner2 = load("res://core/level_runner.gd").new(_db, rng_c)
+	Kit.check("冒险模式起关受理（入口停点）", runner2.start_level_external(3,
+		{"hero_hp": 20, "gp": 0}, {}, Callable(self, "_smoke_rest_stub"), {}, true))
+	Kit.check("起关产图零计数器消费（同图不依赖取数号位）", rng_c.counter() == counter_before)
+	Kit.check("入口停点候选 = 生成图全部无入边节点（单入口时恰 1）",
+		(runner2.next_candidates() as Array).size() >= 1)
+	# ④ 开局种子承载：新档（首局）种子 42 两次开局逐位同图，且与生成器直取一致
+	DirAccess.remove_absolute(_bp_path)   # 测试隔离——上轮落盘残留先删，断点面从零档起
+	var sv_w = SaveManagerScript.new(_bp_path)
+	var adr_x = AdventureRunnerScript.new(_db, _fresh_rng(42))
+	adr_x.set_save_manager(sv_w)   # 先挂档再开局——停点快照由真实写手落盘
+	Kit.check("首局口径种子 42 开局受理（defer_entry 路径）", adr_x.start_adventure(42,
+		{"hero_override": {}, "treasure_unlocked": {}}))
+	var adr_y = AdventureRunnerScript.new(_db, _fresh_rng(42))
+	Kit.check("同种子第二次开局受理", adr_y.start_adventure(42,
+		{"hero_override": {}, "treasure_unlocked": {}}))
+	Kit.check("种子 42 两次开局图逐位同图（教学局恒同图——首局固定种子的确定性承载）",
+		adr_x.runner().nodes() == adr_y.runner().nodes())
+	Kit.check("开局图 = L1 参数档在种子 42 下的生成图（开局无隐式取数分叉）",
+		adr_x.runner().nodes() == (gen.generate(_db.level_gen_params_row(1), 42) as Dictionary).get("nodes", []))
+	# ⑤ 断点写→恢复→再产图同图（续玩按主种子+参数档重生成，断点不存图快照）
+	Kit.check("停点断点落盘在档", sv_w.has_breakpoint())
+	var bp: Dictionary = sv_w.breakpoint_snapshot()
+	var adr_z = AdventureRunnerScript.new(_db, load("res://core/rng_service.gd").new())
+	Kit.check("断点续玩受理（代差标记键在档）", adr_z.resume_adventure(bp,
+		{"hero_override": {}, "treasure_unlocked": {}}))
+	Kit.check("续玩重生成图与中断前逐位同图", adr_z.runner().nodes() == adr_x.runner().nodes())
+	var adr_old = AdventureRunnerScript.new(_db, load("res://core/rng_service.gd").new())
+	var bp_old: Dictionary = bp.duplicate(true)
+	bp_old.erase("graph_gen_v2")   # 换代前旧断点形态（模板池时代无代差标记键）
+	Kit.check("缺生成图代差标记键的旧断点被显式拒绝（禁按新语义静默回放）",
+		adr_old.resume_adventure(bp_old, {}) == false)
+	# ⑥ 关卡表不再携带图数据（图源换代后 level 行只剩行级字段）
+	var tpl_free := true
+	for li in range(1, _db.level_count() + 1):
+		if (_db.level_row(li) as Dictionary).has("templates"):
+			tpl_free = false
+	Kit.check("level 表三行均无 templates 键（模板数据已清出）",
+		tpl_free and _db.level_count() == 3)
 	# ⑦ 收束置位：新档 false → settle 置 true 恰一次（幂等）
-	DirAccess.remove_absolute("user://smoke_node_map_save.json")   # 测试隔离——上轮 settle 写盘的残留档先删
-	var sv = load("res://core/save_manager.gd").new("user://smoke_node_map_save.json")
+	var sv = SaveManagerScript.new(_bp_path + ".flag.json")
 	sv.load_from_disk()
-	Kit.check("新档首次冒险布尔位 = false（默认域）", sv.is_first_adventure_done() == false)
+	Kit.check("新档首次冒险布尔位 = false（默认域——首局恒走固定种子 42）",
+		sv.is_first_adventure_done() == false)
 	var mp = load("res://core/meta_progression.gd").new(_db, sv)
 	mp.settle_adventure({"levels_cleared": 1, "keystone_total": 10, "cleared": false, "result": "failed"})
 	Kit.check("冒险收束点置位（三结局同写——写入只在收束挂点）", sv.is_first_adventure_done() == true)
 	mp.settle_adventure({"levels_cleared": 0, "keystone_total": 0, "cleared": false, "result": "failed"})
 	Kit.check("置位幂等（重复收束不翻转）", sv.is_first_adventure_done() == true)
+	DirAccess.remove_absolute(_bp_path)
+	DirAccess.remove_absolute(_bp_path + ".flag.json")
 
 
-# ---- 冒烟恢复执行体（LevelRunner 注入用——与 AdventureRunner.apply_rest 同式占位；
+# 图数据良构前置（防空集假绿——节点数 > 1、句柄唯一、depth 与 next 键在位）
+func _not_empty_graph(nodes: Array) -> bool:
+	if nodes.size() < 2:
+		return false
+	for node in nodes:
+		var n := node as Dictionary
+		if not n.has("id") or not n.has("depth") or not n.has("next"):
+			return false
+	return true
+
+
+func _handles_unique(nodes: Array) -> bool:
+	var seen := {}
+	for node in nodes:
+		var id: int = int((node as Dictionary).get("id", -1))
+		if id < 0 or seen.has(id):
+			return false
+		seen[id] = true
+	return true
+
+
+func _fresh_rng(seed_val: int):
+	var r = load("res://core/rng_service.gd").new()
+	r.new_adventure(seed_val)
+	return r
+
+
+# ---- 恢复执行体（LevelRunner 注入用——与 AdventureRunner.apply_rest 同式占位；
 # smoke_all.gd helper 的宿主自持私有副本——源文件收尾整体删除，宿主自给自足）----
 func _smoke_rest_stub(pct: int, hp: int, max_hp: int) -> int:
 	return mini(int(floor(float(max_hp) * float(pct) / 100.0)), max_hp - hp)

game/tests/run_all.gd

@@ -87,7 +87,7 @@ func _suites() -> Array:
 		{"path": "res://tests/unit/presentation/modal_flow_test.gd", "expect": 0},   # 模态编排纯逻辑（V6：直接 new/互斥域谓词/三例外锁/演播后排窗）
 		# ---- L2 集成层（跨系统用例，与 unit/ 的隔离断言面分工）----
 		{"path": "res://tests/integration/save_rng_roundtrip_test.gd", "expect": 0},   # 存档⇄RNG 快照往返（SaveManager 迁移链 × 断点消费 × RNG 续跑 × 停点态确定性）
-		{"path": "res://tests/integration/node_map_templates_test.gd", "expect": 0},   # 关卡节点图生成·模板池（模板池跨系统×首冒险置位落盘——批 B 自 smoke_all 迁入，裁决六整套集成不拆）
+		{"path": "res://tests/integration/node_map_templates_test.gd", "expect": 0},   # 关卡节点图生成·确定性承载（生成图复现×首冒险置位落盘——批 B 自 smoke_all 迁入，裁决六整套集成不拆）
 		{"path": "res://tests/integration/cross_system_flow_test.gd", "expect": 0},   # 跨系统真实流×落盘（RNG 事件日志落盘/专长断点往返/存档摘要集成/试玩记录仪真实结算流——批 B 转办块宿主，裁决一/二/三/七）
 		# ---- core 四件与呈现层两件的直接单测 ----
 		{"path": "res://tests/unit/core/board_generator_test.gd", "expect": 0},   # 棋盘生成（尺寸合表/数字＝八邻雷数/同种子逐位一致/可推理自洽）

game/tests/unit/battle_settlement/round_flow_skill_pool_test.gd

@@ -290,7 +290,7 @@ func _smoke_encounter_roll() -> void:
 	# 战斗结算 roll_lo 下限 + 敌人系统 spawn count<1 fail-fast 双闸；单深度单种子是盲区，全域扫描才钉死不变式）
 	var depths: Array = []
 	for node in _level_battle_nodes(1):
-		depths.append(int(node.get("node_depth", -1)))
+		depths.append(int(node.get("depth", -1)))
 	var scan_bad := 0
 	var scan_total := 0
 	for i in range(12):
@@ -317,22 +317,11 @@ func _smoke_encounter_roll() -> void:
 # 节点类型 → 敌人表 row_kind（非 Boss 战斗位恒 battle——深度带批寻址第三维）
 func _row_kind_of(level_index: int, depth: int) -> String:
 	for n in _level_active_nodes(level_index):
-		if int(n.get("node_depth", -1)) == depth and String(n.get("type", "")) == "boss":
+		if int(n.get("depth", -1)) == depth and String(n.get("type", "")) == "boss":
 			return "boss"
 	return "battle"
 
 
-# 该关 Boss 节点深度（单终点图的终点编号——数据驱动，禁写死坐标）
-
-
-# 该关 Boss 节点深度（单终点图的终点编号——数据驱动，禁写死坐标）
-func _boss_depth(level_index: int) -> int:
-	for n in _level_active_nodes(level_index):
-		if String(n.get("type", "")) == "boss":
-			return int(n.get("node_depth", -1))
-	return -1
-
-
 # 首遇带数据驱动定位（契约 8）：该 (L, battle, enemy_id) 的最低 depth_band，禁写死坐标数字
 
 
@@ -353,15 +342,12 @@ func _first_encounter_band(level_index: int, enemy_id: String) -> int:
 # 模板感知取节点表（row.templates 非空取模板 0=现行固定图，保持既有断言语义）
 
 
-# 模板感知取节点表（row.templates 非空取模板 0=现行固定图，保持既有断言语义）
+# 生成图取数面（图 = f(关卡行参数档, 种子 42)——与 runner 起关同图；节点键 id/type/depth/next）
 func _level_active_nodes(level_index: int) -> Array:
-	for row in _db.level.rows:
-		if int(row.level_index) == level_index:
-			var tpls: Array = row.get("templates", [])
-			if not tpls.is_empty():
-				return tpls[0].get("nodes", [])
-			return row.get("nodes", [])
-	return []
+	var rng = load("res://core/rng_service.gd").new()
+	rng.set_master_seed(42)
+	var gen = NodeMapGenerator.new(rng)
+	return (gen.generate(_db.level_gen_params_row(level_index), 42) as Dictionary).get("nodes", [])
 
 
 func _level_battle_nodes(level_index: int) -> Array:

game/tests/unit/core/adventure_feats_test.gd

@@ -58,7 +58,7 @@ func _smoke_adventure_api() -> void:
 	adr.level_started.connect(_api_mark_started.bind(sig_seq))
 	adr.choices_presented.connect(_api_mark_choices.bind(sig_seq, obs))
 	adr.node_entered.connect(_api_mark_node.bind(sig_seq))
-	Kit.check("冒险启动受理（主种子注入恰一次——state=running；first_script=固定模板 0——精确路径断言需要现行图，零抽签）", adr.start_adventure(42, {"first_script": true}))
+	Kit.check("冒险启动受理（主种子注入恰一次——state=running；种子 42＝首局固定种子生成图——精确路径断言需要确定图（卡② 代差））", adr.start_adventure(42))
 	Kit.check("进行中重复 start_adventure 拒绝（重开须待结算完毕）", not adr.start_adventure(43))
 	Kit.check("停点前移次序契约：level_started 先于入口候选呈现（反序选路口会被呈现层 runner 空防御丢弃）", sig_seq.size() == 2 and String(sig_seq[0]) == "level_started" and String(sig_seq[1]) == "choices_presented")
 	Kit.check("入口停点：选路态 + 入口单候选 + 首战未开（呈现零 RNG 消耗——pick 前零战斗域）",
@@ -108,26 +108,27 @@ func _api_mark_node(_node: Dictionary, _info: Dictionary, seq: Array) -> void:
 func _smoke_adventure() -> void:
 	print("--- 冒险结构验收（三关序列 · 大奖励 · 摘要五件事 · 账本封闭）---")
 	var autoplay = load("res://sim/level_autoplay.gd")
-	# ① 表与覆盖义务（序列关数 = 行集关数；行集内每个战斗/Boss 节点跨表精确行集——覆盖义务断言；
-	# enemy 侧键域 = (level_index, row_kind, depth_band)——战斗节点查 battle 键域、Boss 节点查 boss 键域，
-	# 同带多行合法，带键聚合天然兼容〔fv24〕）
+	# ① 表与覆盖义务（序列关数 = 行集关数；节点源 = 参数档在固定种子下的生成图，
+	# 每个战斗/Boss 节点经 ConfigDB 真实解析链查敌行集与棋盘行——顶 clamp 消解禁〔fv24〕）
 	Kit.check("序列关数 = 行集关数（三关正式序列生效）", int(_db.level.rows.size()) == 3)
-	var bg_keys := {}
-	for row in _db.board_gen.rows:
-		bg_keys["%d_%d" % [int(row.level_index), int(row.node_depth)]] = true
-	var en_keys := {}
-	for row in _db.enemy.rows:
-		en_keys["%d_%s_%d" % [int(row.level_index), String(row.get("row_kind", "")), int(row.get("depth_band", -1))]] = true
-	var miss := 0
-	for row in _db.level.rows:
-		for n in _level_active_nodes(int(row.level_index)):
+	var cov_miss := 0
+	var cov_scan := 0
+	for li in range(1, int(_db.level.rows.size()) + 1):
+		for n in _level_active_nodes(li):
 			var nt := String(n.get("type", ""))
 			if nt != "battle" and nt != "boss":
 				continue
-			var key := "%d_%s_%d" % [int(row.level_index), nt, int(n.get("node_depth", -1))]
-			if not bg_keys.has("%d_%d" % [int(row.level_index), int(n.get("node_depth", -1))]) or not en_keys.has(key):
-				miss += 1
-	Kit.check("行集内每个战斗/Boss 节点在 board_gen + enemy 有精确行集（缺失 %d——带键 (L,row_kind,depth_band)）" % miss, miss == 0)
+			var d: int = int(n.get("depth", -1))
+			cov_scan += 1
+			var rk := "boss" if nt == "boss" else "battle"
+			var rs: Array[Dictionary] = _db.resolve_enemy_rowset(li, d, rk)
+			if rs.is_empty() or int(rs[0].get("depth_band", -1)) < d:
+				cov_miss += 1
+			if not (_db.resolve_board_gen(li, d) as Dictionary).is_empty():
+				continue
+			cov_miss += 1
+	Kit.check("生成图每个战斗/Boss 节点经解析链命中敌行集与棋盘行（扫描 %d 节点，缺失 %d）〔fv24〕" % [cov_scan, cov_miss],
+		cov_scan > 0 and cov_miss == 0)
 	# ② 满配通关 + ④ 三层奖励兑付（三选一恰 2 次 · 回血封顶 · 钥石逐杀 · 候选零重复）
 	var st: Dictionary = autoplay.run_adventure(_db, 42, 900, 400)
 	var sum: Dictionary = st["summary"]
@@ -151,7 +152,65 @@ func _smoke_adventure() -> void:
 		elif (ev as Dictionary).has("curio_resolved"):
 			resolves.append((ev as Dictionary)["curio_resolved"])
 	Kit.check("通关三选一恰呈现 2 次、恰兑付 2 次（L1/L2 后——末关不发；resolves 含节点回执另计）", picks.size() == 2 and resolves.size() == 2 + node_picks)
-	Kit.check("奖励节点三选一 ≥1 次（L1 链必经 1 个；L2/L3 图可选路经若干——实际经停 %d）" % node_picks, node_picks >= 1)
+	# 奖励节点在生成图里是可选路位（旧单链模板的「L1 必经 1 个」形状前提随模板消亡）——
+	# 接线证明拆两半：图侧每关含 ≥1 奖励节点，行进侧种子扫描内确有经停（扫描零经停=三选一接线不可达）
+	var reward_levels := 0
+	for li in range(1, int(_db.level.rows.size()) + 1):
+		var rc := 0
+		for n in _level_active_nodes(li):
+			if String(n.get("type", "")) == "reward":
+				rc += 1
+		if rc >= 1:
+			reward_levels += 1
+	Kit.check("三关生成图各含 ≥1 奖励节点（节点三选一候选位在图）", reward_levels == 3)
+	# 行进侧接线证明走真实选路入口：满配打赢入口战→岔口点选奖励分支→三选一候选可取且停点在途
+	# （确定性评分策略恒选战斗/恢复分支，奖励位不在扫描路由上——旧「链必经」形状断言的替代形态）
+	var adr_rw = load("res://core/adventure_runner.gd").new(_db, _fresh_rng(42))
+	adr_rw.set_hero_override(900, 400)
+	Kit.check("奖励分支场景冒险启动（seed 42 满配）", adr_rw.start_adventure(42))
+	var r_rw = adr_rw.runner()
+	var rw_st := _adv_st()
+	var rw_cands: Array = []
+	var rw_guard := 30
+	while r_rw != null and rw_guard > 0:
+		rw_guard -= 1
+		if r_rw.awaiting_choice():
+			var rw_id := -1
+			for c in r_rw.next_candidates():
+				if String((c as Dictionary).get("type", "")) == "reward":
+					rw_id = int((c as Dictionary).get("id", -1))
+					break
+			if rw_id >= 0:
+				r_rw.pick_next_node(rw_id)
+				rw_cands = (adr_rw.node_curio_candidates() as Dictionary).get("candidates", []) as Array
+				break
+			var rw_ids: Array = r_rw.next_candidate_ids()
+			if rw_ids.is_empty():
+				break
+			r_rw.pick_next_node(int(rw_ids[0]))
+			continue
+		var b_rw = r_rw.current_battle()
+		if b_rw == null:
+			break
+		autoplay._autoplay_battle(r_rw, b_rw, rw_st, null)
+	var rw_pending_ok := false
+	if not rw_cands.is_empty():
+		adr_rw.present_node_curio(rw_cands)
+		rw_pending_ok = not (adr_rw._node_curio_pending as Dictionary).is_empty()
+	var rw_pc: Dictionary = {}
+	for c in rw_cands:
+		var cd := c as Dictionary
+		if String(cd.get("kind", "")) != "feat_ticket":
+			rw_pc = cd
+			break
+	if rw_pc.is_empty() and not rw_cands.is_empty():
+		rw_pc = rw_cands[0] as Dictionary
+	var rw_pick_ok := false
+	if rw_pending_ok and not rw_pc.is_empty():
+		rw_pick_ok = adr_rw.apply_node_curio(String(rw_pc.get("kind", "")),
+			String(rw_pc.get("tier", "")), String(rw_pc.get("feat_id", "")))
+	Kit.check("奖励分支点选→三选一停点在途且兑付受理（候选 %d 件）" % rw_cands.size(),
+		rw_pending_ok and rw_pick_ok)
 	var node_resolves := 0
 	for r0 in resolves:
 		if String((r0 as Dictionary).get("context", "")) == "reward_node":
@@ -260,7 +319,7 @@ func _smoke_adventure() -> void:
 	# ⑥ 重复宣布拒绝（settle 后再调 _on_level_finished——摘要零变化）
 	var adr6 = load("res://core/adventure_runner.gd").new(_db, _fresh_rng(7))
 	adr6.set_hero_override(900, 400)
-	Kit.check("重复拒绝场景：冒险启动（seed 7——固定模板 0 同上）", adr6.start_adventure(7, {"first_script": true}))
+	Kit.check("重复拒绝场景：冒险启动（seed 7——生成图确定同上）", adr6.start_adventure(7))
 	adr6.runner().pick_next_node(int(adr6.runner().next_candidate_ids()[0]))   # 入口停点 pick 进首战
 	var b6 = adr6.runner().current_battle()
 	var st6 := _adv_st()
@@ -284,13 +343,13 @@ func _smoke_adventure() -> void:
 	Kit.check("每战完成入账恰一次（gain %d = battles %d——GP 袋件入账单列）" % [gains, int(st["battles"])], gains == int(st["battles"]))
 	Kit.check("钱包 clear 恰一次且为末事件（关卡收束不清——GP 冒险收束清零归冒险结构）", clears == 1 and wallet.size() > 0 and String(wallet[wallet.size() - 1]["event"]) == "clear")
 	var shop_seq: Array = st["shop_gp_seq"]
-	Kit.check("L2 商店房到达余额 > 0（%d——L1 积累跨关延续；两关商店房必经各 1）" % (shop_seq[0] if shop_seq.size() > 0 else -1), shop_seq.size() == 2 and int(shop_seq[0]) > 0)
+	Kit.check("三关商店房各到达一次（每关入口→终点路径恰穿一店的驱动投影）且首达余额 > 0（%d——GP 跨关延续）" % (shop_seq[0] if shop_seq.size() > 0 else -1), shop_seq.size() == 3 and int(shop_seq[0]) > 0)
 	# ⑧ 加算区同账（手工场景：L2 商店购买 → 三选一直调——同一本账累加 + 部分回血封顶）
 	var same := {}
 	for s in range(42, 92):
 		var a8 = load("res://core/adventure_runner.gd").new(_db, _fresh_rng(s))
 		a8.set_hero_override(900, 400)
-		if not a8.start_adventure(s, {"first_script": true}):   # 固定模板 0——种子扫描语义按现行图
+		if not a8.start_adventure(s):   # 种子扫描语义按生成图（同种子同图）
 			continue
 		if _adv_drive_to_shop(a8, _adv_st(), autoplay):
 			same = {"a": a8, "s": s}
@@ -335,7 +394,7 @@ func _smoke_adventure() -> void:
 	# ⑩ 放弃（战斗中拒绝 · 非战斗期受理同失败型结算）
 	var a10 = load("res://core/adventure_runner.gd").new(_db, _fresh_rng(15))
 	a10.set_hero_override(900, 400)
-	Kit.check("放弃场景：冒险启动（seed 15——固定模板 0 同上）", a10.start_adventure(15, {"first_script": true}))
+	Kit.check("放弃场景：冒险启动（seed 15——生成图确定同上）", a10.start_adventure(15))
 	Kit.check("放弃场景：入口停点 pick 进首战（停点前移批 2026-09-23 驱动口径）", a10.runner().pick_next_node(int(a10.runner().next_candidate_ids()[0])))
 	Kit.check("战斗中 abandon 拒绝（战斗域单事务在飞）", not a10.abandon())
 	var b10 = a10.runner().current_battle()
@@ -348,7 +407,7 @@ func _smoke_adventure() -> void:
 	# ⑪ 池耗即枯竭 + 池收缩 + 满血回 0（TP0——white-box：耗尽 attack/ap 令牌后候选零出现；
 	# 无种类次数上限，「达上限剔除」语义由牌库耗尽承载）
 	var a11 = load("res://core/adventure_runner.gd").new(_db, _fresh_rng(11))
-	Kit.check("剔牌库/替换场景：冒险启动（seed 11——道具解锁集只含 wide_scout_band）", a11.start_adventure(11, {"first_script": true, "treasure_unlocked": {"wide_scout_band": true}}))
+	Kit.check("剔牌库/替换场景：冒险启动（seed 11——道具解锁集只含 wide_scout_band）", a11.start_adventure(11, {"treasure_unlocked": {"wide_scout_band": true}}))
 	for di in range(a11._curio_deck.size() - 1, -1, -1):
 		var dk := String((a11._curio_deck[di] as Dictionary).get("kind", ""))
 		if dk == "attack" or dk == "ap":
@@ -370,7 +429,7 @@ func _smoke_adventure() -> void:
 	Kit.check("池收缩——40 次重抽零 aux 候选（停点渠道 aux 卡退役，迭代 11 第①批 T7）", not treasure_seen)
 	# 满血回 0 合法（通关回血封顶口径）
 	var a12 = load("res://core/adventure_runner.gd").new(_db, _fresh_rng(12))
-	a12.start_adventure(12, {"first_script": true})
+	a12.start_adventure(12)
 	var cap := {"payload": {}}
 	a12.curio_choice_presented.connect(func(p): cap["payload"] = p)
 	var max_full := int(_db.hero.max_hp) + int(a12._base_override.get("max_hp", 0))
@@ -379,7 +438,7 @@ func _smoke_adventure() -> void:
 	Kit.check("满血通关回血 0 合法（封顶口径——heal_gained=0 非负溢出）", int(cap["payload"].get("heal_gained", -1)) == 0)
 	# ⑬ 奖励节点共享池（同库同池同摘牌；TP0：attack 令牌耗尽后节点域同样零出现）
 	var a13 = load("res://core/adventure_runner.gd").new(_db, _fresh_rng(13))
-	Kit.check("节点共享池场景：冒险启动（seed 13）", a13.start_adventure(13, {"first_script": true, "treasure_unlocked": {"wide_scout_band": true}}))
+	Kit.check("节点共享池场景：冒险启动（seed 13）", a13.start_adventure(13, {"treasure_unlocked": {"wide_scout_band": true}}))
 	for di13 in range(a13._curio_deck.size() - 1, -1, -1):
 		if String((a13._curio_deck[di13] as Dictionary).get("kind", "")) == "attack":
 			a13._curio_deck.remove_at(di13)
@@ -411,7 +470,7 @@ func _smoke_feats() -> void:
 	Kit.check("feat_table 已加载（30 件=基础 27+迁入 2+卡② 完美保险 1——迭代 31 卡② 换代）", _db.feats != null and (_db.feats.rows as Array).size() == 30)
 	Kit.check("feat_table.validate 零违例（四级 rarity/cap 域/trigger 词表/行键白名单全过）", _db.feats.validate().is_empty())
 	var a_r0 = load("res://core/adventure_runner.gd").new(_db, _fresh_rng(71))
-	Kit.check("专长带场景：冒险启动（seed 71）", a_r0.start_adventure(71, {"first_script": true}))
+	Kit.check("专长带场景：冒险启动（seed 71）", a_r0.start_adventure(71))
 	var feat_tokens := 0
 	var tier_counts := {}
 	for t in a_r0._curio_deck:
@@ -465,7 +524,7 @@ func _smoke_feats() -> void:
 	var live_rows: FeatTable = _db.feats
 	_db.feats = rt
 	var a_r = load("res://core/adventure_runner.gd").new(_db, _fresh_rng(72))
-	Kit.check("专长带场景：冒险启动（seed 72——注入 5 行临时表）", a_r.start_adventure(72, {"first_script": true}))
+	Kit.check("专长带场景：冒险启动（seed 72——注入 5 行临时表）", a_r.start_adventure(72))
 	var deck_relic := 0
 	for t in a_r._curio_deck:
 		if String((t as Dictionary).get("kind", "")) == "relic":
@@ -485,7 +544,7 @@ func _smoke_feats() -> void:
 	Kit.check("节点渠道零专长（60 次重抽零 relic——专长在非 Boss 渠道只以专长凭证形态出现）", not node_relic_seen)
 	# T5 专长凭证行为断言（A5 拿到即开 / A6 保底计数——契约④四口径；独立 runner 防污染 a_r 牌库）
 	var a_t = load("res://core/adventure_runner.gd").new(_db, _fresh_rng(91))
-	a_t.start_adventure(91, {"first_script": true})
+	a_t.start_adventure(91)
 	var stock_before := {}
 	for kk in ["attack", "gp", "heal"]:
 		stock_before[kk] = a_t.pool_stock(kk)
@@ -809,12 +868,7 @@ func _fresh_rng(seed_val: int):
 # ---- ① GP 冒险钱包·到账 ----
 
 
-# 模板感知取节点表（row.templates 非空取模板 0=现行固定图，保持既有断言语义）
+# 生成图取数面（图 = f(关卡行参数档, 种子 42)——与 runner 起关同图；节点键 id/type/depth/next）
 func _level_active_nodes(level_index: int) -> Array:
-	for row in _db.level.rows:
-		if int(row.level_index) == level_index:
-			var tpls: Array = row.get("templates", [])
-			if not tpls.is_empty():
-				return tpls[0].get("nodes", [])
-			return row.get("nodes", [])
-	return []
+	var gen = NodeMapGenerator.new(_fresh_rng(42))
+	return (gen.generate(_db.level_gen_params_row(level_index), 42) as Dictionary).get("nodes", [])

game/tests/unit/core/breakpoint_resume_test.gd

@@ -147,8 +147,52 @@ func _init() -> void:
 	Kit.check_quiet(adr_i.runner().pick_next_node(int(adr_i.runner().next_candidate_ids()[0])), "P6 续玩选路进首战")
 	Kit.check_quiet(adr_i.runner().current_battle().attune_has("morning_order"), "P6 回局首战装配集仍含 morning_order（停点往返载体态一致）")
 
+	# ---- Part 7：生成图换代断言面（快照键换代、停点句柄往返、续玩按种子+参数档重生成同图）----
+	var rng_j = load("res://core/rng_service.gd").new()
+	var sm_j = SaveManagerScript.new(_bp_path)
+	var adr_j = AdventureRunnerScript.new(db, rng_j)
+	adr_j.set_save_manager(sm_j)
+	Kit.check_quiet(adr_j.start_adventure(910042, params), "P7 冒险启动（seed 910042——生成图开局）")
+	var runner_j = adr_j.runner()
+	var graph_j: Array = runner_j.nodes()
+	var bp_j: Dictionary = sm_j.breakpoint_snapshot()
+	Kit.check_quiet(not bp_j.has("template_pick"),
+		"P7 断点快照无已抽模板键（模板链路退役——件核面在档）")
+	Kit.check_quiet(int(bp_j.get("graph_gen_v2", 0)) == 1,
+		"P7 断点含生成图代差标记键（换代承载）")
+	var entry_id: int = int(runner_j.next_candidate_ids()[0])
+	var mid_id: int = _first_out_id(graph_j, entry_id)
+	var bp_mid: Dictionary = bp_j.duplicate(true)
+	bp_mid["node_id"] = mid_id
+	bp_mid["visited_ids"] = [entry_id]
+	var adr_m = AdventureRunnerScript.new(db, load("res://core/rng_service.gd").new())
+	Kit.check_quiet(adr_m.resume_adventure(bp_mid, params), "P7 中途停点断点续玩受理（句柄落档形态）")
+	var runner_m = adr_m.runner()
+	Kit.check_quiet(int(runner_m.current_node_id()) == mid_id,
+		"P7 停点句柄回读一致（图内 id 单空间寻址）")
+	Kit.check_quiet(runner_m.visited_ids() == [entry_id], "P7 已到节点序按句柄往返一致")
+	Kit.check_quiet(runner_m.nodes() == graph_j, "P7 续玩重生成图与中断前逐位同图（断点不存图快照）")
+	var adr_l = AdventureRunnerScript.new(db, load("res://core/rng_service.gd").new())
+	var bp_legacy: Dictionary = bp_mid.duplicate(true)
+	bp_legacy.erase("graph_gen_v2")
+	Kit.check_quiet(adr_l.resume_adventure(bp_legacy, params) == false,
+		"P7 缺生成图代差标记键的旧断点显式拒绝（禁按新句柄空间静默回放）")
+	var adr_n = AdventureRunnerScript.new(db, load("res://core/rng_service.gd").new())
+	Kit.check_quiet(adr_n.start_adventure(910042, params) and adr_n.runner().nodes() == graph_j,
+		"P7 同种子重开局同图（开局入口复现承载）")
+
 	_clear_disk()
-	quit(Kit.finish("breakpoint_resume_test", "PASS — 断点往返/续玩确定性/幂等/退出清断点/装配存档回归 全绿"))
+	quit(Kit.finish("breakpoint_resume_test", "PASS — 断点往返/续玩确定性/幂等/退出清断点/装配存档回归/生成图换代 全绿"))
+
+
+# 句柄寻址夹具辅助：取生成图中指定句柄节点的首个出边目标（构造中途停点落档形态）
+func _first_out_id(nodes: Array, node_id: int) -> int:
+	for node in nodes:
+		var n := node as Dictionary
+		if int(n.get("id", -1)) == node_id:
+			var outs: Array = n.get("next", [])
+			return int(outs[0]) if not outs.is_empty() else -1
+	return -1
 
 
 func _board_fingerprint(b) -> String:

game/tests/unit/core/curio_refresh_paid_test.gd

@@ -53,12 +53,12 @@ func _init() -> void:
 	Kit.check_quiet(lr.spend_gp(20) == true and int(lr.gp) == 10, "足额支出扣账（30→10）")
 
 	# ---- ⑥ Y 断点随存（缺陷锚：续玩自参数面整额重注入=用完 Y 退菜单再续玩满血复活）----
-	var bp_y := {"level_index": 1, "hero_hp": 10, "attune_refresh_y": 2}
+	var bp_y := {"level_index": 1, "hero_hp": 10, "attune_refresh_y": 2, "graph_gen_v2": 1}
 	var adr_r = load("res://core/adventure_runner.gd").new(db, load("res://core/rng_service.gd").new())
 	Kit.check_quiet(adr_r.resume_adventure(bp_y, {"hero_override": {}, "attune_refresh_y": 3}), "续玩受理（最小断点+参数面）")
 	Kit.check_quiet(adr_r._attune_refresh_y == 2, "断点有键=Y 余量随断点还原（花 1 剩 2——不再整额重注入=满血复活堵死）")
 	var adr_o = load("res://core/adventure_runner.gd").new(db, load("res://core/rng_service.gd").new())
-	Kit.check_quiet(adr_o.resume_adventure({"level_index": 1, "hero_hp": 10}, {"hero_override": {}, "attune_refresh_y": 3}), "旧断点续玩受理（快照缺键）")
+	Kit.check_quiet(adr_o.resume_adventure({"level_index": 1, "hero_hp": 10, "graph_gen_v2": 1}, {"hero_override": {}, "attune_refresh_y": 3}), "旧断点续玩受理（快照缺键）")
 	Kit.check_quiet(adr_o._attune_refresh_y == 3, "旧断点缺键=回退参数面整额注入（旧档行为零变化）")
 
 	quit(Kit.finish("curio_refresh_paid"))

game/tests/unit/core/feat_vouchers_test.gd

@@ -22,7 +22,7 @@ func _init() -> void:
 		quit(1)
 		return
 	var a = load("res://core/adventure_runner.gd").new(db, load("res://core/rng_service.gd").new())
-	if not a.start_adventure(301, {"first_script": true}):
+	if not a.start_adventure(301):
 		Kit.check_quiet(false, "V9 前置：冒险启动")
 		quit(Kit.finish("feat_vouchers"))
 		return

game/tests/unit/core/level_map_type_vis_test.gd

@@ -29,61 +29,71 @@ func _init() -> void:
 
 # ---- 夹具 ----
 
-# 图形态夹具（id = node_depth）：单干 0→1→2→3→4→5→6→7 加一条 6→3 跨层跳边。
-# BFS 层：0=0／1=1／2=1／3=2／4=3／5=4／6=5／7=6——锚 6 时候选 3 层距 3 = N+1。
+# 节点构造器（生成图口径：id=图内唯一句柄、depth=自入口最长路径步数、next=出边句柄数组）
+static func _gn(id: int, depth: int, type_: String, next_ids: Array) -> Dictionary:
+	return {"id": id, "type": type_, "depth": depth, "next": next_ids}
+
+
+# 图形态夹具（id = 图内句柄，depth = 自入口沿边严格前进的深度）：干 0→1→{2,8}，2→3，
+# 8→4→5→6，长跳边 6→3（与 2→3 同落节点 3，目标 depth 严格大于源——生成图连线铁律），
+# 3 经尾链 9→10→11 汇入终点 7（7 的 depth = 自入口最长路径步数 10）。
+# BFS 层：0=0／1=1／2=1／3=2／4=3／5=4／6=5／7=6（8=2／9=3／10=4／11=5）——锚 6 时候选 3 层距 3 = N+1。
 func _graph_nodes() -> Array:
 	return [
-		{"node_depth": 0, "type": "battle", "next": [1, 2]},
-		{"node_depth": 1, "type": "battle", "next": [2]},
-		{"node_depth": 2, "type": "reward", "next": [3]},
-		{"node_depth": 3, "type": "rest", "next": [4]},
-		{"node_depth": 4, "type": "battle", "next": [5]},
-		{"node_depth": 5, "type": "battle", "next": [6]},
-		{"node_depth": 6, "type": "battle", "next": [7, 3]},
-		{"node_depth": 7, "type": "boss", "next": []},
+		_gn(0, 0, "battle", [1, 2]),
+		_gn(1, 1, "battle", [2, 8]),
+		_gn(2, 2, "reward", [3]),
+		_gn(3, 6, "rest", [9]),
+		_gn(4, 3, "battle", [5]),
+		_gn(5, 4, "battle", [6]),
+		_gn(6, 5, "battle", [7, 3]),
+		_gn(7, 10, "boss", []),
+		_gn(8, 2, "battle", [4]),
+		_gn(9, 7, "battle", [10]),
+		_gn(10, 8, "battle", [11]),
+		_gn(11, 9, "battle", [7]),
 	]
 
 
-# 单链夹具（无 next 键，仿 L1 现役模板形态）：编号空间 = 数组下标，node_depth 只出现在战斗/Boss 上
+# 单链退化形态 = 出度 ≤1 的图（显式 next 出边、编号 = id 句柄——无数组下标隐式边）
 func _chain_nodes() -> Array:
 	return [
-		{"node_depth": 0, "type": "battle"},
-		{"node_depth": 1, "type": "battle"},
-		{"node_depth": 2, "type": "battle"},
-		{"node_depth": 3, "type": "battle"},
-		{"type": "reward"},
-		{"type": "rest"},
-		{"node_depth": 4, "type": "boss"},
+		_gn(0, 0, "battle", [1]),
+		_gn(1, 1, "battle", [2]),
+		_gn(2, 2, "battle", [3]),
+		_gn(3, 3, "battle", [4]),
+		_gn(4, 4, "reward", [5]),
+		_gn(5, 5, "rest", [6]),
+		_gn(6, 6, "boss", []),
 	]
 
 
 # 表行夹具的正样本（无跨层跳边的合法图——表加载期只核行级字段，图合法性判据见 validate_graph·卡② T1 换代）
 func _valid_graph_nodes() -> Array:
 	return [
-		{"node_depth": 0, "type": "battle", "next": [1, 2]},
-		{"node_depth": 1, "type": "battle", "next": [3]},
-		{"node_depth": 2, "type": "reward", "next": [3]},
-		{"node_depth": 3, "type": "battle", "next": [4]},
-		{"node_depth": 4, "type": "boss", "next": []},
+		_gn(0, 0, "battle", [1, 2]),
+		_gn(1, 1, "battle", [3]),
+		_gn(2, 1, "reward", [3]),
+		_gn(3, 2, "battle", [4]),
+		_gn(4, 3, "boss", []),
 	]
 
 
-# 白盒 runner：夹具行集注入 db.level ＋ level_row，停点态直设（anchor_id < 0 = 入口停点）
-func _runner(db, nodes: Array, anchor_id: int, candidates: Array,
-		graph_mode: bool = true, n: int = 2):
+# 白盒 runner：夹具行集注入 db.level ＋ level_row，停点态直设（anchor_id < 0 = 入口停点；
+# 锚点与候选的编号空间 = 节点 id 句柄——runner._node_id 单点）
+func _runner(db, nodes: Array, anchor_id: int, candidates: Array, n: int = 2):
 	var t := LevelTableScript.new()
 	t.info_visible_layers = n
 	t.rows = [{"level_index": 1, "display_name": "夹具关", "rest_heal_pct": 30, "nodes": nodes}]
 	db.level = t
 	var r = load("res://core/level_runner.gd").new(db, load("res://core/rng_service.gd").new())
 	r.level_row.assign({"level_index": 1, "display_name": "夹具关", "rest_heal_pct": 30, "nodes": nodes})
-	r._graph_mode = graph_mode
 	r.visited.clear()
 	r._candidates.assign(candidates)
 	r.node_index = -1
 	if anchor_id >= 0:
 		for i in nodes.size():
-			if int((nodes[i] as Dictionary).get("node_depth", -1)) == anchor_id:
+			if int((nodes[i] as Dictionary).get("id", -1)) == anchor_id:
 				r.node_index = i
 				break
 	return r
@@ -157,15 +167,15 @@ func _test_single_circle(db) -> void:
 	Kit.check("单圈只按锚层取窗：已过近端节点 4（层距 2）仍可见〔fv7〕", vis.has(4))
 
 
-# ---- ⑤ 单链退化形态（编号空间 = 数组下标）〔fv1〕----
+# ---- ⑤ 单链退化形态（出度 ≤1 图，编号 = id 句柄）〔fv1〕----
 
 func _test_single_chain_entry(db) -> void:
 	var nodes := _chain_nodes()
-	var r = _runner(db, nodes, -1, [nodes[0]], false)
+	var r = _runner(db, nodes, -1, [nodes[0]])
 	var vis: Array = r.type_visible_ids()
-	Kit.check("单链退化形态：入口锚层 0，下标 2 可见〔fv1〕", vis.has(2))
-	Kit.check("单链退化形态：层距 N+1（下标 3）不可见〔fv1〕", not vis.has(3))
-	Kit.check("单链编号空间 = 数组下标：Boss 以末位下标 6 入集（非 node_depth 4）〔fv1〕",
+	Kit.check("单链退化形态：入口锚层 0，句柄 2 可见〔fv1〕", vis.has(2))
+	Kit.check("单链退化形态：层距 N+1（句柄 3）不可见〔fv1〕", not vis.has(3))
+	Kit.check("单链编号空间 = 图句柄 id：Boss 以句柄 6 入集（链上层距 4 的战斗节点 4 入雾）〔fv1〕",
 		vis.has(6) and not vis.has(4))
 
 
@@ -189,20 +199,37 @@ func _test_n_from_table(db) -> void:
 # ---- ⑦ 续玩重建同值〔fv7〕----
 
 func _test_resume_rebuild(db) -> void:
-	var nodes := _graph_nodes()
 	var t := LevelTableScript.new()
 	t.info_visible_layers = 2
-	t.rows = [{"level_index": 1, "display_name": "夹具关", "rest_heal_pct": 30, "nodes": nodes}]
+	t.rows = [{"level_index": 1, "display_name": "夹具关", "rest_heal_pct": 30}]
 	db.level = t
 	var ledger := {"hero_hp": 10, "gp": 0}
 	var resumed = load("res://core/level_runner.gd").new(db, load("res://core/rng_service.gd").new())
-	var ok: bool = resumed.start_level_external(1, ledger, {}, Callable(), {}, false, 0,
+	var ok: bool = resumed.start_level_external(1, ledger, {}, Callable(), {}, false,
 		{"node_id": 2, "visited_ids": [0, 1, 2]})
 	Kit.check_quiet(ok, "续玩用例：resume_state 重建停点成功")
 	if not ok:
 		return
 	Kit.check_quiet(resumed.awaiting_choice(), "续玩用例：重建后处于选路停点")
-	var direct = _runner(db, nodes, 2, [nodes[3]])
-	direct.visited.assign([nodes[0], nodes[1], nodes[2]])
+	# 图源 = 参数化生成图（图 = f(参数档, 种子)）——直入对照侧与 resume 侧同吃一张生成图，
+	# 停点态按句柄对齐：锚 = id 2、visited = id 0/1/2、候选 = id 2 出边指向的节点
+	var gnodes: Array = resumed.nodes()
+	var stop: Dictionary = {}
+	var by_id := {}
+	for node in gnodes:
+		var nid: int = int((node as Dictionary).get("id", -1))
+		by_id[nid] = node
+		if nid == 2:
+			stop = node
+	var cand_nodes: Array = []
+	for tid in (stop.get("next", []) as Array):
+		if by_id.has(int(tid)):
+			cand_nodes.append(by_id[int(tid)])
+	var visited_nodes: Array = []
+	for vid in [0, 1, 2]:
+		if by_id.has(vid):
+			visited_nodes.append(by_id[vid])
+	var direct = _runner(db, gnodes, 2, cand_nodes)
+	direct.visited.assign(visited_nodes)
 	Kit.check("续玩重建同值：resume 路径与同停点直入 type_visible_ids() 逐位一致〔fv7〕",
 		resumed.type_visible_ids() == direct.type_visible_ids())

game/tests/unit/core/meta_progression_forge_test.gd

@@ -313,15 +313,15 @@ func _meta_settle_and_workshop() -> void:
 	Kit.check("开局传参夹具前置：Fork 侧 a 激活 rule 键非空 + Y=Lv2 行表值 2（防断言空转）",
 		rules_e.has("posture_first_strike") and mp_e.attune_refresh_charges() == 2)
 	var p_new: Dictionary = load("res://presentation/main.gd").build_adventure_params(sv_e, mp_e,
-		{"first_script": true, "treasure_unlocked": {}, "shop_mode": "pool"})
+		{"treasure_unlocked": {"wide_scout_band": true}, "shop_mode": "pool"})
 	Kit.check("主菜单开新冒险参数面：同调装配 = 存档装配集（营地装了什么开局就带什么）",
 		(p_new.get("attunement", []) as Array) == (sv_e.attunement_equipped() as Array))
 	Kit.check("主菜单开新冒险参数面：Y 刷新池 = 当前等级行表值（营地升几档开局就给几次）",
 		int(p_new.get("attune_refresh_y", -1)) == mp_e.attune_refresh_charges())
 	Kit.check("主菜单开新冒险参数面：树 rule 键集 = Fork 激活侧 effects（点哪侧带哪侧）",
 		(p_new.get("tree_rules", []) as Array) == rules_e)
-	Kit.check("主菜单开新冒险参数面：入口特有键（first_script/shop_mode）随 extra 原样并入",
-		bool(p_new.get("first_script", false)) and String(p_new.get("shop_mode", "")) == "pool")
+	Kit.check("主菜单开新冒险参数面：入口特有键（treasure_unlocked/shop_mode）随 extra 原样并入",
+		bool((p_new.get("treasure_unlocked", {}) as Dictionary).get("wide_scout_band", false)) and String(p_new.get("shop_mode", "")) == "pool")
 	var p_resume: Dictionary = load("res://presentation/main.gd").build_adventure_params(sv_e, mp_e,
 		{"treasure_unlocked": {}})
 	Kit.check("主菜单继续上局参数面：三键与开新冒险同源同值（续玩不吃白板开局）",
@@ -333,7 +333,7 @@ func _meta_settle_and_workshop() -> void:
 	var adr_res = load("res://core/adventure_runner.gd").new(_db, _fresh_rng(19))
 	var bp_min: Dictionary = {"level_index": 1, "node_id": -1, "hero_hp": 40, "gp": 5,
 		"bonus": {"atk": 0, "max_hp": 0, "armor_class": 0}, "shop_purchased": {},
-		"template_pick": -1, "master_seed": 777, "rng_counter": 3, "keystone": 0,
+		"graph_gen_v2": 1, "master_seed": 777, "rng_counter": 3, "keystone": 0,
 		"visited_ids": []}
 	Kit.check("继续上局受理面：resume_adventure 受理三键参数面（尾裁微批b 受理闭环——受理不再吃白板）",
 		adr_res.resume_adventure(bp_min, p_resume))

game/tests/unit/core/pool_case_d_test.gd

@@ -34,7 +34,7 @@ func _init() -> void:
 
 	# T10——空配置验收闸（三选一池空兜底/商店空货架）
 	var e = load("res://core/adventure_runner.gd").new(db, load("res://core/rng_service.gd").new())
-	e.start_adventure(501, {"first_script": true})
+	e.start_adventure(501)
 	e._curio_pending = {"candidates": []}
 	Kit.check_quiet(e.skip_empty_curio() and e._curio_pending.is_empty(),
 		"空配置闸：三选一池空=停点整体跳过（skip_empty_curio 消化）〔专长批 T10〕")
@@ -65,7 +65,7 @@ func _tiers_of(cands: Array) -> Array:
 
 
 func check_v7(a, db) -> void:
-	if not a.start_adventure(201, {"first_script": true}):
+	if not a.start_adventure(201):
 		Kit.check_quiet(false, "V7 前置：冒险启动")
 		return
 	# 构成①：全池含优秀档以上——曝光槽应出 1 格高档（rank≥excellent）
@@ -110,7 +110,7 @@ func check_v7(a, db) -> void:
 
 
 func check_v6(b, db) -> void:
-	if not b.start_adventure(202, {"first_script": true}):
+	if not b.start_adventure(202):
 		Kit.check_quiet(false, "V6 前置：冒险启动")
 		return
 	# 拿了消耗：直置停点候选后 pick_curio——牌库摘牌单点
@@ -139,7 +139,7 @@ func check_v6(b, db) -> void:
 
 
 func check_v12(m, db) -> void:
-	if not m.start_adventure(401, {"first_script": true}):
+	if not m.start_adventure(401):
 		Kit.check_quiet(false, "V12 前置：冒险启动")
 		return
 	var tier_n := {"common": 0, "excellent": 0, "rare": 0, "legendary": 0}
@@ -157,7 +157,7 @@ func check_v12(m, db) -> void:
 
 
 func check_v8(c, db) -> void:
-	if not c.start_adventure(203, {"first_script": true}):
+	if not c.start_adventure(203):
 		Kit.check_quiet(false, "V8 前置：冒险启动")
 		return
 	# 概率位与 cap 两属性独立：改 cap 不动牌库（概率位）、改牌库不动 cap 字段

game/tests/unit/core/save_manager_domain_test.gd

@@ -184,7 +184,7 @@ func _smoke_save() -> void:
 		"level_index": 2, "node_id": 5, "hero_hp": 13,
 		"bonus": {"atk": 2, "max_hp": 5, "armor_class": 1},
 		"gp": 17, "shop_purchased": {"hp_small": 2, "atk_small": 1},
-		"template_pick": 3,
+		"graph_gen_v2": 1,
 		"master_seed": 424242, "rng_counter": 38, "keystone": 6,
 		"visited_ids": [0, 2, 5],
 		"aux_items": [{"item_id": "aux_scout", "source_class": "reward_node",
@@ -205,7 +205,7 @@ func _smoke_save() -> void:
 	var bp_shop: Dictionary = bp.get("shop_purchased", {})
 	Kit.check("断点七字段往返：商店已购档",
 		int(bp_shop.get("hp_small", -1)) == 2 and int(bp_shop.get("atk_small", -1)) == 1)
-	Kit.check("断点七字段往返：已抽模板", int(bp.get("template_pick", -1)) == 3)
+	Kit.check("断点七字段往返：生成图代差标记键", int(bp.get("graph_gen_v2", 0)) == 1)
 	Kit.check("断点附随件往返：主种子/计数器/钥石累计",
 		int(bp.get("master_seed", -1)) == 424242 and int(bp.get("rng_counter", -1)) == 38
 		and int(bp.get("keystone", -1)) == 6)
@@ -237,7 +237,7 @@ func _smoke_save() -> void:
 	fv2f.store_string(JSON.stringify({"version": 2, "meta": {"keystone_balance": 7},
 		"breakpoint": {"level_index": 1, "node_id": -1, "hero_hp": 40, "gp": 5,
 			"bonus": {"atk": 0, "max_hp": 0, "armor_class": 0}, "shop_purchased": {},
-			"template_pick": -1, "master_seed": 777, "rng_counter": 3, "keystone": 0,
+			"graph_gen_v2": 1, "master_seed": 777, "rng_counter": 3, "keystone": 0,
 			"visited_ids": []}}))
 	fv2f.close()
 	Kit.check("v2 旧档迁移 v3：断点域与 meta 域原样保留（缺新附随件=合法空态）",

game/tests/unit/data_config/table_structure_guard_test.gd

@@ -72,14 +72,6 @@ static func _errs_has_cross_field(errs: Array) -> bool:
 	return false
 
 
-# 该关 Boss 节点深度（单终点图的终点编号——数据驱动，禁写死坐标）
-func _boss_depth(level_index: int) -> int:
-	for n in _level_active_nodes(level_index):
-		if String(n.get("type", "")) == "boss":
-			return int(n.get("node_depth", -1))
-	return -1
-
-
 # 首遇带数据驱动定位（契约 8）：该 (L, battle, enemy_id) 的最低 depth_band，禁写死坐标数字
 func _first_encounter_band(level_index: int, enemy_id: String) -> int:
 	var best := -1
@@ -94,17 +86,6 @@ func _first_encounter_band(level_index: int, enemy_id: String) -> int:
 	return best
 
 
-# 模板感知取节点表（row.templates 非空取模板 0=现行固定图，保持既有断言语义）
-func _level_active_nodes(level_index: int) -> Array:
-	for row in _db.level.rows:
-		if int(row.level_index) == level_index:
-			var tpls: Array = row.get("templates", [])
-			if not tpls.is_empty():
-				return tpls[0].get("nodes", [])
-			return row.get("nodes", [])
-	return []
-
-
 # ① 冒险表（单行全局 Rule 4 豁免——建表与接线闸；TP0 令牌池：配额结构/件值对/池总量域检）
 func _smoke_adventure_table() -> void:
 	print("--- 冒险表（AdventureTable——令牌池行值单点：回血/配额/件值对/同调位）---")

game/tests/unit/presentation/level_map_info_fog_test.gd

@@ -29,7 +29,7 @@ func _run() -> void:
 	quit(Kit.finish("level_map_info_fog_test"))
 
 
-# 白盒 runner：夹具行集注入 db.level ＋ level_row，入口停点态（node_index=-1，候选=入边首节点）
+# 白盒 runner：夹具行集注入 db.level ＋ level_row，入口停点态（node_index=-1，候选=首层首节点句柄 1）
 func _runner(db, nodes: Array, candidates: Array, n: int = 2):
 	var t := LevelTableScript.new()
 	t.info_visible_layers = n
@@ -37,7 +37,6 @@ func _runner(db, nodes: Array, candidates: Array, n: int = 2):
 	db.level = t
 	var r = load("res://core/level_runner.gd").new(db, load("res://core/rng_service.gd").new())
 	r.level_row.assign({"level_index": 1, "display_name": "夹具关", "rest_heal_pct": 30, "nodes": nodes})
-	r._graph_mode = true
 	r.node_index = -1
 	r._candidates.assign(candidates)
 	return r
@@ -46,7 +45,7 @@ func _runner(db, nodes: Array, candidates: Array, n: int = 2):
 # ---- ① 范围外只见结构：雾下节点类型图标与文字均不绘制〔fv2〕----
 
 func _test_fog_hides_type() -> void:
-	var node := {"node_depth": 3, "type": "battle"}
+	var node := {"id": 3, "type": "battle", "depth": 3, "next": []}
 	var shown: Dictionary = ScreenScript.node_display(node, 2, [2], false, false)
 	Kit.check("可见集内节点：图标/类型文字均绘制〔fv2〕",
 		bool(shown["draw_icon"]) and bool(shown["draw_label"]))
@@ -60,24 +59,24 @@ func _test_fog_hides_type() -> void:
 
 func _test_boss_exempt_and_multi_boss() -> void:
 	var type_vis: Array = [1, 7, 9]   # 双 Boss 图：7/9 均在可见集
-	var boss_a: Dictionary = ScreenScript.node_display({"node_depth": 7, "type": "boss"}, 7, type_vis, false, false)
-	var boss_b: Dictionary = ScreenScript.node_display({"node_depth": 9, "type": "boss"}, 9, type_vis, false, false)
+	var boss_a: Dictionary = ScreenScript.node_display({"id": 7, "type": "boss", "depth": 7, "next": []}, 7, type_vis, false, false)
+	var boss_b: Dictionary = ScreenScript.node_display({"id": 9, "type": "boss", "depth": 9, "next": []}, 9, type_vis, false, false)
 	Kit.check("多终点：两个 Boss 节点均带 Boss 描边〔fv3〕",
 		bool(boss_a["boss_border"]) and bool(boss_b["boss_border"]))
 	Kit.check("Boss 不入雾：可见集与图标/文字三通道均在〔fv3〕",
 		bool(boss_a["draw_icon"]) and bool(boss_a["draw_label"]) and bool(boss_b["draw_icon"]))
-	var far_boss: Dictionary = ScreenScript.node_display({"node_depth": 9, "type": "boss"}, 9, [1], false, false)
+	var far_boss: Dictionary = ScreenScript.node_display({"id": 9, "type": "boss", "depth": 9, "next": []}, 9, [1], false, false)
 	Kit.check("Boss 豁免独立于可见集：不在 type_vis 的 Boss 仍出示类型〔fv3〕",
 		bool(far_boss["draw_icon"]) and bool(far_boss["draw_label"]))
-	var fogged_battle: Dictionary = ScreenScript.node_display({"node_depth": 5, "type": "battle"}, 5, type_vis, false, false)
+	var fogged_battle: Dictionary = ScreenScript.node_display({"id": 5, "type": "battle", "depth": 5, "next": []}, 5, type_vis, false, false)
 	Kit.check("Boss 豁免不扩散：雾下非 Boss 仍隐类型〔fv3〕", not bool(fogged_battle["draw_icon"]))
 
 
 # ---- ③ 节点内详情图上从不显示〔fv5〕----
 
 func _test_details_never_shown() -> void:
-	var plain := {"node_depth": 3, "type": "battle"}
-	var loaded := {"node_depth": 3, "type": "battle", "enemy_id": "goblin_secret", "reward_id": "reward_secret"}
+	var plain := {"id": 3, "type": "battle", "depth": 3, "next": [4]}
+	var loaded := {"id": 3, "type": "battle", "depth": 3, "next": [4], "enemy_id": "goblin_secret", "reward_id": "reward_secret"}
 	var a: Dictionary = ScreenScript.node_display(plain, 3, [3], false, true)
 	var b: Dictionary = ScreenScript.node_display(loaded, 3, [3], false, true)
 	var same := true
@@ -92,7 +91,7 @@ func _test_details_never_shown() -> void:
 # ---- ④ label_text 三态文案〔fv2〕----
 
 func _test_label_three_states() -> void:
-	var node := {"node_depth": 3, "type": "battle"}
+	var node := {"id": 3, "type": "battle", "depth": 3, "next": [4]}
 	Kit.check("当前位文案＝「当前位置」〔fv2〕",
 		String(ScreenScript.node_display(node, 3, [3], true, false)["label_text"]) == "当前位置")
 	Kit.check("候选文案＝「战斗 · 可选」〔fv2〕",
@@ -103,9 +102,10 @@ func _test_label_three_states() -> void:
 
 # ---- 大图（11 层×6 槽含双 Boss）画布拟合与布局包络〔fv8〕----
 
-# 大图夹具：编号按 12 层×6 槽构造，层 0 入口、末层双 Boss；含层 1 首节点→第 3 层节点的跨层跳边。
-# 跳边目标按 BFS 最短路径提前一层，其后继链随之提前——布局落 11 层（最大槽 7：
-# 跳边目标并入第 2 层槽组）。断言按布局实测取最大层/最大槽，画布公式与之同源。
+# 大图夹具：按 12 层×6 槽构造（id = 图内句柄 = 构造序号；depth 随构造序号严格前进——生成图连线铁律），
+# 层 0 入口、末层双 Boss（id 61/62，句柄互异、next 恒空）；含层 1 首节点→第 3 层节点的跨层长跳边。
+# 跳边目标按 BFS 最短路径提前一层，其后继链随之逐层提前（目标并入第 2 层槽组）——布局落 11 层。
+# 断言按布局实测取最大层/最大槽，画布公式与之同源。
 func _big_graph_nodes() -> Array:
 	var layers: Array = []
 	var total := 0
@@ -118,30 +118,25 @@ func _big_graph_nodes() -> Array:
 			total += 1
 		layers.append(ids)
 	var nodes: Array = []
-	var jump_from := -1
-	var jump_to := -1
 	for l in tiers:
 		for i in layers[l].size():
 			var nid: int = layers[l][i]
-			var n := {"node_depth": nid}
-			if l == 0:
-				n["type"] = "battle"
-				n["next"] = layers[1].duplicate()   # 入口扇出到全层（层宽 6）
-			elif l == tiers - 1:
-				n["type"] = "boss"
-				n["next"] = []
+			var t := "battle"
+			var next_ids: Array = []
+			if l == tiers - 1:
+				t = "boss"
+			elif l == 0:
+				next_ids = layers[1].duplicate()   # 入口扇出到全层（层宽 6）
 			else:
 				if i % 5 == 0:
-					n["type"] = "reward" if l % 2 == 0 else "rest"
-				else:
-					n["type"] = "battle"
+					t = "reward" if l % 2 == 0 else "rest"
 				var w2: int = layers[l + 1].size()
-				n["next"] = [layers[l + 1][i % w2], layers[l + 1][(i + 1) % w2]]
-			nodes.append(n)
-	jump_from = layers[1][0]
-	jump_to = layers[3][2]
+				next_ids = [layers[l + 1][i % w2], layers[l + 1][(i + 1) % w2]]
+			nodes.append({"id": nid, "type": t, "depth": nid, "next": next_ids})
+	var jump_from: int = layers[1][0]
+	var jump_to: int = layers[3][2]
 	for n in nodes:
-		if int(n["node_depth"]) == jump_from:
+		if int(n["id"]) == jump_from:
 			(n["next"] as Array).append(jump_to)
 			break
 	return nodes
@@ -188,9 +183,9 @@ func _test_big_graph_fit(db) -> void:
 	var boss_ids: Array = []
 	for node in nodes:
 		if String(node["type"]) == "boss":
-			boss_ids.append(int(node["node_depth"]))
+			boss_ids.append(int(node["id"]))
 	Kit.check("大图呈现：两个终点 Boss 均有描边标记〔fv8〕",
 		disp.has(boss_ids[0]) and disp.has(boss_ids[1])
 		and bool(disp[boss_ids[0]]["boss_border"]) and bool(disp[boss_ids[1]]["boss_border"]))
-	Kit.check("大图呈现：入口停点远处战斗节点（编号 32，层 6）类型入雾〔fv8〕", not bool(disp[32]["draw_icon"]))
+	Kit.check("大图呈现：入口停点远处战斗节点（句柄 32，层 6）类型入雾〔fv8〕", not bool(disp[32]["draw_icon"]))
 	screen.queue_free()