feedback1 integrate: WB bounty drafts follow the official R3/R9/R11 structures; special offers drawn as item cards

2026-10-03 06:32:02 +08:00
commit e3dedf3faa
@@ -1 +1 @@
-{"events":{"artifact_paid_1":{"id":"artifact_paid_1","choiceType":"EQUIP_FREE","effectType":"EQUIP","name":"机密商店","desc":"无需消耗资金，获得装备补给。","descRaw":"无需消耗资金，获得装备补给。","color":"#35d8b4","family":"shop","solo":false,"training":false},"artifact_paid_1_s":{"id":"artifact_paid_1_s","choiceType":"EQUIP_FREE","effectType":"EQUIP","name":"机密商店","desc":"无需消耗资金，获得装备补给。","descRaw":"无需消耗资金，获得装备补给。","color":"#f2bd3e","family":"shop","solo":true,"training":false},"artifact_paid_2":{"id":"artifact_paid_2","choiceType":"EQUIP_FREE","effectType":"EQUIP","name":"机密商店","desc":"无需消耗资金，获得装备补给。","descRaw":"无需消耗资金，获得装备补给。","color":"#35d8b4","family":"shop","solo":false,"training":false},"artifact_paid_2_s":{"id":"artifact_paid_2_s","choiceType":"EQUIP_FREE","effectType":"EQUIP","name":"机密商店","desc":"无需消耗资金，获得装备补给。","descRaw":"无需消耗资金，获得装备补给。","color":"#f2bd3e","family":"shop","solo":true,"training":false},"artifact_paid_3":{"id":"artifact_paid_3","choiceType":"EQUIP_FREE","effectType":"EQUIP","name":"机密商店","desc":"无需消耗资金，获得装备补给。","descRaw":"无需消耗资金，获得装备补给。","color":"#35d8b4","family":"shop","solo":false,"training":false},"artifact_paid_3_s":{"id":"artifact_paid_3_s","choiceType":"EQUIP_FREE","effectType":"EQUIP","name":"机密商店","desc":"无需消耗资金，获得装备补给。","descRaw":"无需消耗资金，获得装备补给。","color":"#f2bd3e","family":"shop","solo":true,"training":false},"artifact_paid_4":{"id":"artifact_paid_4","choiceType":"EQUIP_FREE","effectType":"EQUIP","name":"机密商店","desc":"无需消耗资金，获得装备补给。","descRaw":"无需消耗资金，获得装备补给。","color":"#35d8b4","family":"shop","solo":false,"training":false},"artifact_paid_4_s":{"id":"artifact_paid_4_s","choiceType":"EQUIP_FREE","effectType":"EQUIP","name":"机密商店","desc":"无需消耗资金，获得装备补给。","descRaw":"无需消耗资金，获得装备补给。","color":"#f2bd3e","family":"shop","solo":true,"training":false},"artifact_paid_5":{"id":"artifact_paid_5","choiceType":"EQUIP_FREE","effectType":"EQUIP","name":"机密商店","desc":"无需消耗资金，获得装备补给。","descRaw":"无需消耗资金，获得装备补给。","color":"#35d8b4","family":"shop","solo":false,"training":false},"artifact_paid_5_s":{"id":"artifact_paid_5_s","choiceType":"EQUIP_FREE","effectType":"EQUIP","name":"机密商店","desc":"无需消耗资金，获得装备补给。","descRaw":"无需消耗资金，获得装备补给。","color":"#f2bd3e","family":"shop","solo":true,"training":false},"bossInitial_1":{"id":"bossInitial_1","choiceType":"BOUNTY_HUNT","effectType":"ENEMY_GAIN","name":"悬赏决策","desc":"选定悬赏目标，获取额外奖励。","descRaw":"选定悬赏目标，获取额外奖励。","color":"#35d8b4","family":"bounty","solo":false,"training":false},"bossInitial_1_s":{"id":"bossInitial_1_s","choiceType":"BOUNTY_HUNT","effectType":"ENEMY_GAIN","name":"悬赏决策","desc":"选定悬赏目标，获取额外奖励。","descRaw":"选定悬赏目标，获取额外奖励。","color":"#35d8b4","family":"bounty","solo":true,"training":false},"bossInitial_2":{"id":"bossInitial_2","choiceType":"BOUNTY_HUNT","effectType":"ENEMY_GAIN","name":"悬赏决策","desc":"选定悬赏目标，获取额外奖励。","descRaw":"选定悬赏目标，获取额外奖励。","color":"#35d8b4","family":"bounty","solo":false,"training":false},"bossInitial_2_s":{"id":"bossInitial_2_s","choiceType":"BOUNTY_HUNT","effectType":"ENEMY_GAIN","name":"悬赏决策","desc":"选定悬赏目标，获取额外奖励。","descRaw":"选定悬赏目标，获取额外奖励。","color":"#35d8b4","family":"bounty","solo":true,"training":false},"bossInitial_3":{"id":"bossInitial_3","choiceType":"BOUNTY_HUNT","effectType":"ENEMY_GAIN","name":"悬赏决策","desc":"选定悬赏目标，获取额外奖励。","descRaw":"选定悬赏目标，获取额外奖励。","color":"#35d8b4","family":"bounty","solo":false,"training":false},"bossInitial_3_s":{"id":"bossInitial_3_s","choiceType":"BOUNTY_HUNT","effectType":"ENEMY_GAIN","name":"悬赏决策","desc":"选定悬赏目标，获取额外奖励。","descRaw":"选定悬赏目标，获取额外奖励。","color":"#35d8b4","family":"bounty","solo":true,"training":false},"bossInitial_4":{"id":"bossInitial_4","choiceType":"BOUNTY_HUNT","effectType":"ENEMY_GAIN","name":"悬赏决策","desc":"选定悬赏目标，获取额外奖励。","descRaw":"选定悬赏目标，获取额外奖励。","color":"#35d8b4","family":"bounty","solo":false,"training":false},"bossInitial_4_s":{"id":"bossInitial_4_s","choiceType":"BOUNTY_HUNT","effectType":"ENEMY_GAIN","name":"悬赏决策","desc":"Line truncated
+{"events":{"artifact_paid_1":{"id":"artifact_paid_1","choiceType":"EQUIP_FREE","effectType":"EQUIP","name":"机密商店","desc":"无需消耗资金，获得装备补给。","descRaw":"无需消耗资金，获得装备补给。","color":"#35d8b4","family":"shop","solo":false,"training":false},"artifact_paid_1_s":{"id":"artifact_paid_1_s","choiceType":"EQUIP_FREE","effectType":"EQUIP","name":"机密商店","desc":"无需消耗资金，获得装备补给。","descRaw":"无需消耗资金，获得装备补给。","color":"#f2bd3e","family":"shop","solo":true,"training":false},"artifact_paid_2":{"id":"artifact_paid_2","choiceType":"EQUIP_FREE","effectType":"EQUIP","name":"机密商店","desc":"无需消耗资金，获得装备补给。","descRaw":"无需消耗资金，获得装备补给。","color":"#35d8b4","family":"shop","solo":false,"training":false},"artifact_paid_2_s":{"id":"artifact_paid_2_s","choiceType":"EQUIP_FREE","effectType":"EQUIP","name":"机密商店","desc":"无需消耗资金，获得装备补给。","descRaw":"无需消耗资金，获得装备补给。","color":"#f2bd3e","family":"shop","solo":true,"training":false},"artifact_paid_3":{"id":"artifact_paid_3","choiceType":"EQUIP_FREE","effectType":"EQUIP","name":"机密商店","desc":"无需消耗资金，获得装备补给。","descRaw":"无需消耗资金，获得装备补给。","color":"#35d8b4","family":"shop","solo":false,"training":false},"artifact_paid_3_s":{"id":"artifact_paid_3_s","choiceType":"EQUIP_FREE","effectType":"EQUIP","name":"机密商店","desc":"无需消耗资金，获得装备补给。","descRaw":"无需消耗资金，获得装备补给。","color":"#f2bd3e","family":"shop","solo":true,"training":false},"artifact_paid_4":{"id":"artifact_paid_4","choiceType":"EQUIP_FREE","effectType":"EQUIP","name":"机密商店","desc":"无需消耗资金，获得装备补给。","descRaw":"无需消耗资金，获得装备补给。","color":"#35d8b4","family":"shop","solo":false,"training":false},"artifact_paid_4_s":{"id":"artifact_paid_4_s","choiceType":"EQUIP_FREE","effectType":"EQUIP","name":"机密商店","desc":"无需消耗资金，获得装备补给。","descRaw":"无需消耗资金，获得装备补给。","color":"#f2bd3e","family":"shop","solo":true,"training":false},"artifact_paid_5":{"id":"artifact_paid_5","choiceType":"EQUIP_FREE","effectType":"EQUIP","name":"机密商店","desc":"无需消耗资金，获得装备补给。","descRaw":"无需消耗资金，获得装备补给。","color":"#35d8b4","family":"shop","solo":false,"training":false},"artifact_paid_5_s":{"id":"artifact_paid_5_s","choiceType":"EQUIP_FREE","effectType":"EQUIP","name":"机密商店","desc":"无需消耗资金，获得装备补给。","descRaw":"无需消耗资金，获得装备补给。","color":"#f2bd3e","family":"shop","solo":true,"training":false},"bossInitial_1":{"id":"bossInitial_1","choiceType":"BOUNTY_HUNT","effectType":"ENEMY_GAIN","name":"悬赏决策","desc":"选定悬赏目标，获取额外奖励。","descRaw":"选定悬赏目标，获取额外奖励。","color":"#35d8b4","family":"bounty","solo":false,"training":false},"bossInitial_1_s":{"id":"bossInitial_1_s","choiceType":"BOUNTY_HUNT","effectType":"ENEMY_GAIN","name":"悬赏决策","desc":"选定悬赏目标，获取额外奖励。","descRaw":"选定悬赏目标，获取额外奖励。","color":"#35d8b4","family":"bounty","solo":true,"training":false},"bossInitial_2":{"id":"bossInitial_2","choiceType":"BOUNTY_HUNT","effectType":"ENEMY_GAIN","name":"悬赏决策","desc":"选定悬赏目标，获取额外奖励。","descRaw":"选定悬赏目标，获取额外奖励。","color":"#35d8b4","family":"bounty","solo":false,"training":false},"bossInitial_2_s":{"id":"bossInitial_2_s","choiceType":"BOUNTY_HUNT","effectType":"ENEMY_GAIN","name":"悬赏决策","desc":"选定悬赏目标，获取额外奖励。","descRaw":"选定悬赏目标，获取额外奖励。","color":"#35d8b4","family":"bounty","solo":true,"training":false},"bossInitial_3":{"id":"bossInitial_3","choiceType":"BOUNTY_HUNT","effectType":"ENEMY_GAIN","name":"悬赏决策","desc":"选定悬赏目标，获取额外奖励。","descRaw":"选定悬赏目标，获取额外奖励。","color":"#35d8b4","family":"bounty","solo":false,"training":false},"bossInitial_3_s":{"id":"bossInitial_3_s","choiceType":"BOUNTY_HUNT","effectType":"ENEMY_GAIN","name":"悬赏决策","desc":"选定悬赏目标，获取额外奖励。","descRaw":"选定悬赏目标，获取额外奖励。","color":"#35d8b4","family":"bounty","solo":true,"training":false},"bossInitial_4":{"id":"bossInitial_4","choiceType":"BOUNTY_HUNT","effectType":"ENEMY_GAIN","name":"悬赏决策","desc":"选定悬赏目标，获取额外奖励。","descRaw":"选定悬赏目标，获取额外奖励。","color":"#35d8b4","family":"bounty","solo":false,"training":false},"bossInitial_4_s":{"id":"bossInitial_4_s","choiceType":"BOUNTY_HUNT","effectType":"ENEMY_GAIN","name":"悬赏决策","desc":"Line truncated
@@ -319,9 +319,10 @@ Types: `BAND_INITIAL` 41, `BOND` 23, `EQUIP` 115, `ENEMY_GAIN` 129 (悬赏), `BU
 | `events[id]` | `{"id":"enemy_initial_1","choiceType":"BOUNTY_HUNT","effectType":"ENEMY_GAIN","name":"悬赏决策","desc":"…","color":"#35d8b4","family":"bounty","solo":false,"training":false}` | 109 official choice events; `_s` = solo copies; `usedBy` on events opened by items (`hunter_band_1` ← 教鞭 / “神秘顾客”) |
 | `families` | `{"bounty":{"name":"悬赏决策",…},"supply":{…},"shop":{…},"tactic":{…}}` | 悬赏决策 / 道具补给 / 机密商店 / 战术决策 |
 | `format` | `{"multi":{"cards":6,"pickOrder":"random","firstPickSec":30,"otherPickSec":16,"onTimeout":"autoPickRandom","eachPlayerPicks":1},"solo":{"cards":3,"timer":null},"opensAfterIncome":true}` | |
-| `cards.bounty[]` | `{"effectId":"enemyeffect_10_4","name":"悬赏·飞行I","tier":1,"coin":1,"payout":"kill","rounds":2,"multiRound":false,"enemyKey":"enemy_1005_yokai","count":1,"adds":[…],"draft":true,"draftExcluded":null}` | `payout` `kill` (killer gets coins, 联防 helpers too) / `perfect` (chooser's own phase perfect); `rounds` = battles affected (99 = all remaining); `tier` from the I/II/III suffix (else coin value); `draft` = offered by the 悬赏决策 draft — the PRTS 下半 记录 §机变阶段 "敌人轮选" table (105 cards: 1- and 2-battle kill bounties, 源石虫·特训, the 7 multi-round cards); else `draftExcluded` `perfect` (战术特训: "仅由法术教鞭生成" — the 教鞭 Art's cards; 20) / `hidden` (鸭爵 / 高普尼克 / 流泪小子 / 圆仔, commented out of the table; 4) — build-data `bountyDraftExclusion`, `server/match/choices.js draftBounty`, user playtest #6 item 4 |
+| `cards.bounty[]` | `{"effectId":"enemyeffect_10_4","name":"悬赏·飞行I","tier":1,"coin":1,"payout":"kill","rounds":2,"multiRound":false,"enemyKey":"enemy_1005_yokai","count":1,"adds":[…],"draft":true,"draftExcluded":null,"draftPool":"initial","series":10}` | `payout` `kill` (killer gets coins, 联防 helpers too) / `perfect` (chooser's own phase perfect); `rounds` = battles affected (99 = all remaining); `tier` from the I/II/III suffix (else coin value); `enemyKey` = the effect's `enemy_id` (fixed per card; the title only names category and tier); `draft` = offered by a 悬赏决策 draft (86 cards); else `draftExcluded` `perfect` (战术特训: "仅由法术教鞭生成" — the 教鞭 Art's cards; 20) / `hidden` (鸭爵 / 高普尼克 / 流泪小子 / 圆仔; 4) / `unseen` (in none of the 27 official bounty drafts of the user's 33 screenshots: the 7 multi-round cards, enemyeffect_3_*, the boss bounties of no seen R9 group; 19, [ASSUMED] not offered) — build-data `bountyDraftExclusion`, `server/match/choices.js draftBounty`, user playtest #6 item 4, player feedback after 0.1.0 report #2; `draftPool` = the kind of draft that offers it: `initial` (R3: the 42 "接下来两场作战" cards), `boss` (R9: 19 boss bounties + 源石虫·特训), `hunter` (R11: the faction _7 / _8 and 特异 series 16 "下场战斗" cards, 24), null when not drafted; `series` = N of `enemyeffect_N_M` (null otherwise) |
 | `cards.tactic[]` | `{"effectId":"map_m01_1","name":"模拟战场演变·模式一","kind":"terrain","stageId":"act1autochess_m01","team":false}` | `kind` `ally` / `enemyDebuff` / `terrain` (only for the match stage); `team` = also given to teammates |
-| `schedule[modeId]` | `{"spRounds":[3,6,9],"rounds":{"3":{"families":[{"family":"bounty","weight":50},…],"cards":6,"supplyTiers":[1,4],"bountyTiers":[1,2],"events":{"bounty":[…],"supply":[…],"shop":[…],"tactic":[…]},"assumed":true}}}` | research 01 A4 defaults: pick a family by weight; `supplyTiers` = item tier window for 道具补给; 机密商店 draws any tier; `events` = official event ids usable as the phase header |
+| `bountyDrafts[kind]` | `{"initial":{"events":[…],"slots":10,"sets":[{"cards":[…6],"seen":[1,3,5,9]},…],"mixed":{"series":[10,11,12,13,14,15,20],"count":6,"tiers":[1,1,1,2,2,3]},"count":6},"boss":{"events":[…],"templates":[{"featured":[…],"fill":[…],"seen":[1,5]},…],"count":6},"hunter":{"events":[…],"slots":15,"templates":[{"featured":[…],"fill":[…],"seen":[1,6]},…],"rule":{"giants":[…],"groupCards":[…],"groupSizes":[1,2,3,4],"fill":[…]},"onePerSeries":[10,…,15],"count":6}}` | the official 悬赏决策 structures, read from 33 screenshots of 11 official co-op 绝境 / 终极 matches (player feedback after 0.1.0 report #2; build-data `BOUNTY_INITIAL_SETS`, readings in `test/fixtures/official-bounty-drafts.json`, `seen` = its match numbers): `initial` = one of `slots` fixed sets, the seen `sets` or for an unseen slot `mixed` (one card from each of `count` of `series`, with `tiers`) [ASSUMED]; `boss` = a `templates` entry: its `featured` bosses + `fill` drawn to 6 (uniform among the seen groups [ASSUMED]); `hunter` = one of `slots` events: a seen `templates` group — its `featured` 特异III giant + tier-II cards, always together (matches 1 and 6 share the whole group, only the tier-I card differs) — or for an unseen slot a `rule` group (one of `giants` + `groupSizes` of `groupCards`), then tier-I `fill` to 6, at most one card per `onePerSeries` series (the group / fill split by tier, the unseen slots and the uniform pick among the events [ASSUMED]) |
+| `schedule[modeId]` | `{"spRounds":[3,6,9],"rounds":{"3":{"families":[{"family":"bounty","weight":50},…],"cards":6,"supplyTiers":[1,4],"bountyDraft":"initial","events":{"bounty":[…],"supply":[…],"shop":[…],"tactic":[…]},"assumed":true}}}` | research 01 A4 defaults: pick a family by weight; `supplyTiers` = item tier window for 道具补给; 机密商店 draws any tier; `bountyDraft` = the `bountyDrafts` kind of the round's 悬赏决策 (R3 / 险境 R6 `initial`, R9 `boss`, R11 `hunter`); 绝境 / 终极 R11 = 悬赏决策 45 / 机密商店 35 / 战术决策 20 (the official co-op R11s: 5 / 4 / 2 of 11, no 道具补给; weights [ASSUMED]; solo takes the same weights [ASSUMED: no solo screenshot — extrapolated from co-op, the data has solo R11 悬赏决策 events `bounty_hunter_*_s`]); `events` = the official event ids of that kind (`enemy_initial_*`, `bossInitial_*`, `bounty_hunter_*`), usable as the phase header |
 | `pools[poolId]` | `{"kind":"equip","items":[…]}` / `{"kind":"chess","tier":2,"rule":"shopEligible"}` | server-side reward pools referenced by effects (`pool_equip_*`, `pool_chess_shop_N_reward`, `pool_char_later`, …), all [ASSUMED]; `rule:"shopEligible"` = visible/non-hidden entries, `maxTier:"shopLevel"` = ≤ current shop level, `weighted` = `[[id, weight]]`. `pool_equip_vict` (维多利亚, every 25 layers: "获得一件带有随机特殊效果的维式重锤") and `pool_equip_rockr` (洛洛's 定制品; user playtest #4 — the research 04 §8 guess 有限加速器 / 激光发射器 / 护盾无人机 / 双模机械臂 / 蜂鸣器 is superseded) = the 4 special 维式重锤, uniform |

 ## 9. `enemies.json` — `{ [enemyKey]: Enemy }` (249 keys that can appear)
@@ -107,15 +107,30 @@ untimed. The UI picks a card with two taps (select → 确认选择, DESIGN §18
 the mode's static `inactiveBondIds` — 标准 has no 拉特兰 / 阿戈尔 / 卡西米尔 / 奥术 … — and with chess in the pool), so
 玛恩纳的盟誓 / 莫斯提马的盟誓 / 卡西米尔驰援 never show up in 标准. Card generation and the
 family defaults are documented in `choices.js` (bounty / supply / shop / tactic). 机密商店 cards are **free** (official
-text "无需消耗资金"). 悬赏决策 offers only choices.json cards with `draft: true` (`choices.js draftBounty`, user playtest #6
-item 4): the PRTS table 卫戍协议：盟约 下半/PRTS盟约记录 §机变阶段 "敌人轮选" — kill bounties for the next battle ("下场作战")
-or the next two ("接下来两场作战"), 源石虫·特训, and the 7 multi-round cards ("之后 / 后续的每场作战"), but never 战术特训
-(listed under "※以下悬赏任务仅由法术教鞭生成") nor the 鸭爵 / 高普尼克 / 流泪小子 / 圆仔 cards (commented out of the table) —
-105 cards, drawn uniformly. Every bounty card carries the effect's official rich text `descRaw` (the battles in blue
+text "无需消耗资金"). 悬赏决策 offers only choices.json cards with `draft: true` (`choices.js draftBounty`): never 战术特训 (PRTS
+"※以下悬赏任务仅由法术教鞭生成") nor the 鸭爵 / 高普尼克 / 流泪小子 / 圆仔 cards (user playtest #6 item 4). **Each draft is
+built like the official one of its round** (`choices.js bountyDraftCards`, choices.json `bountyDrafts` / schedule
+`bountyDraft`; player feedback after 0.1.0, report #2 — late bounty enemies in the early drafts — settled by 33
+screenshots of 11 official co-op 绝境 / 终极 matches, readings in `test/fixtures/official-bounty-drafts.json`): **R3**
+one of the 10 official sets of six "接下来两场作战" cards, 3 × I + 2 × II + 1 × III — 7 seen (a whole series 17 / 18 / 19,
+or one card from each of 6 of the series 10–15 / 20), the 3 unseen slots built by that rule [ASSUMED]; **R9** boss
+bounties + 源石虫·特训: a seen group of 0–3 named bosses that always come together, filled to 6 with the cheap ones (W /
+碎骨 / 弑君者, 大鲍勃, 庞贝 or 鼠王, 源石虫·特训) — 7 groups for 6 events: two game versions or a group set per match
+(leader, map), open; **R11** (绝境 / 终极 co-op: 悬赏决策, 机密商店 or 战术决策, never 道具补给; solo the same weights
+[ASSUMED]) six "下场战斗" cards like R9: a group — one 特异III giant + 1–4 tier-II cards, always together (matches 1 and 6
+share the whole group, only the tier-I card differs) — filled to 6 with tier-I cards, at most one per faction series;
+4 groups seen for the 15 events, the unseen slots draw a group of that shape [ASSUMED]. 险境 R6 drafts like R3
+[ASSUMED]. A card's enemy is fixed by its effect (`enemy_id`): the title only names category and tier (悬赏·损伤I =
+底海滑动者 or 临时收音师).
+No official draft showed a multi-round card, a pre-series card (enemyeffect_3_*) or the boss bounties 凋零骑士 / “遗弃者”
+/ 锏 / 扎罗 / 迷路的巨像: `draftExcluded: 'unseen'` [ASSUMED], flipped by adding them to build-data
+`BOUNTY_INITIAL_SETS` / `BOUNTY_BOSS_TEMPLATES` / `BOUNTY_HUNTER_TEMPLATES` once a screenshot shows one. The card positions are shuffled; solo
+shows 3 of the 6 [ASSUMED]. The mode's inactive enemy list does not thin the draft (PRTS
+11/18 note "不影响悬赏决策出场"). Every bounty card carries the effect's official rich text `descRaw` (the battles in blue
 "下场作战" / "两场作战"; the overlay and the effects column render it; the effects column also says "还剩 N 场作战").
 **Multi-round cards last two battles** (`choices.js MULTI_ROUND_BOUNTY_BATTLES = 2`, `bountyBattles` / `bountyText`): the
 user does not remember any multi-round bounty (playtest #6 answer, "我不记得有过多轮悬赏"), so until that is confirmed
-otherwise every "之后 / 后续的每场作战" card — drafted, from 教鞭 or “神秘顾客” — lasts two battles exactly like the
+otherwise every "之后 / 后续的每场作战" card — e.g. 教鞭's 法术大师A2·多轮战术特训 — lasts two battles exactly like the
 "接下来两场作战" cards, and its card and effects text read "接下来两场作战" in the same blue (还剩 N 场作战).
 `MULTI_ROUND_BOUNTY_BATTLES = null` restores the official red "每场" (every later battle; effects column
 "之后的每场作战"). The 战术特训 cards are what the 教鞭 Art offers (§2.5).
@@ -308,8 +323,8 @@ Writes (all validated, never throw on bad input, never make funds / pools negati
 | `modifyPrice(delta)` / `setPrice(v)` | onPrice only: edit `ev.price` |
 | `promote(uid)` / `transform(uid, chessId)` / `upgradeItem(uid)` | elite in place / replace a chess (keeps tile) / item → golden |
 | `destroyPiece(uid)` / `equipDirect(itemUid, chessUid)` | remove a piece (chess copies return, items go back) / attach without equip effects |
-| `offerChess(ids, { tier })` | queue a pick-one offer (shown as `shop.rewardOffer`, free) — 寻呼模块 / 信标 style |
-| `offerItems(ids, { tier })` | the same for items (slots of kind `'item'`) — 凯瑟琳 定向投放 style |
+| `offerChess(ids, { tier, label })` | queue a pick-one offer (shown as `shop.rewardOffer`, free) — 寻呼模块 / 信标 style; `label` (default `effectsMeta.offerLabel(source)`: the strategy's effect name, the item's name or the 特质's operator) is the shop bar's header instead of 晋升奖励 (`rewardOffer.source` `'special'`; the promotion reward is `'merge'`) |
+| `offerItems(ids, { tier, label })` | the same for items (slots of kind `'item'`, drawn as item cards) — 凯瑟琳 定向投放 style (player report #6 after 0.1.0) |
 | `triggerGarrisons(uid, eventType, { asUid })` | run another owned chess's 特质 of that eventType now (铃兰 "触发…的获得时效果"); 投资人 still multiplies SERVER_GAIN; SERVER_PRICE cannot be triggered; depth-capped |
 | `setShopSlot(i, { kind, id, price?, frozen? } \| null)` | rewrite a shop slot (special refreshes) |
 | `addDeployCap(n)` / `setDeployCapAtLeast(n)` | deploy cap (+effects; 人事部文档 = 9) |
@@ -411,7 +426,7 @@ Any `choice:` handler whose EffectRef reuses its own key must guard like this (o
  consumed copies are removed; a reward offer of 3
  **different** free chess of tier min(level+1, 6) (copy-weighted from the shared pool, already-drawn ones excluded; a
  short tier tops up from the tier below — user playtest #6 item 19; pick 1, expires at prep end; queued when several
-  merges happen). The same rule holds for every way a merge completes — buy, reward pick, effect / band / choice grants
+  merges or special refreshes happen — `shop.rewardOffer.queued` counts the ones behind the shown offer). The same rule holds for every way a merge completes — buy, reward pick, effect / band / choice grants
  (`acquireChess`), transformations — and in every phase: a merge completed after the prep (SETTLE / Final Assault
  effects such as 突变细胞) keeps its offer for the next prep; its elite takes the deployed copy's tile at once, or goes to
  the hand / temp (kept through the next prep, see Hand). In a boss round's prep the tile is read on the player's half of
@@ -16,7 +16,7 @@
 |---|---|
 | 确认本局信息 | 本局地图（标准模拟固定为「战场#01」；险境从 8 张地图中随机，绝境 / 终极从不含战场#01 的 7 张中随机）、敌方派系、**被禁用的盟约及其干员**、领袖预告。所有人确认后继续；同盟模拟最多 25 秒；只有你一名玩家时（独立模拟，或同盟模拟只带 AI 队友）不限时。 |
 | 选择策略 | 40 名策略（分队长）决定**初始目标生命值（20–45）**和一条永久规则。同盟：随机顺序轮流选，**每人 30 秒**，右上角和「决策中」显示同一个倒计时；AI 队友立即选完；队友已选的不能重复，每人可**跳过一次**（排到最后）；超时自动选你**当前选中**的策略（已被队友选走则选华法琳）。独立：自由选择、不限时；同盟模拟只有你一名玩家时也不限时。 |
-| 机变 | 部分回合开始前出现：同盟共 6 张卡轮流各取 1 张（首位 30 秒，其余 16 秒；只有你一名玩家时不限时），独立 3 选 1。卡片包括装备、资金、干员、盟约层数、悬赏等；**悬赏决策**为你的作战添加悬赏敌人，卡上用蓝字标出持续多久：「下场作战」/「接下来两场作战」的只出现一场或两场，之后不再出现；官方的「多轮悬赏」（原文写「之后的每场作战」）在这里也按「接下来两场作战」处理，只出现两场。击倒它的人（联防中的队友也算）获得资金；右侧效果栏会写「还剩 N 场作战」。每张卡左上是图标和名称，下面写着完整效果（与详情卡相同的官方描述，手机上也显示）；已被选走的卡变暗，右上角显示选走它的玩家头像（悬停可看名字）。选卡要**点两次**：第一次只选中（金框 +「确认选择 · 再次点击」），再点同一张或点右上的「确认选择」才生效；点别的卡换选，按 Esc 或点空白处取消。 |
+| 机变 | 部分回合开始前出现：同盟共 6 张卡轮流各取 1 张（首位 30 秒，其余 16 秒；只有你一名玩家时不限时），独立 3 选 1。卡片包括装备、资金、干员、盟约层数、悬赏等；**悬赏决策**为你的作战添加悬赏敌人，卡上用蓝字标出持续多久：「下场作战」/「接下来两场作战」的只出现一场或两场，之后不再出现；官方的「多轮悬赏」（原文写「之后的每场作战」）在这里也按「接下来两场作战」处理，只出现两场（如教鞭的法术大师A2·多轮战术特训）。各回合的悬赏决策按官方对局截图来出：第 3 回合是 6 张「接下来两场作战」的悬赏（3 张 1 资金、2 张 2 资金、1 张 3 资金）；第 9 回合是各首领的「下场作战」悬赏和「源石虫·特训」；绝境 / 终极的第 11 回合是悬赏决策、机密商店或战术决策之一，其中的悬赏是 1 只特异巨兽加 5 张「下场战斗」悬赏。击倒它的人（联防中的队友也算）获得资金；右侧效果栏会写「还剩 N 场作战」。每张卡左上是图标和名称，下面写着完整效果（与详情卡相同的官方描述，手机上也显示）；已被选走的卡变暗，右上角显示选走它的玩家头像（悬停可看名字）。选卡要**点两次**：第一次只选中（金框 +「确认选择 · 再次点击」），再点同一张或点右上的「确认选择」才生效；点别的卡换选，按 Esc 或点空白处取消。 |
 | 休整期 | 购买、摆阵、配装备、冻结 / 刷新、升级调度中心；同盟有倒计时（65–215 秒，随回合增加）；独立模拟、以及只有你一名玩家（只带 AI 队友）的同盟模拟不限时。所有人「准备就绪」即提前开战，全员就绪前可取消。 |
 | 作战 | 每人在自己的战场各自作战（战斗在你的浏览器里模拟，2 倍速）。干员按**从上到下、从左到右**的顺序自动部署并消耗部署费用（初始 10，+1/秒）。时限 45–115 秒（实际秒数，即屏幕上的倒计时），时间到仍存活的敌人算漏怪。有敌人进入蓝门时，顶栏的目标生命值会**立即**显示扣除后的数值（红字 + 「−N」，每回合至多 10 点），结算时确定；联防阶段标注「联防中」，队友拦下的部分最后不扣。左侧队伍栏同样显示队友的待扣生命值。被击倒的干员**留在原地**（倒地姿势、略微变灰），头上的圆圈是再部署倒计时：绿色圆环 + 秒数；变成黄色「DP」表示部署费用不够，红色「!」表示原位被占。血条下方的一行是**元素损伤**（与原版一致：元素图标 + 白条）：干员为带图标的彩色圆盘，敌人为小号纯色圆盘，右侧白条是剩余元素值，像血条一样从右往左减少，白条耗尽的那一下就是爆条（被大额元素损伤一次打掉一截时白条也会一次少一截，例如掠海漂移体每击约为 25%–50%）；爆条后进入爆发冷却（灼燃 / 神经 / 侵蚀 10 秒，敌方侵蚀 8 秒，凋亡 15 秒），这时白条变成**元素颜色**（神经青绿、侵蚀蓝、灼燃橙红、凋亡灰紫）并在冷却期间慢慢回满、图标闪烁——彩色条表示已经爆条、正在承受爆发效果，不是还剩的元素值；期间所有元素都不会累积也无法被治疗，结束后清零。元素爆发造成的是**无来源伤害**，不吃干员的增伤、穿透和装备加成（例如深巡打海嗣时灼燃爆发固定 7000），击杀仍记在爆条的干员名下；元素脆弱只提高元素伤害，不加快元素条；脆弱不影响元素伤害。已被击杀的敌人不会再被附加元素损伤。 |
 | 联防 | 见第 5 节。 |
@@ -52,7 +52,7 @@

 ## 3. 招募、整备区与晋升

- **购买点两次**：第一次点商店卡片只选中（卡片抬起并打开详情，底部出现「确认购买 · 再次点击」），再点这张卡片的**任意位置**（包括金色的确认条）才购买；点别处或按 Esc 取消。升级调度中心、晋升奖励同样两次。不能购买时（例如已准备就绪）点卡片只打开详情。
+- **购买点两次**：第一次点商店卡片只选中（卡片抬起并打开详情，底部出现「确认购买 · 再次点击」），再点这张卡片的**任意位置**（包括金色的确认条）才购买；点别处或按 Esc 取消。升级调度中心、晋升奖励同样两次；策略或装备带来的免费挑选（如凯瑟琳【定向投放】升级后刷新的 3 件装备、娜仁图亚【见者有份】的 2 件装备、寻呼模块的 3 名干员）也一样出现在商店卡片的位置，左侧标题写着它的来源，装备显示为装备卡（图标、名称、说明、FREE），选 1 个免费获得；同时有多个免费挑选时依次出现，标题下和「稍后」后的提示按钮会写还有几项（如「+1」）。不能购买时（例如已准备就绪）点卡片只打开详情。
 - **公共卡池**（同盟）：每名干员的副本数有限，I–VI 阶分别 12 / 14 / 18 / 16 / 8 / 5 份，所有玩家共用；持有的干员（棋盘 + 整备区）占用副本，商店里展示的不占用。一名干员被大家拿光后就刷不出来了；淘汰玩家的干员会还回卡池。
 - **位置上限**：棋盘最多部署 **8** 名；整备区 **10** 格；整备区满时新获得的单位（合成的精锐、奖励、退回的装备等）进入**临时整备区**（整备区前面的 5 格）。临时整备区有单位时**不能准备就绪**，棋盘上会用红色虚线框标出这一排并说明规则：把它们放进整备区或战场、配发或使用，或者出售 / 销毁。休整期中进入临时整备区的单位，若到**本休整期结束**时仍留在那里就会被自动处理（干员返还卡池、装备销毁）；作战、结算期间或准备就绪之后才进入的（例如战斗奖励、结算时合成的精锐），会保留到**下一个休整期**结束，你一定有机会处理它们。
 - **晋升精锐**：3 名同名干员（无论是否部署）自动合成**精锐**（等级、技能、模组大幅提升；风丸只需 2 名），精锐不会再合成。如果被合成的干员里有**已经部署在战场上**的，精锐会直接出现在**那名干员的位置**（保持原来的朝向，不多占部署位；有两三名都在场上时，取最先部署的那名——从上到下、从左到右）；否则精锐进入整备区（满了进入临时整备区）。原先配发的装备都退回整备区，需要重新配发；被合成干员的召唤物随之移除，场上的精锐会把自己的召唤物送进整备区。点选一张能合成的商店卡片时，精锐将出现的那一格会亮起金色边框，同时打开的详情卡里也会写明去向（「可晋升：精锐干员将出现在作战区原位置 / 将进入整备区」；详情卡会自动停靠在不遮挡这一格的一侧）。在回合开始或结算时因策略、奖励等完成的合成，精锐出现时同样会播放金色的晋升特效。
@@ -187,6 +187,7 @@
 .rwtag__title { writing-mode: vertical-rl; font-size: .22rem; font-weight: 900; letter-spacing: .2em; line-height: 1; }
 .rwtag__micro { font-family: var(--font-display); font-size: .09rem; letter-spacing: .14em; opacity: .75; }
 .rwtag__sub { font-size: .12rem; color: var(--text-md); line-height: 1.3; }
+.rwtag__more { color: var(--gold); }
 .rwtag__later { display: flex; align-items: center; gap: .02rem; margin-top: .04rem; padding: .02rem .08rem; font-size: .13rem; color: var(--text-lo);
  background: rgba(0, 0, 0, .35); border: 1px solid var(--line-2); }
 .rwtag__later .icon { width: .12rem; height: .12rem; }
@@ -200,6 +201,7 @@
  animation: pulse-gold 1.6s ease-in-out infinite;
 }
 .rewardpill .icon { width: .2rem; height: .2rem; }
+.rewardpill__more { padding: 0 .06rem; border: 1px solid var(--gold); font-size: .13rem; line-height: 1.4; }
@keyframes pulse-gold { 50% { box-shadow: 0 0 .24rem rgba(255, 198, 0, .5); } }

 /* ---- two-tap buy / upgrade (research 09 §5): the first tap lifts + enlarges the card and shows 确认购买 ---- */
@@ -559,9 +559,10 @@ function MatchScreen() {
  const spMine = !!sp && !solo && sp.turnPid === myId && !sp.pickOf.has(myId);
  useEffect(() => { if (spMine) audio.sfx('yourTurn'); }, [spMine]);

-  // promotion (merge reward offered) and bond activation cues
-  const hasOffer = !!priv?.shop?.rewardOffer;
-  useEffect(() => { if (hasOffer) audio.sfx('merge'); }, [hasOffer]);
+  // promotion (merge reward offered) and bond activation cues; a special refresh's offer (凯瑟琳 定向投放 …) plays the
+  // shop's refresh sound instead of the promotion cue
+  const offerCue = priv?.shop?.rewardOffer ? (priv.shop.rewardOffer.source === 'special' ? 'refresh' : 'merge') : null;
+  useEffect(() => { if (offerCue) audio.sfx(offerCue); }, [offerCue]);
  // a shop / reward card armed for a purchase that completes a merge lights the tile its elite will take (the deployed
  // copy that deploys first — PRTS 卫戍协议/帮助 "若消耗已部署至作战区的干员，则发送至作战区对应位置", gameLogic.mergeTarget)
  const mergeAt = armedCard?.kind === 'chess' && editable && showPrep ? mergeTarget(priv, armedCard.id, gd.chess) : null;
@@ -538,6 +538,29 @@ export function completesMerge(priv, slot, { getChess = () => null, getItem = ()
  return need > 1 && copies + 1 >= need;
 }

+/**
+ * How the shop bar names a free pick-one offer (m.private shop.rewardOffer): the promotion reward (`source` 'merge')
+ * reads 晋升奖励 / PROMOTION; any other offer — a strategy's special refresh (凯瑟琳 定向投放, 娜仁图亚 见者有份), an item
+ * (寻呼模块, 信标) or a 特质 (松果) — reads its `label` with the refresh icon (player report #6 after 0.1.0: 凯瑟琳's three
+ * items showed up as nameless operator cards under 晋升奖励). `items` = the offer holds items (cards drawn as item cards).
+ * `queued` = offers waiting behind this one (shop.rewardOffer.queued, e.g. a 定向投放 behind a promotion reward put
+ * off): `more` (header) and the pill's "+N" say so, null / no suffix when none.
+ * @param {any} offer
+ * @returns {{ title: string, micro: string, sub: string, icon: string, items: boolean, pill: string, queued: number, more: string|null }}
+ */
+export function offerHeader(offer) {
+  const slots = isObj(offer) && Array.isArray(offer.slots) ? offer.slots : [];
+  const items = slots.some((s) => isObj(s) && s.kind === 'item');
+  const label = isObj(offer) && typeof offer.label === 'string' && offer.label ? offer.label : null;
+  const queued = isObj(offer) && Number.isInteger(offer.queued) && offer.queued > 0 ? offer.queued : 0;
+  const tail = { queued, more: queued ? `之后还有 ${queued} 项` : null };
+  if (!items && (!isObj(offer) || offer.source === 'merge' || offer.source == null) && !label) {
+    return { title: '晋升奖励', micro: 'PROMOTION', sub: '免费选择 1 名', icon: 'crown', items: false, pill: '晋升奖励待选择', ...tail };
+  }
+  const title = label || (items ? '装备补给' : '特殊招募');
+  return { title, micro: 'SPECIAL', sub: items ? '免费选择 1 件' : '免费选择 1 名', icon: 'refresh', items, pill: `${title}待选择`, ...tail };
+}
+
 /**
 * Why a shop action is unavailable (null when available).
 * @param {'buy'|'reward'|'refresh'|'freeze'|'levelUp'|'ready'} kind
@@ -1,9 +1,12 @@
-// Merge reward reminder (research 00 §3): the reward cards themselves live in the shop bar (shopBar.js RewardCards —
-// after a promotion they replace the bar's operator cards, like the original). When the player puts the pick off
-// (稍后选择) this pill above the bar brings the cards back; it disappears once the server clears `shop.rewardOffer`
-// (picked, or the round ended).
+// Pick-one offer reminder (research 00 §3): the offer's cards themselves live in the shop bar (shopBar.js RewardCards —
+// after a promotion, or a special refresh such as 凯瑟琳's 定向投放, they replace the bar's operator cards, like the
+// original). When the player puts the pick off (稍后选择) this pill above the bar brings the cards back; it names the
+// offer like the bar's header (gameLogic.offerHeader: 晋升奖励待选择 / 定向投放待选择 …, player report #6 after 0.1.0), with
+// "+N" while N more offers wait behind it, and disappears once the server clears `shop.rewardOffer` (picked, or the
+// round ended).

 import { html, Icon, TierChip } from './components.js';
+import { offerHeader } from './gameLogic.js';

 /**
 * @param {{ priv:any, minimized:boolean, onMinimize:(m:boolean)=>void }} props
@@ -11,7 +14,8 @@ import { html, Icon, TierChip } from './components.js';
 export function RewardOverlay({ priv, minimized, onMinimize }) {
  const offer = priv?.shop?.rewardOffer;
  if (!offer || !Array.isArray(offer.slots) || !offer.slots.length || !minimized) return null;
+  const head = offerHeader(offer);
  return html`<button type="button" class="rewardpill" onClick=${() => onMinimize(false)}>
-    <${Icon} name="crown" /><span>晋升奖励待选择</span><${TierChip} tier=${offer.tier || 1} size="sm" />
+    <${Icon} name=${head.icon} /><span>${head.pill}</span>${Number.isInteger(offer.tier) ? html`<${TierChip} tier=${offer.tier} size="sm" />` : null}${head.queued ? html`<span class="rewardpill__more" title=${head.more}>+${head.queued}</span>` : null}
  </button>`;
 }
@@ -11,7 +11,9 @@
 // detail); a card that cannot be bought right now (the bar is not editable: ready, round start) opens its detail. The
 // D / R / F keys stay one-press shortcuts. There is no drag-to-sell zone: selling is the 出售 +N button of a tapped
 // unit's underframe (ui/underframe.js). After a promotion the operator cards are replaced by
-// the 晋升奖励 cards (3 free operators, pick 1 — also two taps) until picked or put off (稍后 → rewardOverlay.js pill).
+// the 晋升奖励 cards (3 free operators, pick 1 — also two taps) until picked or put off (稍后 → rewardOverlay.js pill);
+// a special refresh (凯瑟琳 定向投放's 3 items, 娜仁图亚, 寻呼模块, 信标, 松果) takes the same place under its own name, an
+// item slot drawn as an item card (player report #6 after 0.1.0).
 // Every operator card shows the skill it will fight with — the player's 干员调配 loadout (m.private.loadout, DESIGN
 // §16): the skill icon above the name, mint-framed with 已调配 in its title when it is not the default skill (and the
 // module type of an elite card, with its official type icon when the local-client art has it).
@@ -19,7 +21,7 @@
 import { useEffect, useState } from '../../vendor/hooks.module.js';
 import { html, Icon, HexBadge, TierChip, Tooltip, MicroLabel } from './components.js';
 import { Img, BondGlyph, CoinGlyph, GIcon, RichText } from './gameComponents.js';
-import { priceTone, mergeProgress, mergeTarget, shopBlockReason, chessLoadout } from './gameLogic.js';
+import { priceTone, mergeProgress, mergeTarget, shopBlockReason, chessLoadout, offerHeader } from './gameLogic.js';
 import { chessPortraitUrl, itemIconUrl, profIconUrl, uiUrl, skillIconUrl, skillRecordIconUrl, moduleTypeIconUrl } from './assetUrls.js';
 import { data } from '../data.js';

@@ -120,7 +122,7 @@ function SkillBadge({ chess, lo }) {
 * @param {{ slot:any, idx:number, frozen?:boolean, reason?:string|null, armed?:boolean, onTap?:(idx:number)=>void,
 *   onBuy:Function, onDetail:Function }} props
 */
-export function ItemCard({ slot, idx, frozen = false, reason = null, armed = false, onTap = null, onBuy, onDetail }) {
+export function ItemCard({ slot, idx, frozen = false, reason = null, free = false, armed = false, onTap = null, onBuy, onDetail }) {
  const it = data.lookup('items', slot.id);
  const m = data.get('assets');
  const disabled = !!reason;
@@ -132,7 +134,7 @@ export function ItemCard({ slot, idx, frozen = false, reason = null, armed = fal
    <span class="scard__bg" aria-hidden="true"></span>
    <span class="scard__top">
      <${TierChip} tier=${it?.tier ?? 1} size="md" />
-      <${PriceHex} slot=${slot} poor=${reason === '资金不足'} />
+      <${PriceHex} slot=${slot} free=${free} poor=${reason === '资金不足'} />
    </span>
    <span class="scard__itemart"><${Img} src=${itemIconUrl(m, it)} fallback=${html`<${GIcon} name="bolt" />`} /></span>
    <span class="scard__body">
@@ -140,7 +142,7 @@ export function ItemCard({ slot, idx, frozen = false, reason = null, armed = fal
      <span class="scard__idesc"><${RichText} text=${it?.descRaw || it?.desc || ''} /></span>
    </span>
    ${frozen ? html`<span class="scard__ice" aria-hidden="true"><${Icon} name="snow" /></span>` : null}
-    ${armed ? html`<${ArmedTag} reason=${reason} />` : null}
+    ${armed ? html`<${ArmedTag} reason=${reason} free=${free} />` : null}
  </button>`;
  return reason && reason !== '已售出' && !armed ? html`<${Tooltip} text=${reason} block=${true} class="scard-wrap">${card}<//>` : card;
 }
@@ -210,24 +212,33 @@ export function useTwoTap({ editable, keys }) {
 }

 /**
- * Promotion reward (research 00 §3): after a merge the operator cards of the bar are replaced by 3 free operators of
- * tier min(level+1, 6); pick 1 (g.reward idx) or put it off (稍后选择 → the normal shop + a reminder pill).
+ * A free pick-one offer in place of the bar's operator cards (pick 1 — g.reward idx — or put it off: 稍后选择 → the
+ * normal shop + a reminder pill): the promotion reward (research 00 §3: 3 free operators of tier min(level+1, 6)) and
+ * the special refreshes of strategies, items and 特质 — e.g. 凯瑟琳 【定向投放】 "在调度中心刷新随机3件装备，可以选择并获得
+ * 其中1件". Each slot is drawn by its kind: an item slot is an item card (icon, name, tier, description, FREE) — player
+ * report #6 after 0.1.0, the items used to be drawn as nameless operator cards — and the header names the offer
+ * (gameLogic.offerHeader: 晋升奖励 / the strategy's effect name …; "之后还有 N 项" while more offers wait behind it).
 */
-function RewardCards({ offer, priv, editable, onPick, onDetail, onLater, armed, onTap }) {
-  return html`<div class="shopbar__reward" role="group" aria-label="晋升奖励">
+export function RewardCards({ offer, priv, editable, onPick, onDetail, onLater, armed, onTap }) {
+  const head = offerHeader(offer);
+  return html`<div class=${cx('shopbar__reward', head.items && 'is-items')} role="group" aria-label=${head.title}>
    <div class="rwtag">
-      <${Icon} name="crown" class="rwtag__icon" />
-      <b class="rwtag__title">晋升奖励</b>
-      <span class="rwtag__micro">PROMOTION</span>
-      <span class="rwtag__sub">免费选择 1 名</span>
+      <${Icon} name=${head.icon} class="rwtag__icon" />
+      <b class="rwtag__title">${head.title}</b>
+      <span class="rwtag__micro">${head.micro}</span>
+      <span class="rwtag__sub">${head.sub}</span>
+      ${head.more ? html`<span class="rwtag__sub rwtag__more">${head.more}</span>` : null}
      <button type="button" class="rwtag__later" onClick=${onLater} title="稍后选择（回合结束后消失）"><${Icon} name="minus" />稍后</button>
    </div>
    <div class="shopbar__rwcards">
-      ${offer.slots.map((s, i) => (s && !s.sold
-        ? html`<${ChessCard} key=${`rw${i}:${s.id}`} slot=${{ ...s, price: 0 }} idx=${i} priv=${priv} free=${true}
-            armed=${armed === armKey('r', i, s)} onTap=${(idx) => onTap('r', idx, s, 'chess', shopBlockReason('reward', { priv, editable, slot: s, ...LOOKUPS }), onPick)}
-            reason=${shopBlockReason('reward', { priv, editable, slot: s, ...LOOKUPS })} onBuy=${onPick} onDetail=${onDetail} />`
-        : html`<div key=${`rw${i}`} class="scard scard--sold"><span class="scard__soldtxt"><span>已选择</span></span></div>`))}
+      ${offer.slots.map((s, i) => {
+        if (!s || s.sold) return html`<div key=${`rw${i}`} class=${cx('scard', 'scard--sold', s && s.kind === 'item' && 'scard--item')}><span class="scard__soldtxt"><span>已选择</span></span></div>`;
+        const kind = s.kind === 'item' ? 'item' : 'chess';
+        const reason = shopBlockReason('reward', { priv, editable, slot: s, ...LOOKUPS });
+        const props = { slot: { ...s, price: 0 }, idx: i, free: true, reason, armed: armed === armKey('r', i, s), onBuy: onPick, onDetail,
+          onTap: (idx) => onTap('r', idx, s, kind, reason, onPick) };
+        return kind === 'item' ? html`<${ItemCard} key=${`rw${i}:${s.id}`} ...${props} />` : html`<${ChessCard} key=${`rw${i}:${s.id}`} priv=${priv} ...${props} />`;
+      })}
    </div>
  </div>`;
 }
@@ -96,7 +96,7 @@ export class PlayerState {
    this.loadout = Object.freeze({});
    if (!this.isBot && seat.loadout) this.setLoadout(seat.loadout);
    this.shop = { level: 1, upgradePrice: this.gd.upgradeBase(1) ?? 0, slots: [], frozen: false, freeRefreshes: 0 };
-    /** reward offers queue (merge rewards, special refreshes): { tier, source, slots: [{ kind, id, price, sold }] } */
+    /** reward offers queue (merge rewards, special refreshes): { tier, source, label, slots: [{ kind, id, price, sold }] } */
    this.offers = [];
    /** @type {Array<any>} */
    this.hand = new Array(HAND_SIZE).fill(null);
@@ -593,7 +593,7 @@ export class PlayerState {
   * up from the tier below (user playtest #6 item 19: the official promotion reward never offers one operator twice —
   * the user's first-hand report; the normal shop's slots may repeat). The offer reserves no copies (the pick takes one).
   */
-  pushRewardOffer(source = 'merge', { tier = null, ids = null } = {}) {
+  pushRewardOffer(source = 'merge', { tier = null, ids = null, label = null } = {}) {
    const ro = this.gd.rewardOffer();
    const t = Number.isInteger(tier) ? tier : Math.min(this.shop.level + ro.tierOffset, ro.maxTier);
    // an offer never shows one operator twice, whoever built the list (user playtest #6 item 19)
@@ -608,17 +608,20 @@ export class PlayerState {
      }
    }
    if (!list.length) return null;
-    const offer = { tier: t, source, slots: list.slice(0, MAX_OFFER_SLOTS).map((id) => ({ kind: 'chess', id, price: ro.price, sold: false })) };
+    const offer = { tier: t, source, label: typeof label === 'string' && label ? label : null, slots: list.slice(0, MAX_OFFER_SLOTS).map((id) => ({ kind: 'chess', id, price: ro.price, sold: false })) };
    this.offers.push(offer);
    this.dirty();
    return offer;
  }

-  /** Queue a free pick-one offer of items (凯瑟琳 定向投放 and similar); shown as shop.rewardOffer with kind 'item'. */
-  pushItemOffer(ids, { source = 'effect', tier = null } = {}) {
-    const list = (Array.isArray(ids) ? ids : []).filter((id) => this.gd.item(id)).slice(0, MAX_OFFER_SLOTS);
+  /**
+   * Queue a free pick-one offer of items (凯瑟琳 定向投放, 娜仁图亚 见者有份); shown as shop.rewardOffer with slots of kind
+   * 'item' under its `label` (the effect's name; player report #6 after 0.1.0).
+   */
+  pushItemOffer(ids, { source = 'effect', tier = null, label = null } = {}) {
+    const list = [...new Set(Array.isArray(ids) ? ids : [])].filter((id) => this.gd.item(id)).slice(0, MAX_OFFER_SLOTS);
    if (!list.length) return null;
-    const offer = { tier: Number.isInteger(tier) ? tier : null, source, slots: list.map((id) => ({ kind: 'item', id, price: 0, sold: false })) };
+    const offer = { tier: Number.isInteger(tier) ? tier : null, source, label: typeof label === 'string' && label ? label : null, slots: list.map((id) => ({ kind: 'item', id, price: 0, sold: false })) };
    this.offers.push(offer);
    this.dirty();
    return offer;
@@ -1481,7 +1484,9 @@ export class PlayerState {
        freeRefreshes: this.shop.freeRefreshes,
        frozen: this.shop.frozen,
        slots,
-        rewardOffer: offer ? { tier: offer.tier, slots: offer.slots.map((s) => ({ kind: s.kind === 'item' ? 'item' : 'chess', id: s.id, price: s.price, sold: !!s.sold })) } : null,
+        // `source` 'merge' = the promotion reward (晋升奖励); any other offer (a strategy, an item, a 特质) carries the
+        // `label` the bar shows instead; `queued` = offers waiting behind it (player report #6 after 0.1.0)
+        rewardOffer: offer ? { tier: offer.tier, source: offer.source === 'merge' ? 'merge' : 'special', label: offer.label || null, queued: this.offers.length - 1, slots: offer.slots.map((s) => ({ kind: s.kind === 'item' ? 'item' : 'chess', id: s.id, price: s.price, sold: !!s.sold })) } : null,
      },
      hand: this.hand.map((p) => (p ? this.pieceView(p) : null)),
      temp: this.temp.map((p) => (p ? this.pieceView(p) : null)),
@@ -3,11 +3,22 @@
 //
 // Generation (generateDraft): the family is a weighted pick from choices.schedule[modeId].rounds[r].families; the card
 // count is `cards` (co-op 6, solo 3):
-//   bounty  悬赏决策  distinct cards.bounty entries with tier ∈ bountyTiers whose enemy exists and is active in the mode,
-//                     draft cards only (`draftBounty`, choices.json `draft`: the PRTS 下半 记录 §机变阶段 "敌人轮选" table —
-//                     never 战术特训, which only 法术教鞭 creates, nor the hidden 鸭爵 set; the 7 multi-round "之后 / 后续
-//                     的每场作战" cards stay in, as the table lists them); each card carries its official rich text
-//                     `descRaw` (the battles in blue "下场作战" / "两场作战"); a multi-round card lasts
+//   bounty  悬赏决策  six distinct cards.bounty entries (solo: 3 of them) built like the official draft of the round
+//                     (`bountyDraftCards`; player feedback after 0.1.0, report #2 — late bounty enemies in the early
+//                     drafts; 33 official screenshots, tools/build-data.mjs BOUNTY_INITIAL_SETS): schedule `bountyDraft`
+//                     names the kind and choices.json `bountyDrafts[kind]` its structure —
+//                       initial (R3, 险境 R6 [ASSUMED]): one of the 10 official sets of "接下来两场作战" cards — a seen
+//                               set, or for an unseen slot one card from each of 6 of the series 10–15 / 20 with the
+//                               tiers I I I II II III;
+//                       boss (R9): a seen group of named bosses + the group's cheap boss bounties / 源石虫·特训 to 6;
+//                       hunter (R11): one of the 15 official events — a seen group (a 特异III giant + its tier-II
+//                               "下场战斗" cards, always together) or for an unseen slot a group of that shape
+//                               [ASSUMED] — filled to 6 with tier-I cards, at most one card per faction series;
+//                     only `draft` cards of that `draftPool` (never 战术特训 — 法术教鞭 only —, the 鸭爵 set, the 7
+//                     multi-round cards or the pre-series cards: no official draft shows them); positions shuffled; the
+//                     mode's inactive enemy list does not apply (PRTS 卫戍协议：盟约 11/18 note "以上调整仅针对战术特训敌人，
+//                     不影响悬赏决策出场"); each card carries its official rich text `descRaw` (the battles in blue
+//                     "下场作战" / "两场作战"); a multi-round card (教鞭's 法术大师A2·多轮战术特训) lasts
 //                     MULTI_ROUND_BOUNTY_BATTLES battles and says so (`bountyBattles` / `bountyText`: the user's call
 //                     after playtest #6 — "我不记得有过多轮悬赏")
 //   supply  道具补给  random normal EQUIP shop items with tier in supplyTiers [lo, hi] (duplicates allowed)
@@ -75,7 +86,16 @@ function scheduleFor(gd, round) {
  const r = sch && sch.rounds && sch.rounds[String(round)];
  if (r && typeof r === 'object') return r;
  // fallback: a supply draft
-  return { families: [{ family: 'supply', weight: 1 }], cards: gd.isSolo ? 3 : 6, supplyTiers: [1, Math.min(6, 1 + Math.floor(round / 3))], bountyTiers: [1, 2] };
+  return { families: [{ family: 'supply', weight: 1 }], cards: gd.isSolo ? 3 : 6, supplyTiers: [1, Math.min(6, 1 + Math.floor(round / 3))] };
+}
+
+/**
+ * The kind of official 悬赏决策 a round has when its schedule does not say (`bountyDraft`): R3 'initial', R9 'boss',
+ * R11 'hunter' (choices.json bountyDrafts; player feedback after 0.1.0, report #2).
+ */
+export function bountyDraftKind(round) {
+  const r = Number(round);
+  return r < 8 ? 'initial' : r < 11 ? 'boss' : 'hunter';
 }

 function formatCount(gd) {
@@ -105,7 +125,7 @@ export function generateDraft(gd, rng, round, { stageId = null, bondAvailable =
  const fams = Array.isArray(sch.families) && sch.families.length ? sch.families.map((f) => [f.family, f.weight]) : [['supply', 1]];
  let family = weightedPick(rng, fams) || 'supply';
  const n = Number.isInteger(sch.cards) && sch.cards > 0 ? Math.min(sch.cards, 6) : formatCount(gd);
-  const opts = { stageId, bondAvailable };
+  const opts = { stageId, bondAvailable, round };
  let cards = buildCards(gd, rng, family, n, sch, opts);
  if (!cards.length && family !== 'supply') { family = 'supply'; cards = buildCards(gd, rng, family, n, sch, opts); }
  if (!cards.length) return null;
@@ -144,30 +164,119 @@ export function cardTargetBonds(gd, effectId) {

 /**
 * A bounty card the 悬赏决策 draft may offer (choices.json cards.bounty `draft`, tools/build-data.mjs
- * bountyDraftExclusion: the PRTS "敌人轮选" table — no 战术特训, no 鸭爵 set; user playtest #6 item 4). Data without the
- * flag (older builds, test fixtures) falls back to the kill bounties.
+ * bountyDraftExclusion: no 战术特训, no 鸭爵 set — user playtest #6 item 4 —, nothing no official draft showed — player
+ * feedback #2). Data without the flag (older builds, test fixtures) falls back to the kill bounties. With `kind`
+ * ('initial' | 'boss' | 'hunter') the card must also belong to that kind of draft (choices.json `draftPool`; a card
+ * without one — test fixtures — fits every kind).
 */
-export function draftBounty(c) {
+export function draftBounty(c, kind = null) {
  if (!c) return false;
+  if (kind != null && typeof c.draftPool === 'string' && c.draftPool !== kind) return false;
  if (typeof c.draft === 'boolean') return c.draft;
  return c.payout !== 'perfect';
 }

-function buildCards(gd, rng, family, n, sch, { stageId = null, bondAvailable = null } = {}) {
-  const cardsData = gd.choices.cards || {};
-  if (family === 'bounty') {
-    const tiers = Array.isArray(sch.bountyTiers) && sch.bountyTiers.length ? sch.bountyTiers : [1, 2];
-    const pool = (Array.isArray(cardsData.bounty) ? cardsData.bounty : []).filter((c) => c && draftBounty(c) && tiers.includes(c.tier) && gd.enemy(c.enemyKey) && !gd.inactiveEnemies.has(c.enemyKey));
-    const pick = pool.slice();
-    rng.shuffle(pick);
-    return pick.slice(0, n).map((c) => {
-      const eff = typeof gd.effect === 'function' ? gd.effect(c.effectId) : null;
-      return {
-        kind: 'bounty', id: c.effectId, name: c.name, desc: bountyText(c.desc || '', c), descRaw: bountyText((eff && eff.descRaw) || null, c), tier: c.tier, coin: c.coin,
-        payout: c.payout, rounds: bountyBattles(c), enemyKey: c.enemyKey, count: c.count,
-      };
-    });
+/** The draft card of a cards.bounty entry (the official rich text, a multi-round card's battles and text rewritten). */
+export function bountyCard(gd, c) {
+  const eff = typeof gd.effect === 'function' ? gd.effect(c.effectId) : null;
+  return {
+    kind: 'bounty', id: c.effectId, name: c.name, desc: bountyText(c.desc || '', c), descRaw: bountyText((eff && eff.descRaw) || null, c), tier: c.tier, coin: c.coin,
+    payout: c.payout, rounds: bountyBattles(c), enemyKey: c.enemyKey, count: c.count,
+  };
+}
+
+/** Up to `k` cards of `list` not in `taken`, at most one per series of `onePer` (a Set), in a shuffled order. */
+function drawDistinct(rng, list, k, taken, onePer = null) {
+  const out = [];
+  const used = new Set([...taken].map((c) => c.series));
+  for (const c of rng.shuffle(list.slice())) {
+    if (out.length >= k) break;
+    if (taken.has(c)) continue;
+    if (onePer && onePer.has(c.series) && used.has(c.series)) continue;
+    out.push(c);
+    taken.add(c);
+    used.add(c.series);
  }
+  return out;
+}
+
+/**
+ * The cards of a 悬赏决策 of kind `kind` after its official structure (choices.json `bountyDrafts[kind]`, see the module
+ * header), over the eligible cards `byId` (effectId → cards.bounty entry). Ids the eligible list lacks are skipped.
+ */
+function structuredBounty(rng, kind, spec, byId) {
+  const get = (ids) => (Array.isArray(ids) ? ids : []).map((id) => byId.get(id)).filter(Boolean);
+  const taken = new Set();
+  const count = Number.isInteger(spec.count) ? spec.count : 6;
+  if (kind === 'initial') {
+    const sets = Array.isArray(spec.sets) ? spec.sets : [];
+    const slot = rng.int(Math.max(sets.length, Number.isInteger(spec.slots) ? spec.slots : 0));
+    if (slot < sets.length) return get(sets[slot].cards).slice(0, count);
+    // an unseen official set: one card from each of `count` series, with the seen sets' tier mix
+    const mx = spec.mixed || {};
+    const series = rng.shuffle((mx.series || []).slice()).slice(0, mx.count || count);
+    const tiers = rng.shuffle((mx.tiers || []).slice());
+    const all = [...byId.values()];
+    const out = [];
+    series.forEach((s, i) => {
+      const ofSeries = all.filter((c) => c.series === s);
+      const want = ofSeries.filter((c) => c.tier === tiers[i]);
+      const c = rng.pick(want.length ? want : ofSeries);
+      if (c) out.push(c);
+    });
+    return out;
+  }
+  if (kind === 'boss') {
+    const t = rng.pick(Array.isArray(spec.templates) ? spec.templates : []);
+    if (!t) return [];
+    const featured = get(t.featured);
+    featured.forEach((c) => taken.add(c));
+    return [...featured, ...drawDistinct(rng, get(t.fill), count - featured.length, taken)].slice(0, count);
+  }
+  if (kind === 'hunter') {
+    // one of the official events: a seen group, or for an unseen slot a group of the same shape; then tier-I fill to 6
+    const onePer = new Set(Array.isArray(spec.onePerSeries) ? spec.onePerSeries : []);
+    const templates = Array.isArray(spec.templates) ? spec.templates : [];
+    const slots = Math.max(templates.length, Number.isInteger(spec.slots) ? spec.slots : 0);
+    const slot = slots > 0 ? rng.int(slots) : 0;
+    let group;
+    let fill;
+    if (slot < templates.length) {
+      group = get(templates[slot].featured);
+      group.forEach((c) => taken.add(c));
+      fill = get(templates[slot].fill);
+    } else {
+      const r = spec.rule || {};
+      const sizes = Array.isArray(r.groupSizes) && r.groupSizes.length ? r.groupSizes : [1];
+      const giant = drawDistinct(rng, get(r.giants), 1, taken);
+      group = [...giant, ...drawDistinct(rng, get(r.groupCards), rng.pick(sizes), taken, onePer)];
+      fill = get(r.fill);
+    }
+    return [...group, ...drawDistinct(rng, fill, count - group.length, taken, onePer)];
+  }
+  return [];
+}
+
+/**
+ * Build `n` 悬赏决策 cards for `round` (module header): the official structure of the round's kind, topped up with other
+ * eligible cards of that kind when it falls short (test fixtures with a restricted card list), shuffled into place —
+ * the official card positions vary — and cut to `n` (solo 3 [ASSUMED]).
+ */
+function bountyDraftCards(gd, rng, n, sch, round) {
+  const kind = typeof sch.bountyDraft === 'string' ? sch.bountyDraft : bountyDraftKind(round);
+  const all = Array.isArray(gd.choices.cards && gd.choices.cards.bounty) ? gd.choices.cards.bounty : [];
+  const eligible = all.filter((c) => c && draftBounty(c, kind) && gd.enemy(c.enemyKey));
+  const byId = new Map(eligible.map((c) => [c.effectId, c]));
+  const spec = gd.choices.bountyDrafts && gd.choices.bountyDrafts[kind];
+  const out = spec ? structuredBounty(rng, kind, spec, byId) : [];
+  const taken = new Set(out);
+  if (out.length < n) out.push(...drawDistinct(rng, eligible, n - out.length, taken));
+  return rng.shuffle(out).slice(0, n).map((c) => bountyCard(gd, c));
+}
+
+function buildCards(gd, rng, family, n, sch, { stageId = null, bondAvailable = null, round = 1 } = {}) {
+  const cardsData = gd.choices.cards || {};
+  if (family === 'bounty') return bountyDraftCards(gd, rng, n, sch, round);
  if (family === 'supply' || family === 'shop') {
    let lo = 1;
    let hi = 6;
@@ -351,6 +351,22 @@ function ownedChess(ps) {

 const finiteInt = (n) => (Number.isFinite(n) ? Math.trunc(n) : 0);

+/**
+ * What a pick-one offer made by an effect is called on the shop bar (m.private shop.rewardOffer.label; player report #6
+ * after 0.1.0 — 凯瑟琳's three items came under the promotion reward's 晋升奖励 header): a strategy's effect name
+ * (定向投放, 见者有份), an item's name (寻呼模块, 信标), the operator whose 特质 it is (松果), else null.
+ * @param {import('./gamedata.js').GameData} gd
+ * @param {object} source the dispatch source (kind band / item / garrison …)
+ * @returns {string|null}
+ */
+export function offerLabel(gd, source) {
+  if (!source || typeof source !== 'object') return null;
+  if (source.kind === 'band') { const b = source.band || gd.band(source.bandId); return (b && (b.effectName || b.name)) || null; }
+  if (source.kind === 'item') { const it = source.item || (source.piece ? gd.item(source.piece.id) : null); return (it && it.name) || null; }
+  if (source.kind === 'garrison' && source.piece) { const c = gd.chess(source.piece.id); return (c && c.name) || null; }
+  return null;
+}
+
 /**
 * @param {import('./Match.js').Match} m
 * @param {import('./PlayerState.js').PlayerState} ps
@@ -510,9 +526,10 @@ export function makeCtx(m, ps, source, hook, ev = null) {
      ps.recompute();
      return true;
    },
-    offerChess: (ids, opts = {}) => !!ps.pushRewardOffer(opts.source || source.key || 'effect', { ids, tier: opts.tier ?? null }),
+    /** Queue a free pick-one offer of chess (shop.rewardOffer; `label` defaults to offerLabel(source), the bar's header). */
+    offerChess: (ids, opts = {}) => !!ps.pushRewardOffer(opts.source || source.key || 'effect', { ids, tier: opts.tier ?? null, label: opts.label ?? offerLabel(gd, source) }),
    /** Queue a free pick-one offer of items (shop.rewardOffer with slots of kind 'item'). */
-    offerItems: (ids, opts = {}) => !!ps.pushItemOffer(ids, { source: opts.source || source.key || 'effect', tier: opts.tier ?? null }),
+    offerItems: (ids, opts = {}) => !!ps.pushItemOffer(ids, { source: opts.source || source.key || 'effect', tier: opts.tier ?? null, label: opts.label ?? offerLabel(gd, source) }),
    setShopSlot: (i, slot) => {
      if (!Number.isInteger(i) || i < 0 || i >= ps.shop.slots.length) return false;
      if (slot == null) { ps.shop.slots[i] = null; ps.dirty(); return true; }
@@ -27,8 +27,9 @@ function dataWith(modeId, round, family, { tactic = null, bounty = null, cards =
  const out = { ...DATA, choices: { ...ch, schedule: { ...ch.schedule, [modeId]: { ...sch, rounds: { ...sch.rounds, [String(round)]: r } } }, cards: { ...ch.cards } } };
  if (tactic) out.choices.cards.tactic = ch.cards.tactic.filter((c) => tactic.includes(c.effectId));
  // the listed bounty cards are offered by this draft even when the real one would not (战术特训 comes from 法术教鞭
-  // only — choices.json `draft`, user playtest #6 item 4): these tests drive the payouts through the draft
-  if (bounty) out.choices.cards.bounty = ch.cards.bounty.filter((c) => bounty.includes(c.effectId)).map((c) => ({ ...c, draft: true }));
+  // only — choices.json `draft`, user playtest #6 item 4; each card belongs to one kind of official draft —
+  // `draftPool`, player feedback #2; a card without one fits every draft): these tests drive the payouts through the draft
+  if (bounty) out.choices.cards.bounty = ch.cards.bounty.filter((c) => bounty.includes(c.effectId)).map(({ draftPool, ...c }) => ({ ...c, draft: true }));
  return out;
 }

@@ -147,7 +148,7 @@ const KILL2 = 'enemyeffect_12_4'; // 悬赏·损伤I: 1 enemy, killer +1, next 2
 const PERF = 'enemyeffect_11_1';  // 战术特训·频次I: 1 enemy, +1 when the own phase is perfect

 test('悬赏决策 E2E (co-op, real battles): the picker\'s own battle gets the enemy; the killer earns the kill coins, 战术特训 pays a perfect own phase', () => {
-  const data = dataWith('mode_multi_normal', 3, 'bounty', { bounty: [KILL, PERF], extra: { bountyTiers: [1, 2, 3] } });
+  const data = dataWith('mode_multi_normal', 3, 'bounty', { bounty: [KILL, PERF] });
  const h = makeMatch({ mode: 'coop', difficulty: 'NORMAL', humans: 2, seed: 31, data, registry: REG });
  const m = h.m;
  // real battles where every enemy of a player is struck down by that player's operator the tick it appears
@@ -0,0 +1,69 @@
+{
+  "_doc": "Official 机变 drafts at the start of rounds 3, 9 and 11, read from screenshots of 11 official co-op matches collected by the user (2026-10-03; player names left out). The cards are in screen order (left to right, top to bottom). A bounty card is [title, enemy as printed, coins, battles] (battles 2 = 接下来两场作战, 1 = 下场作战 / 下场战斗; 源石虫·特训 pays 0); a 机密商店 card is [item, tier]; a 战术决策 card is [name]. Names are converted to Simplified Chinese. Matches 1 and 2 come from the Traditional-Chinese client, 3-11 from Simplified-Chinese video captures. Every match is a 4-player co-op match of 绝境 or 终极 (the modes whose SP rounds are 3, 9 and 11; the HUD does not say which). Used by test/match/feedback1-bounty.test.js.",
+  "season": "act2autochess",
+  "aliases": { "深池重甲卫队队长": "深池重甲卫士队长" },
+  "matches": {
+    "1": {
+      "3": { "family": "bounty", "cards": [["悬赏·损伤I", "临时收音师", 1, 2], ["悬赏·损伤III", "主角阵营角色", 3, 2], ["悬赏·特异I", "迷茫的修理小助手", 1, 2], ["悬赏·特异II", "寻仇者", 2, 2], ["悬赏·特异II", "圣堂剑士", 2, 2], ["悬赏·特异I", "高能源石虫", 1, 2]] },
+      "9": { "family": "bounty", "cards": [["“庞贝”·悬赏", "“庞贝”", 2, 1], ["喷气人·悬赏", "喷气人", 3, 1], ["纠缠藤蔓·悬赏", "纠缠藤蔓", 3, 1], ["大鲍勃·悬赏", "大鲍勃", 2, 1], ["W·悬赏", "W", 1, 1], ["源石虫·特训", "源石虫", 0, 1]] },
+      "11": { "family": "bounty", "cards": [["悬赏·特异II", "异质裂兽·α", 2, 1], ["悬赏·折射II", "深池重甲卫士队长", 2, 1], ["悬赏·特异III", "温顺的武装大驮兽", 3, 1], ["悬赏·损伤II", "灼藤", 2, 1], ["悬赏·持续II", "尖端萨卡兹枯朽战车", 2, 1], ["悬赏·飞行I", "法术大师A2", 1, 1]] }
+    },
+    "2": {
+      "3": { "family": "bounty", "cards": [["悬赏·特异I", "节日气球", 1, 2], ["悬赏·特异II", "咸鳞汁推荐者", 2, 2], ["悬赏·特异I", "简饲源石虫", 1, 2], ["悬赏·损伤III", "反派阵营角色", 3, 2], ["悬赏·折射I", "深池侦察犬pro", 1, 2], ["悬赏·飞行II", "吉兆飞鳞", 2, 2]] },
+      "9": { "family": "bounty", "cards": [["源石虫·特训", "源石虫", 0, 1], ["弑君者·悬赏", "弑君者", 1, 1], ["泥岩·悬赏", "泥岩", 4, 1], ["大鲍勃·悬赏", "大鲍勃", 2, 1], ["“庞贝”·悬赏", "“庞贝”", 2, 1], ["澪·悬赏", "澪", 3, 1]] },
+      "11": { "family": "shop", "cards": [["变形同构体", 6], ["护盾无人机", 4], ["骑士储蓄罐", 3], ["盟约之币", 1], ["天马之盔", 5], ["天师古鼎", 6]] }
+    },
+    "3": {
+      "3": { "family": "bounty", "cards": [["悬赏·特异I", "高能源石虫", 1, 2], ["悬赏·损伤I", "临时收音师", 1, 2], ["悬赏·特异I", "迷茫的修理小助手", 1, 2], ["悬赏·损伤III", "主角阵营角色", 3, 2], ["悬赏·特异II", "圣堂剑士", 2, 2], ["悬赏·特异II", "寻仇者", 2, 2]] },
+      "9": { "family": "bounty", "cards": [["腐败骑士·悬赏", "腐败骑士", 3, 1], ["“墓碑”·悬赏", "“墓碑”", 4, 1], ["W·悬赏", "W", 1, 1], ["碎骨·悬赏", "碎骨", 1, 1], ["源石虫·特训", "源石虫", 0, 1], ["“巨大的丑东西”·悬赏", "“巨大的丑东西”", 5, 1]] },
+      "11": { "family": "bounty", "cards": [["悬赏·折射II", "深池重甲卫队队长", 2, 1], ["悬赏·飞行I", "法术大师A2", 1, 1], ["悬赏·隐匿I", "重弩突袭者", 1, 1], ["悬赏·特异III", "狂暴宿主组长", 3, 1], ["悬赏·持续II", "尖端萨卡兹枯朽战车", 2, 1], ["悬赏·频次I", "沏虹", 1, 1]] }
+    },
+    "4": {
+      "3": { "family": "bounty", "cards": [["悬赏·频次I", "磨砻", 1, 2], ["悬赏·损伤II", "控潮术师", 2, 2], ["悬赏·折射I", "深池方阵战士", 1, 2], ["悬赏·持续III", "萨卡兹枯朽战车", 3, 2], ["悬赏·飞行II", "暴鸰", 2, 2], ["悬赏·特异I", "潜伏者", 1, 2]] },
+      "9": { "family": "bounty", "cards": [["弑君者·悬赏", "弑君者", 1, 1], ["大鲍勃·悬赏", "大鲍勃", 2, 1], ["碎骨·悬赏", "碎骨", 1, 1], ["W·悬赏", "W", 1, 1], ["“庞贝”·悬赏", "“庞贝”", 2, 1], ["源石虫·特训", "源石虫", 0, 1]] },
+      "11": { "family": "shop", "cards": [["双模机械臂", 5], ["人事部文档", 6], ["盟约之币", 1], ["家族徽章", 6], ["商业包装方案", 5], ["盟约之币", 1]] }
+    },
+    "5": {
+      "3": { "family": "bounty", "cards": [["悬赏·损伤III", "主角阵营角色", 3, 2], ["悬赏·特异I", "高能源石虫", 1, 2], ["悬赏·特异II", "寻仇者", 2, 2], ["悬赏·损伤I", "临时收音师", 1, 2], ["悬赏·特异I", "迷茫的修理小助手", 1, 2], ["悬赏·特异II", "圣堂剑士", 2, 2]] },
+      "9": { "family": "bounty", "cards": [["喷气人·悬赏", "喷气人", 3, 1], ["纠缠藤蔓·悬赏", "纠缠藤蔓", 3, 1], ["碎骨·悬赏", "碎骨", 1, 1], ["W·悬赏", "W", 1, 1], ["大鲍勃·悬赏", "大鲍勃", 2, 1], ["源石虫·特训", "源石虫", 0, 1]] },
+      "11": { "family": "shop", "cards": [["铳骑之威", 6], ["博士投影", 5], ["盟约之币", 1], ["变形同构体", 6], ["寻呼模块", 4], ["盟约之币", 1]] }
+    },
+    "6": {
+      "3": { "family": "bounty", "cards": [["悬赏·损伤III", "术师快艇", 3, 2], ["悬赏·折射II", "深池暗影术师", 2, 2], ["悬赏·频次II", "烹泉", 2, 2], ["悬赏·隐匿I", "隐形弩手", 1, 2], ["悬赏·飞行I", "妖怪", 1, 2], ["悬赏·频次I", "俗心", 1, 2]] },
+      "9": { "family": "bounty", "cards": [["“邪魔的利刃”·悬赏", "“邪魔的利刃”", 3, 1], ["碎骨·悬赏", "碎骨", 1, 1], ["萨卡兹百夫长·悬赏", "萨卡兹百夫长", 2, 1], ["W·悬赏", "W", 1, 1], ["“复仇者”·悬赏", "“复仇者”", 6, 1], ["弑君者·悬赏", "弑君者", 1, 1]] },
+      "11": { "family": "bounty", "cards": [["悬赏·损伤II", "灼藤", 2, 1], ["悬赏·频次I", "沏虹", 1, 1], ["悬赏·折射II", "深池重甲卫队队长", 2, 1], ["悬赏·特异III", "温顺的武装大驮兽", 3, 1], ["悬赏·持续II", "尖端萨卡兹枯朽战车", 2, 1], ["悬赏·特异II", "异质裂兽·α", 2, 1]] }
+    },
+    "7": {
+      "3": { "family": "bounty", "cards": [["悬赏·特异II", "水遁忍者", 2, 2], ["悬赏·特异I", "雪孩子", 1, 2], ["悬赏·特异II", "骇笑看客", 2, 2], ["悬赏·特异III", "自制投石机", 3, 2], ["悬赏·特异I", "冒失的小弟", 1, 2], ["悬赏·特异I", "新手祭司学徒", 1, 2]] },
+      "9": { "family": "bounty", "cards": [["W·悬赏", "W", 1, 1], ["大鲍勃·悬赏", "大鲍勃", 2, 1], ["陷落雪祀·悬赏", "陷落雪祀", 3, 1], ["杰斯顿·威廉姆斯·悬赏", "杰斯顿·威廉姆斯", 4, 1], ["碎骨·悬赏", "碎骨", 1, 1], ["弑君者·悬赏", "弑君者", 1, 1]] },
+      "11": { "family": "tactic", "cards": [["补给"], ["补给"], ["谢拉格驰援"], ["列装"], ["莫斯提马的盟誓"], ["升华"]] }
+    },
+    "8": {
+      "3": { "family": "bounty", "cards": [["悬赏·折射I", "深池方阵战士", 1, 2], ["悬赏·损伤I", "底海滑动者", 1, 2], ["悬赏·频次II", "烹泉", 2, 2], ["悬赏·特异II", "“独轮车玩具”", 2, 2], ["悬赏·飞行I", "妖怪", 1, 2], ["悬赏·隐匿III", "山海众头目", 3, 2]] },
+      "9": { "family": "bounty", "cards": [["弑君者·悬赏", "弑君者", 1, 1], ["碎骨·悬赏", "碎骨", 1, 1], ["W·悬赏", "W", 1, 1], ["“自在”·悬赏", "“自在”", 4, 1], ["大鲍勃·悬赏", "大鲍勃", 2, 1], ["杰斯顿·威廉姆斯·悬赏", "杰斯顿·威廉姆斯", 4, 1]] },
+      "11": { "family": "shop", "cards": [["变形同构体", 6], ["盟约之币", 1], ["商业包装方案", 5], ["变形同构体", 6], ["天马之盔", 5], ["双模机械臂", 5]] }
+    },
+    "9": {
+      "3": { "family": "bounty", "cards": [["悬赏·损伤III", "主角阵营角色", 3, 2], ["悬赏·特异I", "高能源石虫", 1, 2], ["悬赏·特异I", "迷茫的修理小助手", 1, 2], ["悬赏·特异II", "寻仇者", 2, 2], ["悬赏·特异II", "圣堂剑士", 2, 2], ["悬赏·损伤I", "临时收音师", 1, 2]] },
+      "9": { "family": "bounty", "cards": [["“鼠王”·悬赏", "“鼠王”", 2, 1], ["大鲍勃·悬赏", "大鲍勃", 2, 1], ["源石虫·特训", "源石虫", 0, 1], ["杰斯顿·威廉姆斯·悬赏", "杰斯顿·威廉姆斯", 4, 1], ["“自在”·悬赏", "“自在”", 4, 1], ["W·悬赏", "W", 1, 1]] },
+      "11": { "family": "tactic", "cards": [["锐利"], ["升华"], ["财富"], ["银灰的盟誓"], ["阿戈尔驰援"], ["列装"]] }
+    },
+    "10": {
+      "3": { "family": "bounty", "cards": [["悬赏·特异I", "潜伏者", 1, 2], ["悬赏·折射I", "深池方阵战士", 1, 2], ["悬赏·损伤II", "控潮术师", 2, 2], ["悬赏·飞行II", "暴鸰", 2, 2], ["悬赏·频次I", "磨砻", 1, 2], ["悬赏·持续III", "萨卡兹枯朽战车", 3, 2]] },
+      "9": { "family": "bounty", "cards": [["W·悬赏", "W", 1, 1], ["源石虫·特训", "源石虫", 0, 1], ["“自在”·悬赏", "“自在”", 4, 1], ["杰斯顿·威廉姆斯·悬赏", "杰斯顿·威廉姆斯", 4, 1], ["碎骨·悬赏", "碎骨", 1, 1], ["“鼠王”·悬赏", "“鼠王”", 2, 1]] },
+      "11": { "family": "bounty", "cards": [["悬赏·隐匿II", "家族暗影灭迹人", 2, 1], ["悬赏·特异III", "萨卡兹骸骨拷打者", 3, 1], ["悬赏·飞行I", "法术大师A2", 1, 1], ["悬赏·损伤II", "灼藤", 2, 1], ["悬赏·损伤I", "心虚设计师", 1, 1], ["悬赏·折射II", "愤怒的守墓石像", 2, 1]] }
+    },
+    "11": {
+      "3": { "family": "bounty", "cards": [["悬赏·持续I", "萨卡兹枯朽战士组长", 1, 2], ["悬赏·损伤I", "底海滑动者", 1, 2], ["悬赏·频次III", "清明", 3, 2], ["悬赏·折射II", "深池暗影术师", 2, 2], ["悬赏·飞行I", "妖怪", 1, 2], ["悬赏·隐匿II", "隐形术师", 2, 2]] },
+      "9": { "family": "bounty", "cards": [["杰斯顿·威廉姆斯·悬赏", "杰斯顿·威廉姆斯", 4, 1], ["弑君者·悬赏", "弑君者", 1, 1], ["源石虫·特训", "源石虫", 0, 1], ["W·悬赏", "W", 1, 1], ["碎骨·悬赏", "碎骨", 1, 1], ["陷落雪祀·悬赏", "陷落雪祀", 3, 1]] },
+      "11": { "family": "bounty", "cards": [["悬赏·特异II", "拥霜羽兽", 2, 1], ["悬赏·隐匿I", "重弩突袭者", 1, 1], ["悬赏·损伤I", "心虚设计师", 1, 1], ["悬赏·特异III", "乌顶巨角卢鲁", 3, 1], ["悬赏·频次I", "沏虹", 1, 1], ["悬赏·持续I", "假想敌：蚀裂", 1, 1]] }
+    }
+  },
+  "extra": {
+    "bahamut-12294": {
+      "_doc": "The co-op 悬赏决策 screenshot of Bahamut thread 33651/12294 (research 06 §15, image Wrkhtxv); team LP 6 / 10 / 9 / 15, round not shown (a boss draft: R9).",
+      "family": "bounty",
+      "cards": [["“复仇者”·悬赏", "“复仇者”", 6, 1], ["“庞贝”·悬赏", "“庞贝”", 2, 1], ["W·悬赏", "W", 1, 1], ["萨卡兹百夫长·悬赏", "萨卡兹百夫长", 2, 1], ["“邪魔的利刃”·悬赏", "“邪魔的利刃”", 3, 1], ["碎骨·悬赏", "碎骨", 1, 1]]
+    }
+  }
+}
@@ -0,0 +1,319 @@
+// Player feedback after 0.1.0, report #2 (workstream WB): "本来应该后期出的悬赏的怪物在前期的悬赏就出现了，导致选了打不过".
+// The user then collected the official 悬赏决策 of rounds 3, 9 and 11 in 11 official co-op matches (33 screenshots, 绝境 /
+// 终极; the readings are test/fixtures/official-bounty-drafts.json, player names left out). They settle the draft rules
+// (tools/build-data.mjs BOUNTY_INITIAL_SETS, server/match/choices.js bountyDraftCards):
+//   R3  six "接下来两场作战" cards, 3 × I + 2 × II + 1 × III, one of the official fixed sets (a whole series 17 / 18 / 19,
+//       or one card from each of 6 of the series 10–15 / 20) — 7 of the 10 events seen;
+//   R9  boss bounties + 源石虫·特训: a group of named bosses that come together + cheap ones to 6;
+//   R11 悬赏决策 / 机密商店 / 战术决策 (never 道具补给); its bounty: a group (one 特异III giant + 1–4 tier-II "下场战斗" cards,
+//       always together — matches 1 and 6 share the whole group) + tier-I cards to 6, at most one per faction series;
+//   no draft shows a multi-round card, a pre-series card (enemyeffect_3_*), 战术特训 or the 鸭爵 set; no card twice.
+// Each card's enemy is fixed by its effect; the title only names category and tier (悬赏·损伤I = 底海滑动者 in
+// enemyeffect_12_4, 临时收音师 in enemyeffect_18_1). Real data, real draft code, the real match path for the players' case.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync, existsSync } from 'node:fs';
+import { PHASE } from '../../shared/constants.js';
+import { DATA, makeMatch } from './harness.js';
+import { FakeBattle } from './fakeBattle.js';
+import { GameData } from '../../server/match/gamedata.js';
+import { generateDraft, bountyDraftKind } from '../../server/match/choices.js';
+import { createRng } from '../../server/sim/rng.js';
+
+const OFFICIAL = JSON.parse(readFileSync(new URL('../fixtures/official-bounty-drafts.json', import.meta.url), 'utf8'));
+const CARDS = DATA.choices.cards.bounty;
+const CARD = new Map(CARDS.map((c) => [c.effectId, c]));
+const SPEC = DATA.choices.bountyDrafts;
+const COOP_BOUNTY_MODES = ['mode_multi_normal', 'mode_multi_hard', 'mode_multi_abyss'];
+const isBoss = (key) => DATA.enemies[key] && DATA.enemies[key].rank === 'BOSS';
+const sameSet = (a, b) => a.length === b.length && [...a].sort().join() === [...b].sort().join();
+
+/** The data card of a screenshot reading [title, enemy, coins, battles] (by title, the enemy in the text, coins, battles). */
+function resolve([title, enemy, coin, battles]) {
+  const name = OFFICIAL.aliases[enemy] || enemy;
+  const hits = CARDS.filter((c) => c.name === title && c.coin === coin && (c.desc.includes(`1只${name}`) || c.desc.includes(`1个${name}`))
+    && (battles === 2 ? c.rounds === 2 : c.rounds === 1));
+  assert.equal(hits.length, 1, `${title} ${enemy} ${coin}: ${hits.map((c) => c.effectId).join(', ') || 'no card'}`);
+  return hits[0].effectId;
+}
+/** Every official draft of the fixture: [{ where, round, family, ids? }] (ids for 悬赏决策). */
+function officialDrafts() {
+  const out = [];
+  for (const [match, rounds] of Object.entries(OFFICIAL.matches)) {
+    for (const [round, d] of Object.entries(rounds)) out.push({ where: `match ${match} R${round}`, round: Number(round), family: d.family, ids: d.family === 'bounty' ? d.cards.map(resolve) : null });
+  }
+  for (const [key, d] of Object.entries(OFFICIAL.extra)) out.push({ where: key, round: 9, family: d.family, ids: d.cards.map(resolve) });
+  return out;
+}
+const tiersOf = (ids) => ids.map((id) => CARD.get(id).tier).sort().join('');
+
+/** The rule of the unseen R3 slots (and of the seen mixed sets): one card from each of 6 of the series, I I I II II III. */
+function mixedRule(ids) {
+  const mx = SPEC.initial.mixed;
+  const series = ids.map((id) => CARD.get(id).series);
+  return ids.length === mx.count && ids.every((id) => CARD.get(id).draftPool === 'initial') && new Set(series).size === series.length
+    && series.every((s) => mx.series.includes(s)) && tiersOf(ids) === mx.tiers.slice().sort().join('');
+}
+/** Which official R3 structure a set of ids is: 'set:<i>' (a seen set), 'mixed' (the unseen-slot rule) or null. */
+function initialFit(ids) {
+  const i = SPEC.initial.sets.findIndex((s) => sameSet(s.cards, ids));
+  if (i >= 0) return `set:${i}`;
+  return mixedRule(ids) ? 'mixed' : null;
+}
+/** The R9 groups a set of ids fits (its featured bosses all there, the rest from the group's fill). */
+const bossFits = (ids) => SPEC.boss.templates.map((t, i) => [t, i]).filter(([t]) => ids.length === SPEC.boss.count
+  && t.featured.every((id) => ids.includes(id)) && ids.filter((id) => !t.featured.includes(id)).every((id) => t.fill.includes(id))).map(([, i]) => i);
+/** At most one card per faction series 10–15 (every official R11 draft). */
+function onePerSeries(ids) {
+  const series = ids.map((id) => CARD.get(id).series).filter((s) => SPEC.hunter.onePerSeries.includes(s));
+  return new Set(series).size === series.length;
+}
+/** The seen R11 groups a set of ids fits (the group's giant + tier-II cards all there, the rest from its fill). */
+const hunterFits = (ids) => SPEC.hunter.templates.map((t, i) => [t, i]).filter(([t]) => ids.length === SPEC.hunter.count && onePerSeries(ids)
+  && t.featured.every((id) => ids.includes(id)) && ids.filter((id) => !t.featured.includes(id)).every((id) => t.fill.includes(id))).map(([, i]) => i);
+/** The R11 shape an unseen slot is built by: one tier-III giant, 1–4 tier-II group cards, tier-I fill, one per faction series. */
+function hunterShape(ids) {
+  const r = SPEC.hunter.rule;
+  const giants = ids.filter((id) => r.giants.includes(id)).length;
+  const group = ids.filter((id) => r.groupCards.includes(id)).length;
+  const fill = ids.filter((id) => r.fill.includes(id)).length;
+  return ids.length === SPEC.hunter.count && giants === 1 && r.groupSizes.includes(group) && giants + group + fill === ids.length && onePerSeries(ids);
+}
+
+/** Bounty drafts generated for `modeId` at `round` over `seeds` seeds. */
+function drafts(modeId, round, seeds, data = DATA) {
+  const gd = new GameData(data, modeId);
+  const out = [];
+  for (let seed = 1; seed <= seeds; seed++) {
+    const d = generateDraft(gd, createRng(seed * 7919 + round * 31), round, { stageId: 'act2autochess_m01' });
+    if (d && d.family === 'bounty') out.push(d);
+  }
+  return out;
+}
+
+test('#2 screenshots → data: every card read is one act2autochess (下半) effect, whose enemy_id is the enemy the card brings', (t) => {
+  const seen = new Set();
+  for (const d of officialDrafts()) for (const id of d.ids || []) seen.add(id);
+  assert.equal(seen.size, 72, 'distinct cards in the 27 bounty drafts: 36 at R3, 20 at R9, 16 at R11');
+  // the R3(1) question: the title names category and tier only — two different 悬赏·损伤I cards, each with its own enemy
+  assert.equal(resolve(['悬赏·损伤I', '临时收音师', 1, 2]), 'enemyeffect_18_1');
+  assert.equal(resolve(['悬赏·损伤I', '底海滑动者', 1, 2]), 'enemyeffect_12_4');
+  assert.equal(CARD.get('enemyeffect_18_1').enemyKey, 'enemy_10094_crstf');
+  assert.equal(CARD.get('enemyeffect_12_4').enemyKey, 'enemy_1148_dssbr');
+  const p = new URL('../../.cache/gamedata/excel/activity_table.json', import.meta.url);
+  if (!existsSync(p)) { t.diagnostic('no .cache/gamedata: the season cross-check is skipped'); return; }
+  const act = JSON.parse(readFileSync(p, 'utf8')).activity.AUTOCHESS_SEASON;
+  for (const id of seen) {
+    const bb = act.act2autochess.effectBuffInfoDataDict[id][0].blackboard.find((x) => x.key === 'enemy_id').valueStr;
+    assert.equal(CARD.get(id).enemyKey, bb, `${id}: the card's enemy is the effect's enemy_id`);
+  }
+  // 上半 (act1autochess) lacks the series 17–20 and 澪 / 纠缠藤蔓 … and has 沉沙 where 下半 has 清明: the screenshots are 下半
+  for (const id of ['enemyeffect_17_1', 'enemyeffect_18_1', 'enemyeffect_19_1', 'enemyeffect_20_2', 'enemyeffect_b_19', 'enemyeffect_b_24']) {
+    assert.ok(seen.has(id) && !act.act1autochess.effectInfoDataDict[id], `${id} is 下半-only`);
+  }
+  assert.match(act.act1autochess.effectInfoDataDict.enemyeffect_11_6.effectDesc, /沉沙/);
+});
+
+test('#2 R3 (11 of 11 official drafts): one of the official sets of six "接下来两场作战" cards, 3 × I + 2 × II + 1 × III', () => {
+  const r3 = officialDrafts().filter((d) => d.round === 3);
+  assert.equal(r3.length, 11);
+  const hits = SPEC.initial.sets.map(() => 0);
+  for (const d of r3) {
+    assert.equal(d.family, 'bounty', `${d.where}: R3 is a 悬赏决策`);
+    assert.ok(d.ids.every((id) => CARD.get(id).rounds === 2 && CARD.get(id).draftPool === 'initial'), `${d.where}: two-battle cards`);
+    assert.equal(tiersOf(d.ids), '111223', `${d.where}: tiers`);
+    assert.ok(d.ids.every((id) => !isBoss(CARD.get(id).enemyKey)), `${d.where}: no boss`);
+    const fit = initialFit(d.ids);
+    assert.match(fit || '', /^set:/, `${d.where}: a seen set`);
+    hits[Number(fit.slice(4))]++;
+  }
+  assert.deepEqual(hits, [4, 1, 1, 2, 1, 1, 1], 'series 18 ×4, 19, 17, the 10_5… set ×2, three more mixed sets');
+  // each seen set is a whole series 17 / 18 / 19 or follows the rule the unseen slots are built by
+  for (const s of SPEC.initial.sets) {
+    const series = new Set(s.cards.map((id) => CARD.get(id).series));
+    assert.ok(series.size === 1 ? [17, 18, 19].includes([...series][0]) && s.cards.length === 6 : mixedRule(s.cards), s.cards.join());
+    assert.equal(tiersOf(s.cards), '111223');
+  }
+  assert.equal(SPEC.initial.slots, 10, 'enemy_initial_1..10');
+});
+
+test('#2 R3 generated: a seen set or an unseen-slot set (one card from each of 6 of the series 10–15 / 20, I I I II II III) — every seen set comes up, the unseen slots about 3 in 10', () => {
+  const counts = new Map();
+  let n = 0;
+  for (const modeId of COOP_BOUNTY_MODES) {
+    for (const round of DATA.choices.schedule[modeId].spRounds.filter((r) => bountyDraftKind(r) === 'initial')) {
+      for (const d of drafts(modeId, round, modeId === 'mode_multi_hard' ? 400 : 60)) {
+        const ids = d.cards.map((c) => c.id);
+        assert.equal(new Set(ids).size, 6, 'six different cards');
+        const fit = initialFit(ids);
+        assert.ok(fit, `${modeId} R${round}: ${d.cards.map((c) => c.name).join(', ')}`);
+        assert.ok(d.cards.every((c) => c.rounds === 2 && !isBoss(c.enemyKey)), 'two-battle cards, no boss');
+        assert.match(d.eventId, /^enemy_initial_\d+$/);
+        if (modeId === 'mode_multi_hard') { counts.set(fit, (counts.get(fit) || 0) + 1); n++; }
+      }
+    }
+  }
+  for (let i = 0; i < SPEC.initial.sets.length; i++) assert.ok(counts.get(`set:${i}`) > 0, `set ${i} offered`);
+  const mixed = (counts.get('mixed') || 0) / n;
+  assert.ok(mixed > 0.2 && mixed < 0.4, `unseen-slot sets ${(mixed * 100).toFixed(0)} %`);
+  // solo: 3 cards of such a set
+  for (const d of drafts('mode_single_hard', 3, 40)) {
+    assert.equal(d.cards.length, 3);
+    assert.ok(d.cards.every((c) => CARD.get(c.id).draftPool === 'initial'));
+  }
+});
+
+test('#2 R9 (12 of 12 official drafts): boss bounties + 源石虫·特训 — a group of named bosses always together, filled to 6 with the cheap ones', () => {
+  const r9 = officialDrafts().filter((d) => d.round === 9);
+  assert.equal(r9.length, 12, '11 matches + the Bahamut co-op screenshot');
+  const hits = SPEC.boss.templates.map(() => 0);
+  for (const d of r9) {
+    assert.equal(d.family, 'bounty', `${d.where}: R9 is a 悬赏决策`);
+    assert.ok(d.ids.every((id) => CARD.get(id).draftPool === 'boss' && CARD.get(id).rounds === 1), `${d.where}: boss bounties / 源石虫·特训, 下场作战`);
+    const fits = bossFits(d.ids);
+    assert.equal(fits.length, 1, `${d.where}: fits exactly one seen group (${fits.join(', ')})`);
+    hits[fits[0]]++;
+  }
+  assert.ok(hits.every((x) => x > 0), `every group seen (${hits.join(' ')})`);
+  for (const d of drafts('mode_multi_abyss', 9, 300)) {
+    const ids = d.cards.map((c) => c.id);
+    assert.equal(new Set(ids).size, 6);
+    assert.ok(bossFits(ids).length > 0, ids.join(', '));
+    assert.match(d.eventId, /^bossInitial_\d+$/);
+  }
+  const offered = new Set(drafts('mode_multi_hard', 9, 300).flatMap((d) => d.cards.map((c) => c.id)));
+  for (const t of SPEC.boss.templates) for (const id of t.featured) assert.ok(offered.has(id), `${CARD.get(id).name} offered`);
+  for (const id of ['enemyeffect_b_6', 'enemyeffect_b_7', 'enemyeffect_b_15', 'enemyeffect_b_16', 'enemyeffect_b_18']) {
+    assert.equal(CARD.get(id).draftExcluded, 'unseen', `${CARD.get(id).name}: in no official R9 draft`);
+    assert.ok(!offered.has(id));
+  }
+});
+
+test('#2 R11 (11 matches: 悬赏决策 5, 机密商店 4, 战术决策 2, 道具补给 0): the families, and the bounty — a group (one 特异III giant + its tier-II cards, always together) + tier-I fill, one card per faction series', () => {
+  const r11 = officialDrafts().filter((d) => d.round === 11);
+  const fam = {};
+  for (const d of r11) fam[d.family] = (fam[d.family] || 0) + 1;
+  assert.deepEqual(fam, { bounty: 5, shop: 4, tactic: 2 });
+  const hits = SPEC.hunter.templates.map(() => 0);
+  const byMatch = {};
+  for (const d of r11.filter((x) => x.family === 'bounty')) {
+    assert.ok(d.ids.every((id) => CARD.get(id).draftPool === 'hunter' && CARD.get(id).rounds === 1), `${d.where}: R11 cards, 下场战斗`);
+    assert.ok(hunterShape(d.ids), `${d.where}: the shape the unseen slots are built by (${tiersOf(d.ids)})`);
+    const fits = hunterFits(d.ids);
+    assert.equal(fits.length, 1, `${d.where}: fits exactly one seen group (${fits.join(', ')})`);
+    hits[fits[0]]++;
+    byMatch[d.where.split(' ')[1]] = d.ids;
+  }
+  assert.deepEqual(hits, [2, 1, 1, 1], 'the 16_4 group in matches 1 and 6, three more groups once');
+  // the evidence against a free draw: matches 1 and 6 share the giant and all four tier-II cards, only the tier-I card differs
+  const shared = byMatch['1'].filter((id) => byMatch['6'].includes(id));
+  assert.equal(shared.length, 5);
+  assert.deepEqual(byMatch['1'].filter((id) => !shared.includes(id)).concat(byMatch['6'].filter((id) => !shared.includes(id))).map((id) => CARD.get(id).tier), [1, 1]);
+  for (const id of ['enemyeffect_10_8', 'enemyeffect_11_8', 'enemyeffect_12_8']) assert.ok(!Object.values(byMatch).flat().includes(id), `${id} in no official R11 draft`);
+  for (const modeId of ['mode_multi_hard', 'mode_multi_abyss', 'mode_single_hard', 'mode_single_abyss']) {
+    const sch = DATA.choices.schedule[modeId].rounds['11'];
+    assert.deepEqual(sch.families.map((f) => f.family).sort(), ['bounty', 'shop', 'tactic'], `${modeId} R11 (solo: extrapolated from co-op, [ASSUMED])`);
+    assert.equal(sch.bountyDraft, 'hunter');
+    assert.equal(sch.assumed, true);
+  }
+  assert.equal(SPEC.hunter.slots, 15, 'bounty_hunter_1..15');
+  // generated: a seen group (about 4 in 15) or a group of the same shape; every seen group and every R11 card comes up
+  const gd = new GameData(DATA, 'mode_multi_hard');
+  const seen = {};
+  const groups = SPEC.hunter.templates.map(() => 0);
+  const offered = new Set();
+  let bounty = 0;
+  let fitSeen = 0;
+  for (let seed = 1; seed <= 1500; seed++) {
+    const d = generateDraft(gd, createRng(seed * 13 + 11), 11, { stageId: 'act2autochess_m01' });
+    seen[d.family] = (seen[d.family] || 0) + 1;
+    if (d.family !== 'bounty') continue;
+    const ids = d.cards.map((c) => c.id);
+    assert.equal(new Set(ids).size, 6);
+    assert.ok(hunterShape(ids), d.cards.map((c) => c.name).join(', '));
+    assert.match(d.eventId, /^bounty_hunter_\d+$/);
+    const fits = hunterFits(ids);
+    if (fits.length) { fitSeen++; groups[fits[0]]++; }
+    bounty++;
+    ids.forEach((id) => offered.add(id));
+  }
+  assert.deepEqual(Object.keys(seen).sort(), ['bounty', 'shop', 'tactic'], 'no 道具补给 at R11');
+  assert.ok(seen.bounty > seen.shop && seen.shop > seen.tactic, JSON.stringify(seen));
+  assert.ok(groups.every((x) => x > 0), `every seen group offered (${groups.join(' ')})`);
+  assert.ok(fitSeen / bounty > 0.17 && fitSeen / bounty < 0.4, `seen groups ${(100 * fitSeen / bounty).toFixed(0)} % of ${bounty}`);
+  for (const c of CARDS.filter((x) => x.draftPool === 'hunter')) assert.ok(offered.has(c.effectId), `${c.effectId} ${c.name} offered at R11`);
+});
+
+test('#2 never offered by a draft (in none of the 27 official bounty drafts): multi-round cards, enemyeffect_3_*, 战术特训, the 鸭爵 set', () => {
+  const reasons = {};
+  for (const c of CARDS) {
+    if (!c.draft) reasons[c.draftExcluded] = (reasons[c.draftExcluded] || 0) + 1;
+    assert.equal(c.draft, c.draftPool != null, `${c.effectId}: drafted iff it has a draft kind`);
+    if (c.multiRound) assert.equal(c.draftExcluded, c.payout === 'kill' ? 'unseen' : 'perfect', `${c.effectId} ${c.name}`);
+    if (/^enemyeffect_3_/.test(c.effectId)) assert.equal(c.draftExcluded, 'unseen', `${c.effectId} ${c.name}`);
+  }
+  assert.deepEqual(reasons, { perfect: 20, hidden: 4, unseen: 19 });
+  const pools = {};
+  for (const c of CARDS) if (c.draft) pools[c.draftPool] = (pools[c.draftPool] || 0) + 1;
+  assert.deepEqual(pools, { initial: 42, boss: 20, hunter: 24 });
+  for (const modeId of [...COOP_BOUNTY_MODES, 'mode_single_hard', 'mode_single_abyss']) {
+    for (const r of DATA.choices.schedule[modeId].spRounds) {
+      for (const d of drafts(modeId, r, 40)) {
+        for (const c of d.cards) {
+          const card = CARD.get(c.id);
+          assert.ok(card.draft && card.draftPool === bountyDraftKind(r), `${modeId} R${r}: ${c.id} ${c.name}`);
+          assert.ok(!card.multiRound && card.payout === 'kill');
+        }
+      }
+    }
+  }
+});
+
+test('#2 the mode\'s inactive enemy list does not thin the bounty draft (PRTS 卫戍协议：盟约 11/18 note "不影响悬赏决策出场")', () => {
+  // 险境 turns off 尖端萨卡兹枯朽战车 and 灼藤 in its waves; their R11 cards (13_8, 12_7) stay in an R11-kind draft there
+  const sch = DATA.choices.schedule.mode_multi_normal;
+  const data = { ...DATA, choices: { ...DATA.choices, schedule: { ...DATA.choices.schedule, mode_multi_normal: { ...sch, rounds: { ...sch.rounds, 9: { ...sch.rounds['9'], families: [{ family: 'bounty', weight: 1 }], bountyDraft: 'hunter' } } } } } };
+  const gd = new GameData(data, 'mode_multi_normal');
+  const dropped = ['enemy_1272_nhtank_2', 'enemy_10067_ftsjc'];
+  for (const k of dropped) assert.ok(gd.inactiveEnemies.has(k), `${k} is inactive in 险境 waves`);
+  const seen = new Set();
+  for (const d of drafts('mode_multi_normal', 9, 200, data)) for (const c of d.cards) if (dropped.includes(c.enemyKey)) seen.add(c.enemyKey);
+  assert.deepEqual([...seen].sort(), dropped.slice().sort());
+});
+
+test('#2 E2E (co-op 绝境, the players\' case): the real R3 draft is an official R3 set, and the picked enemy comes for R3 and R4 at their round scale', () => {
+  for (let seed = 1; seed <= 6; seed++) {
+    const h = makeMatch({ mode: 'coop', difficulty: 'HARD', humans: 1, bots: 1, seed: 910 + seed, fake: true }).start();
+    const m = h.m;
+    assert.ok(h.drive(() => m.phase === PHASE.SP_DRAFT && m.round === 3, { ready: true }), 'the R3 draft');
+    assert.equal(m.sp.family, 'bounty', 'R3 of 绝境 is always a bounty draft');
+    const names = m.sp.cards.map((c) => c.name).join(', ');
+    assert.ok(initialFit(m.sp.cards.map((c) => c.id)), `seed ${seed}: ${names}`);
+    for (const c of m.sp.cards) assert.ok(!isBoss(c.enemyKey), `seed ${seed}: ${c.name} is a boss bounty`);
+    assert.equal(m.publicView().sp.cards.length, m.sp.cards.length);
+    // the human takes a card when its turn comes; the bot picks by itself
+    let picked = null;
+    for (let guard = 0; guard < 200 && m.phase === PHASE.SP_DRAFT; guard++) {
+      if (m.spTurn() === 'p_0') {
+        picked = m.sp.cards.find((c) => m.sp.taken[c.idx] == null);
+        assert.deepEqual(m.handle('p_0', { t: 'g.choice', idx: picked.idx }), { ok: true });
+      } else h.sched.runNext();
+    }
+    assert.ok(picked, 'the human picked');
+    const b = h.ps('p_0').bounties.find((x) => x.card.effectId === picked.id);
+    assert.ok(b, 'the picker holds the bounty');
+    h.drive(() => m.phase === PHASE.ROUND_START && m.round === 6, { ready: true });
+    const rounds = [];
+    for (const f of FakeBattle.instances) {
+      if (f.kind !== 'normal' || !f.players.includes('p_0')) continue;
+      const spec = f.spawns.find((s) => s.tag === 'bounty' && s.mods && s.mods.bountyId === b.id);
+      if (!spec) continue;
+      rounds.push(f.round);
+      const scale = m.gd.enemyScale(f.round);
+      assert.equal(spec.mods.hpMul, scale.hpMul, `R${f.round}: the bounty enemy takes the round's HP scale`);
+      assert.equal(spec.mods.atkMul, scale.atkMul, `R${f.round}: the bounty enemy takes the round's ATK scale`);
+    }
+    assert.deepEqual(rounds, [3, 4], `seed ${seed}: ${picked.name} (两场作战) spawned in R${rounds.join(', R')}`);
+    m.dispose();
+  }
+});
@@ -7,7 +7,7 @@ import { PHASE } from '../../shared/constants.js';
 import { DATA, makeMatch, give, chessOfTier, checkInvariants } from './harness.js';
 import { FakeBattle } from './fakeBattle.js';
 import { GameData } from '../../server/match/gamedata.js';
-import { generateDraft, cardView, MULTI_ROUND_BOUNTY_BATTLES } from '../../server/match/choices.js';
+import { generateDraft, cardView, bountyCard, MULTI_ROUND_BOUNTY_BATTLES } from '../../server/match/choices.js';
 import { createRng } from '../../server/sim/rng.js';
 import { Battle } from '../../server/sim/Battle.js';
 import { uniteLeft, battleProgress } from '../../server/sim/spec.js';
@@ -106,12 +106,12 @@ test('#19 a tier short of different operators: the offer tops up from the tier b

 // =====================================================================================================================
 // #4 — "官方版悬赏决策的敌人我没记错的话正常只会在选择之后出现两回合，现在是一直出"
-// The draft pool follows the PRTS 敌人轮选 table (卫戍协议：盟约 下半/PRTS盟约记录 §机变阶段), which lists the multi-round
-// "之后 / 后续的每场作战" cards too: v2.4.1 also drafted 战术特训 (only 法术教鞭 makes those) and the hidden 鸭爵 set, put
-// one or more multi-round cards in about half of the co-op R3 drafts and showed every card as plain text, so a "每场"
-// card looked like a "下场" one. Now: no 战术特训 / 鸭爵 set (战术特训 is the 教鞭 Art's, test/content/items.test.js), the
-// multi-round cards stay in as PRTS lists them, and each card names its battles in the official colours (blue "下场作战" /
-// "两场作战", red "每场"); a 1–2-battle bounty stops after its battles.
+// v2.4.1 drafted 战术特训 (only 法术教鞭 makes those) and the hidden 鸭爵 set, put one or more multi-round "之后 / 后续的每场
+// 作战" cards in about half of the co-op R3 drafts and showed every card as plain text, so a "每场" card looked like a
+// "下场" one. Now: no 战术特训 / 鸭爵 set (战术特训 is the 教鞭 Art's, test/content/items.test.js); since player feedback
+// #2 the drafts follow the 33 official screenshots (test/match/feedback1-bounty.test.js), where no multi-round card
+// appears; each card names its battles in the official colours (blue "下场作战" / "两场作战", red "每场"); a 1–2-battle
+// bounty stops after its battles; a multi-round card (教鞭's 法术大师A2·多轮战术特训) lasts two battles.

 const BOUNTY_MODES = ['mode_multi_normal', 'mode_multi_hard', 'mode_multi_abyss', 'mode_single_hard', 'mode_single_abyss'];
 /** 鸭爵 / 高普尼克 / 流泪小子 / 圆仔·悬赏: commented out of the PRTS 敌人轮选 table */
@@ -121,10 +121,9 @@ const DURATION_RE = { 1: /<@ba\.vup>下场(作战|战斗)<\/>/, 2: /<@ba\.vup>
 /** The official multi-round cards ("之后 / 后续的每场作战"): two battles since the user's playtest #6 answer. */
 const MULTI = new Set(DATA.choices.cards.bounty.filter((c) => c.multiRound).map((c) => c.effectId));

-test('#4 the 悬赏决策 draft: PRTS 敌人轮选 cards only (no 战术特训, no 鸭爵 set), each naming its battles in the official colours', () => {
+test('#4 the 悬赏决策 draft: kill bounties only (no 战术特训, no 鸭爵 set, no multi-round card), each naming its battles in the official colours', () => {
  let bountyDrafts = 0;
  let cards = 0;
-  let withMulti = 0;
  for (const modeId of BOUNTY_MODES) {
    const gd = new GameData(DATA, modeId);
    const sch = DATA.choices.schedule[modeId];
@@ -133,44 +132,38 @@ test('#4 the 悬赏决策 draft: PRTS 敌人轮选 cards only (no 战术特训,
        const d = generateDraft(gd, createRng(seed * 131 + r), r, { stageId: 'act2autochess_m01' });
        if (!d || d.family !== 'bounty') continue;
        bountyDrafts++;
-        let multi = 0;
        assert.equal(new Set(d.cards.map((c) => c.id)).size, d.cards.length, 'distinct cards');
        for (const c of d.cards) {
          cards++;
          assert.equal(c.payout, 'kill', `${modeId} R${r}: ${c.id} ${c.name} — 战术特训 comes from 法术教鞭 only`);
          assert.ok(!HIDDEN.has(c.id), `${c.id} ${c.name}: hidden from the PRTS table`);
          assert.ok([1, 2].includes(c.rounds), `${c.id}: ${c.rounds} battles`);
-          if (MULTI.has(c.id)) {
-            multi++;
-            assert.equal(c.rounds, 2, `${c.id} ${c.name}: a multi-round card lasts two battles (the user's call)`);
-            assert.ok(!/每场/.test(c.descRaw || ''), `${c.id}: no 每场 left in the card text`);
-          }
+          assert.ok(!MULTI.has(c.id), `${c.id} ${c.name}: no official draft shows a multi-round card (player feedback #2)`);
          assert.match(c.descRaw || '', DURATION_RE[c.rounds], `${c.id} ${c.name}: the card text shows its battles (${c.descRaw})`);
          assert.equal(cardView(c).descRaw, c.descRaw, 'the public card carries the rich text (ui/choiceOverlay.js renders it first)');
        }
-        if (multi) withMulti++;
      }
    }
  }
  assert.ok(bountyDrafts >= 100 && cards >= 400, `${bountyDrafts} bounty drafts, ${cards} cards`);
-  assert.ok(withMulti > 0, 'the multi-round cards are still offered (PRTS lists them), as two-battle cards');
 });

-test('#4 data: cards.bounty marks the draft pool after the PRTS table — 战术特训 (教鞭) and the 鸭爵 set are out, the multi-round cards and 源石虫·特训 in', () => {
+test('#4 data: cards.bounty marks the draft pool — 战术特训 (教鞭), the 鸭爵 set and the cards no official draft shows are out, 源石虫·特训 in', () => {
  const list = DATA.choices.cards.bounty;
  const reasons = {};
  for (const c of list) {
-    const expect = c.payout === 'kill' && !HIDDEN.has(c.effectId);
-    assert.equal(c.draft, expect, `${c.effectId} ${c.name}: draft ${c.draft}`);
+    if (c.payout !== 'kill') assert.equal(c.draftExcluded, 'perfect', `${c.effectId} ${c.name}`);
+    else if (HIDDEN.has(c.effectId)) assert.equal(c.draftExcluded, 'hidden', `${c.effectId} ${c.name}`);
    if (!c.draft) reasons[c.draftExcluded] = (reasons[c.draftExcluded] || 0) + 1;
    else assert.equal(c.draftExcluded, null);
  }
-  assert.deepEqual(reasons, { perfect: 20, hidden: 4 });
-  assert.equal(list.filter((c) => c.draft).length, 105);
+  assert.deepEqual(reasons, { perfect: 20, hidden: 4, unseen: 19 });
+  assert.equal(list.filter((c) => c.draft).length, 86);
  const multi = list.filter((c) => c.rounds >= 99 && c.payout === 'kill');
  assert.equal(multi.length, 7, '多轮悬赏 · 假想敌 ×6 + 山海众头目·多轮悬赏');
-  assert.ok(multi.every((c) => c.draft), 'PRTS lists them in 敌人轮选');
-  assert.equal(list.find((c) => c.effectId === 'enemyeffect_5_1').draft, true, '源石虫·特训 is in the table too');
+  assert.ok(multi.every((c) => !c.draft && c.draftExcluded === 'unseen'), 'in none of the 27 official bounty drafts');
+  const slime = list.find((c) => c.effectId === 'enemyeffect_5_1');
+  assert.ok(slime.draft && slime.draftPool === 'boss', '源石虫·特训 is an R9 card (8 of the 11 official R9 drafts)');
 });

 /** Drive a co-op 绝境 match to its R3 bounty draft; the human takes the first free card `want(card, free)` accepts. */
@@ -191,7 +184,7 @@ function pickAtR3(seed, want) {
  return { h, m, ps: h.ps('p_0'), picked };
 }

-/** Rounds (≤ R8) whose normal battle of p_0 spawned bounty `bountyId`. */
+/** Rounds whose normal battle of p_0 spawned bounty `bountyId`. */
 function bountyRounds(bountyId) {
  const out = [];
  for (const f of FakeBattle.instances) {
@@ -221,27 +214,29 @@ test('#4 E2E (co-op 绝境, the real R3 draft): a 1–2-battle bounty\'s enemies
 });

 test('#4 E2E: a multi-round card lasts two battles like the "两场作战" cards — blue text on the card and in the effects column (the user\'s call)', () => {
-  // "我不记得有过多轮悬赏" (user, after playtest #6): choices.js MULTI_ROUND_BOUNTY_BATTLES = 2; null restores 每场
+  // "我不记得有过多轮悬赏" (user, after playtest #6): choices.js MULTI_ROUND_BOUNTY_BATTLES = 2; null restores 每场. No
+  // official draft shows a multi-round card (player feedback #2); 教鞭's 法术大师A2·多轮战术特训 is one
  assert.equal(MULTI_ROUND_BOUNTY_BATTLES, 2);
-  let done = false;
-  for (let seed = 1; seed <= 40 && !done; seed++) {
-    const { h, m, ps, picked } = pickAtR3(700 + seed, (c) => MULTI.has(c.id));
-    if (!picked) { m.dispose(); continue; }
-    done = true;
-    assert.equal(picked.rounds, 2);
-    assert.match(picked.descRaw, /接下来<@ba\.vup>两场作战<\/>/, 'the draft card says 两场作战 in blue');
-    assert.ok(!/每场/.test(picked.descRaw), 'no red 每场');
-    const b = ps.bounties.find((x) => x.card.effectId === picked.id);
-    assert.equal(b.roundsLeft, 2);
-    const e = ps.privateView().effects.find((x) => x.id === b.id);
-    assert.equal(e.counterText, '还剩 2 场作战');
-    assert.match(e.desc, /<@ba\.vup>两场作战<\/>/, 'the effects tooltip says the same');
-    h.drive(() => m.phase === PHASE.ROUND_START && m.round === 9, { ready: true });
-    assert.deepEqual(bountyRounds(b.id), [3, 4], 'its enemy comes for two battles, then never again');
-    assert.ok(!ps.bounties.some((x) => x.id === b.id), 'and the bounty is gone');
-    m.dispose();
-  }
-  assert.ok(done, 'some R3 draft offered a multi-round card');
+  const h = makeMatch({ mode: 'coop', difficulty: 'HARD', humans: 1, bots: 1, seed: 701, fake: true }).start();
+  const m = h.m;
+  h.toPrep(4);
+  const ps = h.ps('p_0');
+  const src = DATA.choices.cards.bounty.find((c) => c.effectId === 'enemyeffect_2');
+  assert.ok(MULTI.has(src.effectId) && src.payout === 'perfect', '法术大师A2·多轮战术特训');
+  const card = bountyCard(m.gd, src);
+  assert.equal(card.rounds, 2);
+  assert.match(card.descRaw, /接下来<@ba\.vup>两场作战<\/>/, 'the card says 两场作战 in blue');
+  assert.ok(!/每场/.test(card.descRaw), 'no red 每场');
+  const id = m.addBounty(ps, src);
+  const b = ps.bounties.find((x) => x.id === id);
+  assert.equal(b.roundsLeft, 2);
+  const e = ps.privateView().effects.find((x) => x.id === b.id);
+  assert.equal(e.counterText, '还剩 2 场作战');
+  assert.match(e.desc, /<@ba\.vup>两场作战<\/>/, 'the effects tooltip says the same');
+  h.drive(() => m.phase === PHASE.ROUND_START && m.round === 7, { ready: true });
+  assert.deepEqual(bountyRounds(b.id), [4, 5], 'its enemies come for two battles, then never again');
+  assert.ok(!ps.bounties.some((x) => x.id === b.id), 'and the bounty is gone');
+  m.dispose();
 });

 test('#4 the active bounty says how many battles it has left, with its card text in the official colours (effects column)', () => {
@@ -0,0 +1,202 @@
+// Real-server browser E2E of player report #6 after 0.1.0: "凯瑟琳策略升级刷新的三个装备显示异常". A solo 险境 prep with the
+// strategy 凯瑟琳 (【定向投放】"每次升级调度中心时，在调度中心刷新随机3件装备，可以选择并获得其中1件"; test/e2e/fastServer.mjs
+// SP_START_ROUND 2: a starter kit + 20 funds) is driven with real input: the LEVEL card is tapped twice (确认升级) and the
+// three free items replace the bar's operator cards — each drawn as an item card (icon, name, tier, description, FREE),
+// under a 定向投放 header (not 晋升奖励 / PROMOTION), with the item's detail on the first tap; the second tap takes it into
+// the hand and the bar shows the shop again. Desktop 1920×1080 and the phones 844×390 / 756×366 (touch). Zero console
+// errors. Screenshots: test/e2e/out/fb1-offer-*.png. A second case puts the offer off (稍后) and levels up again: the
+// pill reads 定向投放待选择 +1, the header 之后还有 1 项, and the second offer follows the first pick
+// (test/e2e/out/fb1-queue-*.png).
+//
+//   SP_E2E=1 node --test test/ui/feedback1-offers.e2e.test.js
+
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { Client, ROOT, sleep, hasChrome, startRealServer, problemsOf } from '../e2e/client.mjs';
+
+const ENABLED = process.env.SP_E2E === '1' && hasChrome() && existsSync(path.join(ROOT, 'public/assets'));
+
+async function soloToPrep(c, bandName) {
+  await c.open();
+  await c.enter('煌');
+  await c.click('.mode-card', '独立模拟');
+  await c.click('.diff-card', '险境');
+  await c.click('.create-box button', '开始独立模拟');
+  await c.waitFor((s) => !!s.room, 'solo room');
+  if (!(await c.st()).phase) await c.click('.room-bar__right button', '开始模拟', { timeout: 20000 });
+  await c.waitFor((s) => s.phase === 'INFO_CHECK', 'briefing', 30000);
+  await c.click('.brief__foot .btn--primary', '准备就绪');
+  await c.waitFor((s) => s.phase === 'BAND_DRAFT', 'band draft', 30000);
+  await c.click('.dband', bandName);
+  await c.click('.draft-detail__btns .btn--primary', '确认选择');
+  await c.waitFor((x) => x.phase === 'PREP' && !x.ready, 'prep', 60000);
+  await sleep(1800);
+}
+
+/** The offer as drawn: header texts, the cards (kind, name, description, art, free tag) and their boxes. */
+function offerDom(c) {
+  return c.page.evaluate(() => {
+    const box = (el) => { if (!el) return null; const r = el.getBoundingClientRect(); return { l: r.left, t: r.top, r: r.right, b: r.bottom, w: r.width, h: r.height }; };
+    const root = document.querySelector('.shopbar__reward');
+    if (!root) return null;
+    const cards = [...root.querySelectorAll('.scard')].map((el) => ({
+      item: el.classList.contains('scard--item'),
+      name: el.querySelector('.scard__name')?.textContent.trim() || '',
+      desc: el.querySelector('.scard__idesc')?.textContent.trim() || '',
+      icon: !!el.querySelector('.scard__itemart img'),
+      free: !!el.querySelector('.scard__free'),
+      tier: el.querySelector('.tierchip, [class*="tier"]')?.textContent.trim() || '',
+      box: box(el),
+      clipped: el.scrollHeight > el.clientHeight + 1 || el.scrollWidth > el.clientWidth + 1,
+    }));
+    return {
+      title: root.querySelector('.rwtag__title')?.textContent.trim() || '',
+      micro: root.querySelector('.rwtag__micro')?.textContent.trim() || '',
+      sub: root.querySelector('.rwtag__sub')?.textContent.trim() || '',
+      cards, root: box(root), vw: innerWidth, vh: innerHeight,
+    };
+  });
+}
+
+const privOf = (c) => c.page.evaluate(() => globalThis.__SP__.store.get().match.private);
+
+describe('player report #6: 凯瑟琳\'s three free items after a level-up (real server, headless Chrome)', { skip: !ENABLED && 'set SP_E2E=1 (and have Chrome + assets) to run' }, () => {
+  test('the level-up offer shows three item cards (desktop and phones); a pick puts the item into the hand', { timeout: 240000 }, async () => {
+    const puppeteer = (await import('puppeteer-core')).default;
+    const srv = await startRealServer({ fast: { timerScale: 0.5, combatSpeed: 4, startRound: 2 } });
+    const c = new Client(puppeteer, srv.base, 'cathy', { prefix: 'fb1-offer' });
+    try {
+      await soloToPrep(c, '凯瑟琳');
+      assert.equal((await privOf(c)).bandId, 'band_cathy', 'strategy 凯瑟琳');
+      // LEVEL: first tap arms 确认升级, the second upgrades
+      await c.click('.lvcard');
+      await sleep(250);
+      await c.click('.lvcard');
+      await c.page.waitForFunction(() => !!globalThis.__SP__.store.get().match.private?.shop?.rewardOffer, { timeout: 8000 });
+      await sleep(600);
+      const priv = await privOf(c);
+      const offer = priv.shop.rewardOffer;
+      assert.equal(offer.slots.length, 3, 'three items');
+      assert.ok(offer.slots.every((s) => s.kind === 'item' && s.price === 0), JSON.stringify(offer));
+      const names = await c.page.evaluate((ids) => ids.map((id) => globalThis.__SP__.data.lookup('items', id)?.name), offer.slots.map((s) => s.id));
+      await c.shot('desktop');
+      const dom = await offerDom(c);
+      assert.ok(dom, 'the offer is in the bar');
+      assert.equal(dom.title, '定向投放', `the header names the strategy (${dom.title} / ${dom.micro})`);
+      assert.match(dom.sub, /免费选择 1 件/);
+      assert.deepEqual(dom.cards.map((x) => x.name), names, 'the item names');
+      for (const card of dom.cards) {
+        assert.ok(card.item, `${card.name}: drawn as an item card`);
+        assert.ok(card.icon, `${card.name}: the item icon`);
+        assert.ok(card.desc.length > 2, `${card.name}: the description`);
+        assert.ok(card.free, `${card.name}: FREE`);
+      }
+      // phones (touch, landscape): the same cards inside the viewport, none overlapping another
+      const browserUa = await c.browser.userAgent();
+      for (const [w, h] of [[844, 390], [756, 366]]) {
+        await c.page.emulate({ viewport: { width: w, height: h, deviceScaleFactor: 2, isMobile: true, hasTouch: true, isLandscape: true }, userAgent: browserUa });
+        await c.page.waitForFunction(() => !!document.querySelector('.shopbar__reward .scard'), { timeout: 30000 });
+        await sleep(900);
+        await c.page.screenshot({ path: path.join(ROOT, 'test/e2e/out', `fb1-offer-${w}x${h}.png`) });
+        const d = await offerDom(c);
+        assert.ok(d && d.cards.length === 3, `${w}×${h}: three cards`);
+        for (const card of d.cards) {
+          assert.ok(card.item && card.icon, `${w}×${h} ${card.name}: an item card with its icon`);
+          assert.ok(card.box.l >= 0 && card.box.r <= w + 0.5 && card.box.t >= 0 && card.box.b <= h + 0.5, `${w}×${h} ${card.name}: inside the viewport ${JSON.stringify(card.box)}`);
+        }
+        for (let i = 1; i < d.cards.length; i++) assert.ok(d.cards[i].box.l >= d.cards[i - 1].box.r - 0.5, `${w}×${h}: cards ${i - 1} / ${i} do not overlap`);
+      }
+      await c.page.emulate({ viewport: { width: 1920, height: 1080, deviceScaleFactor: 1, isMobile: false, hasTouch: false }, userAgent: browserUa });
+      // switching touch emulation reloads the page: the session resumes with the offer still queued (re-hook the intents)
+      await c.page.waitForFunction(() => !!globalThis.__SP__?.store.get().match.private?.shop?.rewardOffer && !!document.querySelector('.shopbar__reward'), { timeout: 30000 });
+      await sleep(900);
+      await c.hookRequests();
+      // first tap: armed + the item's detail; second tap: taken
+      const want = names[1];
+      await c.click('.shopbar__reward .scard', want);
+      await sleep(400);
+      const armed = await c.page.evaluate(() => ({
+        armed: document.querySelector('.shopbar__reward .scard.is-armed .scard__name')?.textContent.trim() || null,
+        strip: document.querySelector('.shopbar__reward .scard.is-armed .scard__confirm')?.textContent.trim() || null,
+        detail: document.querySelector('.dpanel')?.textContent || '',
+      }));
+      assert.equal(armed.armed, want, 'the tapped card is armed');
+      assert.match(armed.strip || '', /确认选择/);
+      assert.ok(armed.detail.includes(want), 'the detail card shows the item');
+      await c.shot('armed');
+      await c.click('.shopbar__reward .scard.is-armed');
+      await c.page.waitForFunction(() => !globalThis.__SP__.store.get().match.private?.shop?.rewardOffer, { timeout: 8000 });
+      const after = await privOf(c);
+      const got = await c.page.evaluate((hand) => hand.filter((p) => p && p.kind === 'item').map((p) => globalThis.__SP__.data.lookup('items', p.id)?.name), after.hand);
+      assert.ok(got.includes(want), `the item is in the hand (${got.join(', ')})`);
+      assert.equal((await c.requests('g.reward')).length, 1, 'one g.reward');
+      await sleep(300);
+      assert.ok(await c.exists('.shopbar__cards'), 'the shop is back');
+      await c.shot('after');
+      assert.deepEqual(problemsOf([c]), []);
+    } finally {
+      await c.close();
+      await srv.stop();
+    }
+  });
+
+  test('an offer put off (稍后) and a second level-up: the pill says "+1", the header "之后还有 1 项", then the second offer', { timeout: 180000 }, async () => {
+    const puppeteer = (await import('puppeteer-core')).default;
+    const srv = await startRealServer({ fast: { timerScale: 0.5, combatSpeed: 4, startRound: 2 } });
+    const c = new Client(puppeteer, srv.base, 'cathy2', { prefix: 'fb1-queue' });
+    const levelUp = async () => { await c.click('.lvcard'); await sleep(250); await c.click('.lvcard'); };
+    const offerOf = () => c.page.evaluate(() => globalThis.__SP__.store.get().match.private?.shop?.rewardOffer || null);
+    try {
+      await soloToPrep(c, '凯瑟琳');
+      await levelUp();
+      await c.page.waitForFunction(() => !!document.querySelector('.shopbar__reward .scard'), { timeout: 8000 });
+      await c.click('.rwtag__later');
+      await c.page.waitForFunction(() => !!document.querySelector('.rewardpill') && !!document.querySelector('.shopbar__cards'), { timeout: 8000 });
+      await levelUp();
+      await c.page.waitForFunction(() => globalThis.__SP__.store.get().match.private?.shop?.rewardOffer?.queued === 1, { timeout: 8000 });
+      await sleep(400);
+      const pill = await c.page.evaluate(() => document.querySelector('.rewardpill')?.textContent.replace(/\s+/g, '') || '');
+      assert.match(pill, /定向投放待选择/);
+      assert.match(pill, /\+1/, `the pill counts the offer behind (${pill})`);
+      await c.shot('pill');
+      await c.click('.rewardpill');
+      await c.page.waitForFunction(() => !!document.querySelector('.shopbar__reward .scard'), { timeout: 8000 });
+      await sleep(300);
+      assert.equal(await c.page.evaluate(() => document.querySelector('.rwtag__more')?.textContent.trim() || null), '之后还有 1 项');
+      await c.shot('offer');
+      // the narrowest phone: the header strip still holds every line and the 稍后 button inside the screen
+      const browserUa = await c.browser.userAgent();
+      await c.page.emulate({ viewport: { width: 756, height: 366, deviceScaleFactor: 2, isMobile: true, hasTouch: true, isLandscape: true }, userAgent: browserUa });
+      await c.page.waitForFunction(() => !!document.querySelector('.rwtag__more'), { timeout: 30000 });
+      await sleep(900);
+      await c.page.screenshot({ path: path.join(ROOT, 'test/e2e/out', 'fb1-queue-756x366.png') });
+      const strip = await c.page.evaluate(() => {
+        const box = (el) => { const r = el.getBoundingClientRect(); return { l: r.left, t: r.top, r: r.right, b: r.bottom }; };
+        const tag = document.querySelector('.rwtag');
+        return { tag: box(tag), parts: [...tag.children].map((el) => ({ cls: el.className, ...box(el) })), vw: innerWidth, vh: innerHeight };
+      });
+      for (const part of strip.parts) {
+        assert.ok(part.t >= strip.tag.t - 0.5 && part.b <= strip.tag.b + 0.5 && part.b <= strip.vh + 0.5, `756×366 ${part.cls}: inside the strip and the screen ${JSON.stringify(strip)}`);
+      }
+      await c.page.emulate({ viewport: { width: 1920, height: 1080, deviceScaleFactor: 1, isMobile: false, hasTouch: false }, userAgent: browserUa });
+      await c.page.waitForFunction(() => !!document.querySelector('.shopbar__reward .scard'), { timeout: 30000 });
+      await sleep(900);
+      await c.hookRequests();
+      const first = await offerOf();
+      await c.click('.shopbar__reward .scard');
+      await sleep(300);
+      await c.click('.shopbar__reward .scard.is-armed');
+      await c.page.waitForFunction((ids) => { const o = globalThis.__SP__.store.get().match.private?.shop?.rewardOffer; return !!o && o.queued === 0 && o.slots.map((x) => x.id).join() !== ids; }, { timeout: 8000 }, first.slots.map((x) => x.id).join());
+      await sleep(300);
+      assert.equal(await c.exists('.rwtag__more'), false, 'nothing behind the second offer');
+      assert.equal(await c.page.evaluate(() => document.querySelector('.rwtag__title')?.textContent.trim()), '定向投放');
+      await c.shot('second');
+      assert.deepEqual(problemsOf([c]), []);
+    } finally {
+      await c.close();
+      await srv.stop();
+    }
+  });
+});
@@ -0,0 +1,224 @@
+// Player feedback after 0.1.0, report #6 (workstream WB): "凯瑟琳策略升级刷新的三个装备显示异常". The strategy 凯瑟琳
+// (【定向投放】"每次升级调度中心时，在调度中心刷新随机3件装备，可以选择并获得其中1件") queues a free pick-one offer of three
+// items; the shop bar drew every offer slot as an operator card (ChessCard on an item id: no art, the raw id as the name,
+// tier I, no description) under the promotion reward's 晋升奖励 / PROMOTION header, and the reminder pill said
+// 晋升奖励待选择. Now: m.private shop.rewardOffer says what made the offer (`source` 'merge' | 'special', `label` = the
+// effect's name — effectsMeta.offerLabel), an item slot is drawn as an item card (FREE) and the header / pill name the
+// offer (gameLogic.offerHeader; `queued` — "之后还有 N 项" / the pill's "+N" — when more offers wait behind it, e.g. a
+// 定向投放 behind a promotion reward put off). The same path serves 娜仁图亚 见者有份 (two items), 寻呼模块 / 信标
+// (operators, an item's name) and 松果's 特质. Real match paths for the server side; the bar's offer cards rendered as
+// vnodes.
+// The browser check (desktop + phones, real input) is test/ui/feedback1-offers.e2e.test.js (SP_E2E=1).
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
+globalThis.fetch = async (url) => {
+  const name = String(url).split('/').pop();
+  try {
+    const body = readFileSync(path.join(ROOT, 'data', name), 'utf8');
+    return { ok: true, status: 200, json: async () => JSON.parse(body) };
+  } catch {
+    return { ok: false, status: 404, json: async () => ({}) };
+  }
+};
+
+const { offerHeader } = await import('../../public/js/ui/gameLogic.js');
+const { RewardCards, ItemCard, ChessCard } = await import('../../public/js/ui/shopBar.js');
+const { RewardOverlay } = await import('../../public/js/ui/rewardOverlay.js');
+const { data } = await import('../../public/js/data.js');
+const { DATA, makeMatch, give, giveItem, chessOfTier, legalTileFor } = await import('../match/harness.js');
+const { offerLabel } = await import('../../server/match/effectsMeta.js');
+
+await data.loadAll('chess', 'bonds', 'items', 'assets');
+
+const OK = { ok: true };
+const PAGER = 'chess_item_4_01_e_a'; // 寻呼模块
+
+/** A solo prep with an empty board and hand, plenty of funds, the given strategy. */
+function prep(band, seed = 61) {
+  const h = makeMatch({ mode: 'solo', difficulty: 'NORMAL', seed, fake: true }).start();
+  h.toPrep(1);
+  const m = h.m;
+  const ps = h.ps('p_0');
+  for (const p of [...ps.board.values(), ...ps.hand.filter(Boolean)]) if (p.kind === 'chess') ps.returnCopies(p);
+  ps.board.clear();
+  ps.hand.fill(null);
+  ps.offers.length = 0;
+  ps.funds = 60;
+  ps.bandId = band;
+  ps.recompute();
+  return { h, m, ps };
+}
+
+function* walk(v) {
+  if (Array.isArray(v)) { for (const x of v) yield* walk(x); return; }
+  if (!v || typeof v !== 'object') return;
+  yield v;
+  yield* walk(v.props?.children);
+}
+
+describe('#6 the server names its offers (m.private shop.rewardOffer source / label)', () => {
+  test('凯瑟琳 (the players\' case): a level-up offers three different items, free, labelled 定向投放; a pick takes one into the hand', () => {
+    const { m, ps } = prep('band_cathy');
+    ps.shop.upgradePrice = 0;
+    assert.deepEqual(m.handle('p_0', { t: 'g.levelUp' }), OK);
+    const offer = ps.privateView().shop.rewardOffer;
+    assert.ok(offer, 'an offer after the level-up');
+    assert.equal(offer.source, 'special');
+    assert.equal(offer.label, '定向投放', 'the strategy\'s effect name');
+    assert.equal(offer.tier, null, 'items carry their own tiers');
+    assert.equal(offer.slots.length, 3);
+    assert.equal(new Set(offer.slots.map((s) => s.id)).size, 3, 'three different items');
+    for (const s of offer.slots) {
+      assert.equal(s.kind, 'item');
+      assert.equal(s.price, 0);
+      assert.ok(DATA.items[s.id] && DATA.items[s.id].itemType === 'EQUIP' && DATA.items[s.id].tier <= ps.shop.level, s.id);
+    }
+    const want = offer.slots[1].id;
+    const funds = ps.funds;
+    assert.deepEqual(m.handle('p_0', { t: 'g.reward', idx: 1 }), OK);
+    assert.equal(ps.funds, funds, 'free');
+    assert.ok([...ps.hand, ...ps.temp].some((p) => p && p.kind === 'item' && (p.id === want || p.id === DATA.items[want].goldenId)), 'the item is owned');
+    assert.equal(ps.privateView().shop.rewardOffer, null, 'the offer is gone');
+    m.dispose();
+  });
+
+  test('two level-ups in one prep queue two offers: the second shows after the first pick, never stale', () => {
+    const { m, ps } = prep('band_cathy', 62);
+    for (let i = 0; i < 2; i++) { ps.shop.upgradePrice = 0; assert.deepEqual(m.handle('p_0', { t: 'g.levelUp' }), OK); }
+    assert.equal(ps.offers.length, 2, 'two offers queued');
+    assert.equal(ps.privateView().shop.rewardOffer.slots.length, 3, 'the first one is shown');
+    assert.equal(ps.privateView().shop.rewardOffer.queued, 1, 'one more waits behind it');
+    assert.deepEqual(m.handle('p_0', { t: 'g.reward', idx: 0 }), OK);
+    const second = ps.privateView().shop.rewardOffer;
+    assert.ok(second && second.label === '定向投放' && second.slots.length === 3 && second.slots.every((s) => !s.sold), 'the second offer, all free to pick');
+    assert.equal(second.queued, 0);
+    assert.deepEqual(m.handle('p_0', { t: 'g.reward', idx: 2 }), OK);
+    assert.equal(ps.privateView().shop.rewardOffer, null);
+    m.dispose();
+  });
+
+  test('娜仁图亚 见者有份 (two items), 寻呼模块 (operators of its bond) and the promotion reward', () => {
+    const { m, ps } = prep('band_narant', 63);
+    ps.shop.level = 3;
+    m.round = 2;
+    m.dispatch(ps, 'onRoundStart', { round: 2 });
+    let offer = ps.privateView().shop.rewardOffer;
+    assert.ok(offer && offer.source === 'special' && offer.label === '见者有份', JSON.stringify(offer));
+    assert.equal(offer.slots.length, 2);
+    assert.ok(offer.slots.every((s) => s.kind === 'item'));
+    ps.offers.length = 0;
+    // 寻呼模块: equipped on an operator — three operators sharing a bond, labelled with the item
+    const id = chessOfTier(1).find((x) => m.pool.has(x) && m.pool.left(x) > 0);
+    const op = give(m, ps, id, 'board', legalTileFor(m, ps, id));
+    const pager = giveItem(m, ps, PAGER);
+    assert.deepEqual(m.handle('p_0', { t: 'g.equip', itemUid: pager.uid, targetUid: op.uid }), OK);
+    offer = ps.privateView().shop.rewardOffer;
+    assert.ok(offer && offer.source === 'special' && offer.label === '寻呼模块', JSON.stringify(offer));
+    assert.ok(offer.slots.length >= 1 && offer.slots.every((s) => s.kind === 'chess'));
+    ps.offers.length = 0;
+    // the promotion reward
+    ps.pushRewardOffer('merge');
+    offer = ps.privateView().shop.rewardOffer;
+    assert.equal(offer.source, 'merge');
+    assert.equal(offer.label, null);
+    assert.ok(Number.isInteger(offer.tier));
+    m.dispose();
+  });
+
+  test('a promotion reward put off, then a 凯瑟琳 level-up: the promotion reward shows with "+1" (queued 1), then 定向投放', () => {
+    const { m, ps } = prep('band_cathy', 65);
+    ps.pushRewardOffer('merge');
+    ps.shop.upgradePrice = 0;
+    assert.deepEqual(m.handle('p_0', { t: 'g.levelUp' }), OK);
+    let offer = ps.privateView().shop.rewardOffer;
+    assert.equal(offer.source, 'merge', 'the promotion reward first');
+    assert.equal(offer.queued, 1, 'the 定向投放 offer waits behind it');
+    const head = offerHeader(offer);
+    assert.equal(head.pill, '晋升奖励待选择');
+    assert.equal(head.queued, 1);
+    assert.equal(head.more, '之后还有 1 项');
+    const pill = RewardOverlay({ priv: { shop: { rewardOffer: offer } }, minimized: true, onMinimize() {} });
+    const texts = [...walk(pill)].flatMap((n) => (Array.isArray(n.props?.children) ? n.props.children.filter((x) => typeof x === 'string' || typeof x === 'number') : typeof n.props?.children === 'string' ? [n.props.children] : []));
+    assert.ok(texts.join('').includes('+1'), `the pill says +1 (${texts.join(' | ')})`);
+    assert.deepEqual(m.handle('p_0', { t: 'g.reward', idx: 0 }), OK);
+    offer = ps.privateView().shop.rewardOffer;
+    assert.ok(offer.source === 'special' && offer.label === '定向投放' && offer.queued === 0, JSON.stringify(offer));
+    assert.equal(offerHeader(offer).more, null);
+    m.dispose();
+  });
+
+  test('offerLabel: a strategy → its effect name, an item → its name, a 特质 → its operator, anything else → null', () => {
+    const { m } = prep(null, 64);
+    const gd = m.gd;
+    assert.equal(offerLabel(gd, { kind: 'band', bandId: 'band_cathy' }), '定向投放');
+    assert.equal(offerLabel(gd, { kind: 'band', band: gd.band('band_narant') }), '见者有份');
+    assert.equal(offerLabel(gd, { kind: 'item', piece: { id: 'chess_item_5_04_e_a' } }), '信标');
+    const chess = chessOfTier(2)[0];
+    assert.equal(offerLabel(gd, { kind: 'garrison', piece: { id: chess } }), DATA.chess[chess].name);
+    assert.equal(offerLabel(gd, { kind: 'global', key: 'global:x' }), null);
+    assert.equal(offerLabel(gd, null), null);
+    m.dispose();
+  });
+});
+
+describe('#6 the shop bar draws the offer by its slots and names it', () => {
+  const ITEMS = Object.values(DATA.items).filter((it) => it.itemType === 'EQUIP' && !it.isGolden).slice(0, 3).map((it) => it.id);
+  const cathy = { tier: null, source: 'special', label: '定向投放', slots: ITEMS.map((id) => ({ kind: 'item', id, price: 0, sold: false })) };
+  const merge = { tier: 3, source: 'merge', label: null, slots: chessOfTier(3).slice(0, 3).map((id) => ({ kind: 'chess', id, price: 0, sold: false })) };
+
+  test('offerHeader: 晋升奖励 for the promotion reward, the label for a special refresh (items: 免费选择 1 件)', () => {
+    assert.deepEqual(offerHeader(merge), { title: '晋升奖励', micro: 'PROMOTION', sub: '免费选择 1 名', icon: 'crown', items: false, pill: '晋升奖励待选择', queued: 0, more: null });
+    assert.deepEqual(offerHeader(cathy), { title: '定向投放', micro: 'SPECIAL', sub: '免费选择 1 件', icon: 'refresh', items: true, pill: '定向投放待选择', queued: 0, more: null });
+    assert.equal(offerHeader({ ...cathy, queued: 2 }).more, '之后还有 2 项');
+    assert.equal(offerHeader({ ...cathy, queued: -1 }).queued, 0, 'a bad count is ignored');
+    assert.equal(offerHeader({ ...merge, source: 'special', label: '寻呼模块' }).title, '寻呼模块');
+    assert.equal(offerHeader({ ...merge, source: 'special', label: '寻呼模块' }).sub, '免费选择 1 名');
+    assert.equal(offerHeader({ ...cathy, label: null }).title, '装备补给', 'an unnamed item offer');
+    assert.equal(offerHeader({ tier: 2, slots: merge.slots }).title, '晋升奖励', 'an offer view without source (older server) is the promotion reward');
+  });
+
+  test('RewardCards: item slots → ItemCard (FREE), chess slots → ChessCard; the header says 定向投放', () => {
+    const priv = { alive: true, funds: 0, hand: Array(10).fill(null), temp: Array(5).fill(null), board: [], shop: { rewardOffer: cathy } };
+    const v = RewardCards({ offer: cathy, priv, editable: true, onPick() {}, onDetail() {}, onLater() {}, armed: null, onTap() {} });
+    const nodes = [...walk(v)];
+    const cards = nodes.filter((n) => n.type === ItemCard || n.type === ChessCard);
+    assert.equal(cards.length, 3);
+    for (const c of cards) {
+      assert.equal(c.type, ItemCard, 'an item card');
+      assert.equal(c.props.free, true, 'FREE');
+      assert.equal(c.props.slot.price, 0);
+      assert.equal(c.props.reason, null, 'pickable with 0 funds');
+    }
+    const title = nodes.find((n) => typeof n.props?.class === 'string' && n.props.class.includes('rwtag__title'));
+    assert.equal(String(title.props.children), '定向投放');
+    // the item card itself: icon, name, description, FREE (no price hex)
+    const card = ItemCard({ ...cards[0].props });
+    const inner = [...walk(card.type === 'button' || card.props?.class?.includes?.('scard') ? card : card.props.children)];
+    const texts = inner.flatMap((n) => (typeof n.props?.children === 'string' ? [n.props.children] : []));
+    assert.ok(texts.includes(DATA.items[ITEMS[0]].name), `the name (${texts.join(' | ')})`);
+    assert.ok(inner.some((n) => typeof n.props?.class === 'string' && n.props.class.includes('scard__itemart')), 'the item art');
+    // the promotion reward still draws operator cards under 晋升奖励
+    const vm = RewardCards({ offer: merge, priv: { ...priv, shop: { rewardOffer: merge } }, editable: true, onPick() {}, onDetail() {}, onLater() {}, armed: null, onTap() {} });
+    const mcards = [...walk(vm)].filter((n) => n.type === ItemCard || n.type === ChessCard);
+    assert.ok(mcards.length === 3 && mcards.every((c) => c.type === ChessCard));
+    assert.equal(String([...walk(vm)].find((n) => typeof n.props?.class === 'string' && n.props.class.includes('rwtag__title')).props.children), '晋升奖励');
+    assert.ok(!nodes.some((n) => typeof n.props?.class === 'string' && n.props.class.includes('rwtag__more')), 'nothing queued: no "之后还有" line');
+    // an offer with another one behind it says so in the header
+    const vq = RewardCards({ offer: { ...merge, queued: 1 }, priv: { ...priv, shop: { rewardOffer: merge } }, editable: true, onPick() {}, onDetail() {}, onLater() {}, armed: null, onTap() {} });
+    const more = [...walk(vq)].find((n) => typeof n.props?.class === 'string' && n.props.class.includes('rwtag__more'));
+    assert.equal(String(more.props.children), '之后还有 1 项');
+  });
+
+  test('the reminder pill names the offer (定向投放待选择), with a tier chip only for operator offers', () => {
+    const pill = RewardOverlay({ priv: { shop: { rewardOffer: cathy } }, minimized: true, onMinimize() {} });
+    const texts = [...walk(pill)].flatMap((n) => (typeof n.props?.children === 'string' ? [n.props.children] : []));
+    assert.ok(texts.includes('定向投放待选择'), texts.join(' | '));
+    const mp = RewardOverlay({ priv: { shop: { rewardOffer: merge } }, minimized: true, onMinimize() {} });
+    assert.ok([...walk(mp)].flatMap((n) => (typeof n.props?.children === 'string' ? [n.props.children] : [])).includes('晋升奖励待选择'));
+  });
+});
@@ -10,7 +10,7 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { DATA } from '../match/harness.js';
 import { GameData } from '../../server/match/gamedata.js';
-import { generateDraft, cardView } from '../../server/match/choices.js';
+import { generateDraft, cardView, bountyCard } from '../../server/match/choices.js';
 import { createRng } from '../../server/sim/rng.js';

 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
@@ -37,10 +37,15 @@ test('#4 the draft overlay shows each bounty card\'s battles in the official col
  // the official multi-round cards: two battles, in the two-battle cards' blue (the user's call after playtest #6)
  const MULTI = new Set(DATA.choices.cards.bounty.filter((c) => c.multiRound).map((c) => c.effectId));
  const seen = new Set();
-  for (let seed = 1; seed <= 40 && seen.size < 3; seed++) {
-    const d = generateDraft(gd, createRng(seed * 977 + 3), 3, { stageId: 'act2autochess_m02' });
-    assert.equal(d.family, 'bounty', 'co-op 绝境 R3 is a bounty draft');
-    const sp = normalizeSp({ family: d.family, cards: d.cards.map(cardView), order: ['p_0'], turn: 'p_0', picks: {}, taken: {} }, [{ playerId: 'p_0' }]);
+  // R3 offers the two-battle cards, R9 the next-battle ones (player feedback #2: the official drafts); no draft offers a
+  // multi-round card any more, so one (教鞭's 法术大师A2·多轮战术特训) goes through the same card view on its own
+  const multiCard = bountyCard(gd, DATA.choices.cards.bounty.find((c) => c.effectId === 'enemyeffect_2'));
+  for (let seed = 1; seed <= 80 && seen.size < 3; seed++) {
+    const round = seed % 2 ? 3 : 9;
+    const d = generateDraft(gd, createRng(seed * 977 + 3), round, { stageId: 'act2autochess_m02' });
+    assert.equal(d.family, 'bounty', `co-op 绝境 R${round} is a bounty draft`);
+    const cards = seed === 1 ? [...d.cards.slice(0, 5), { ...multiCard, idx: 5, family: 'bounty' }] : d.cards;
+    const sp = normalizeSp({ family: d.family, cards: cards.map(cardView), order: ['p_0'], turn: 'p_0', picks: {}, taken: {} }, [{ playerId: 'p_0' }]);
    for (const card of sp.cards) {
      const view = resolveSpCard(card, sp.family);
      const segs = parseRichText(view.desc).filter((s) => s.text);
@@ -2319,11 +2319,15 @@ const ROMAN = { I: 1, II: 2, III: 3 };
 *              "※以下悬赏任务仅由法术教鞭生成"
 *   'hidden'   鸭爵 / 高普尼克 / 流泪小子 / 圆仔·悬赏 (enemyeffect_5..8): commented out of the table (the 鸭爵 strategy
 *              “神秘顾客” swaps those enemies into the waves instead)
- * Everything else is drafted, as the table lists it: the "下场作战" and "接下来两场作战" kill bounties, 源石虫·特训
- * ("但不获得资金") and the 7 multi-round cards ("之后 / 后续的每场作战": 山海众头目·多轮悬赏, 多轮悬赏·假想敌 ×6), whose
+ *   'unseen'   kill bounties no official draft showed (33 screenshots of 11 official matches, player feedback after
+ *              0.1.0 report #2 — see BOUNTY_INITIAL_SETS below): the 7 multi-round cards ("之后 / 后续的每场作战": 山海众头目·
+ *              多轮悬赏, 多轮悬赏·假想敌 ×6), the pre-series cards enemyeffect_3_* and the boss bounties of no seen R9 group
+ *              (凋零骑士, “遗弃者”, 锏, 扎罗, 迷路的巨像) [ASSUMED: not offered]
+ * The rest is drafted, by the kind of draft it belongs to (`draftPool`, bountyDraftPool): the "接下来两场作战" cards at R3,
+ * the boss bounties and 源石虫·特训 ("但不获得资金") at R9, the faction / 特异 "下场战斗" cards at R11. A multi-round card's
 * official text carries the red "每场" (`multiRound`, `rounds` 99 kept as the data has them; the server makes such a
 * card last MULTI_ROUND_BOUNTY_BATTLES = 2 battles and rewrites its text — server/match/choices.js bountyBattles /
- * bountyText, the user's call after playtest #6). The 战术特训 cards are what the
+ * bountyText, the user's call after playtest #6; 教鞭's 法术大师A2·多轮战术特训 is one). The 战术特训 cards are what the
 * 教鞭 Art offers (PRTS 法术 教鞭 "于3个战术特训的悬赏任务中选择一项"; server/sim/content/items/meta.js); nothing in
 * act2 offers the 鸭爵 set.
 */
@@ -2334,6 +2338,91 @@ function bountyDraftExclusion(e, main) {
  return null;
 }

+/**
+ * The official 悬赏决策 drafts (player feedback after 0.1.0, report #2: "本来应该后期出的悬赏的怪物在前期的悬赏就出现了，导致选了
+ * 打不过"), read from 33 screenshots of 11 official co-op 绝境 / 终极 matches at the start of rounds 3, 9 and 11 (collected
+ * by the user, 2026-10-03; the readings are test/fixtures/official-bounty-drafts.json). Every card's title, enemy and coin
+ * value is an act2autochess (下半) effect. A card's enemy is fixed by its effect (blackboard `enemy_id`); the title only
+ * names the category and tier, so 悬赏·损伤I is 底海滑动者 in enemyeffect_12_4 and 临时收音师 in enemyeffect_18_1. The draft
+ * of a round is one of three kinds (the event ids are the data's; which event lists which cards is server-side):
+ *   initial  R3 (enemy_initial_1..10): six "接下来两场作战" cards, always 3 × I (1 coin) + 2 × II + 1 × III. All 11 R3
+ *            drafts are one of 7 fixed sets (BOUNTY_INITIAL_SETS): a whole series 17 / 18 / 19 (18 in 4 matches) or one
+ *            card from each of 6 of the series 10–15 and 20 (one such set in two matches). The 3 other events of the 10
+ *            are unseen: built by that rule (BOUNTY_INITIAL_MIXED) [ASSUMED].
+ *   boss     R9 (bossInitial_1..6): the boss bounties "X·悬赏" and 源石虫·特训, all "下场作战". All 12 drafts (11 matches +
+ *            the Bahamut 12294 co-op screenshot) are a group of 0–3 named bosses that always come together, filled up to 6
+ *            with cheap ones (W / 碎骨 / 弑君者 1, 大鲍勃 2, 庞贝 or 鼠王 2, 源石虫·特训 0): BOUNTY_BOSS_TEMPLATES. 7 groups
+ *            were seen for 6 events (庞贝 and 鼠王 never in one draft; 杰斯顿 only in matches 7–11): two game versions,
+ *            or a group set by something of the match (its leader, its map — the 杰斯顿 groups came on both boards) —
+ *            open; uniform among the seen groups [ASSUMED]. 凋零骑士, “遗弃者”, 锏, 扎罗 and 迷路的巨像 never appeared: not
+ *            offered [ASSUMED].
+ *   hunter   R11 (bounty_hunter_1..15; R11 is a 悬赏决策 in 5 of the 11 matches): six "下场战斗" cards, exactly one 特异III
+ *            giant (enemyeffect_16_1..8, 3 coins), the others tier II / I faction _7 / _8 cards and enemyeffect_16_9..12,
+ *            at most one per faction series 10–15 (5 of 5 drafts). Not a free draw within that rule: matches 1 and 6
+ *            show the same giant (16_4) and the same four tier-II cards (16_10 15_7 12_7 13_8) and differ only in their
+ *            one tier-I card (10_7 / 11_7); 15_7 + 13_8 come together in matches 1, 3 and 6; 10_8, 11_8 and 12_8 never
+ *            show (a uniform draw under the rule gives some pair of 5 drafts 5 shared cards in about 2.5 % of samples).
+ *            Like R9, a draft is a group — the giant + 1–4 tier-II cards, always together — filled to 6 with tier-I
+ *            cards: BOUNTY_HUNTER_TEMPLATES, 4 groups seen for the 15 events (fill = the 5 tier-I cards seen); an unseen
+ *            event draws a group of that shape over all the R11 cards (BOUNTY_HUNTER) [ASSUMED: the group / fill split
+ *            by tier, uniform among the 15 events]. The fill cards 16_11 and 13_7 only came in matches 10–11 (the
+ *            杰斯顿 period of R9) — too few drafts to split the fill by period.
+ * In none of the 27 bounty drafts: the 7 multi-round cards (山海众头目·多轮悬赏, 多轮悬赏·假想敌 ×6), the pre-series cards
+ * enemyeffect_3_* (法术大师A2·悬赏 …), 战术特训 (法术教鞭 only) and the 鸭爵 set; no card twice in one draft.
+ */
+const EE = (s) => `enemyeffect_${s}`;
+const seriesIds = (n) => [1, 2, 3, 4, 5, 6].map((i) => EE(`${n}_${i}`));
+/** The R3 sets seen (`seen` = match numbers of test/fixtures/official-bounty-drafts.json). */
+const BOUNTY_INITIAL_SETS = [
+  { cards: seriesIds(18), seen: [1, 3, 5, 9] },
+  { cards: seriesIds(19), seen: [2] },
+  { cards: seriesIds(17), seen: [7] },
+  { cards: ['10_5', '11_4', '12_5', '13_6', '15_4', '20_3'].map(EE), seen: [4, 10] },
+  { cards: ['10_4', '11_5', '12_6', '14_4', '15_5', '20_2'].map(EE), seen: [6] },
+  { cards: ['10_4', '11_5', '12_4', '14_6', '15_4', '20_4'].map(EE), seen: [8] },
+  { cards: ['10_4', '11_6', '12_4', '13_4', '14_5', '15_5'].map(EE), seen: [11] },
+];
+/** An unseen R3 set: one card from each of `count` of these series, with these tiers (the seen mixed sets' rule). */
+const BOUNTY_INITIAL_MIXED = { series: [10, 11, 12, 13, 14, 15, 20], count: 6, tiers: [1, 1, 1, 2, 2, 3] };
+const BOSS_FILL_A = ['b_1', 'b_3', 'b_10', 'b_12', 'b_13', '5_1'].map(EE); // 碎骨 弑君者 W 庞贝 大鲍勃 源石虫·特训
+const BOSS_FILL_B = ['b_1', 'b_3', 'b_10', 'b_11', 'b_13', '5_1'].map(EE); // 鼠王 in place of 庞贝
+/** The R9 groups seen: `featured` always all on the card row, `fill` drawn to make 6. */
+const BOUNTY_BOSS_TEMPLATES = [
+  { featured: [], fill: BOSS_FILL_A, seen: [4] },
+  { featured: ['b_8', 'b_24'].map(EE), fill: BOSS_FILL_A, seen: [1, 5] }, // 喷气人 纠缠藤蔓
+  { featured: ['b_4', 'b_19'].map(EE), fill: BOSS_FILL_A, seen: [2] }, // 泥岩 澪
+  { featured: ['b_5', 'b_17', 'b_20'].map(EE), fill: BOSS_FILL_A, seen: [3] }, // 腐败骑士 “墓碑” “巨大的丑东西”
+  { featured: ['b_22', 'b_21', 'b_2'].map(EE), fill: BOSS_FILL_A, seen: [6, 'bahamut-12294'] }, // “邪魔的利刃” “复仇者” 萨卡兹百夫长
+  { featured: ['b_9', 'b_23'].map(EE), fill: BOSS_FILL_B, seen: [7, 11] }, // 杰斯顿·威廉姆斯 陷落雪祀
+  { featured: ['b_9', 'b_14'].map(EE), fill: BOSS_FILL_B, seen: [8, 9, 10] }, // 杰斯顿·威廉姆斯 “自在”
+];
+const HUNTER_FILL = ['10_7', '11_7', '13_7', '14_7', '16_11'].map(EE); // 法术大师A2 沏虹 假想敌：蚀裂 重弩突袭者 心虚设计师
+/** The R11 groups seen: `featured` (the 特异III giant + its tier-II cards) always all on the card row, `fill` (tier I) drawn to make 6. */
+const BOUNTY_HUNTER_TEMPLATES = [
+  { featured: ['16_4', '16_10', '15_7', '12_7', '13_8'].map(EE), fill: HUNTER_FILL, seen: [1, 6] }, // 温顺的武装大驮兽 异质裂兽·α 深池重甲卫士队长 灼藤 尖端萨卡兹枯朽战车
+  { featured: ['16_3', '15_7', '13_8'].map(EE), fill: HUNTER_FILL, seen: [3] }, // 狂暴宿主组长 深池重甲卫士队长 尖端萨卡兹枯朽战车
+  { featured: ['16_5', '14_8', '12_7', '15_8'].map(EE), fill: HUNTER_FILL, seen: [10] }, // 萨卡兹骸骨拷打者 家族暗影灭迹人 灼藤 愤怒的守墓石像
+  { featured: ['16_7', '16_9'].map(EE), fill: HUNTER_FILL, seen: [11] }, // 乌顶巨角卢鲁 拥霜羽兽
+];
+/**
+ * An unseen R11 group (the seen groups' shape): one tier-III giant + `groupSizes` (one drawn: the seen 4 / 2 / 3 / 1)
+ * tier-II cards, filled with tier-I cards, at most one card per series of `onePerSeries` — over the R11 cards by tier
+ * (buildChoices). [ASSUMED]
+ */
+const BOUNTY_HUNTER = { groupSizes: [1, 2, 3, 4], onePerSeries: [10, 11, 12, 13, 14, 15], count: 6 };
+/** The kind of a round's 悬赏决策: R3 (and 险境 R6, [ASSUMED]) initial, R9 boss, R11 hunter. */
+const bountyDraftOf = (r) => (r < 8 ? 'initial' : r < 11 ? 'boss' : 'hunter');
+
+/** The draft kind a bounty card belongs to by its shape, null when no draft offers it (see above). */
+function bountyDraftPool(e, main, draftExcluded) {
+  if (draftExcluded) return null;
+  if (main.rounds === 2) return 'initial';
+  if (main.rounds !== 1) return null; // multi-round
+  if (/^enemyeffect_b_\d+$/.test(e.effectId) || e.effectId === 'enemyeffect_5_1') return 'boss';
+  if (/^enemyeffect_1[0-5]_[78]$/.test(e.effectId) || /^enemyeffect_16_\d+$/.test(e.effectId)) return 'hunter';
+  return null; // the pre-series cards enemyeffect_3_*
+}
+
 /** Classify a 机变 choice event id into a family. */
 function choiceFamily(ev) {
  if (ev.choiceType === 'BOUNTY_HUNT' || ev.choiceType === 'PERSONAL_CHOOSE') return 'bounty';
@@ -2382,15 +2471,34 @@ function buildChoices(ctx, effects, items, chess) {
    if (multiRound) tier = 2;
    for (const a of adds) if (a.enemyKey && !ctx.enemyDb.has(a.enemyKey)) warn(`bounty ${e.effectId}: unknown enemy ${a.enemyKey}`);
    const coin = e.enemyPrice || main.coin;
-    const draftExcluded = bountyDraftExclusion(e, main);
+    let draftExcluded = bountyDraftExclusion(e, main);
    if (draftExcluded === 'hidden' && !/鸭爵|高普尼克|流泪小子|圆仔/.test(e.name || '')) warn(`bounty ${e.effectId} "${e.name}": expected one of the 鸭爵 set`);
+    let draftPool = bountyDraftPool(e, main, draftExcluded);
+    // a boss bounty is offered only through a seen R9 group (BOUNTY_BOSS_TEMPLATES)
+    if (draftPool === 'boss' && !BOUNTY_BOSS_TEMPLATES.some((t) => t.featured.includes(e.effectId) || t.fill.includes(e.effectId))) draftPool = null;
+    if (!draftExcluded && !draftPool) draftExcluded = 'unseen';
+    const sm = /^enemyeffect_(\d+)_\d+$/.exec(e.effectId);
    bounty.push({
      effectId: e.effectId, name: e.name, desc: e.desc, tier, coin,
      payout: main.payout, rounds: main.rounds, multiRound, enemyKey: main.enemyKey, count: main.count, adds,
-      draft: !draftExcluded, draftExcluded,
+      draft: !draftExcluded, draftExcluded, draftPool, series: sm ? Number(sm[1]) : null,
    });
  }
  bounty.sort((a, b) => naturalCmp(a.effectId, b.effectId));
+  // the official draft structures (see BOUNTY_INITIAL_SETS) only name cards of their own kind
+  const bountyById = new Map(bounty.map((c) => [c.effectId, c]));
+  const checkKind = (ids, kind, what) => { for (const id of ids) if (bountyById.get(id)?.draftPool !== kind) warn(`bounty draft ${what}: ${id} is not a "${kind}" card`); };
+  for (const s of BOUNTY_INITIAL_SETS) checkKind(s.cards, 'initial', 'R3 set');
+  for (const t of BOUNTY_BOSS_TEMPLATES) checkKind([...t.featured, ...t.fill], 'boss', 'R9 group');
+  for (const t of BOUNTY_HUNTER_TEMPLATES) {
+    checkKind([...t.featured, ...t.fill], 'hunter', 'R11 group');
+    const tiers = t.featured.map((id) => bountyById.get(id)?.tier);
+    if (tiers.filter((x) => x === 3).length !== 1 || tiers.some((x) => x !== 3 && x !== 2)) warn(`bounty draft R11 group ${t.featured.join(' ')}: not one giant + tier-II cards`);
+    if (t.fill.some((id) => bountyById.get(id)?.tier !== 1)) warn(`bounty draft R11 group ${t.featured.join(' ')}: a fill card is not tier I`);
+  }
+  // the unseen R11 groups draw over the R11 cards by tier: III the giants, II the group cards, I the fill
+  const hunterTier = (t) => bounty.filter((c) => c.draftPool === 'hunter' && c.tier === t).map((c) => c.effectId);
+  if (hunterTier(1).length + hunterTier(2).length + hunterTier(3).length !== bounty.filter((c) => c.draftPool === 'hunter').length) warn('bounty: an R11 card of no tier I–III');

  // Tactic cards (BUFF_GAIN effects).
  const tactic = [];
@@ -2412,7 +2520,8 @@ function buildChoices(ctx, effects, items, chess) {
  // Per-mode schedule of families (research 01 A4).
  const schedule = {};
  const supplyWindow = { 3: [1, 4], 6: [2, 5], 9: [3, 6], 11: [4, 6] };
-  const bountyTiers = { 3: [1, 2], 6: [1, 2, 3], 9: [2, 3], 11: [2, 3] };
+  // the 悬赏决策 of a round is the kind of official draft its round has (bountyDraftOf: R3 initial, R9 boss, R11 hunter)
+  const bountyEventRe = { initial: /^enemy_initial_/, boss: /^bossInitial_/, hunter: /^bounty_hunter_/ };
  for (const [modeId, rounds] of Object.entries(act.battleDataDict)) {
    const mode = act.modeDataDict[modeId];
    const solo = mode.modeType === 'SINGLE';
@@ -2423,16 +2532,21 @@ function buildChoices(ctx, effects, items, chess) {
      let families;
      if (diff === 'TRAINING') families = [{ family: 'supply', weight: 100 }];
      else if (diff === 'HARD' || diff === 'ABYSS') {
-        families = r === 11 ? [{ family: 'supply', weight: 50 }, { family: 'shop', weight: 50 }] : [{ family: 'bounty', weight: 100 }];
+        // R11 of the 11 official co-op matches (player feedback after 0.1.0 report #2, the screenshots of BOUNTY_INITIAL_SETS):
+        // 悬赏决策 5, 机密商店 4, 战术决策 2, 道具补给 0 — the weights follow those counts [ASSUMED]. Solo 绝境 / 终极 take the
+        // same weights [ASSUMED: no solo screenshot; extrapolated from co-op — the data has solo 悬赏决策 events for R11,
+        // bounty_hunter_*_s, which the previous supply 50 / shop 50 never used]
+        families = r === 11 ? [{ family: 'bounty', weight: 45 }, { family: 'shop', weight: 35 }, { family: 'tactic', weight: 20 }] : [{ family: 'bounty', weight: 100 }];
      } else if (diff === 'NORMAL') {
        families = solo
          ? [{ family: r === 9 ? 'tactic' : 'supply', weight: 100 }]
          : [{ family: 'bounty', weight: 50 }, { family: 'supply', weight: 25 }, { family: 'shop', weight: 10 }, { family: 'tactic', weight: 15 }];
      } else families = [{ family: 'supply', weight: 45 }, { family: 'tactic', weight: 35 }, { family: 'shop', weight: 20 }];
-      const bountyEvents = r <= 3 ? eventsOf('bounty', (e) => /^enemy_initial/.test(e.id) && e.solo === solo) : eventsOf('bounty', (e) => /^(bounty_hunter|bossInitial)/.test(e.id) && e.solo === solo);
+      const bountyDraft = bountyDraftOf(r);
+      const bountyEvents = eventsOf('bounty', (e) => bountyEventRe[bountyDraft].test(e.id) && e.solo === solo);
      m[r] = {
        families, cards: solo ? 3 : 6,
-        supplyTiers: supplyWindow[r] || [1, 6], bountyTiers: bountyTiers[r] || [1, 3],
+        supplyTiers: supplyWindow[r] || [1, 6], bountyDraft,
        events: {
          bounty: bountyEvents,
          supply: diff === 'TRAINING' ? eventsOf('supply', (e) => e.training) : eventsOf('supply', (e) => !e.training && e.solo === solo),
@@ -2448,7 +2562,7 @@ function buildChoices(ctx, effects, items, chess) {
  return {
    events,
    families: {
-      bounty: { name: '悬赏决策', desc: '选定悬赏目标，获取额外奖励。', cards: 'cards.bounty entries with draft: true (PRTS 敌人轮选: no 战术特训 — the 教鞭 Art offers those — and no 鸭爵 set)' },
+      bounty: { name: '悬赏决策', desc: '选定悬赏目标，获取额外奖励。', cards: 'bountyDrafts[schedule[*].bountyDraft] — the official draft structure of the round (initial: one of the R3 sets; boss: an R9 group + cheap fill; hunter: an R11 group — one 特异III giant + tier-II cards — + tier-I fill, one per faction series), over cards.bounty entries with draft: true and that draftPool' },
      supply: { name: '道具补给', desc: '无需消耗资金，获得装备补给。', cards: 'random normal EQUIP items in schedule[*].supplyTiers (duplicates allowed)' },
      shop: { name: '机密商店', desc: '无需消耗资金，获得装备补给。', cards: 'random normal EQUIP items of any tier I–VI (duplicates allowed)' },
      tactic: { name: '战术决策', desc: '选择战术增益。', cards: 'cards.tactic (terrain cards only for the match stage)' },
@@ -2459,6 +2573,19 @@ function buildChoices(ctx, effects, items, chess) {
      opensAfterIncome: true,
    },
    cards: { bounty, tactic },
+    // the official 悬赏决策 structures by kind (tools/build-data.mjs BOUNTY_INITIAL_SETS; `seen` = the match numbers of
+    // test/fixtures/official-bounty-drafts.json; `slots` = the official events, the unseen ones built by `mixed` / `rule`)
+    bountyDrafts: {
+      initial: { events: eventsOf('bounty', (e) => bountyEventRe.initial.test(e.id) && !e.solo), slots: eventsOf('bounty', (e) => bountyEventRe.initial.test(e.id) && !e.solo).length, sets: BOUNTY_INITIAL_SETS, mixed: BOUNTY_INITIAL_MIXED, count: 6, assumed: ['the unseen slots built by `mixed`', '险境 R6 drafts like R3'] },
+      boss: { events: eventsOf('bounty', (e) => bountyEventRe.boss.test(e.id) && !e.solo), templates: BOUNTY_BOSS_TEMPLATES, count: 6, assumed: ['a uniform pick among the seen groups', 'boss bounties of no seen group are not offered'] },
+      hunter: {
+        events: eventsOf('bounty', (e) => bountyEventRe.hunter.test(e.id) && !e.solo), slots: eventsOf('bounty', (e) => bountyEventRe.hunter.test(e.id) && !e.solo).length,
+        templates: BOUNTY_HUNTER_TEMPLATES,
+        rule: { giants: hunterTier(3), groupCards: hunterTier(2), groupSizes: BOUNTY_HUNTER.groupSizes, fill: hunterTier(1) },
+        onePerSeries: BOUNTY_HUNTER.onePerSeries, count: BOUNTY_HUNTER.count,
+        assumed: ['a group (the giant + tier-II cards) + tier-I fill, like R9', 'the unseen slots built by `rule`', 'a uniform pick among the 15 events'],
+      },
+    },
    schedule,
    pools: {
      pool_equip_normal: { kind: 'equip', rule: 'shopEligible', maxTier: 'shopLevel', assumed: true },