diff --git a/docs/PLAYING.md b/docs/PLAYING.md
index 700f9ed4..29ac54d0 100644
--- a/docs/PLAYING.md
+++ b/docs/PLAYING.md
@@ -74,7 +74,7 @@
 - 想只改朝向：把干员拖回它自己所在的格子再选方向。朝向会一直保留到下一回合。
 - **点选按地上的方格**：点哪个方格就选中站在那个方格上的单位，点空方格不选任何单位（点到后一格干员画出来的头部，算作点了后面那一格）。作战中友方同样按方格；敌人在格子之间走动，点它的身体或脚下附近（0.6 格内）即可，飞行敌人点它的身体。
 - 拖动时模型一直在指针 / 手指下（脚在指针下方约半格，鼠标和触屏一样），**指针所在的格子**就是落点并高亮；装备拖到哪个格子，就配发给那个格子上的干员；在商店栏上松手则放回原位。
-- 点击干员显示攻击范围和底部按钮（「撤退」回到整备区、「出售 +1」）；右键 / 长按查看详细信息：头像旁是盟约，下面第一项就是干员的**特质**（如「休整期结束时 …」），之后是特性、属性、攻击范围、技能、模组、装备、天赋。属性是**实时数值**：作战中每秒刷新 4 次（当前生命、攻击、防御、法抗、攻击间隔、阻挡），休整期显示棋盘上的干员**开战时**的数值（已算入装备、盟约层数、特质、策略与机变效果）；高于基础值为绿色、低于为红色并标出差值（攻击间隔变短算增益），鼠标悬停可看基础值。基础值是官方数据在该阶级的等级、技能等级（和精锐的模组）下、**满潜能**、0 信赖的数值：所有干员（精锐、补位、自选也一样）都带上全部潜能加成——部署费用、再部署时间、攻击力 / 生命 / 防御 / 法抗 / 攻速，以及「天赋效果增强」，召唤物的天赋也按召唤者的满潜能（维护者 2026-10-07 的决定，GitHub #252：官方赛事视频里的刺玫正是满潜能的攻击 435、费用 15）。
+- 点击干员显示攻击范围和底部按钮（「撤退」回到整备区、「出售 +1」）；右键 / 长按查看详细信息。作战中、查看队友的阵地时，点开场上我方干员或召唤物（包括队友的）的详情卡，棋盘上也会画出它**当前的攻击范围**（按它现在的位置、朝向和技能，例如开着扩大攻击范围的技能时就是扩大后的范围），关掉详情卡、拖动或选方向时消失；敌人、整备区和临时整备区里的单位不画。详情卡里：头像旁是盟约，下面第一项就是干员的**特质**（如「休整期结束时 …」），之后是特性、属性、攻击范围、技能、模组、装备、天赋。属性是**实时数值**：作战中每秒刷新 4 次（当前生命、攻击、防御、法抗、攻击间隔、阻挡），休整期显示棋盘上的干员**开战时**的数值（已算入装备、盟约层数、特质、策略与机变效果）；高于基础值为绿色、低于为红色并标出差值（攻击间隔变短算增益），鼠标悬停可看基础值。基础值是官方数据在该阶级的等级、技能等级（和精锐的模组）下、**满潜能**、0 信赖的数值：所有干员（精锐、补位、自选也一样）都带上全部潜能加成——部署费用、再部署时间、攻击力 / 生命 / 防御 / 法抗 / 攻速，以及「天赋效果增强」，召唤物的天赋也按召唤者的满潜能（维护者 2026-10-07 的决定，GitHub #252：官方赛事视频里的刺玫正是满潜能的攻击 435、费用 15）。
 - **召唤物手动摆放**：把带可部署召唤物的干员放上棋盘后，它的召唤物会进入整备区（赫默的医疗探机、巫恋的诅咒娃娃、凯瑟琳的 2 个支援装置、浊心斯卡蒂的海嗣、伺夜的狼群、缪尔赛思的流形；同一干员的召唤物叠在一格，不占部署位），像干员一样拖到棋盘上并选方向。凯瑟琳的支援装置给**它面朝的那一格**上的干员加屏障，所以要放在干员旁边、朝向干员。**战术家的援军**（伺夜的狼群、缪尔赛思的流形，也就是选战术点）和官方一样**只能放在召唤者的攻击范围内**：拖动时只有这些格子会亮起；之后在原地给战术家换朝向时，不在新攻击范围里的援军会退回整备区（还在范围里的保持不动；整备区和临时整备区都满、援军无处可退时，这次换朝向不生效并提示「整备区已满」）。撤退或出售干员时它的召唤物一起移除；**移动干员到别的格子时（包括把召唤物拖到干员身上交换位置），它已摆放的召唤物会退回整备区**，需要重新摆放。整备区满时退回的召唤物进入临时整备区，休整期结束还没处理的会在下一回合重新回到整备区。
 - 作战中：海嗣、狼群、流形、支援装置开战时就在摆放的位置部署；医疗探机、诅咒娃娃开战时也在摆放的位置免费部署一次（持续 10 / 15 秒，和官方一样不需要先开技能），之后所属干员每次发动技能时再次在原位出现；所属干员被击倒、再部署回场时，技能给的那一个如果还没出现，会立刻出现。巫恋退场时诅咒娃娃随之撤退，赫默退场时已出现的医疗探机不受影响。医疗探机、诅咒娃娃、海嗣（以及自选干员的工程蓄水炮、沙地兽、打字机、本能的召唤）这类不会受到攻击、到时间就离场的召唤物不受任何伤害（活性源石也一样）、也不会被治疗，它们的血条就是倒计时：随时间减少，空了就离场。琳琅诗怀雅二技能的香槟炸弹也不会掉血（活性源石和各种伤害都不会）、不会被治疗，不会因为生命值而消失，只在「见面礼」炸到碰到它的第一个地面敌人后消失（维护者 2026-10-08 的决定）；隐匿（没有被反隐、也没有被阻挡）或沉睡的敌人选不中，不会触发它。医疗探机、诅咒娃娃、支援装置、海嗣没有摆放就不会出现；狼群、流形（战术家的援军）没有摆放时会在战术点出现。狼群最后一只狼影被击倒后进入战术点形态：暂时离开战斗（不阻挡、不攻击、不会被攻击，格子仍然占着），经过狼影的恢复时间（25 秒）后在原地满血、带着 1 只狼影回来，之后重新开始每 25 秒加 1 只狼影；伺夜退场时狼群随之撤退，伺夜再部署回场时狼群重新带着 2 只狼影出现。
 - **阻挡**看接触：干员阻挡中心距离约 0.7 格以内、与它接触的敌人（地面干员挡不住飞行和近地悬浮的敌人）。敌人卡在两名干员之间时，阻挡它的干员倒下、撤退或被晕眩后，另一名仍与它接触、还有空余阻挡数的干员会**立刻接替阻挡**；都没有空位时敌人才会走掉。被冻结或晕眩的敌人同样会被接触到的干员挡住：干员再部署到它身边就会阻挡它，隐匿的敌人也随之破隐（沉睡、浮空、恐惧的敌人仍然挡不住）。迎面走来的敌人会停在干员格子前面。**阻挡了就一定能打到**：任何干员（包括站在近战位的远程干员和召唤物）总能攻击自己阻挡的敌人，不管它在不在攻击范围内、在干员哪一侧，并且优先攻击它——只有速射手例外：攻击范围内有飞行敌人时先打飞行敌人（特性「优先攻击空中单位」，维护者 2026-10-08 的决定，GitHub #220）（医疗干员除外：咒愈师以外的医疗挡住敌人时照常治疗队友，不会攻击它；「停止攻击」类技能期间也除外；技能原文另有限制的也按原文：普罗旺斯二技能开启时不以生命值高于 80% 的敌人为目标，寒檀二技能的冰凌随机落在攻击范围内的地块上）。
@@ -137,7 +137,7 @@
 - 休整期、或自己的作战结束后（显示「作战结束，等待队友完成作战」），点左侧队友头像 →「前往查看」观看他的战场；自己的作战进行中不能观战。联防和最终攻势中可以用 ‹ › 切换左半 / 全景 / 右半。
 - 被淘汰后可以自由观看任何战场，而且**不用每回合重选**：你上次点「前往查看」的是谁，之后每个阶段（回合开始、机变、休整期、作战、最终攻势）都会自动跟到他的阵地或战场；没选过或他也被淘汰时，跟随座位顺序第一位还在场的博士（包括 AI 队友）。阶段中途换人立即生效，之后就跟随新选的人。
 - **观战席**（本作新增，原版没有）：每个同盟房间另有 2 个观战席。在大厅输入同盟密钥后点「观战」进入（模拟进行中也可以），不占博士席位、不算参战人数，也不能购买、部署、准备或发送表情；观看方式与被淘汰的玩家相同——自动跟随你上次查看的博士（没查看过则是座位顺序第一位还在场的博士）：休整期显示他的阵地，作战时观看他的战场，点左侧成员头像可切换查看任何人。断线重连会回到观战席；创建者可以在等待室用观战者名字旁的 ✕ 将其移出；模拟开始后，顶栏延迟旁会出现一个「👁 人数」的小胶囊（没有观战者时不显示），点开是观战者名单（离线的有标记），创建者可以在名单里用 ✕ 把观战者移出，被移出的人立刻回到大厅、不再收到战场画面（观战席上限仍是 2 个，不能调整）；观战者在等待室有空位时可以点「入座」成为博士。
-- **观看谁，盟约栏就显示谁的盟约**：查看队友的阵地或战场时（休整期、作战结束后、被淘汰后自动观战），左上的盟约栏换成**该队友的盟约、人数和层数**，前面有琥珀色的「👁 队友名」标签，点开的盟约详情也写着「队友名 的盟约」（成员一栏只标出他在场上的干员，整备区看不到）；作战中层数实时增长（与他自己看到的一致）。联防和最终攻势里跟随 ‹ ›：镜头在队友的半场时显示他的盟约，在你自己的半场时显示你自己的；「全景」时，你在这个战场上作战就显示你自己的，你不在这个战场上（漏怪后观看联防、被淘汰后观战）则显示你点「前往查看」选中的那名队友，没选过就显示该战场的第一名玩家（1 号联防者 / 这一组的第一位），**不会显示你自己的**。在这样的战场上点某名队友的头像 →「前往查看」，镜头会直接移到他的半场，‹ › 上的「👁 队友名」与盟约栏的标签一致；‹ › 旁边有「返回战场」（被淘汰时没有）。盟约栏换人时，从盟约栏打开的盟约详情会自动关闭。点开场上某个干员的详情卡时，卡上的盟约（以及点它打开的盟约详情）属于**这个干员的主人**，与盟约栏当前显示谁无关——例如在「全景」点队友的干员，看到的是「队友名 的盟约」及他的人数和层数；在队友的半场点你自己的干员，看到的是你自己的。回到自己的阵地 / 战场后恢复成你自己的盟约。作战结束后观看队友时刷新页面 / 断线重连，仍会回到正在观看的队友战场，「👁 队友名」和「返回战场」都还在。已被淘汰的队友不再显示盟约（也无法被查看）。
+- **观看谁，盟约栏就显示谁的盟约**：查看队友的阵地或战场时（休整期、作战结束后、被淘汰后自动观战），左上的盟约栏换成**该队友的盟约、人数和层数**，前面有琥珀色的「👁 队友名」标签，点开的盟约详情也写着「队友名 的盟约」（成员一栏标出他在场上的干员；休整期查看时他整备区、临时整备区里的干员也会列出、标为「整备区」，和他自己看到的一样计数：投资人、远见、奇迹这类含整备区的盟约把整备区的算进成员人数，临时整备区的哪个盟约都不算；作战中只列出场上的）；作战中层数实时增长（与他自己看到的一致）。联防和最终攻势里跟随 ‹ ›：镜头在队友的半场时显示他的盟约，在你自己的半场时显示你自己的；「全景」时，你在这个战场上作战就显示你自己的，你不在这个战场上（漏怪后观看联防、被淘汰后观战）则显示你点「前往查看」选中的那名队友，没选过就显示该战场的第一名玩家（1 号联防者 / 这一组的第一位），**不会显示你自己的**。在这样的战场上点某名队友的头像 →「前往查看」，镜头会直接移到他的半场，‹ › 上的「👁 队友名」与盟约栏的标签一致；‹ › 旁边有「返回战场」（被淘汰时没有）。盟约栏换人时，从盟约栏打开的盟约详情会自动关闭。点开场上某个干员的详情卡时，卡上的盟约（以及点它打开的盟约详情）属于**这个干员的主人**，与盟约栏当前显示谁无关——例如在「全景」点队友的干员，看到的是「队友名 的盟约」及他的人数和层数；在队友的半场点你自己的干员，看到的是你自己的。回到自己的阵地 / 战场后恢复成你自己的盟约。作战结束后观看队友时刷新页面 / 断线重连，仍会回到正在观看的队友战场，「👁 队友名」和「返回战场」都还在。已被淘汰的队友不再显示盟约（也无法被查看）。
 
 ## 9. 结算称号
 
@@ -171,7 +171,7 @@
 | `Space` | 准备就绪 / 取消准备；独立模拟的作战中暂停 / 继续 |
 | `Esc` | 取消 / 关闭：依次关闭表情面板、敌人预览、盟约浮层、详情卡、本局信息 / 敌方情报（固定，不能修改） |
 
-刷新、冻结、升级、撤退、出售和准备只在休整期有效，撤退 / 出售要先点选一名干员。方向轮盘（方向键预览、`Enter` 确认、`Esc` 取消）、「玩法说明」和「干员调配」的翻页键是这些界面自己的按键，不能修改。
+刷新、冻结、升级、撤退、出售和准备只在休整期有效，撤退 / 出售要先点选一名干员。方向轮盘（方向键预览、`Enter` 确认、`Esc` 取消；按 Tab 先到轮盘上的「点击取消」，在它上面按 `Enter` 是取消，Tab 到其他按钮上按 `Enter` 没有反应）、「玩法说明」和「干员调配」的翻页键是这些界面自己的按键，不能修改。
 
 **修改快捷键**：标题画面的「设置」按钮、大厅和房间顶栏的「设置」（玩法说明左边）或对局左下角的「设置」→「快捷键」。点一下要改的按键（只用键盘时按 Tab 移到它上面再按 Enter），出现「按下新按键…」后按新的键；按 `Esc` 取消，设置窗口不会关闭。可以用字母、数字、空格、标点符号键和 Delete / Insert / Home / End / PageUp / PageDown；`Esc`、`Tab`、`Enter`、方向键和 F1–F12 留给界面使用，也不能搭配 Ctrl / Alt / ⌘。新按键已被另一个快捷键使用时两者互换，列表下方会写明（例如把「撤退选中干员」改成 `X`，「出售选中干员」就换成原来的 `Q`）。「恢复默认」改回上表的按键。修改立即生效，商店栏、准备按钮和单位底部「撤退 / 出售」按钮上显示的按键也跟着变；设置和音量等一起保存在当前浏览器里（换浏览器或清除网站数据后回到默认）。按键按键帽上印的字符识别（AZERTY 等键盘按印着的字母），俄文等非拉丁布局按键位识别。手机等纯触屏设备要连接键盘才能用快捷键，设置里的快捷键列表默认折叠。
 
diff --git a/docs/design/client.md b/docs/design/client.md
index 4f9fd6ad..458554ba 100644
--- a/docs/design/client.md
+++ b/docs/design/client.md
@@ -46,7 +46,7 @@ Screens: **Title** (season art backdrop, 开始 → nickname), **Lobby** (独立
 
 A bond the mode never activates (标准: official `inactiveBondIdList`) reads 本局禁用 on shop / reward cards (struck through), detail chips and the popup — no 在场 count, no 当前效果 (§21.7); a strategy built around one carries a 本局禁用 tag and note in the strategy draft and stays selectable (bands.json `bondIds`, §21.26).
 
-Interactions (research 09 §1.2 / §5, which supersede the first draft): shop card, upgrade and 机变 card are two-tap (select → confirm, §18.2) — a tap anywhere on the card, its confirm strip included, is the card's tap (shop cards have no ⓘ corner; the armed bar sits above the detail card; a shop card that cannot be bought right now opens its detail on tap, §20.7); a press / drop goes by the tile under the pointer (§18.1); drag bench↔board — a legal board drop (also onto the piece's own tile) opens the 4-direction deploy wheel (swipe UP/RIGHT/DOWN/LEFT with the rotated range striped orange; release in the centre, ✕ 点击取消 or Esc cancels); tap a unit's tile ⇒ underframe with **出售 +N** (and **撤退** on the board; items/Arts in the hand / temp: **销毁** — equipped items are locked, §6.2) plus its rotated range; no drag-to-sell; drag an item onto a unit's tile ⇒ equip that unit (both slots used ⇒ the replace dialog `ui/equipReplace.js` shows the incoming and the two equipped items; the player picks the one to replace — it is destroyed — `g.equip replaceUid`; cancel changes nothing); Arts are dropped on a tile and get the direction step; right-click or long-press ⇒ detail (or a tap on a shop card while the bar is locked); keyboard shortcuts — the defaults, which each player rebinds in 设置 → 快捷键 (`ui/gameLogic/shortcuts.js`, saved with the settings; §25.15) — `R` refresh, `F` freeze, `D` level-up, `Q` retreat / `X` sell the selected operator, `Space` ready (in a solo battle: pause / resume, §14 Solo pause); `Esc` closes (fixed); none acts while a text field has the focus or a dialog is open. All actions optimistic-free: UI waits for server state (latency is small).
+Interactions (research 09 §1.2 / §5, which supersede the first draft): shop card, upgrade and 机变 card are two-tap (select → confirm, §18.2) — a tap anywhere on the card, its confirm strip included, is the card's tap (shop cards have no ⓘ corner; the armed bar sits above the detail card; a shop card that cannot be bought right now opens its detail on tap, §20.7); a press / drop goes by the tile under the pointer (§18.1); drag bench↔board — a legal board drop (also onto the piece's own tile) opens the 4-direction deploy wheel (swipe UP/RIGHT/DOWN/LEFT with the rotated range striped orange; release in the centre, ✕ 点击取消 or Esc cancels); tap a unit's tile ⇒ underframe with **出售 +N** (and **撤退** on the board; items/Arts in the hand / temp: **销毁** — equipped items are locked, §6.2) plus its rotated range — the range follows the open detail card (`screens/game/range.js inspectRange`, GitHub PR #281): an own board piece in prep, and in battle or on a scouted board any ally operator / summon on the field with its current range (the live stats' `range` and `dir`, the snapshot's tile), never an enemy or a bench unit (UnitInfo `area` hand / temp); drag, the wheel and the pen hide it; no drag-to-sell; drag an item onto a unit's tile ⇒ equip that unit (both slots used ⇒ the replace dialog `ui/equipReplace.js` shows the incoming and the two equipped items; the player picks the one to replace — it is destroyed — `g.equip replaceUid`; cancel changes nothing); Arts are dropped on a tile and get the direction step; right-click or long-press ⇒ detail (or a tap on a shop card while the bar is locked); keyboard shortcuts — the defaults, which each player rebinds in 设置 → 快捷键 (`ui/gameLogic/shortcuts.js`, saved with the settings; §25.15) — `R` refresh, `F` freeze, `D` level-up, `Q` retreat / `X` sell the selected operator, `Space` ready (in a solo battle: pause / resume, §14 Solo pause); `Esc` closes (fixed); none acts while a text field has the focus or a dialog is open. All actions optimistic-free: UI waits for server state (latency is small).
 
 Audio: autochess BGM per phase, UI SFX (buy/sell/refresh/level/merge/ready/timer), per-unit attack/hit SFX (throttled; an impact plays for a hostile attack's phys / arts / true damage only, never an operator's skill-mode file for a normal attack, ≤ 2 copies of one battle sound — §18.4; a skill cue that reaches the client before its unit — the sim emits a deploy-tick cast ahead of the unit's `['spawn']` — is held and sounds once when the unit is tracked, `AudioManager.pendingSkill`, GitHub PR #292 by @LimitlessHPPK; entering a field late hands the sound the buffered `spawn` tuples only, `screens/game/early.js audioEarly`, so no old death, deploy or cast replays), boss music in R14/15.
 
diff --git a/docs/design/network.md b/docs/design/network.md
index 5f2e70e6..d3f48ca0 100644
--- a/docs/design/network.md
+++ b/docs/design/network.md
@@ -33,7 +33,7 @@ S→C:
   interpolate linearly; nothing is inferred from the attack animation.
 - `b.ev` — `{ fieldId, ev: [ ... ] }` event tuples: `['spawn', UnitInfo]`, `['atk', srcId, tgtId, projKind]`, `['dmg', tgtId, amount, type]`, `['heal', tgtId, amount]`, `['skill', id, on:0|1]`, `['die', id, reason]` (reason `'killed'`, `'retreat'`, `'expired'` …; only `'killed'` plays an operator's knock-down sound), `['status', id, key, on]`, `['fx', kind, x, y, extra]` (`'hitCap' {id, n}` = a cancelled 限伤 hit, drawn as nothing, §20.12; `extra.form` = the unit's model form from then on (an enemy's mode, a 傀儡师's 替身 §22.11) — `shared/protocol.js fxForm`, state like a spawn: never dropped by the client, §21.4), `['layer', playerId, bondId, n]`, `['bounty', playerId, coins]`, `['deploy', id]`
 - `m.toast {kind, text}` · `m.ticker {text, id, type, priority, playerId}` (the strip plays the highest priority first, §21.10) · `m.emote {playerId, id}` · `m.result {...}`
-- `m.unitStats {seq, round, units: [unitStatsEntry]}` — the answer to `g.unitStats` (`seq` echoed): every own board operator / summon by uid with `{id, uid, defId, hp, alive, maxHp, atk, def, res, interval, blockCnt, moveSpeed, range?, base: {…same}}` (shared/protocol.js `unitStatsEntry`; `range` = an ally's live range grid, facing RIGHT, never a target-selection grid, §21.16) as its next battle starts (§18.5)
+- `m.unitStats {seq, round, units: [unitStatsEntry]}` — the answer to `g.unitStats` (`seq` echoed): every own board operator / summon by uid with `{id, uid, defId, hp, alive, maxHp, atk, def, res, interval, blockCnt, moveSpeed, range?, base: {…same}}` and `dir?` (shared/protocol.js `unitStatsEntry`; `range` = an ally's live range grid, facing RIGHT, never a target-selection grid, §21.16; `dir` = the unit's facing now, UP|RIGHT|DOWN|LEFT — the snapshot tuples carry none and UnitInfo `dir` is the facing at send time — which the detail card's range overlay rotates by, GitHub PR #281) as its next battle starts (§18.5)
 
 `UnitInfo = { id, kind, side, ownerId, defId, name, tier, golden, spine, avatar, x, y, facing, dir, maxHp, skillIndex?, moduleId?, items?, form? }` (`dir` = the ally's deploy direction; the renderer picks the model (Back for UP, mirrored for LEFT) and the ground wedge from it; `skillIndex` = the ally's equipped skill (§16): the renderer plays that skill's Spine clip (`anims.skills[i]`) and the audio its own ON_SKILL_START sound; `moduleId` = an elite ally's equipped module (uniEquipId | 'none'); `items` = an ally operator's equipped item ids (absent without any; never on enemies or summons): the bond popup lists a 变形同构体 wearer from them and the detail card shows its 同构 chip and 装备 (§21.11); all three also on the prep-scouting `m.field` units (`Match.prepFieldMeta`, the held pieces included), so a teammate's unit shows its owner's loadout in the detail card and its equipped items as item pips on the unit (prep surfaces; user playtest #2 item 3); `form` = the unit's current model form (an enemy's mode §21.4, a 傀儡师's 替身 §22.11; a view built mid-battle starts in it)).
 
diff --git a/public/css/screens/game-panels.css b/public/css/screens/game-panels.css
index 1cda7adb..94773851 100644
--- a/public/css/screens/game-panels.css
+++ b/public/css/screens/game-panels.css
@@ -515,6 +515,8 @@ button.bpop__harmony:hover { border-style: solid; color: #fff; }
 
 /* ---- direction wheel (ui/facingWheel.js, research 09 §1.2): white diamond, 4 chevrons, "✕ 点击取消", orange range ---- */
 .fwheel { position: fixed; inset: 0; z-index: 6; touch-action: none; user-select: none; -webkit-user-select: none; cursor: crosshair; }
+/* the wheel takes the keyboard focus when it opens (Enter confirms there, GitHub #394): no ring around the whole screen */
+.fwheel:focus-visible { outline: none; }
 .fwheel__stripes { position: absolute; inset: 0; width: 100%; height: 100%; overflow: visible; pointer-events: none; }
 .fwheel__dia { position: absolute; transform: translate(-50%, -50%); pointer-events: none; animation: fwheel-in 160ms var(--ease-out); }
 @keyframes fwheel-in { from { opacity: 0; transform: translate(-50%, -50%) scale(.82); } }
diff --git a/public/js/render/app/info.js b/public/js/render/app/info.js
index 51885de7..3e2d983b 100644
--- a/public/js/render/app/info.js
+++ b/public/js/render/app/info.js
@@ -41,6 +41,8 @@ export function renderInfo(u) {
     // skill aura is drawn for it (render/fx/rings.js _aura)
     ammoSkill: u.ammoSkill === true ? true : undefined,
     moduleId: typeof u.moduleId === 'string' ? u.moduleId : undefined,
+    // Scouted hand and temp units have details but no field attack range.
+    area: typeof u.area === 'string' ? u.area : undefined,
     // the ally's equipped item ids (UnitInfo.items, DESIGN §16 / §21.11): the detail card needs them for a teammate's
     // unit (resolveDetail `unitItems` → the read-only 装备 section and the 变形同构体 pairing chips); the owner's own
     // unit takes its items from the piece instead, so only other players' boards ever read this field
diff --git a/public/js/render/fx/simfx.js b/public/js/render/fx/simfx.js
index 0796e434..4319e8d5 100644
--- a/public/js/render/fx/simfx.js
+++ b/public/js/render/fx/simfx.js
@@ -101,7 +101,12 @@ export class FxSim {
         else this.zone(at.x, at.y, at.z, r, col, d, 'ring', true);
         break;
       }
-      case 'chill': this.flashScreen(col, 0.35, 0.8); this.snowfall(col); break;
+      // 盟约寒风 (谢拉格's field-wide wind — the device emits it with no anchor unit): a blizzard up the field and a
+      // stronger cold flash (PR #386); an operator's own cold (灵知 S3's start, 麦哲伦 S1's pulse every 3 s: `id` = the
+      // unit) keeps the light flurry and the softer flash — a full-screen blizzard every pulse would bury the field
+      case 'chill':
+        if (ex.id == null) { this.flashScreen(col, 0.45, 1); this.snowfall(col, true); } else { this.flashScreen(col, 0.35, 0.8); this.snowfall(col); }
+        break;
       case 'heal': this.heal(at.v || { x: at.x, y: at.y, z: at.z }, 0); break;
       case 'healAoe': {
         this.ring(at.x, at.y, at.z, 0.2, r, col, 0.6);
diff --git a/public/js/render/fx/zones.js b/public/js/render/fx/zones.js
index 3dcad273..a6ad4f86 100644
--- a/public/js/render/fx/zones.js
+++ b/public/js/render/fx/zones.js
@@ -180,11 +180,32 @@ export class FxZones {
     this.tintSprite.tint = tint;
   }
 
-  /** A short flurry of snow over the field (cold wind). */
-  snowfall(tint) {
+  /**
+   * Snow over the field (cold wind). `gust` — 盟约寒风, 谢拉格's field-wide wind: a blizzard sweeping the screen from the
+   * bottom up, the official direction (the owner's confirmation of 2026-10-08; PR #386 by @leiming2333 after the
+   * community report 「谢拉格的效果特性不明显，暴风雪应该从下向上刮」): snowflakes rise off the bottom edge on a crosswind
+   * with gust streaks racing along, so it reads as wind driving up the field, not quiet snowfall (flake / streak counts,
+   * speeds and lives are a visual choice [ASSUMED]; screen y grows downward, so a negative vy rises). Without `gust` (an
+   * operator's own cold: 灵知 S3, 麦哲伦 S1's pulses) a short light flurry drifting down, as before.
+   */
+  snowfall(tint, gust = false) {
     const size = this.ctx.screenSize();
-    for (let i = 0; i < (this.quality === 'low' ? 10 : 26); i++) {
-      this.particle('dot', Math.random() * size.width, Math.random() * size.height * 0.7, { tint, vx: 30 + Math.random() * 40, vy: 60 + Math.random() * 60, life: 1 + Math.random() * 0.6, s0: 0.25 + Math.random() * 0.3, s1: 0.1, a0: 0.8, a1: 0, fadeIn: 0.2 });
+    const W = size.width, H = size.height, low = this.quality === 'low';
+    if (!gust) {
+      for (let i = 0; i < (low ? 10 : 26); i++) {
+        this.particle('dot', Math.random() * W, Math.random() * H * 0.7, { tint, vx: 30 + Math.random() * 40, vy: 60 + Math.random() * 60, life: 1 + Math.random() * 0.6, s0: 0.25 + Math.random() * 0.3, s1: 0.1, a0: 0.8, a1: 0, fadeIn: 0.2 });
+      }
+      return;
+    }
+    // snowflakes: lifted off the bottom edge (a share starts below it), blown up-right and tumbled by the gust
+    for (let i = 0; i < (low ? 22 : 48); i++) {
+      const vy = -H * (0.55 + Math.random() * 0.5), vx = W * (0.04 + Math.random() * 0.1);
+      this.particle('dot', Math.random() * W, H * (0.55 + Math.random() * 0.55), { tint, vx, vy, life: 1.4 + Math.random() * 0.9, s0: 0.22 + Math.random() * 0.34, s1: 0.08, a0: 0.9, a1: 0, fadeIn: 0.12, spin: (Math.random() - 0.5) * 6 });
+    }
+    // gust streaks: thin wind lines racing up through the field along their velocity
+    for (let i = 0; i < (low ? 4 : 10); i++) {
+      const vy = -H * (0.9 + Math.random() * 0.6), vx = W * (0.1 + Math.random() * 0.12);
+      this.particle('streak', Math.random() * W, H * (0.6 + Math.random() * 0.5), { tint, vx, vy, life: 0.7 + Math.random() * 0.4, s0: 0.04 + Math.random() * 0.03, s1: 0.02, sx: 6 + Math.random() * 6, a0: 0.55, a1: 0, fadeIn: 0.08, rot: Math.atan2(vy, vx) });
     }
   }
 
diff --git a/public/js/screens/game.js b/public/js/screens/game.js
index 93a4e18d..b26ad5f1 100644
--- a/public/js/screens/game.js
+++ b/public/js/screens/game.js
@@ -117,6 +117,7 @@ import { useDocClass, FullscreenButton } from '../ui/device.js';
 import { HUD_HZ_MS, MERGE_HL, SEL_RANGE, cx } from './game/marks.js';
 import { keepEarly, audioEarly } from './game/early.js';
 import { MatchEnded, PausedOverlay } from './game/overlays.js';
+import { inspectRange } from './game/range.js';
 import { t, tParts } from '../../../shared/i18n.js';
 
 /** Router for the in-match screens. */
@@ -477,6 +478,9 @@ function MatchScreen() {
     }
     if (earlySnap) {
       view.pushSnapshot(earlySnap);
+      if (Array.isArray(earlySnap.units)) {
+        snapUnitsRef.current = new Map(earlySnap.units.filter(Array.isArray).map((t) => [t[0], t]));
+      }
       hudRef.current = snapHud(earlySnap);
       setHud(hudRef.current);
     }
@@ -1045,10 +1049,6 @@ function MatchScreen() {
   }, []);
 
   // ---- direction step (research 09 §1.2) and the selected piece's underframe ------------------------------------
-  // DESIGN §16: previews show the range the unit fights with under the player's loadout (an elite's module grid); a
-  // chess the player does not own the range of its stand-in (0.2.0 补位, gameLogic deployedRecord)
-  const lookups = useMemo(() => ({ getChess: ownChess, getToken: gd.token, getItem: gd.item,
-    chessRecord: (rec) => deployedRecord(rec, live.current.priv, ownChess, gd.backups) }), [gd.ready]);
   const heldRef = useRef(new Map());                     // uid → { row, col, t } committed placements awaiting m.private
   const releaseHold = useCallback((uid) => {
     heldRef.current.delete(uid);
@@ -1100,16 +1100,10 @@ function MatchScreen() {
   useEffect(() => {
     if (facing && (!editable || !placeCtx.pieces.get(facing.uid))) cancelFacing();
   }, [editable, placeCtx, facing]);
-  // the selected piece: gone / not editable → deselect; on the board its range tiles show (rotated to its facing)
+  // the selected piece: gone / not editable → deselect (its range tiles: the detail card's, cardRange below)
   const selEntry = sel ? placeCtx.pieces.get(sel.uid) || null : null;
   live.current.showPrep = showPrep;
   useEffect(() => { if (sel && (!selEntry || !editable || !showPrep)) setSel(null); }, [sel, selEntry, editable, showPrep]);
-  const selRangeKey = selEntry && selEntry.area === 'board' ? `${selEntry.piece.uid}:${selEntry.row},${selEntry.col}:${pieceDir(selEntry.piece)}` : '';
-  useEffect(() => {
-    if (!view || !selRangeKey) return undefined;
-    showRange(view, previewGrid(lookups, selEntry.piece), selEntry.row, selEntry.col, pieceDir(selEntry.piece), SEL_RANGE);
-    return () => showRange(view, null, 0, 0, null, SEL_RANGE);
-  }, [view, selRangeKey]);
   // the selected piece's underframe on screen: the detail card docks on the side away from it (user playtest #2
   // item 8 — at some aspect ratios a bench unit's 出售 sat under the left card); the underframe is drawn above every
   // panel anyway (css z-index), this keeps it visible too
@@ -1296,7 +1290,7 @@ function MatchScreen() {
   }, [strip.ownerId]);
   // the popup shows the player it was opened for (ui/watchBonds.js popupView): their entry + live layers, their name,
   // and as members your pieces or their operators on the field on screen — under client-side combat the battle's own
-  // (the runner's field meta is taken before they deploy); their hand is never sent
+  // (the runner's field meta is taken before they deploy); a battle sends no bench (a prep scout does: ownerBoard)
   const popOps = cc && battleRunner && field?.local && bondOpen && bondOpen.ownerId !== myId ? battleRunner.ownerOps(bondOpen.ownerId, field.fieldId) : null;
   const bondPop = popupView({ open: bondOpen, pub, priv, myId, field, units: popOps, live: liveLayers });
   const openBond = (id, ownerId, from) => { setBondOpen((b) => toggleBond(b, id, ownerId, from)); audio.sfx('click', { volume: 0.4 }); };
@@ -1350,6 +1344,23 @@ function MatchScreen() {
     }
     return priv?.loadout ?? null; // own pieces, shop / reward / bond-member cards
   })();
+  // the open detail card's unit draws its attack range on the field (screens/game/range.js inspectRange, GitHub PR #281):
+  // an own board piece in prep (its loadout / stand-in record, its facing); in battle or on a scouted board an ally
+  // operator / summon on the field — the range it fights with now (the live stats' `range` and `dir`, the snapshot's
+  // tile) — never an enemy, a dead unit or a bench unit (UnitInfo `area` hand / temp); drag, the wheel and the pen
+  // draw their own
+  const cardRange = !drag && !facing && !pen ? inspectRange({
+    target: detailTarget, detail: resolved, pieces: placeCtx.pieces, showPrep, field,
+    snapshot: snapUnitsRef.current.get(resolved?.unitId),
+    live: typeof liveStats === 'function' ? liveStats() : liveStats,
+    loadout: detailLoadout, getChess: gd.chess, backups: gd.backups,
+  }) : null;
+  const cardRangeKey = cardRange ? JSON.stringify(cardRange) : '';
+  useEffect(() => {
+    if (!view) return undefined;
+    showRange(view, cardRange?.grid, cardRange?.row, cardRange?.col, cardRange?.dir, SEL_RANGE);
+    return () => showRange(view, null, 0, 0, null, SEL_RANGE);
+  }, [view, cardRangeKey, showPrep, field]);
   // the card's bond chips — and the popup a chip opens: a battle / scouted unit's OWNER's bonds (yours, or that
   // teammate's — m.public + live layers), your own piece's yours, a popup member card the popup's player; shop / reward
   // cards read the strip's (ui/watchBonds.js detailBondOwner)
diff --git a/public/js/screens/game/range.js b/public/js/screens/game/range.js
new file mode 100644
index 00000000..969d528e
--- /dev/null
+++ b/public/js/screens/game/range.js
@@ -0,0 +1,32 @@
+// screens/game/range.js — the attack range the open detail card's unit draws on the field (GitHub PR #281 by
+// @IceCodeNew; the field-detail range idea after @BBleae's fork): see game.js cardRange.
+import { attackRangeGrid } from '../../../../shared/loadoutRecord.js';
+import { chessLoadout, standInLoadout } from '../../ui/gameLogic.js';
+import { tokenVariantFor } from '../../ui/gameLogic/loadout.js';
+import { normDir } from '../../ui/facing.js';
+
+/** Resolve the inspected field unit without granting placement or sale actions. */
+export function inspectRange({ target, detail, pieces, showPrep = false, field, snapshot, live, loadout, getChess, backups }) {
+  if (!detail || (detail.type !== 'chess' && detail.type !== 'token')) return null;
+  let row, col, dir;
+  if (target?.kind === 'piece' && showPrep) {
+    const e = pieces?.get(target.uid);
+    if (!e || e.area !== 'board') return null;
+    row = e.row; col = e.col; dir = normDir(e.piece.dir);
+  } else if (target?.kind === 'unit' && !showPrep) {
+    const unit = target.unit;
+    if (!unit || unit.side !== 'ally' || (unit.kind !== 'op' && unit.kind !== 'token')) return null;
+    if (unit.area != null && unit.area !== 'board') return null;
+    // Snapshots exclude undeployed, hidden and removed units. Dead units remain briefly for their death animation.
+    if (!field?.prep && (!snapshot || snapshot[3] <= 0)) return null;
+    row = Math.round(snapshot ? snapshot[2] : unit.y);
+    col = Math.round(snapshot ? snapshot[1] : unit.x);
+    dir = normDir(live?.dir, null) || normDir(unit.dir, null) || (unit.facing === -1 ? 'LEFT' : 'RIGHT');
+  } else return null;
+  if (!Number.isFinite(row) || !Number.isFinite(col)) return null;
+  const record = detail.type === 'token' ? { ...detail.token, ...tokenVariantFor(detail.token, detail.ownerId) }
+    : detail.standIn ? standInLoadout(detail.standIn, getChess, backups)?.record || detail.standIn
+    : chessLoadout(detail.chess, detail.diy ? null : loadout, getChess)?.record || detail.chess;
+  const grid = Array.isArray(live?.range) ? live.range : attackRangeGrid(record);
+  return grid?.length ? { grid, row, col, dir } : null;
+}
diff --git a/public/js/ui/bondStrip.js b/public/js/ui/bondStrip.js
index b656f4f4..e606bc9f 100644
--- a/public/js/ui/bondStrip.js
+++ b/public/js/ui/bondStrip.js
@@ -17,7 +17,9 @@
 // already did.
 // Watching a teammate (DESIGN §20.15, ui/watchBonds.js) the strip and the popup show THAT player's bonds and layers:
 // the strip carries an amber "👁 name" tag (`owner`, the observing pill's spelling, research 09 §3.1) and amber rings,
-// the popup a "👁 name 的盟约" line; its member list reads the teammate's operators on the field (no hand: never sent).
+// the popup a "👁 name 的盟约" line; its member list reads the teammate's operators on the field — in prep their bench
+// too, counted like their own popup counts it (ui/watchBonds.js ownerBoard: hand / temp by the scout's `area`, GitHub
+// #385); a battle sends no bench.
 // 0.2.0 补位: a member the player fields as its stand-in (the own m.private.standIns; a teammate's unit that says so —
 // UnitInfo `standInFor`) is drawn as the stand-in — avatar, name, a small 「替补」 mark on the thumbnail — and its row
 // opens the stand-in's card (gameLogic memberStandIn; the owner's recall of the official mode, 2026-10-06).
diff --git a/public/js/ui/detailPanel.js b/public/js/ui/detailPanel.js
index 272c06ea..5a41b815 100644
--- a/public/js/ui/detailPanel.js
+++ b/public/js/ui/detailPanel.js
@@ -46,6 +46,7 @@ import { SKILL_SUMMON_START_DEPLOY } from '../../../shared/constants.js';
 import { moduleBadge, fullTraitText } from './loadoutModel.js';
 import { t, tc, N_ } from '../../../shared/i18n.js';
 import { audio } from '../audio.js';
+import { tokenVariantFor } from './gameLogic/loadout.js';
 
 const cx = (...p) => p.flat().filter(Boolean).join(' ');
 
@@ -580,21 +581,6 @@ export function summonDeployHint(token, startDeploy = SKILL_SUMMON_START_DEPLOY)
     : t('所属干员发动技能时才在摆放的位置出现（未摆放则不会出现）');
 }
 
-/**
- * The token variant of the summon's owner (tokens.json `variants`, keyed by owner chess id): a golden owner's `_b`
- * entry (精锐 赫默's drone ATK 114, 精锐 巫恋's doll −30%), else its normal `_a` entry, else the first one.
- * @param {any} token tokens.json record
- * @param {string|null} ownerId the owner's chess id (null: unknown, e.g. a teammate's summon)
- */
-export function tokenVariantFor(token, ownerId = null) {
-  const vs = token?.variants || {};
-  if (typeof ownerId === 'string') {
-    const v = vs[ownerId] || vs[ownerId.replace(/_b$/, '_a')];
-    if (v) return v;
-  }
-  return Object.values(vs)[0] || null;
-}
-
 /** Chess id of the operator owning a token piece (`ownerUid`), from the player's own pieces (indexPieces). */
 function tokenOwnerId(piece, pieces) {
   if (!piece || piece.kind !== 'token' || !Number.isInteger(piece.ownerUid)) return null;
diff --git a/public/js/ui/facingWheel.js b/public/js/ui/facingWheel.js
index a4987ccf..c688a1d8 100644
--- a/public/js/ui/facingWheel.js
+++ b/public/js/ui/facingWheel.js
@@ -13,7 +13,8 @@
 //     LEFT, facing.js boardDir): the chevrons follow the finger, the range / model / intent use the board direction;
 //   * release outside the centre commits (g.move {uid, to, dir} / g.art {…, dir}); release inside the centre, a tap
 //     on ✕, a press outside the diamond or Esc cancels (the piece returns to where it came from). Arrow keys preview a
-//     direction and Enter commits it (keyboard alternative). Mouse, pen and touch all use pointer events.
+//     direction and Enter commits it (keyboard alternative) — Enter on a focused ✕ cancels, on any other focused
+//     button does nothing while the wheel is open (GitHub #394). Mouse, pen and touch all use pointer events.
 //
 // View bridge: the field view (render/app.js or the DOM fallback) may implement `tileScreen(row, col)`,
 // `holdPiece(uid, tile|null)` and `setPieceDir(uid, dir)` (render/app.js does, DESIGN §9); a view without them falls
@@ -25,7 +26,7 @@ import { useEffect, useLayoutEffect, useRef, useState } from '../../vendor/hooks
 import { html } from './components.js';
 import { LocalSprite } from './gameComponents.js';
 import { DIRS, DIR_LABEL, DEAD_ZONE_TILES, dirFromDelta, dirFromKey, rangeTiles, normDir, boardDir, viewMirrored } from './facing.js';
-import { facingSwallows } from './gameLogic.js';
+import { facingSwallows, facingEnter } from './gameLogic.js';
 import { settingsStore } from './settings.js';
 import { t } from '../../../shared/i18n.js';
 
@@ -236,24 +237,36 @@ export function FacingWheel({ view, row, col, grid, name = '', onPreview, onComm
   };
   const onPointerCancel = () => { setDrag(null); setDir(null); };
 
-  // keyboard: arrows preview, Enter commits, Esc cancels (capture: the game's own shortcuts must not see them)
+  // keyboard: arrows preview, Enter commits, Esc cancels (capture: the game's own shortcuts must not see them). Enter
+  // follows the focus (gameLogic facingEnter, GitHub #394): on ✕ it cancels, on any other button (Tab reaches the HUD
+  // behind the wheel) it does nothing, elsewhere it commits the previewed direction. The wheel takes the focus when it
+  // opens, so a button focused before the drop (a click leaves it focused) cannot swallow the confirming Enter; Tab then
+  // reaches ✕ first. Nothing gives the focus back when it closes (a restored 准备 would take the next Enter / Space).
+  const rootRef = useRef(null);
   useEffect(() => {
     const onKey = (e) => {
       const L = live.current;
       if (e.key === 'Escape') { e.preventDefault(); e.stopImmediatePropagation(); L.onCancel(); return; }
       const k = dirFromKey(e.key);
       if (k) { e.preventDefault(); e.stopImmediatePropagation(); setDir(k); return; }
-      if (e.key === 'Enter' && L.dir) { e.preventDefault(); e.stopImmediatePropagation(); L.onCommit(L.bdir); return; }
+      const enter = facingEnter(e, !!L.dir);
+      if (enter) {
+        e.preventDefault(); e.stopImmediatePropagation();
+        if (enter === 'cancel') L.onCancel();
+        else if (enter === 'commit') L.onCommit(L.bdir);
+        return;
+      }
       // no ready / shop while choosing: Space and every key of the player's map (设置 → 快捷键)
       if (facingSwallows(e, settingsStore.get().keys)) { e.preventDefault(); e.stopImmediatePropagation(); }
     };
     window.addEventListener('keydown', onKey, true);
+    try { rootRef.current?.focus({ preventScroll: true }); } catch { /* no focus: Enter still follows whatever has it */ }
     return () => window.removeEventListener('keydown', onKey, true);
   }, []);
 
   const outside = !!drag && !!dir;
   const box = half * 2;
-  return html`<div class=${cx('fwheel', drag && 'is-pressed', dir && `is-${dir.toLowerCase()}`)} role="dialog" aria-label=${name ? t('选择「{name}」的朝向', { name }) : t('选择朝向')}
+  return html`<div ref=${rootRef} tabIndex="-1" class=${cx('fwheel', drag && 'is-pressed', dir && `is-${dir.toLowerCase()}`)} role="dialog" aria-label=${name ? t('选择「{name}」的朝向', { name }) : t('选择朝向')}
       onPointerDown=${onDown} onPointerMove=${onMove} onPointerUp=${onUp} onPointerCancel=${onPointerCancel}
       onContextMenu=${(e) => { e.preventDefault(); onCancel(); }}>
     ${g ? html`<${Stripes} tiles=${tiles} view=${view} row=${row} col=${col} />` : null}
diff --git a/public/js/ui/gameLogic.js b/public/js/ui/gameLogic.js
index 9d871918..8be1a0cf 100644
--- a/public/js/ui/gameLogic.js
+++ b/public/js/ui/gameLogic.js
@@ -39,7 +39,7 @@ export { terrainInfo, deviceInfo, deviceTipAt, noteDeviceUnits } from './gameLog
 export { normalizeDraft, normalizeSp } from './gameLogic/draft.js';
 export { groupEnemies, PEN, penZoneTiles, penPlacement, previewEnemyKey, factionTypes } from './gameLogic/enemies.js';
 export { snapHud, bossFrac, bossPctText, hasFlag, UF, attackInterval, fmtNum, rangeGridBox } from './gameLogic/format.js';
-export { shortcutFor, closesOnFieldPress, shortcutBlocked, HOTKEY_ACTIONS, DEFAULT_HOTKEYS, isBindableCode, hotkeyLabel, sanitizeHotkeys, rebindHotkey, isDefaultHotkeys, hotkeyOf, actionForKey, captureHotkey, facingSwallows } from './gameLogic/shortcuts.js';
+export { shortcutFor, closesOnFieldPress, shortcutBlocked, HOTKEY_ACTIONS, DEFAULT_HOTKEYS, isBindableCode, hotkeyLabel, sanitizeHotkeys, rebindHotkey, isDefaultHotkeys, hotkeyOf, actionForKey, captureHotkey, facingSwallows, facingEnter } from './gameLogic/shortcuts.js';
 export { DEFAULT_SETTINGS, VOICE_LANGS, sanitizeSettings } from './gameLogic/settings.js';
 export { normalizeResult } from './gameLogic/result.js';
 export { chessLoadout, unitLoadout } from './gameLogic/loadout.js';
diff --git a/public/js/ui/gameLogic/loadout.js b/public/js/ui/gameLogic/loadout.js
index ac4f9017..38e1beab 100644
--- a/public/js/ui/gameLogic/loadout.js
+++ b/public/js/ui/gameLogic/loadout.js
@@ -5,6 +5,15 @@ import { loadoutRecord, resolveRecordLoadout } from '../../../../shared/loadoutR
 import { isObj } from './shared.js';
 import { t } from '../../../../shared/i18n.js';
 
+/** The summon owner's variant: exact chess id, normal sibling, then the first available variant. */
+export function tokenVariantFor(token, ownerId = null) {
+  const vs = token?.variants || {};
+  if (typeof ownerId === 'string') {
+    const v = vs[ownerId] || vs[ownerId.replace(/_b$/, '_a')];
+    if (v) return v;
+  }
+  return Object.values(vs)[0] || null;
+}
 
 // ---- operator loadout (DESIGN §16) ----------------------------------------------------------------------------------
 
diff --git a/public/js/ui/gameLogic/shortcuts.js b/public/js/ui/gameLogic/shortcuts.js
index 5042f495..a6b74409 100644
--- a/public/js/ui/gameLogic/shortcuts.js
+++ b/public/js/ui/gameLogic/shortcuts.js
@@ -140,8 +140,8 @@ export function captureHotkey(e) {
  * Map a keydown to a game shortcut under the player's key map (defaults: R refresh, F freeze, D level-up, Q retreat,
  * X sell, Space ready) or Esc (close; fixed). A shortcut key means its action even while a HUD button has focus (a
  * mouse click leaves the shop card / 刷新 focused, and Space must not re-trigger it); the caller prevents the button's
- * own activation. Enter still activates buttons (it cannot be a shortcut). Nothing while Ctrl / ⌘ / Alt is held or a
- * text field has the focus.
+ * own activation. Enter still activates buttons (it cannot be a shortcut; behind the facing wheel only its ✕:
+ * facingEnter). Nothing while Ctrl / ⌘ / Alt is held or a text field has the focus.
  * @param {{ key?: string, code?: string, ctrlKey?: boolean, metaKey?: boolean, altKey?: boolean, repeat?: boolean, target?: any }} e
  * @param {any} [keys] the player's map (settings `keys`)
  * @returns {'refresh'|'freeze'|'levelUp'|'retreat'|'sell'|'ready'|'escape'|null}
@@ -164,6 +164,27 @@ export function shortcutFor(e, keys = DEFAULT_HOTKEYS) {
  */
 export const facingSwallows = (e, keys = DEFAULT_HOTKEYS) => e?.key === ' ' || actionForKey(e, keys) != null;
 
+// what a focused element is when Enter would activate it (a button, a link, a form field, an ARIA control)
+const CONTROL = 'button, a[href], input, select, textarea, summary, [contenteditable=""], [contenteditable="true"], '
+  + '[role="button"], [role="link"], [role="checkbox"], [role="switch"], [role="tab"], [role="menuitem"], [role="option"]';
+
+/**
+ * What Enter does while the facing wheel is open (GitHub #394, PR #395): on the wheel's own ✕ button it cancels; on
+ * any other control (准备, 刷新, 设置, 玩法说明, a shop card … — Tab reaches them behind the wheel) nothing happens — the
+ * wheel holds the keyboard as it holds Space and the shortcuts; with the focus anywhere else (the wheel itself, the
+ * page) it confirms the previewed direction, and does nothing while none is previewed. null: not Enter.
+ * @param {{ key?: string, target?: any }} e @param {boolean} chosen a direction is previewed
+ * @returns {'cancel'|'commit'|'swallow'|null}
+ */
+export function facingEnter(e, chosen) {
+  if (e?.key !== 'Enter') return null;
+  const t = e.target;
+  const closest = (sel) => (t && typeof t.closest === 'function' ? t.closest(sel) : null);
+  if (closest('.fwheel__cancel')) return 'cancel';
+  if (closest(CONTROL)) return 'swallow';
+  return chosen ? 'commit' : 'swallow';
+}
+
 /**
  * Whether a press on the field closes the open detail card: a card opened from the field itself (an own piece — tap,
  * right-click or long press — or a battle / teammate unit). Shop, reward, bond-member and intel (enemy) cards stay.
diff --git a/public/js/ui/watchBonds.js b/public/js/ui/watchBonds.js
index cab69058..970d35ef 100644
--- a/public/js/ui/watchBonds.js
+++ b/public/js/ui/watchBonds.js
@@ -151,27 +151,30 @@ export function withLiveLayers(bonds, live) {
  * A teammate's board as far as the screen shows it, in the m.private shape the bond popup's member list reads
  * (gameLogic bondMembers): their operators on the field meta on screen (the prep scouting board, a server-run battle
  * field's units) and, under client-side combat, the battle on screen's (`extra` = battle/runner.js ownerOps: the meta
- * the runner publishes is taken before the operators deploy). Their hand is never sent — members count as owned only
- * when they are on the field. Their operators keep the items the unit info carries (UnitInfo `items`), so a 变形同构体
- * wearer is listed as a member of the bond it grants (gameLogic grantedBonds), and a 补位 unit its `standInFor` (the
- * popup draws the stand-in). null without a field or battle.
- * @param {any} field @param {string} ownerId @param {any[]|null} [extra] UnitInfo-like { kind, ownerId, defId, items?, standInFor? }
+ * the runner publishes is taken before the operators deploy). A prep scout also carries their bench, each unit tagged
+ * with its `area` (server prepFieldMeta): a 'hand' operator goes to the hand list, a 'temp' one to the temp list, so the
+ * popup counts them as the player's own popup does (GitHub #385, PR #387) — owned, not 在场; a hand operator counts for
+ * the bonds that count the 整备区 (投资人 远见 奇迹: memberHeadCount), the 5 temporary slots for none. A unit without
+ * an area (a battle's, an older server's) is on the board; a battle sends no bench. Their operators keep the items the
+ * unit info carries (UnitInfo `items`), so a 变形同构体 wearer is listed as a member of the bond it grants (gameLogic
+ * grantedBonds), and a 补位 unit its `standInFor` (the popup draws the stand-in). null without a field or battle.
+ * @param {any} field @param {string} ownerId @param {any[]|null} [extra] UnitInfo-like { kind, ownerId, defId, area?, items?, standInFor? }
  */
 export function ownerBoard(field, ownerId, extra = null) {
   const fromField = isObj(field) && Array.isArray(field.units) ? field.units : null;
   const fromBattle = Array.isArray(extra) ? extra : null;
   if (!fromField && !fromBattle) return null;
-  const board = [...(fromField || []), ...(fromBattle || [])]
-    .filter((u) => isObj(u) && u.ownerId === ownerId && u.kind === 'op' && typeof u.defId === 'string')
-    .map((u) => {
-      const p = Array.isArray(u.items) && u.items.length ? { kind: 'chess', id: u.defId, items: u.items.filter((x) => typeof x === 'string') } : { kind: 'chess', id: u.defId };
-      // 0.2.0 自选编队: a DIY slot's unit names its operator (UnitInfo diy) — the popup counts it for that operator's bonds
-      if (isObj(u.diy) && typeof u.diy.charId === 'string') p.diy = u.diy;
-      // 0.2.0 补位: a unit fighting as its stand-in says so (UnitInfo standInFor) — the popup draws that member as the stand-in
-      if (typeof u.standInFor === 'string' && u.standInFor) p.standInFor = u.standInFor;
-      return p;
-    });
-  return { board, hand: [], temp: [] };
+  const out = { board: /** @type {any[]} */ ([]), hand: /** @type {any[]} */ ([]), temp: /** @type {any[]} */ ([]) };
+  for (const u of [...(fromField || []), ...(fromBattle || [])]) {
+    if (!isObj(u) || u.ownerId !== ownerId || u.kind !== 'op' || typeof u.defId !== 'string') continue;
+    const p = Array.isArray(u.items) && u.items.length ? { kind: 'chess', id: u.defId, items: u.items.filter((x) => typeof x === 'string') } : { kind: 'chess', id: u.defId };
+    // 0.2.0 自选编队: a DIY slot's unit names its operator (UnitInfo diy) — the popup counts it for that operator's bonds
+    if (isObj(u.diy) && typeof u.diy.charId === 'string') p.diy = u.diy;
+    // 0.2.0 补位: a unit fighting as its stand-in says so (UnitInfo standInFor) — the popup draws that member as the stand-in
+    if (typeof u.standInFor === 'string' && u.standInFor) p.standInFor = u.standInFor;
+    out[u.area === 'hand' ? 'hand' : u.area === 'temp' ? 'temp' : 'board'].push(p);
+  }
+  return out;
 }
 
 /**
diff --git a/server/match/match/views.js b/server/match/match/views.js
index 6b51b37e..a6f5a13e 100644
--- a/server/match/match/views.js
+++ b/server/match/match/views.js
@@ -225,7 +225,8 @@ export class MatchViews {
     return p ? { charId: p.charId, skillIndex: p.skillIndex, uniEquipId: p.uniEquipId } : undefined;
   }
 
-  /** UnitInfo of a player's board pieces on their (board) tiles — a prep scout's board, the boss partner's (bossMateView). */
+  /** UnitInfo of a player's board pieces on their (board) tiles — a prep scout's board, the boss partner's (bossMateView).
+   *  `area: 'board'` (a bench unit says 'hand' / 'temp': prepFieldMeta). */
   _prepBoardUnits(ps) {
     const units = [];
     // the player's own view of the data (0.2.0 自选编队: its slotted DIY slots are its operators — player/diy.js)
@@ -241,6 +242,7 @@ export class MatchViews {
       const lo = piece.kind === 'chess' && chess ? ps.loadoutFor(chess) : null;
       units.push({
         id: piece.uid, uid: piece.uid, kind: piece.kind === 'token' ? 'token' : 'op', side: 'ally', ownerId: ps.playerId, defId: piece.id,
+        area: 'board',
         name: rec ? rec.name : piece.id, tier: rec && Number.isInteger(rec.tier) ? rec.tier : 1, golden: !!(rec && rec.isGolden),
         spine: assets.spine || (rec && rec.charId) || piece.id, avatar: assets.avatar || (rec && rec.charId) || piece.id,
         x: c, y: r, dir: pieceDir(piece), facing: pieceDir(piece) === 'LEFT' ? -1 : 1, maxHp: rec && rec.stats && Number.isFinite(rec.stats.maxHp) ? rec.stats.maxHp : 1,
@@ -292,7 +294,11 @@ export class MatchViews {
     // (test/match/spectator.test.js). User playtest #2 item 1 (GitHub #44).
     // (a held chess the player fields as its stand-in is the stand-in there too — name, art, max HP — and carries
     // `standInFor`, like a board piece: the owner's recall of the official mode, 2026-10-06, the hand shows the stand-in)
-    const benchUnit = (piece, i, y) => {
+    // Each unit says where it waits (`area` 'hand' | 'temp'; a board unit 'board'): the bond popup of a watched player
+    // counts it like the player's own (ui/watchBonds.js ownerBoard — a hand operator is owned and counts for 投资人 远见
+    // 奇迹, a temp one counts for nothing; GitHub #385, PR #387). The tag survives the boss-half remap (_onBossHalf), the
+    // row does not.
+    const benchUnit = (piece, i, y, area) => {
       const rec = piece.kind === 'item' ? gd.item(piece.id) : piece.kind === 'token' ? gd.token(piece.id) : gd.chess(piece.id);
       const standIn = piece.kind === 'chess' && rec && ps.fieldsStandIn(rec) ? this.gd.standIn(rec.chessId) : null;
       const body = standIn || rec;
@@ -300,7 +306,7 @@ export class MatchViews {
       const lo = piece.kind === 'chess' && rec ? ps.loadoutFor(rec) : null;
       units.push({
         id: piece.uid, uid: piece.uid, kind: piece.kind === 'token' ? 'token' : piece.kind === 'item' ? 'item' : 'op',
-        side: 'ally', ownerId: ps.playerId, defId: piece.id,
+        side: 'ally', ownerId: ps.playerId, defId: piece.id, area,
         name: body ? body.name : piece.id, tier: rec && Number.isInteger(rec.tier) ? rec.tier : 1, golden: !!(rec && rec.isGolden),
         spine: assets.spine || (body && body.charId) || piece.id, avatar: assets.avatar || (body && body.charId) || piece.id,
         x: i, y, maxHp: body && body.stats && Number.isFinite(body.stats.maxHp) ? body.stats.maxHp : 1,
@@ -312,10 +318,10 @@ export class MatchViews {
       });
     };
     for (let i = 0; i < ps.hand.length; i++) {
-      if (ps.hand[i]) benchUnit(ps.hand[i], i, GEO.HAND_ROW);
+      if (ps.hand[i]) benchUnit(ps.hand[i], i, GEO.HAND_ROW, 'hand');
     }
     for (let i = 0; i < ps.temp.length; i++) {
-      if (ps.temp[i]) benchUnit(ps.temp[i], GEO.TEMP_C0 + i, GEO.TEMP_ROW);
+      if (ps.temp[i]) benchUnit(ps.temp[i], GEO.TEMP_C0 + i, GEO.TEMP_ROW, 'temp');
     }
     // `nextEnemies`: the scouted player's coming enemies — their preview pen shows on the scouting board too (research 09
     // §2.2 "Teammates"; render/app.js enterBattle({ prep: true, nextEnemies }))
diff --git a/server/sim/content/items/meta.js b/server/sim/content/items/meta.js
index df07541c..ea90ac93 100644
--- a/server/sim/content/items/meta.js
+++ b/server/sim/content/items/meta.js
@@ -119,17 +119,23 @@ export function registerMeta(registry) {
   // 画卷 — trap_copy_front_char: copy the operator in range (elite status included) with its equipment. A copied
   // normal item that completes a pair with an owned one merges at once and the golden stays in the hand (research 04
   // addendum "两个同名道具（无论是否被装备）会自动合并…并自动返回整备区"); the built-in equipped that golden on the copy.
+  // A copy that completes a three-copy merge (GitHub #389, PR #390): the elite wears nothing — the promotion returns the
+  // copies' equipment to the hand (PRTS 帮助 "在失去该干员（…合并等）…时自动卸除") — and the copied items stay in the hand
+  // too (PRTS 画卷 备注 "获得的装备为未装备状态"), a copied normal item merging with the returned original.
   wrap(registry, 'chess_item_6_02_m', () => ({
     onArt(ctx, ev) {
       const target = (ev.targets || []).find((p) => p && p.kind === 'chess');
       if (!target) { ev.error = 'BAD_TARGET'; ev.detail = 'no operator in range'; return; }
+      // snapshot before the gain: a gain that completes a merge consumes the target and empties `target.items`, and an
+      // item merge detaches the original's copy from `target.items` while we iterate (the built-in's live loop then
+      // skipped the next item)
+      const itemIds = (target.items || []).map((it) => it.id);
       const copy = ctx.grantChess(target.id, { requirePool: false, source: 'item:chess_item_6_02_m' });
       if (!copy) { ev.error = 'HAND_FULL'; return; }
-      // snapshot first: a merge detaches the original's copy of the item from `target.items` while we iterate
-      // (the built-in's live loop then skipped the next item)
-      for (const itemId of (target.items || []).map((it) => it.id)) {
+      const promoted = copy.id !== target.id;
+      for (const itemId of itemIds) {
         const got = ctx.grantItem(itemId, { source: 'item:chess_item_6_02_m' });
-        const holder = got ? ctx.piece(copy.uid) : null;
+        const holder = got && !promoted ? ctx.piece(copy.uid) : null;
         if (got && got.id === itemId && holder && holder.kind === 'chess') ctx.equipDirect(got.uid, holder.uid);
       }
     },
diff --git a/server/sim/content/kits/ops/chess_char_5_15-thorn2.js b/server/sim/content/kits/ops/chess_char_5_15-thorn2.js
index 77c0cd72..2c32a73e 100644
--- a/server/sim/content/kits/ops/chess_char_5_15-thorn2.js
+++ b/server/sim/content/kits/ops/chess_char_5_15-thorn2.js
@@ -67,7 +67,10 @@ export default {
       if (z.type === 'guard') {
         const inZone = (a) => Math.abs(a.tileR - z.r) <= 1 && Math.abs(a.tileC - z.c) <= 1;
         const allies = battle.alliesFor(unit).filter(inZone);
-        for (const a of allies) battle.addBuff(a, { key: 'thorn2:bastion', duration: AURA_DUR, mods: mods({ defFlat: num(bb.def) }) });
+        // one DEF buff per alchemy unit, so two units on one ally add up (+60 +60; PRTS 度算浪波 备注 「效果均可叠加」,
+        // GitHub #388 — one shared key let the last unit's buff replace the other's)
+        z.defKey ??= `thorn2:bastion:${unit.id}:${unit.mem.bastionSeq = (unit.mem.bastionSeq ?? 0) + 1}`;
+        for (const a of allies) battle.addBuff(a, { key: z.defKey, duration: AURA_DUR, mods: mods({ defFlat: num(bb.def) }) });
         if (z.acc >= 1 - 1e-9) {
           z.acc -= 1;
           const regen = unit.s.atk * num(bb.hp_recovery_per_sec_ratio);   // 生命回复速度 (see the header)
diff --git a/shared/protocol.js b/shared/protocol.js
index 3fe5c07a..a8beaa9e 100644
--- a/shared/protocol.js
+++ b/shared/protocol.js
@@ -282,13 +282,14 @@ const statView = (x) => ({
  * runner's live battle stats (public/js/battle/runner.js unitStats). An ally with a range also carries `range`: the grid
  * (`[dRow, dCol]`, facing RIGHT) it attacks with now — a running skill's range, rangeExtend included, not a kit's
  * target-selection grid (the sim's `unit.liveRangeGrid`, Battle._refreshRange; community report E1 after 0.1.0: 烛煌
- * S3's 4-11 never reached the card).
- * @param {{ id?: number, uid?: number|null, defId?: string, hp?: number, alive?: boolean, base?: any, liveRangeGrid?: any } | null} u
+ * S3's 4-11 never reached the card). `dir`: the unit's facing now (UP / RIGHT / DOWN / LEFT; UnitInfo.dir is the facing
+ * at send time and the snapshot tuples carry none) — the detail card's range overlay rotates by it (GitHub PR #281).
+ * @param {{ id?: number, uid?: number|null, defId?: string, hp?: number, alive?: boolean, base?: any, liveRangeGrid?: any, dir?: string } | null} u
  * @param {any} [s] aggregated stats (missing ⇒ the base)
  * @returns {{ id: number|null, uid: number|null, defId: string|null, hp: number, alive: boolean, maxHp: number, atk: number,
  *   def: number, res: number, interval: number|null, blockCnt: number, moveSpeed: number,
  *   base: { maxHp: number, atk: number, def: number, res: number, interval: number|null, blockCnt: number, moveSpeed: number },
- *   range?: Array<[number, number]> }}
+ *   range?: Array<[number, number]>, dir?: string }}
  */
 export function unitStatsEntry(u, s = null) {
   const base = u && u.base && typeof u.base === 'object' ? u.base : {};
@@ -305,6 +306,7 @@ export function unitStatsEntry(u, s = null) {
     ...statView(cur),
     base: statView(base),
     ...(range ? { range } : {}),
+    ...(isDir(u?.dir) ? { dir: u.dir } : {}),
     // the enemy card greys a SILENCE-format line (折射) from this; absent flags ⇒ not silenced
     silenced: !!(cur.flags && cur.flags.silence),
   };
diff --git a/test/content/kits_alt_t5.test.js b/test/content/kits_alt_t5.test.js
index 43743413..0f4bdbb6 100644
--- a/test/content/kits_alt_t5.test.js
+++ b/test/content/kits_alt_t5.test.js
@@ -1031,6 +1031,36 @@ test('引星棘刺 S1 度算浪波: an alchemy unit on the lowest-HP ally: DEF +
   }
 });
 
+test('引星棘刺 S1 度算浪波: two alchemy units on one ally add their DEF (PRTS 备注 「效果均可叠加」, GitHub #388)', () => {
+  // two 引星棘刺 (a normal and an elite: +60 and +75) throw at the same lowest-HP ally; one shared buff key used to let the
+  // last unit's DEF replace the other's (+75 instead of +135) while both heals already landed
+  const [na, el] = pair('15');
+  const h = run({
+    defs: { chess: { t_low: ally('t_low', { stats: { def: 100 } }) } },
+    units: [entry(na, 'skchr_thorn2_1', { row: 10, col: 3 }), entry(el, 'skchr_thorn2_1', { row: 11, col: 3 }), { chessId: 't_low', row: 10, col: 5 }],
+    enemies: [],
+  });
+  const a = sel(h, na, 'skchr_thorn2_1'), b = sel(h, el, 'skchr_thorn2_1');
+  const low = h.unit('t_low');
+  h.step();
+  low.hp = low.s.maxHp * 0.3;
+  for (const u of [a, b]) u.skill.gainSp(1000);
+  h.runUntil(() => [a, b].every((u) => (u.mem.zones || []).some((z) => z.type === 'guard')), 10);
+  h.run(1.1);
+  const [za, zb] = [a, b].map((u) => u.mem.zones.find((z) => z.type === 'guard'));
+  assert.deepEqual([za.r, za.c, zb.r, zb.c], [10, 5, 10, 5], 'both on the lowest-HP ally');
+  assert.equal(low.s.def, 100 + bbOf(a).def + bbOf(b).def, '+60 +75');
+  assert.ok(low.hp > low.s.maxHp * 0.3, 'and they restore its HP');
+  // one unit runs out: the other's DEF stays
+  mute(h, a); mute(h, b);
+  h.run(Math.max(0, za.dur - za.t) + 0.6);
+  assert.ok(!a.mem.zones.includes(za) && b.mem.zones.includes(zb), 'the elite\'s unit (7 s) outlasts the normal one (6 s)');
+  assert.equal(low.s.def, 100 + bbOf(b).def, 'its DEF stays alone');
+  h.run(zb.dur);
+  assert.equal(low.s.def, 100, 'no DEF bonus afterwards');
+  done(h);
+});
+
 test('引星棘刺 S1 度算浪波 (AUTO): fires as soon as its SP is full, no enemy needed (GitHub #124)', () => {
   for (const id of pair('15')) {
     const h = run({
diff --git a/test/golden/roster.json b/test/golden/roster.json
index 35e2da6e..64e19ad1 100644
--- a/test/golden/roster.json
+++ b/test/golden/roster.json
@@ -2017,64 +2017,64 @@
       "round": 12,
       "seed": 3754088384,
       "waveId": "act1autochess_h05",
-      "time": 219.47,
-      "ticks": 6584,
+      "time": 214.93,
+      "ticks": 6448,
       "reason": "cleared",
-      "killed": 35,
+      "killed": 54,
       "total": 167,
       "unspawned": 0,
       "bossHpLeft": null,
-      "rngDraws": 182,
+      "rngDraws": 203,
       "errors": {"count":0,"kinds":[]},
       "players": {
         "p1": {
-          "killed": 35,
+          "killed": 54,
           "total": 167,
           "perfect": false,
-          "leaks": 132,
+          "leaks": 113,
           "leaksUncounted": 0,
           "coins": 2,
-          "dmg": 366322,
+          "dmg": 579384,
           "bossDmg": 0,
-          "heal": 45493,
-          "deaths": 31,
-          "layerGains": {"indomShip":35}
+          "heal": 69092,
+          "deaths": 26,
+          "layerGains": {"indomShip":75}
         }
       },
       "units": [
-        ["p1",1,"op","chess_char_5_11_a",0,null,0,0,7,3,18161,12816,11936,37,6],
-        ["p1",2,"op","chess_char_5_19_a",0,null,0,0,181,1,24090,10511,2980,9,1],
-        ["p1",3,"op","chess_char_5_13_a",0,null,0,0,182,4,69847,16642,1033,31,1],
-        ["p1",4,"op","chess_char_5_14_a",0,null,0,0,200,0,2553,6628,1432,9,2],
-        ["p1",5,"op","chess_char_5_06_b",0,"uniequip_003_etlchi",0,0,88,14,152980,19394,11582,36,8],
-        ["p1",6,"op","chess_char_5_17_a",0,null,0,0,198,0,16224,20093,192,30,7],
-        ["p1",7,"op","chess_char_5_12_a",1,null,0,0,3,3,14164,3395,1991,13,2],
-        ["p1",8,"op","chess_char_5_15_a",0,null,0,0,201,5,18715,1950,98,75,20],
-        ["p1",9,"op","chess_char_5_20_a",0,null,0,0,184,0,7091,3502,178,15,1],
-        ["p1",10,"op","chess_char_5_21_a",0,null,0,0,189,0,5581,7990,180,9,0],
-        ["p1",11,"op","chess_char_5_22_a",0,null,0,0,193,5,34367,5558,1385,49,2],
-        ["p1",12,"op","chess_char_5_23_a",0,null,1422,1,202,0,0,6488,11768,20,7],
+        ["p1",1,"op","chess_char_5_11_a",0,null,0,0,185,6,24682,19544,18577,52,11],
+        ["p1",2,"op","chess_char_5_19_a",0,null,3241,1,200,8,50200,14729,7170,23,3],
+        ["p1",3,"op","chess_char_5_13_a",0,null,681.15,1,202,6,179758,34866,5612,46,1],
+        ["p1",4,"op","chess_char_5_14_a",0,null,1331.1,1,203,0,4188,13059,3998,14,2],
+        ["p1",5,"op","chess_char_5_06_b",0,"uniequip_003_etlchi",2992,1,204,15,169257,19787,11958,43,10],
+        ["p1",6,"op","chess_char_5_17_a",0,null,723.48,1,193,1,20066,17784,192,37,9],
+        ["p1",7,"op","chess_char_5_12_a",1,null,1404,1,3,3,15355,4263,3154,15,3],
+        ["p1",8,"op","chess_char_5_15_a",0,null,769.65,1,4,7,30505,713,557,126,34],
+        ["p1",9,"op","chess_char_5_20_a",0,null,0,0,188,0,7281,3522,198,16,1],
+        ["p1",10,"op","chess_char_5_21_a",0,null,0,0,191,0,5581,7990,180,9,0],
+        ["p1",11,"op","chess_char_5_22_a",0,null,1237,1,5,8,69963,3136,3136,103,4],
+        ["p1",12,"op","chess_char_5_23_a",0,null,1422,1,205,0,0,8541,13622,21,7],
         ["-","~1","device","trap_1105_accrate",null,null,100,1,1,0,0,0,0,0,null],
         ["-","~2","device","trap_1105_accrate",null,null,100,1,2,0,0,0,0,0,null],
         ["p1","~1","token","token_10015_dusk_drgn",null,null,1947.38,0,38,0,2547,787,737,8,null]
       ],
       "enemies": {
-        "enemy_1005_yokai_3": [1,0,1,5891,11900],
-        "enemy_1009_lurker": [72,17,55,921,93670],
+        "enemy_1005_yokai_3": [1,0,1,5415,17555],
+        "enemy_1009_lurker": [72,19,53,995,136536],
         "enemy_10159_mntrjn": [1,0,1,0,25020],
-        "enemy_1019_jshoot_2": [51,12,39,19173,94135],
+        "enemy_1019_jshoot_2": [51,24,27,18021,164779],
         "enemy_1118_lidbox_2": [1,1,0,39,14774],
         "enemy_1196_msfyin": [1,1,0,0,3],
         "enemy_1252_lysytb_2": [1,0,1,338,11250],
-        "enemy_1364_spnaxe_2": [1,0,1,5266,7966],
-        "enemy_1404_msnip": [36,4,32,77659,149942],
-        "enemy_1516_jakill": [1,0,1,6133,5143],
-        "enemy_9011_acrefr": [1,0,1,336,2479]
+        "enemy_1364_spnaxe_2": [1,0,1,4584,15996],
+        "enemy_1404_msnip": [36,9,27,111370,227827],
+        "enemy_1516_jakill": [1,0,1,7554,10944],
+        "enemy_9011_acrefr": [1,0,1,408,6100]
       },
-      "hooks": [1,202,6584,853,853,3205,3222,10125,66,199,57,57,0,18157,181,97,167,132,1,69,7,0,8],
-      "events": {"atk":955,"bounty":1,"deploy":33,"die":67,"dmg":3218,"engage":12,"fx":68,"heal":56,"layer":7,"leak":132,"skill":114,"spawn":182,"status":191},
-      "fx": {"aoe":2,"crit":4,"dodge":8,"dollEnd":3,"garrison":7,"healAoe":6,"hpShare":1,"palsy":1,"reborn":2,"revive":6,"sp":4,"substitute":3,"summon":1,"zone":20},
-      "snaps": "0092f82c 0dd327ad 53a3d810 58ba1139 90f0fe1e 37f52c37 cd5a8c36 c2f3acff ca099967 25de291a 2f88cb0f 5966eb8a c429d9ee 2513f9c2 c0f223dd 17c04486 0f59775e 7a41457d 4c1669d7 078e9615 676431e7 b6538f95"
+      "hooks": [1,205,6448,1165,1165,4391,4433,16853,80,194,85,83,0,27673,241,133,167,113,1,86,15,0,6],
+      "events": {"atk":1276,"bounty":1,"deploy":36,"die":81,"dmg":4429,"engage":12,"fx":107,"heal":69,"layer":15,"leak":113,"skill":168,"spawn":182,"status":237},
+      "fx": {"aoe":2,"crit":6,"dodge":6,"dollEnd":3,"garrison":15,"healAoe":11,"hpShare":1,"palsy":1,"reborn":2,"revive":11,"sp":5,"substitute":6,"summon":1,"swap":3,"zone":34},
+      "snaps": "0092f82c 0dd327ad 53a3d810 58ba1139 90f0fe1e cb512e37 ceb2cf74 a613cd55 5ce6b6e5 d58de777 28df897a f1e4ae5f b4781ed7 3af8405e 2c626d36 ce72c9fa e19c7d08 6db15d3a b2ed2de3 dadece28 8a66c30e ce8ff9d7"
     },
     "roster-034": {
       "about": "pass 1 band 6: chess_char_5_08_b chess_char_5_11_b chess_char_5_19_b chess_char_5_13_b chess_char_5_14_b chess_char_5_07_b chess_char_5_17_b chess_char_5_10_b chess_char_5_12_b chess_char_5_15_b chess_char_5_20_b chess_char_5_21_b",
@@ -2088,26 +2088,26 @@
       "time": 230,
       "ticks": 6900,
       "reason": "timeout",
-      "killed": 86,
+      "killed": 90,
       "total": 104,
       "unspawned": 0,
       "bossHpLeft": null,
-      "rngDraws": 621,
+      "rngDraws": 565,
       "errors": {"count":0,"kinds":[]},
-      "players": {"p1":{"killed":86,"total":104,"perfect":false,"leaks":18,"leaksUncounted":0,"coins":8,"dmg":5013885,"bossDmg":0,"heal":163673,"deaths":1,"layerGains":{}}},
+      "players": {"p1":{"killed":90,"total":104,"perfect":false,"leaks":14,"leaksUncounted":0,"coins":8,"dmg":5110704,"bossDmg":0,"heal":120360,"deaths":1,"layerGains":{}}},
       "units": [
-        ["p1",1,"op","chess_char_5_08_b",0,"uniequip_003_horn",3000,1,7,25,1690098,32737,709,96,86],
-        ["p1",2,"op","chess_char_5_11_b",0,"uniequip_003_demkni",4176.51,1,10,0,29905,12253,69243,182,38],
-        ["p1",3,"op","chess_char_5_19_b",0,"none",3682,1,11,3,184370,9411,9828,136,5],
-        ["p1",4,"op","chess_char_5_13_b",0,"uniequip_003_ghost2",3050.48,1,13,3,99196,55309,54515,210,5],
-        ["p1",5,"op","chess_char_5_14_b",0,"none",3261,1,15,0,16840,26781,26785,217,15],
-        ["p1",6,"op","chess_char_5_07_b",0,"uniequip_003_surtr",1804.11,1,8,6,337400,27088,605,137,60],
-        ["p1",7,"op","chess_char_5_17_b",0,"uniequip_003_f12yin",214.49,1,97,4,324747,5435,193,119,54],
-        ["p1",8,"op","chess_char_5_10_b",0,"uniequip_003_lisa",1470,1,4,4,161523,0,0,118,6],
-        ["p1",9,"op","chess_char_5_12_b",1,"uniequip_003_dusk",1667,1,5,33,1577956,0,0,89,5],
-        ["p1",10,"op","chess_char_5_15_b",0,"none",1907.5,1,12,0,47882,0,0,166,89],
-        ["p1",11,"op","chess_char_5_20_b",0,"uniequip_003_aglina",1352,1,14,3,205107,1794,1794,138,7],
-        ["p1",12,"op","chess_char_5_21_b",0,"none",3330.35,1,6,5,338859,0,0,67,3],
+        ["p1",1,"op","chess_char_5_08_b",0,"uniequip_003_horn",1512.22,1,7,28,1726631,34150,947,96,84],
+        ["p1",2,"op","chess_char_5_11_b",0,"uniequip_003_demkni",3477.62,1,10,0,39384,11346,66820,184,36],
+        ["p1",3,"op","chess_char_5_19_b",0,"none",3682,1,11,4,178330,6313,6313,129,5],
+        ["p1",4,"op","chess_char_5_13_b",0,"uniequip_003_ghost2",3448.92,1,13,3,109842,29514,29300,210,5],
+        ["p1",5,"op","chess_char_5_14_b",0,"none",3261,1,15,0,16840,13747,13949,217,20],
+        ["p1",6,"op","chess_char_5_07_b",0,"uniequip_003_surtr",2680,1,8,7,313834,25889,788,121,56],
+        ["p1",7,"op","chess_char_5_17_b",0,"uniequip_003_f12yin",538.04,1,97,6,252445,5368,450,89,42],
+        ["p1",8,"op","chess_char_5_10_b",0,"uniequip_003_lisa",1470,1,4,5,160605,0,0,120,6],
+        ["p1",9,"op","chess_char_5_12_b",1,"uniequip_003_dusk",1667,1,5,32,1794727,0,0,91,6],
+        ["p1",10,"op","chess_char_5_15_b",0,"none",1907.5,1,12,1,57355,0,0,166,82],
+        ["p1",11,"op","chess_char_5_20_b",0,"uniequip_003_aglina",1352,1,14,2,213658,1794,1794,138,6],
+        ["p1",12,"op","chess_char_5_21_b",0,"none",3330.35,1,6,2,247052,0,0,57,3],
         ["-","~1","device","trap_1105_accrate",null,null,100,0,1,0,0,0,0,0,null],
         ["-","~2","device","trap_1105_accrate",null,null,100,1,2,0,0,0,0,0,null],
         ["-","~3","device","trap_1105_accrate",null,null,100,1,3,0,0,0,0,0,null]
@@ -2119,16 +2119,16 @@
         "enemy_1165_duhond_2": [1,1,0,114,24767],
         "enemy_1204_msfhu": [1,1,0,0,12],
         "enemy_1288_duskls": [1,1,0,1594,30964],
-        "enemy_1381_winman": [27,23,4,6312,906059],
-        "enemy_1381_winman_2": [39,29,9,26620,1665434],
-        "enemy_1387_winshd": [30,26,2,114701,2095022],
+        "enemy_1381_winman": [27,25,2,4083,938899],
+        "enemy_1381_winman_2": [39,31,7,24737,1719910],
+        "enemy_1387_winshd": [30,26,2,76127,2104525],
         "enemy_1425_lrcmra_2": [1,1,0,11329,154793],
         "enemy_2009_csaudc": [1,1,0,2690,49534]
       },
-      "hooks": [1,120,6900,2623,2623,4011,4006,10250,87,103,373,370,0,31826,6617,100,104,15,1,88,0,0,14],
-      "events": {"atk":3112,"bounty":4,"deploy":13,"die":88,"dmg":3995,"engage":12,"fx":345,"heal":38,"leak":15,"skill":743,"spawn":119,"status":810},
-      "fx": {"aoe":15,"crit":21,"dodge":14,"ember":1,"healAoe":38,"hpShare":5,"sp":140,"zone":111},
-      "snaps": "de3bd2e2 efefe0a2 43519431 531ae1eb aa084bc8 507c87eb 0f5120b4 9a46e524 080c06c4 5b040f54 0c7a6be0 c2043b05 ae95d0ab e2cd74c3 5ca51241 aaf4ddc9 9f2d19ce dd8d93e5 7dbbf487 3f8ce0c6 325e24cf 4a98b418 a0f8abef"
+      "hooks": [1,120,6900,2558,2558,3995,3996,8433,91,103,351,349,0,31469,6479,104,104,11,1,92,0,0,8],
+      "events": {"atk":3070,"bounty":4,"deploy":13,"die":92,"dmg":3985,"engage":12,"fx":326,"heal":36,"leak":11,"skill":700,"spawn":119,"status":807},
+      "fx": {"aoe":20,"crit":14,"dodge":8,"ember":1,"healAoe":36,"hpShare":5,"sp":139,"zone":103},
+      "snaps": "de3bd2e2 23f28d96 7a63c0f2 28a9a6fe e6984bca 8eae402d 2b24991d c8788f23 5a001b21 0fed151a 87c013c7 b38057af 123bb336 e5b070fc 7fac01fd fb1d6e4d 2f2bc32b d3c63947 a34e6643 97d460d1 3c1349d8 783047e8 2de5f6f2"
     },
     "roster-035": {
       "about": "pass 1 band 6: chess_char_6_03_a chess_char_6_06_a chess_char_6_07_a chess_char_5_22_b chess_char_5_23_b chess_char_6_01_a chess_char_6_02_a chess_char_6_04_a chess_char_6_05_a chess_char_6_08_a chess_char_6_09_a chess_char_6_11_a token_10017_skadi2_dedant token_10030_mlyss_wtrman",
diff --git a/test/match/feedback5-boss-pair-prep.test.js b/test/match/feedback5-boss-pair-prep.test.js
index cc8b27a7..f1775eb1 100644
--- a/test/match/feedback5-boss-pair-prep.test.js
+++ b/test/match/feedback5-boss-pair-prep.test.js
@@ -56,6 +56,7 @@ test('a move of the partner reaches the player\'s m.private and a scout of eithe
   const h = bossPrep(4, 5102);
   const m = h.m;
   const b = place(h, 'p_1', chessOfTier(1)[1]);
+  const held = give(m, h.ps('p_0'), chessOfTier(1)[2]); // into p_0's hand
   m.flush(true);
   // p_3 (eliminated) scouts p_0: the scout shows p_0's half and p_1's board on the other half
   h.ps('p_3').eliminate(13);
@@ -63,6 +64,9 @@ test('a move of the partner reaches the player\'s m.private and a scout of eithe
   let scout = h.lastTo('p_3', 'm.field');
   assert.deepEqual([scout.kind, scout.side, scout.mate], ['boss', 'L', { playerId: 'p_1', side: 'R' }]);
   assert.ok(scout.units.some((u) => u.uid === b.piece.uid && u.x >= 10), 'the partner\'s piece on the right half');
+  // the area tags survive the boss-half remap (the rows do not): the bond popup tells the bench from the board (GitHub #385)
+  assert.equal(scout.units.find((u) => u.uid === b.piece.uid).area, 'board');
+  assert.equal(scout.units.find((u) => u.uid === held.uid).area, 'hand', 'a held operator stays tagged as held');
   // p_1 moves its piece: p_0's m.private and p_3's scout of p_0 follow
   const ps1 = h.ps('p_1');
   const to = legalTileFor(m, ps1, b.piece.id, new Set([`${b.tile[0]},${b.tile[1]}`]));
diff --git a/test/match/prep-bench.test.js b/test/match/prep-bench.test.js
index ec7e765a..baae0d12 100644
--- a/test/match/prep-bench.test.js
+++ b/test/match/prep-bench.test.js
@@ -37,6 +37,7 @@ test('#44 prep scout: held pieces are units on the hand row; deploying moves the
     const u = first.units.find((x) => x.uid === piece.uid);
     assert.ok(u, `${pid}: the held operator is a unit of the scout`);
     assert.deepEqual([u.x, u.y], [0, GEO.HAND_ROW], `${pid}: standing on the first hand slot`);
+    assert.equal(u.area, 'hand', 'tagged with its area: the bond popup counts it as held, not in play (GitHub #385)');
     assert.equal(u.kind, 'op');
     assert.equal(u.items, undefined, 'no items equipped yet');
   }
@@ -48,6 +49,7 @@ test('#44 prep scout: held pieces are units on the hand row; deploying moves the
   const last = h.lastTo('p_0', 'm.field');
   const u = last.units.find((x) => x.uid === piece.uid);
   assert.deepEqual([u.x, u.y], [c, r], 'deployed onto the watched board');
+  assert.equal(u.area, 'board');
   assert.equal(last.units.some((x) => x.uid === piece.uid && x.y === GEO.HAND_ROW), false, 'and gone from the hand row');
   m.dispose();
 });
@@ -74,6 +76,7 @@ test('#44 prep scout: a held item is a kind-item unit on the hand row; equipped
   assert.ok(iu, 'the held item is a unit of the scout');
   assert.equal(iu.kind, 'item');
   assert.equal(iu.y, GEO.HAND_ROW);
+  assert.equal(iu.area, 'hand');
   // equip the item onto the operator (still in the hand): the operator's unit carries the item id
   assert.deepEqual(m.handle('p_1', { t: 'g.equip', itemUid: item.uid, targetUid: op.uid }), { ok: true });
   const after = h.lastTo('p_0', 'm.field');
@@ -109,7 +112,10 @@ test("PR #129 review: moving a hand piece to another slot is a scout change (x f
   const first = h.lastTo('p_0', 'm.field');
   const tu = first.units.find((x) => x.uid === c.uid);
   assert.deepEqual([tu.x, tu.y], [GEO.TEMP_C0, GEO.TEMP_ROW], 'the temp piece scouts on the temp row (first slot, col 4)');
-  assert.equal(first.units.find((x) => x.uid === a.uid).x, 0);
+  assert.equal(tu.area, 'temp');
+  const hu = first.units.find((x) => x.uid === a.uid);
+  assert.equal(hu.x, 0);
+  assert.equal(hu.area, 'hand');
 
   // a hand piece moved to another slot keeps uid and id — the slot must be in the signature for the push to fire
   assert.deepEqual(m.handle('p_1', { t: 'g.move', uid: a.uid, to: { area: 'hand', idx: 3 } }), { ok: true });
diff --git a/test/match/scroll-copy-merge.test.js b/test/match/scroll-copy-merge.test.js
new file mode 100644
index 00000000..ca4a597c
--- /dev/null
+++ b/test/match/scroll-copy-merge.test.js
@@ -0,0 +1,113 @@
+// A Picture Scroll (画卷) gain can consume its own target in an immediate three-copy promotion (GitHub #389, PR #390).
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { makeMatch, legalTileFor } from './harness.js';
+
+const OP = 'chess_char_1_06_a'; // 刺玫, the operator of the report
+const SCROLL = 'chess_item_6_02_m';
+const HAMMER = 'chess_item_1_01_e_a';
+const SHIELD = 'chess_item_1_02_e_a';
+const FILLER = 'chess_item_6_09_e_a'; // non-mergeable
+const OK = { ok: true };
+
+function prep(t, { copies = 2, golden = false, items = [HAMMER] } = {}) {
+  const h = makeMatch({ mode: 'solo', difficulty: 'FUNNY', seed: 8 }).start();
+  t.after(() => h.m.dispose());
+  h.toPrep(1, { band: 'band_dusk' });
+  const m = h.m, ps = h.ps('p_0');
+  assert.equal(m.gd.mergeCount(OP), 3);
+  const id = golden ? m.gd.goldenIdOf(OP) : OP;
+  const target = ps.acquireChess(id);
+  const [row, col] = legalTileFor(m, ps, id);
+  assert.deepEqual(m.handle('p_0', { t: 'g.move', uid: target.uid, to: { area: 'board', row, col }, dir: 'RIGHT' }), OK);
+  for (let i = 1; i < copies; i++) ps.acquireChess(id);
+  for (const itemId of items) {
+    const item = ps.acquireItem(itemId);
+    assert.deepEqual(m.handle('p_0', { t: 'g.equip', itemUid: item.uid, targetUid: target.uid }), OK);
+  }
+  const art = ps.hand.find((p) => p?.id === SCROLL);
+  assert.ok(art, 'Dusk grants the scroll in round 1');
+  h.invariants();
+  const cast = () => m.handle('p_0', { t: 'g.art', itemUid: art.uid, row, col, dir: 'RIGHT' });
+  return { h, m, ps, target, art, row, col, cast };
+}
+
+function itemIds(ps) {
+  return [...ps.hand, ...ps.temp, ...ps.board.values()].filter(Boolean)
+    .flatMap((p) => p.kind === 'item' ? [p.id] : (p.items || []).map((it) => it.id)).sort();
+}
+
+test('Picture Scroll: a third normal copy preserves the target equipment through promotion', (t) => {
+  const { h, m, ps, target, art, row, col, cast } = prep(t);
+  const funds = ps.funds;
+  assert.deepEqual(cast(), OK);
+  const elite = ps.board.get(`${row},${col}`);
+  assert.equal(elite.id, m.gd.goldenIdOf(OP));
+  assert.equal(elite.dir, 'RIGHT');
+  assert.equal(ps.find(target.uid), null, 'the original target was consumed');
+  assert.equal(ps.find(art.uid), null, 'the scroll was consumed');
+  assert.deepEqual(itemIds(ps), [m.gd.item(HAMMER).goldenId]);
+  assert.ok(ps.hand.some((p) => p?.id === m.gd.item(HAMMER).goldenId), 'the original and copied hammer merge into an advanced hammer in hand');
+  assert.deepEqual(elite.items, []);
+  assert.equal(ps.stats.merges, 1);
+  assert.equal(ps.stats.itemMerges, 1);
+  assert.equal(ps.funds, funds);
+  h.invariants();
+});
+
+for (const advanced of [false, true]) {
+  test(`Picture Scroll: promotion copies both ${advanced ? 'advanced' : 'normal'} equipped items, none of them worn by the elite`, (t) => {
+    const items = [HAMMER, SHIELD].map((id) => advanced ? id.replace(/_a$/, '_b') : id);
+    const { h, m, ps, row, col, cast } = prep(t, { items });
+    assert.deepEqual(cast(), OK);
+    const elite = ps.board.get(`${row},${col}`);
+    const upgraded = items.map((id) => m.gd.item(id).goldenId || id).sort();
+    // advanced items do not merge: the returned originals and the copies all wait in the hand ("获得的装备为未装备状态")
+    assert.deepEqual(itemIds(ps), advanced ? [...items, ...items].sort() : upgraded);
+    assert.deepEqual(elite.items, [], 'the promotion unequips, and the copies are not put back on the elite');
+    assert.equal([...ps.hand, ...ps.temp].filter((p) => p?.kind === 'item').length, advanced ? 4 : 2);
+    h.invariants();
+  });
+}
+
+for (const golden of [false, true]) {
+  test(`Picture Scroll: one ${golden ? 'elite' : 'normal'} target still copies its equipment without promotion`, (t) => {
+    const { h, m, ps, target, cast } = prep(t, { copies: 1, golden });
+    assert.deepEqual(cast(), OK);
+    assert.equal(ps.find(target.uid)?.piece, target);
+    assert.equal(ps.allChess().length, 2);
+    assert.equal(ps.allChess().filter((p) => p.id === target.id).length, 2);
+    assert.deepEqual(itemIds(ps), [m.gd.item(HAMMER).goldenId]);
+    assert.equal(ps.stats.merges, 0);
+    h.invariants();
+  });
+}
+
+test('Picture Scroll: a third copy without equipment still promotes normally', (t) => {
+  const { h, m, ps, row, col, cast } = prep(t, { items: [] });
+  assert.deepEqual(cast(), OK);
+  assert.equal(ps.board.get(`${row},${col}`).id, m.gd.goldenIdOf(OP));
+  assert.deepEqual(itemIds(ps), []);
+  h.invariants();
+});
+
+test('Picture Scroll: a promotion at full hand and temp still copies the hammer', (t) => {
+  const { h, m, ps, cast } = prep(t);
+  while (ps.hand.some((p) => p == null) || ps.temp.some((p) => p == null)) assert.ok(ps.acquireItem(FILLER));
+  h.invariants();
+  assert.deepEqual(cast(), OK);
+  assert.deepEqual(itemIds(ps).filter((id) => id !== FILLER), [m.gd.item(HAMMER).goldenId]);
+  assert.equal(itemIds(ps).filter((id) => id === FILLER).length, 13);
+  h.invariants();
+});
+
+test('Picture Scroll: a full hand and temp without promotion keeps the refused scroll and target equipment', (t) => {
+  const { h, ps, target, art, cast } = prep(t, { copies: 1 });
+  while (ps.hand.some((p) => p == null) || ps.temp.some((p) => p == null)) assert.ok(ps.acquireItem(FILLER));
+  const before = ps.privateView();
+  assert.equal(cast().error, 'HAND_FULL');
+  assert.ok(ps.find(art.uid));
+  assert.deepEqual(target.items.map((p) => p.id), [HAMMER]);
+  assert.deepEqual(ps.privateView(), before);
+  h.invariants();
+});
diff --git a/test/render/fxchill.test.js b/test/render/fxchill.test.js
new file mode 100644
index 00000000..d44da581
--- /dev/null
+++ b/test/render/fxchill.test.js
@@ -0,0 +1,60 @@
+// test/render/fxchill.test.js — the 'chill' fx of coldWind (render/fx/simfx.js + zones.js snowfall), PR #386 by
+// @leiming2333: 谢拉格's 盟约寒风 blows a blizzard UP the field (the official direction, the owner's confirmation of
+// 2026-10-08) with a stronger cold flash; an operator's own coldWind (灵知 S3, 麦哲伦 S1's pulse every 3 s — emitted with
+// the unit's `id`) keeps the light downward flurry and the softer flash. Against the headless fake PIXI
+// (test/render/fakepixi.js), like fxchen3wave.test.js.
+
+import { test, describe, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { installFakePixi, fakeViewCtx } from './fakepixi.js';
+import { presetCamera } from '../../public/js/render/projection.js';
+
+let fake, FX;
+before(async () => {
+  fake = installFakePixi();
+  FX = await import('../../public/js/render/fx.js');
+});
+after(() => fake.restore());
+
+const W = 1600, H = 900;
+const cam = presetCamera('normal', { width: W, height: H });
+
+function makeFx(quality = 'high') {
+  const P = fake.P;
+  const ctx = fakeViewCtx(P);
+  const unit = { id: 7, x: 5, y: 10, z: 0, hover: 0, _headTiles: 1.2, alive: true, destroyed: false, info: { defId: 'x' }, onHit() {} };
+  return new FX.FxSystem({
+    P, layers: ctx.layers, cam: () => cam, heightAt: () => 0, settings: { quality, damageNumbers: true },
+    timeScale: () => 1, loadLevel: () => 0, subProfOf: () => null, view: (id) => (id === unit.id ? unit : null),
+    screenSize: () => ({ width: W, height: H }), fieldTop: () => 120,
+  });
+}
+const live = (fx) => fx.parts.filter((p) => p.sp && p.sp.visible !== false);
+
+describe('coldWind: 谢拉格\'s 盟约寒风 blows up the field, an operator\'s own cold keeps the light flurry', () => {
+  test('the bond\'s gust (the device emits no anchor unit): 48 flakes and 10 streaks rising from the bottom, the stronger flash', () => {
+    const fx = makeFx();
+    // server/sim/content/devices.js startColdWind: the field centre, the player, the cold stacks, the cold duration
+    fx.simFx('coldWind', 8, 9, { x: 8, y: 9, playerId: 'p1', n: 3, duration: 5 });
+    const ps = live(fx);
+    assert.equal(ps.length, 58, '48 flakes + 10 streaks at quality high');
+    assert.ok(ps.every((p) => p.vy < 0), 'every particle rises (screen y grows downward)');
+    assert.ok(ps.every((p) => p.vx > 0), 'on a crosswind');
+    assert.ok(ps.every((p) => p.y >= H * 0.55 - 1e-9), 'lifted off the lower part of the screen (some start below it)');
+    assert.equal(ps.filter((p) => p.sp.texture === fx.tex.streak).length, 10, 'gust streaks');
+    assert.deepEqual([fx.tintA, fx.tintDur], [0.45, 1]);
+    const low = makeFx('low');
+    low.simFx('coldWind', 8, 9, { x: 8, y: 9, playerId: 'p1', n: 3, duration: 5 });
+    assert.equal(live(low).length, 26, 'quality low: 22 flakes + 4 streaks');
+  });
+
+  test('an operator\'s own coldWind (灵知 S3, 麦哲伦\'s pulse: `id` = the unit): the light flurry drifting down, the softer flash', () => {
+    const fx = makeFx();
+    fx.simFx('coldWind', 5, 10, { x: 5, y: 10, id: 7, n: 2 });
+    const ps = live(fx);
+    assert.equal(ps.length, 26);
+    assert.ok(ps.every((p) => p.vy > 0), 'falling as before');
+    assert.equal(ps.filter((p) => p.sp.texture === fx.tex.streak).length, 0, 'no gust streaks');
+    assert.deepEqual([fx.tintA, fx.tintDur], [0.35, 0.8]);
+  });
+});
diff --git a/test/ui/facing.e2e.test.js b/test/ui/facing.e2e.test.js
new file mode 100644
index 00000000..324bb7e3
--- /dev/null
+++ b/test/ui/facing.e2e.test.js
@@ -0,0 +1,157 @@
+// The facing wheel's keyboard in the mock match (headless Chrome, the DOM field — no art / WebGL needed): GitHub #394 /
+// PR #395 (the drag / Tab flow of this file is the PR's, by @Xinglan233). Enter follows the focus while the wheel is
+// open — the wheel takes the focus when it opens, so arrows + Enter confirm (also with a HUD button focused before the
+// drop); Tab reaches ✕ first and Enter on it cancels; Enter on any other button (准备, 设置 …) does nothing; Esc cancels.
+// Unit side: test/ui/feedback5-hotkeys.test.js (facingEnter).
+// SP_E2E=1 CHROME_PATH=/path/to/chrome node --test test/ui/facing.e2e.test.js
+import { test, describe, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { existsSync } from 'node:fs';
+
+const CHROME = process.env.CHROME_PATH || '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';
+const ENABLED = process.env.SP_E2E === '1' && existsSync(CHROME);
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+describe('facing wheel keyboard (mock match, headless Chrome)', { skip: !ENABLED && 'set SP_E2E=1 (and have Chrome) to run' }, () => {
+  let srv, browser;
+  before(async () => {
+    const { startServer } = await import('../../server/index.js');
+    const puppeteer = (await import('puppeteer-core')).default;
+    srv = await startServer({ port: 0, host: '127.0.0.1', quiet: true });
+    browser = await puppeteer.launch({ executablePath: CHROME, headless: true, args: ['--no-sandbox', '--no-proxy-server'] });
+  });
+  after(async () => { await browser?.close(); await srv?.close(); });
+
+  async function setup(t) {
+    const page = await browser.newPage();
+    t.after(() => page.close());
+    await page.setViewport({ width: 1920, height: 1080 });
+    const errors = [];
+    page.on('pageerror', (e) => errors.push(e.message));
+    await page.goto(`http://127.0.0.1:${srv.port}/dev/game-mock.html?shot=1&render=fallback&phase=PREP`, { waitUntil: 'networkidle0' });
+    await page.waitForSelector('.ff-piece');
+    const state = () => page.evaluate(() => JSON.parse(JSON.stringify(globalThis.__MOCK__.S().priv)));
+    const moves = () => page.evaluate(() => globalThis.__MOCK__.S().requests.filter(([type]) => type === 'g.move'));
+    const sent = () => page.evaluate(() => globalThis.__MOCK__.S().requests.map(([type]) => type));
+    const initial = await state();
+    // room under the deploy cap (sell a board operator through the underframe), then a free legal tile
+    const sell = initial.board.find((p) => p.kind === 'chess' && !p.golden);
+    await page.click(`.ff-piece[data-uid="${sell.uid}"]`);
+    await page.waitForSelector('.uframe__btn--sell');
+    await page.click('.uframe__btn--sell');
+    await page.waitForFunction((uid) => !globalThis.__MOCK__.S().priv.board.some((p) => p.uid === uid), {}, sell.uid);
+    const ready = await state();
+    const piece = ready.hand.find((p) => p?.kind === 'chess');
+    const tile = [[9, 9], [9, 8], [12, 6], [11, 7], [10, 7], [9, 7]].find(([r, c]) => !ready.board.some((p) => p.row === r && p.col === c));
+    assert.ok(piece && tile, 'an operator and a free legal tile exist');
+    const center = (sel) => page.$eval(sel, (el) => { const r = el.getBoundingClientRect(); return { x: r.left + r.width / 2, y: r.top + r.height / 2 }; });
+    const open = async () => {
+      const from = await center(`.ff-piece[data-uid="${piece.uid}"]`);
+      const to = await center(`.ff-tile[data-row="${tile[0]}"][data-col="${tile[1]}"]`);
+      await page.mouse.move(from.x, from.y); await page.mouse.down();
+      await page.mouse.move(from.x + 20, from.y, { steps: 4 }); // a drag also when the piece re-orients on its own tile
+      await page.mouse.move(to.x, to.y, { steps: 12 }); await sleep(80); await page.mouse.up();
+      await page.waitForSelector('.fwheel__dia');
+      await sleep(200);
+    };
+    const preview = async (key) => {
+      await page.keyboard.press(key);
+      await page.waitForSelector(`.fwheel.is-${key.slice(5).toLowerCase()}`);
+    };
+    const active = () => page.evaluate(() => {
+      const a = document.activeElement;
+      return { wheel: !!a?.matches('.fwheel'), cancel: !!a?.closest('.fwheel__cancel'), button: a?.tagName === 'BUTTON' && !a.closest('.fwheel'), cls: a?.className || a?.tagName };
+    });
+    const tabUntil = async (want) => {
+      for (let i = 0; i < 80; i++) {
+        if (want(await active())) return;
+        await page.keyboard.press('Tab');
+      }
+      assert.fail('Tab never reached the wanted element');
+    };
+    const isOpen = () => page.evaluate(() => !!document.querySelector('.fwheel'));
+    const closed = async () => { await page.waitForFunction(() => !document.querySelector('.fwheel')); await sleep(150); };
+    return { page, state, moves, sent, errors, ready, piece, tile, open, preview, active, tabUntil, isOpen, closed };
+  }
+
+  test('the wheel takes the focus: arrows + Enter confirm once in all four directions', async (t) => {
+    const h = await setup(t);
+    for (const dir of ['UP', 'RIGHT', 'DOWN', 'LEFT']) {
+      await h.open();
+      assert.equal((await h.active()).wheel, true, 'the wheel has the focus when it opens');
+      await h.page.keyboard.press('Enter');
+      await sleep(150);
+      assert.equal(await h.isOpen(), true, 'Enter with no direction previewed does nothing');
+      await h.preview(`Arrow${dir[0] + dir.slice(1).toLowerCase()}`);
+      const count = (await h.moves()).length;
+      await h.page.keyboard.press('Enter');
+      await h.closed();
+      assert.equal((await h.moves()).length, count + 1, 'one intent per confirmation');
+      assert.deepEqual((await h.moves()).at(-1)[1].dir, dir);
+      const board = (await h.state()).board.filter((p) => p.uid === h.piece.uid);
+      assert.deepEqual([board.length, board[0].row, board[0].col, board[0].dir], [1, ...h.tile, dir]);
+    }
+    assert.deepEqual(h.errors, []);
+  });
+
+  test('Tab reaches ✕ first and Enter on it cancels; Esc cancels; Space on ✕ stays swallowed', async (t) => {
+    const h = await setup(t);
+    await h.open();
+    await h.preview('ArrowRight');
+    await h.page.keyboard.press('Tab');
+    assert.equal((await h.active()).cancel, true, 'the first Tab from the wheel lands on ✕');
+    await h.page.keyboard.press('Space');
+    await sleep(150);
+    assert.equal(await h.isOpen(), true, 'Space does not activate the focused ✕ (no ready / shop keys while choosing)');
+    await h.page.keyboard.press('Enter');
+    await h.closed();
+    assert.deepEqual(await h.moves(), [], 'cancelling sends no deployment');
+    assert.deepEqual(await h.state(), h.ready, 'the operator stays where it was');
+    await h.open();
+    await h.preview('ArrowLeft');
+    await h.page.keyboard.press('Escape');
+    await h.closed();
+    assert.deepEqual(await h.moves(), []);
+    assert.deepEqual(h.errors, []);
+  });
+
+  test('Enter on another focused button (准备, 设置 …) does nothing while the wheel is open', async (t) => {
+    const h = await setup(t);
+    await h.open();
+    await h.preview('ArrowRight');
+    const before = await h.sent();
+    // walk the focus past ✕ to the HUD behind the wheel: every button reached gets an Enter
+    const seen = new Set();
+    for (let i = 0; i < 80 && seen.size < 6; i++) {
+      await h.page.keyboard.press('Tab');
+      const a = await h.active();
+      if (!a.button || seen.has(a.cls)) continue;
+      seen.add(a.cls);
+      await h.page.keyboard.press('Enter');
+      await sleep(120);
+      assert.equal(await h.isOpen(), true, `Enter on ${a.cls} keeps the wheel open`);
+      assert.equal(await h.page.evaluate(() => !!document.querySelector('.modal')), false, `Enter on ${a.cls} opens nothing`);
+    }
+    assert.ok(seen.size >= 2, `Tab reached HUD buttons behind the wheel (${[...seen].join(' | ')})`);
+    assert.ok([...seen].some((c) => /readybtn|gm__gear/.test(c)), '准备 or 设置 among them');
+    assert.deepEqual(await h.sent(), before, 'no intent of any kind (no g.move, no ready, no shop)');
+    assert.equal((await h.state()).ready, h.ready.ready, 'still not ready');
+    await h.page.keyboard.press('Escape');
+    await h.closed();
+    assert.deepEqual(await h.moves(), []);
+    assert.deepEqual(h.errors, []);
+  });
+
+  test('a HUD button focused before the drop does not swallow the confirming Enter', async (t) => {
+    const h = await setup(t);
+    await h.page.focus('.gm__gear');
+    await h.open();
+    assert.equal((await h.active()).wheel, true);
+    await h.preview('ArrowDown');
+    await h.page.keyboard.press('Enter');
+    await h.closed();
+    assert.equal((await h.moves()).length, 1);
+    assert.equal(await h.page.evaluate(() => !!document.querySelector('.modal')), false, 'the settings did not open');
+    assert.deepEqual(h.errors, []);
+  });
+});
diff --git a/test/ui/feedback5-hotkeys.test.js b/test/ui/feedback5-hotkeys.test.js
index 5d106ac2..d598ce13 100644
--- a/test/ui/feedback5-hotkeys.test.js
+++ b/test/ui/feedback5-hotkeys.test.js
@@ -11,7 +11,7 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import {
   HOTKEY_ACTIONS, DEFAULT_HOTKEYS, isBindableCode, hotkeyLabel, sanitizeHotkeys, rebindHotkey, isDefaultHotkeys, hotkeyOf,
-  actionForKey, captureHotkey, facingSwallows, shortcutFor, shortcutBlocked, sanitizeSettings, DEFAULT_SETTINGS,
+  actionForKey, captureHotkey, facingSwallows, facingEnter, shortcutFor, shortcutBlocked, sanitizeSettings, DEFAULT_SETTINGS,
 } from '../../public/js/ui/gameLogic.js';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
@@ -201,6 +201,59 @@ describe('the one lookup (actionForKey) and shortcutFor', () => {
     assert.equal(facingSwallows({ key: ' ', code: 'Space' }, { ...DEFAULT_HOTKEYS, ready: 'KeyE' }), true, 'Space always: a focused button must not activate');
     assert.equal(facingSwallows({ key: 'z', code: 'KeyZ' }), false);
   });
+
+  // GitHub #394 / PR #395: Enter followed the previewed direction whatever had the focus — Tab to 准备 / 设置 / ✕ and
+  // Enter deployed. A tiny element tree whose closest() understands the selector forms facingEnter uses.
+  const el = (tag, attrs = {}, parent = null) => {
+    const self = {
+      tagName: tag.toUpperCase(), attrs, parent,
+      matches(sel) {
+        return sel.split(',').map((s) => s.trim()).some((s) => {
+          const m = /^([a-z]*)((?:\.[\w-]+)*)((?:\[[\w-]+(?:="[^"]*")?\])*)$/.exec(s);
+          if (!m) return false;
+          if (m[1] && m[1].toUpperCase() !== self.tagName) return false;
+          const classes = String(attrs.class || '').split(/\s+/);
+          if (m[2] && !m[2].slice(1).split('.').every((c) => classes.includes(c))) return false;
+          for (const [, k, v] of m[3].matchAll(/\[([\w-]+)(?:="([^"]*)")?\]/g)) {
+            if (!(k in attrs) || (v !== undefined && String(attrs[k]) !== v)) return false;
+          }
+          return !!(m[1] || m[2] || m[3]);
+        });
+      },
+      closest(sel) { for (let n = self; n; n = n.parent) if (n.matches(sel)) return n; return null; },
+    };
+    return self;
+  };
+  test('the facing wheel\'s Enter follows the focus: ✕ cancels, another control does nothing, elsewhere it commits', () => {
+    const body = el('body');
+    const wheel = el('div', { class: 'fwheel', role: 'dialog', tabindex: '-1' }, body);
+    const cancel = el('button', { class: 'fwheel__cancel' }, el('div', { class: 'fwheel__dia' }, wheel));
+    const cancelText = el('span', {}, cancel);
+    const ready = el('button', { class: 'ready' }, el('header', {}, body));
+    const gear = el('button', { class: 'gm__gear' }, body);
+    const card = el('div', { role: 'button', tabindex: '0' }, body);
+    const link = el('a', { href: '#' }, body);
+    const field = el('input', { type: 'text' }, body);
+    for (const chosen of [true, false]) {
+      assert.equal(facingEnter({ key: 'Enter', target: cancel }, chosen), 'cancel', 'Enter on ✕ cancels (a direction previewed or not)');
+      assert.equal(facingEnter({ key: 'Enter', target: cancelText }, chosen), 'cancel');
+      for (const t of [ready, gear, card, link, field]) assert.equal(facingEnter({ key: 'Enter', target: t }, chosen), 'swallow', 'another control does nothing');
+    }
+    assert.equal(facingEnter({ key: 'Enter', target: wheel }, true), 'commit', 'the wheel has the focus when it opens: Enter confirms');
+    assert.equal(facingEnter({ key: 'Enter', target: body }, true), 'commit');
+    assert.equal(facingEnter({ key: 'Enter', target: null }, true), 'commit');
+    assert.equal(facingEnter({ key: 'Enter', target: wheel }, false), 'swallow', 'nothing to confirm yet');
+    assert.equal(facingEnter({ key: ' ', target: cancel }, true), null, 'not Enter: Space stays with facingSwallows');
+    assert.equal(facingEnter({ key: 'ArrowUp', target: body }, true), null);
+    assert.equal(facingEnter(null, true), null);
+  });
+  test('the wheel wires it: Enter through facingEnter, the wheel focusable and focused when it opens', () => {
+    const src = read('public/js/ui/facingWheel.js');
+    assert.match(src, /const enter = facingEnter\(e, !!L\.dir\);/);
+    assert.doesNotMatch(src, /e\.key === 'Enter' && L\.dir/, 'no Enter that ignores the focus');
+    assert.match(src, /<div ref=\$\{rootRef\} tabIndex="-1" class=\$\{cx\('fwheel'/);
+    assert.match(src, /rootRef\.current\?\.focus\(\{ preventScroll: true \}\)/);
+  });
 });
 
 describe('capturing a new key (the settings wait for a key)', () => {
diff --git a/test/ui/inspect-range.e2e.test.js b/test/ui/inspect-range.e2e.test.js
new file mode 100644
index 00000000..770d1ae4
--- /dev/null
+++ b/test/ui/inspect-range.e2e.test.js
@@ -0,0 +1,92 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { existsSync } from 'node:fs';
+import { startServer } from '../../server/index.js';
+import { makeBattle } from '../helpers/battleHarness.js';
+import { spawnMapChar } from '../../server/sim/content/tokens.js';
+
+const chrome = process.env.CHROME_PATH;
+const enabled = process.env.SP_E2E === '1' && chrome && existsSync(chrome);
+
+test('user Given a real battle with strategy medics When clicking units and closing details Then attack tiles follow selection',
+  { skip: !enabled && 'Set SP_E2E=1 and CHROME_PATH', timeout: 60000 }, async () => {
+    const server = await startServer({ port: 0, host: '127.0.0.1', quiet: true });
+    const puppeteer = (await import('puppeteer-core')).default;
+    const browser = await puppeteer.launch({ executablePath: chrome, headless: true, args: ['--no-sandbox'] });
+    try {
+      for (const medicId of ['char_613_acmedc', 'char_605_cmedic']) {
+        const h = makeBattle({ stageId: 'act2autochess_m01', units: [{ chessId: 'chess_char_1_01_a', row: 10, col: 4 }], autoFinish: false });
+        h.step();
+        assert.ok(spawnMapChar(h.b, h.b.players[0].playerId, medicId));
+        h.step();
+        const field = h.b.fieldMeta();
+        const snapshot = h.b.snapshot();
+        assert.equal(field.units.length, 2);
+        const page = await browser.newPage();
+        await page.setViewport({ width: 1280, height: 720, deviceScaleFactor: 2 });
+        const errors = [];
+        page.on('pageerror', (error) => errors.push(error.message));
+        await page.goto(`http://127.0.0.1:${server.port}/dev/game-mock.html?render=fallback&shot=1&phase=PREP`);
+        await page.waitForSelector('.ff-piece');
+        await page.evaluate(async ({ field, snapshot }) => {
+          const { store } = await import('/js/store.js');
+          const { net } = await import('/js/net.js');
+          const pub = store.get().match.public;
+          store.patch('match', { public: { ...pub, phase: 'COMBAT', fields: [{ fieldId: field.fieldId, players: [pub.players[0].playerId] }] }, field });
+          // The local runner emits the snapshot synchronously, before the screen's field-entry effect.
+          net._emit('b.snap', snapshot);
+        }, { field, snapshot });
+        await page.waitForSelector('.ff-unit');
+        for (let i = 0; i < field.units.length; i++) {
+          const units = await page.$$('.ff-unit');
+          await units[i].click();
+          await page.waitForSelector('.dpanel');
+          await page.waitForSelector('.ff-tile.is-range');
+          const lit = await page.$$eval('.ff-tile.is-range', (els) => els.map((e) => [Number(e.dataset.row), Number(e.dataset.col)]));
+          const u = field.units[i];
+          if (u.defId === medicId) {
+            assert.ok(lit.some(([r, c]) => r === 10 && c === 5), 'medic reaches three columns right from the stage tile');
+            assert.ok(!lit.some(([, c]) => c === 6), 'inactive skill does not extend the base range');
+          }
+          // A new wire snapshot must refresh the open overlay, not just the unit sprite.
+          await page.evaluate(async ({ snapshot, id }) => {
+            const { net } = await import('/js/net.js');
+            net._emit('b.snap', { ...snapshot, units: snapshot.units.map((v) => v[0] === id ? [v[0], v[1] + 1, ...v.slice(2)] : v) });
+          }, { snapshot, id: u.id });
+          await page.waitForFunction((before) => {
+            const now = [...document.querySelectorAll('.ff-tile.is-range')].map((e) => [Number(e.dataset.row), Number(e.dataset.col)]);
+            return now.length === before.length && now.every(([r, c]) => before.some(([br, bc]) => br === r && bc + 1 === c));
+          }, {}, lit);
+          await page.evaluate(async () => {
+            const { store } = await import('/js/store.js');
+            store.patch('match', { public: { ...store.get().match.public, phase: 'SETTLE' } });
+            // Allow Preact's after-paint phase effects to run before asserting retained UI.
+            await new Promise((resolve) => setTimeout(resolve, 250));
+          });
+          assert.ok(await page.$('.dpanel'), 'same-field settlement keeps the inspected card');
+          assert.ok(await page.$('.ff-tile.is-range'), 'same-field settlement keeps its range');
+          await page.click('.dpanel__close');
+          await page.waitForFunction(() => !document.querySelector('.ff-tile.is-range'));
+          await page.evaluate(async (snapshot) => {
+            const { net } = await import('/js/net.js');
+            net._emit('b.snap', snapshot);
+          }, snapshot);
+        }
+        await (await page.$$('.ff-unit'))[0].click();
+        await page.waitForSelector('.ff-tile.is-range');
+        await page.evaluate(async ({ field, snapshot }) => {
+          const { store } = await import('/js/store.js');
+          const { net } = await import('/js/net.js');
+          const fieldId = `${field.fieldId}:next`;
+          store.patch('match', { field: { ...field, fieldId } });
+          net._emit('b.snap', { ...snapshot, fieldId });
+        }, { field, snapshot });
+        await page.waitForFunction(() => !document.querySelector('.dpanel') && !document.querySelector('.ff-tile.is-range'));
+        assert.deepEqual(errors, []);
+        await page.close();
+      }
+    } finally {
+      await browser.close();
+      await server.close();
+    }
+  });
diff --git a/test/ui/inspect-range.test.js b/test/ui/inspect-range.test.js
new file mode 100644
index 00000000..49e1674e
--- /dev/null
+++ b/test/ui/inspect-range.test.js
@@ -0,0 +1,106 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { inspectRange } from '../../public/js/screens/game/range.js';
+import { renderInfo } from '../../public/js/render/app/info.js';
+import { rangeTiles } from '../../public/js/ui/facing.js';
+import { unitStatsEntry } from '../../shared/protocol.js';
+import { makeBattle } from '../helpers/battleHarness.js';
+
+const read = (name) => JSON.parse(readFileSync(new URL(`../../data/${name}.json`, import.meta.url), 'utf8'));
+const chess = read('chess'), tokens = read('tokens');
+const getChess = (id) => chess[id];
+const medic = (id = 'char_613_acmedc', extra = {}) => renderInfo({ id: 71, defId: id, kind: 'token', side: 'ally', x: 5, y: 9, dir: 'UP', ...extra });
+const args = (unit, extra = {}) => ({ target: { kind: 'unit', unit }, detail: { type: 'token', token: tokens[unit.defId] },
+  getChess, field: { prep: true }, ...extra });
+
+test('user Given Jessica inspected beside her shield When it expires Then her open range turns back with her', () => {
+  const h = makeBattle({ autoFinish: false, units: [
+    { uid: 1, diy: { slot: 'chess_char_5_diy1_a', charId: 'char_1034_jesca2', skillIndex: 0 }, row: 10, col: 4 },
+    { uid: 2, kind: 'token', tokenId: 'token_10032_jesca2_jckshd', ownerUid: 1, row: 11, col: 4 },
+  ] });
+  h.step();
+  const u = h.unit(1);
+  const unit = h.b.fieldMeta().units.find((v) => v.id === u.id);
+  const input = { target: { kind: 'unit', unit }, detail: { type: 'chess', chess: u.def.raw, diy: true }, getChess, field: {} };
+  const tiles = () => {
+    const r = inspectRange({ ...input, live: unitStatsEntry(u, u.s), snapshot: h.b.snapshot().units.find((v) => v[0] === u.id) });
+    return rangeTiles(r.grid, r.row, r.col, r.dir);
+  };
+  assert.deepEqual(tiles(), [[10, 4], [11, 4], [12, 4]]);
+  h.b.retreat(h.unit(2), { reason: 'expired', permanent: true });
+  h.run(0.5);
+  assert.deepEqual(tiles(), [[10, 4], [10, 5], [10, 6]]);
+});
+
+test('user Given strategy medics When inspecting them Then their healing tiles rotate on the field', () => {
+  for (const id of ['char_613_acmedc', 'char_605_cmedic']) {
+    const r = inspectRange(args(medic(id)));
+    assert.equal(r.grid.length, 12);
+    const tiles = rangeTiles(r.grid, r.row, r.col, r.dir);
+    assert.equal(tiles.length, 12);
+    assert.ok(tiles.some(([row, col]) => row === 12 && col === 4));
+    assert.ok(!tiles.some(([row]) => row === 8));
+  }
+});
+
+test('user Given a moving battle medic When its current range changes Then the overlay follows live range and position', () => {
+  const r = inspectRange(args(medic(), { field: { prep: false }, snapshot: [71, 8, 10, 120, 200], live: { range: tokens.char_613_acmedc.skill.rangeGrid } }));
+  assert.equal(r.grid.length, 18);
+  assert.deepEqual([r.row, r.col, r.dir], [10, 8, 'UP']);
+  const tiles = rangeTiles(r.grid, r.row, r.col, r.dir);
+  assert.ok(tiles.some(([row, col]) => row === 15 && col === 9));
+  assert.ok(!tiles.some(([, col]) => col === 5));
+});
+
+test('user Given an enemy, scouted hand or absent battle unit When inspecting Then no attack tiles appear', () => {
+  for (const extra of [{ side: 'enemy' }, { area: 'hand' }, { area: 'temp' }, { kind: 'device' }]) {
+    assert.equal(inspectRange(args(medic(undefined, extra))), null);
+  }
+  assert.equal(inspectRange(args(medic(), { field: { prep: false } })), null);
+  assert.equal(inspectRange(args(medic(), { field: {}, snapshot: [71, 5, 9, 0, 200] })), null);
+  assert.equal(inspectRange(args(medic(), { showPrep: true })), null);
+  assert.equal(inspectRange(args(medic(), { live: { range: [] } })), null);
+});
+
+test('user Given an own board operator When its details open Then its range uses the board direction and clears off board', () => {
+  const piece = { kind: 'chess', id: 'chess_char_1_01_a', uid: 5, dir: 'LEFT' };
+  const input = { target: { kind: 'piece', uid: 5 }, detail: { type: 'chess', chess: chess[piece.id], piece },
+    pieces: new Map([[5, { piece, area: 'board', row: 11, col: 2 }]]), showPrep: true, getChess };
+  const r = inspectRange(input);
+  const tiles = rangeTiles(r.grid, r.row, r.col, r.dir);
+  assert.ok(tiles.every(([, col]) => col >= 0 && col <= 2));
+  assert.ok(tiles.some(([, col]) => col === 0));
+  assert.equal(inspectRange({ ...input, pieces: new Map() }), null);
+  assert.equal(inspectRange({ ...input, target: { kind: 'chess', id: piece.id } }), null);
+  assert.equal(inspectRange({ ...input, showPrep: false }), null);
+});
+
+test('a scouted prep board (the server\'s m.field): the board operator draws its range, the bench (area hand / temp) none', async () => {
+  const { makeMatch, give, giveItem, legalTileFor, chessOfTier } = await import('../match/harness.js');
+  const h = makeMatch({ mode: 'coop', humans: 2, seed: 44, fake: true }).start();
+  h.toPrep(1);
+  const m = h.m;
+  const b = h.ps('p_1');
+  m.handle('p_1', { t: 'g.ready', ready: false });
+  for (const p of [...b.board.values(), ...b.hand.filter(Boolean), ...b.temp.filter(Boolean)]) if (p.kind === 'chess') b.returnCopies(p);
+  b.board.clear(); b.hand.fill(null); b.temp.fill(null); b.recompute();
+  const [id1, id2, id3] = chessOfTier(1, (c) => c.position === 'MELEE').filter((x) => m.pool.has(x));
+  const deployed = give(m, b, id1);
+  const [r, c] = legalTileFor(m, b, id1);
+  m.handle('p_1', { t: 'g.move', uid: deployed.uid, to: { area: 'board', row: r, col: c }, dir: 'UP' });
+  const held = give(m, b, id2);
+  while (b.hand.some((x) => x == null)) giveItem(m, b, 'chess_item_6_09_e_a'); // a full hand keeps the temp piece in temp
+  const waiting = give(m, b, id3, 'temp');
+  m.handle('p_0', { t: 'g.watch', fieldId: 'n:p_1' });
+  const field = h.lastTo('p_0', 'm.field');
+  const range = (piece) => {
+    const unit = renderInfo(field.units.find((u) => u.uid === piece.uid));
+    return inspectRange({ target: { kind: 'unit', unit }, detail: { type: 'chess', chess: chess[piece.id] }, field, getChess });
+  };
+  const own = range(deployed);
+  assert.deepEqual([own.row, own.col, own.dir], [r, c, 'UP']);
+  assert.equal(range(held), null, 'a held operator (area hand) has no field range');
+  assert.equal(range(waiting), null, 'nor one in the 临时整备区 (area temp)');
+  m.dispose();
+});
diff --git a/test/ui/playtest6_summons.test.js b/test/ui/playtest6_summons.test.js
index 54cfa639..c6f6e423 100644
--- a/test/ui/playtest6_summons.test.js
+++ b/test/ui/playtest6_summons.test.js
@@ -23,7 +23,8 @@ globalThis.fetch = async (url) => {
   }
 };
 
-const { TokenDetail, summonDeployHint, resolveDetail, tokenVariantFor } = await import('../../public/js/ui/detailPanel.js');
+const { TokenDetail, summonDeployHint, resolveDetail } = await import('../../public/js/ui/detailPanel.js');
+const { tokenVariantFor } = await import('../../public/js/ui/gameLogic/loadout.js');
 const { indexPieces } = await import('../../public/js/ui/gameLogic.js');
 const { SKILL_SUMMON_START_DEPLOY } = await import('../../shared/constants.js');
 const simTokens = await import('../../server/sim/content/tokens.js');
diff --git a/test/ui/watch-bonds.test.js b/test/ui/watch-bonds.test.js
index bcd5f4dc..ef7411ce 100644
--- a/test/ui/watch-bonds.test.js
+++ b/test/ui/watch-bonds.test.js
@@ -281,16 +281,45 @@ describe('§20.15 the bonds: views + live layers', () => {
     assert.deepEqual(mate.bonds.map((b) => [b.bondId, b.layers]), [['sargonShip', 44], ['kjeragShip', 7]], 'THEIR bonds, THEIR live count');
     assert.deepEqual(playerBonds({ pub, priv: PRIV, myId: ME, ownerId: 'p3', live }).map((b) => b.layers), [120]);
   });
-  test('ownerBoard: the teammate\'s operators on the field on screen feed the popup\'s member list (no hand)', () => {
+  test('ownerBoard: the teammate\'s operators on the field on screen feed the popup\'s member list; a scout\'s bench goes to hand / temp', () => {
     const field = { fieldId: 'n:p2', prep: true, units: [
-      { id: 1, kind: 'op', side: 'ally', ownerId: 'p2', defId: 'chess_char_1_19_a' },
-      { id: 2, kind: 'token', side: 'ally', ownerId: 'p2', defId: 'tok' },
+      { id: 1, kind: 'op', side: 'ally', ownerId: 'p2', defId: 'chess_char_1_19_a', area: 'board' },
+      { id: 2, kind: 'token', side: 'ally', ownerId: 'p2', defId: 'tok', area: 'board' },
       { id: 3, kind: 'op', side: 'ally', ownerId: 'p3', defId: 'chess_other' },
       { id: 4, kind: 'enemy', side: 'enemy', ownerId: null, defId: 'enemy_1' },
+      { id: 5, kind: 'op', side: 'ally', ownerId: 'p2', defId: 'chess_char_1_03_a', area: 'hand' },
+      { id: 6, kind: 'op', side: 'ally', ownerId: 'p2', defId: 'chess_char_2_04_a', area: 'temp' },
+      { id: 7, kind: 'item', side: 'ally', ownerId: 'p2', defId: 'chess_item_1_01_e_a', area: 'hand' },
     ] };
-    assert.deepEqual(ownerBoard(field, 'p2'), { board: [{ kind: 'chess', id: 'chess_char_1_19_a' }], hand: [], temp: [] });
+    assert.deepEqual(ownerBoard(field, 'p2'), {
+      board: [{ kind: 'chess', id: 'chess_char_1_19_a' }], hand: [{ kind: 'chess', id: 'chess_char_1_03_a' }], temp: [{ kind: 'chess', id: 'chess_char_2_04_a' }],
+    });
+    // a unit without an area (a battle's, an older server's prep scout) is on the board
+    assert.deepEqual(ownerBoard({ units: [{ kind: 'op', ownerId: 'p2', defId: 'chess_char_1_19_a' }] }, 'p2').board, [{ kind: 'chess', id: 'chess_char_1_19_a' }]);
     assert.equal(ownerBoard(null, 'p2'), null);
   });
+  test('GitHub #385: a scouted bench counts in the popup\'s 成员 header as in the player\'s own (hand for 远见 / 奇迹 / 投资人, temp never)', () => {
+    // 远见 (BOARD_AND_DECK, countsHand: the server's 在场 is 2 — 赫默 on the board, 初雪 in the hand; 伊内丝 waits in temp)
+    // 炎 (BOARD: 在场 1 — 小满; 琳琅诗怀雅 in the hand, 烛煌 in temp)
+    const u = (id, defId, area) => ({ id, kind: 'op', side: 'ally', ownerId: 'p2', defId, area });
+    const field = { fieldId: 'n:p2', prep: true, units: [
+      u(1, 'chess_char_2_02_a', 'board'), u(2, 'chess_char_2_04_a', 'board'),
+      u(3, 'chess_char_3_14_a', 'hand'), u(4, 'chess_char_3_04_a', 'hand'),
+      u(5, 'chess_char_4_04_a', 'temp'), u(6, 'chess_char_5_03_a', 'temp'),
+    ] };
+    const head = (bondId) => {
+      const v = BondPopup({ bondId, entry: bond(bondId, 0, 0, 0), priv: ownerBoard(field, 'p2'), owner: '阿米娅', onClose() {} });
+      const h4 = [...walk(v)].find((x) => x.type === 'h4' && /成员/.test(textOf(x)));
+      const members = [...walk(v)].filter((x) => hasClass(x, 'bpop__member'));
+      return { head: textOf(h4).replace(/\s+/g, ''), on: members.filter((x) => hasClass(x, 'is-on')).length, owned: members.filter((x) => hasClass(x, 'is-owned')).length };
+    };
+    const visi = head('visiShip');
+    assert.match(visi.head, /^成员2\//, '远见: the board member and the hand member (含整备区), not the temp one');
+    assert.deepEqual([visi.on, visi.owned], [1, 2], 'only 赫默 is 在场; 初雪 and 伊内丝 are owned');
+    const yan = head('yanShip');
+    assert.match(yan.head, /^成员1\//, '炎: the board member only');
+    assert.deepEqual([yan.on, yan.owned], [1, 2]);
+  });
   test('ownerBoard: under client-side combat the battle on screen\'s operators join (the runner\'s meta predates their deploy)', () => {
     const meta = { fieldId: 'b1', local: true, units: [{ id: 90, kind: 'enemy', side: 'enemy', ownerId: null, defId: 'boss' }] };
     const ops = [{ kind: 'op', ownerId: 'p2', defId: 'chess_char_1_09_a' }, { kind: 'op', ownerId: 'p2', defId: 'chess_char_1_03_a' }];
@@ -405,7 +434,7 @@ describe('§20.15 the popup of a card\'s bond chip: the UNIT owner\'s bond (a sh
     assert.deepEqual([v.entry.bondId, v.entry.count, v.entry.active, v.entry.layers], ['sargonShip', 2, true, 55], 'the partner\'s count / tier, their live layers');
     assert.notEqual(v.priv, PRIV, 'not the viewer\'s pieces');
     assert.deepEqual(v.priv.board.map((x) => x.id).sort(), ['chess_char_1_09_a', 'chess_char_1_12_a'], 'the partner\'s operators on the field on screen');
-    assert.deepEqual([v.priv.hand, v.priv.temp], [[], []], 'their hand is never sent');
+    assert.deepEqual([v.priv.hand, v.priv.temp], [[], []], 'a battle field sends no bench');
   });
   test('popupView: your own bond (m.private entry with thresholds, your pieces, no name); a bond not listed → no entry; nothing open → null', () => {
     const own = popupView({ open: { id: 'yanShip', ownerId: ME, from: 'detail' }, pub, priv: PRIV, myId: ME, field: b1, live: null });