feedback5 R19D: 5-阿戈尔 revives — the members the battle-start devour knocks out revive once every devour pass is over, by board position (columns from the left, bottom first: the [ASSUMED] reading of the community report's 「左下到右上」), not in knock-out order; later knock-outs take the slots left in time order, uneaten members none (community report relayed 2026-10-07); golden: unchanged

The report's steps 1-2 were verified and hold: the bond HP is on every member before the devour (an elite 深巡,
2904 HP / DEF 655, stands its 4345 from 15 layers on), and each mark is one 5000 物理流失 less DEF (PRTS), so a member
in the middle of a chain is marked by every 阿戈尔 behind it — that is what knocked out the reporter's 蓝蒂 / 小鲨.
Golden unchanged: the corpus's only 5-阿戈尔 battle (bond-egirShip-high, 999 layers) has no devour knock-out.
DESIGN §25.22.5.

CHANGELOG.md

@@ -70,6 +70,7 @@
 - 自制投石机「索敌不受阻挡影响」：被站在排气格栅上（隐匿）的干员阻挡、范围内又没有别的干员时不会攻击，和原版一样；其他敌人仍会攻击阻挡自己的隐匿干员（社区反馈）。
 - 升级调度中心后，新增的商品栏位立即放上新卡，不用等下一次刷新（社区反馈；官方教程「升级后将出现更多的商品栏位」）。
 - 被冻结或晕眩的敌人仍会被接触到的干员阻挡：干员再部署到它身边、或阻挡数空出来时会立即挡住它，隐匿的敌人也随之破隐，不用再等冻结或晕眩结束；沉睡、浮空、恐惧和不可阻挡的敌人仍然不会被阻挡（GitHub #232，感谢 @ccyl、@kukiC）。
+- 五人阿戈尔：开场吞噬击倒的阿戈尔，等所有吞噬结算完，再按棋盘位置从左下开始复活（从最左一列起，每列从下往上），最多 3 名，不再按被击倒的先后；作战中之后首次被击倒的阿戈尔按时间先后用剩下的名额，没被击倒的阿戈尔仍然不占名额（社区反馈）。
 
 ### 界面
 
@@ -127,6 +128,7 @@
 - 本局禁用的盟约在每个难度都一样，只移除全部盟约都被禁用的干员；炎佑也会受到源石溶剂「每秒受到 60 真实伤害」的效果（PRTS 备注）；两名变形同构体变成的阿戈尔照常吞噬（社区反馈）。
 - 伺夜的狼群最多 3 只狼影，吟游者的特性可以回复战术家召唤物和不屈者的生命，荒芜拉普兰德三技能期间由无人机攻击、本人不普攻，叙拉古的恐惧概率，都和官方一致；突袭的玛恩纳攻击范围内有敌人时不突袭，是盟约原文的规则（社区反馈）。
 - 以下没有复现，需要具体的对局（干员、地图、回合或录像）：野鬃把敌人顶出地图、锏拉动领袖、昆图斯占地变小、炼金单元没有伤害、归溟幽灵鲨被吞噬时进入再部署、炎佑被空中单位阻挡、选 Pith 策略时联防里阿戈尔的加成被清空、满血时源石溶剂不生效（社区反馈）。
+- 阿戈尔的生命值加成在开场吞噬之前就已生效，和官方一致：精二深巡（2904 生命、655 防御）被吞噬一次受到 4345 点，阿戈尔 15 层起就能扛住。生命超过 5000 的阿戈尔扛得住一次吞噬，但站在吞噬链中间时，身后的每一名阿戈尔都会各吞噬它一次（每次 5000 点物理流失，按防御减免），这也和官方一致（社区反馈；PRTS 盟约记录）。
 
 ## 0.1.4 — 2026-10-06
 

data/bonds.json

@@ -1 +1 @@
-{"yanShip":{"bondId":"yanShip","name":"炎","identifier":1,"isCore":true,"bondType":"SEASON","bondOrder":2,"powerIdList":["yan","sui","lungmen","lee","lgd"],"iconId":"icon_yanShip","activeCount":3,"thresholds":[3,6,9],"maxCount":null,"thresholdTemplate":"count_threshold_upward","countMode":"BOARD","countsHand":false,"countsGoldenOnly":false,"activeType":"BATTLE","isActiveInDeck":false,"noStack":false,"weight":10,"maxInactiveBondCount":-1,"layerMilestones":[],"desc":"【炎】干员攻击力提升（受层数影响）\n<在场6名不同【炎】干员>战斗开始时召唤可自主行动的“炎佑”，其攻击力生命值分别为开战时【炎】干员攻击力生命值总和的30%，“炎佑”同时攻击3个目标，可使用“祛恶之焰”，攻击时附带攻击力一定比例的灼燃损伤且周围敌人受到一定比例的元素脆弱\n<在场9名不同【炎】干员>改为召唤2只“炎佑”，攻击力提升至1.5倍，受到的伤害-90%","descRaw":"【炎】干员<@ba.vup>攻击力</>提升<@autochess.gray>（受层数影响）</>\n<在场<@autochess.dgreen>6</>名不同【炎】干员>战斗开始时召唤可自主行动的<@ba.vup>“炎佑”</>，其攻击力生命值分别为开战时【炎】干员攻击力生命值总和的30%，“炎佑”同时攻击3个目标，可使用<@ba.vup>“祛恶之焰”</>，攻击时附带攻击力一定比例的灼燃损伤且周围敌人受到一定比例的元素脆弱\n<在场<@autochess.dgreen>9</>名不同【炎】干员>改为召唤2只<@ba.vup>“炎佑”</>，攻击力提升至<@ba.vup>1.5</>倍，受到的伤害<@ba.vup>-90%</>","effectId":"bondeffect_yan","effectName":"炎","effectDesc":"【炎】干员攻击力+{0:0%}（受层数影响）\n<在场6名不同【炎】干员>战斗开始时收集【炎】干员部分属性召唤“炎佑”（其攻击力和生命值为【炎】干员攻击力和生命值总和的30%）；“炎佑”同时攻击3个目标，攻击附带20%攻击力的灼燃损伤，周围敌人受到20%的元素脆弱，周期性使用“祛恶之焰”\n<在场9名不同【炎】干员>改为召唤2只“炎佑”；“炎佑”攻击力提升至1.5倍，受到的伤害-90%","effectDescRaw":"【炎】干员攻击力<@ba.vup>+{0:0%}</><@ba.acrem>（受层数影响）</>\n<在场<@ba.vup>6</>名不同【炎】干员>战斗开始时收集【炎】干员部分属性召唤“炎佑”（其攻击力和生命值为【炎】干员攻击力和生命值总和的30%）；“炎佑”同时攻击3个目标，攻击附带20%<@ba.vup>攻击力</>的<@ba.vup>灼燃损伤</>，周围敌人受到20%的<@ba.vup>元素脆弱</>，周期性使用“祛恶之焰”\n<在场<@ba.vup>9</>名不同【炎】干员>改为召唤2只“炎佑”；“炎佑”攻击力提升至1.5倍，受到的伤害-90%","effectDescParams":[{"index":0,"format":"0%","base":"base_atk","perStack":"atk_per_stack"}],"bb":{"base_atk":0.23,"atk_per_stack":0.009,"power_bond_char_cnt":6,"ex_bond_char_cnt":9,"damage_resistance":0.9,"atk":1.5},"bbStr":{"key":"act1autochess_bond_eff_yan"},"buffs":[{"key":"env_gbuff_new","bb":{"base_atk":0.23,"atk_per_stack":0.009,"power_bond_char_cnt":6,"ex_bond_char_cnt":9,"damage_resistance":0.9,"atk":1.5},"bbStr":{"key":"act1autochess_bond_eff_yan"}}],"baseParams":["base_atk"],"perStackParams":["atk_per_stack"],"members":["chess_char_1_03_a","chess_char_2_04_a","chess_char_3_03_a","chess_char_3_04_a","chess_char_4_15_a","chess_char_4_17_a","chess_char_5_03_a","chess_char_5_12_a","chess_char_5_23_a","chess_char_6_03_a","chess_char_6_15_a"],"visibleMembers":["chess_char_1_03_a","chess_char_2_04_a","chess_char_3_03_a","chess_char_3_04_a","chess_char_4_17_a","chess_char_5_03_a","chess_char_5_12_a","chess_char_5_23_a","chess_char_6_03_a","chess_char_6_15_a"],"spec":{"tiers":[{"need":"3 distinct 炎 on board","effect":"炎 members (+调和 members) ATK x(1 + 0.23 + 0.009*L)."},{"need":"6 distinct","effect":"At battle start spawn 1 \"炎佑\" (enemy_9012_acloon template, allied flying ranged unit, not blockable, moves on its own). ATK = 0.30 x sum(ATK of 炎 operators on board at battle start), maxHP = 0.30 x sum(maxHP of those operators). Template: DEF 200, RES 0, BAT 2.5 s, ASPD 100, attack range radius 2.0 tiles, magic damage, hits up to 3 targets; every hit adds 灼燃损伤 (burn elemental damage) = 20% of its ATK and applies 元素脆弱 (elemental damage taken x1.2) to enemies within 0.8 tiles of the target. Skill \"祛恶之焰\": cooldown 15 s (first cast 15 s after spawn), channels a flame on one enemy in range dealing 60% ATK magic damage per second to it and to enemies within 1.0 tile, for up to 20 s."},{"need":"9 distinct","effect":"Spawn 2 炎佑 instead; each has ATK x1.5 and takes 90% less damage (damage_resistance 0.9)."}],"formulas":{"atkMultiplier":"1 + 0.23 + 0.009*L"},"caps":"none","layerGain":"Economy-driven: 惊蛰 获得时 +shop level (no activation needed); 小满 休整期结束 +1 per operator gained this rouLine truncated
+{"yanShip":{"bondId":"yanShip","name":"炎","identifier":1,"isCore":true,"bondType":"SEASON","bondOrder":2,"powerIdList":["yan","sui","lungmen","lee","lgd"],"iconId":"icon_yanShip","activeCount":3,"thresholds":[3,6,9],"maxCount":null,"thresholdTemplate":"count_threshold_upward","countMode":"BOARD","countsHand":false,"countsGoldenOnly":false,"activeType":"BATTLE","isActiveInDeck":false,"noStack":false,"weight":10,"maxInactiveBondCount":-1,"layerMilestones":[],"desc":"【炎】干员攻击力提升（受层数影响）\n<在场6名不同【炎】干员>战斗开始时召唤可自主行动的“炎佑”，其攻击力生命值分别为开战时【炎】干员攻击力生命值总和的30%，“炎佑”同时攻击3个目标，可使用“祛恶之焰”，攻击时附带攻击力一定比例的灼燃损伤且周围敌人受到一定比例的元素脆弱\n<在场9名不同【炎】干员>改为召唤2只“炎佑”，攻击力提升至1.5倍，受到的伤害-90%","descRaw":"【炎】干员<@ba.vup>攻击力</>提升<@autochess.gray>（受层数影响）</>\n<在场<@autochess.dgreen>6</>名不同【炎】干员>战斗开始时召唤可自主行动的<@ba.vup>“炎佑”</>，其攻击力生命值分别为开战时【炎】干员攻击力生命值总和的30%，“炎佑”同时攻击3个目标，可使用<@ba.vup>“祛恶之焰”</>，攻击时附带攻击力一定比例的灼燃损伤且周围敌人受到一定比例的元素脆弱\n<在场<@autochess.dgreen>9</>名不同【炎】干员>改为召唤2只<@ba.vup>“炎佑”</>，攻击力提升至<@ba.vup>1.5</>倍，受到的伤害<@ba.vup>-90%</>","effectId":"bondeffect_yan","effectName":"炎","effectDesc":"【炎】干员攻击力+{0:0%}（受层数影响）\n<在场6名不同【炎】干员>战斗开始时收集【炎】干员部分属性召唤“炎佑”（其攻击力和生命值为【炎】干员攻击力和生命值总和的30%）；“炎佑”同时攻击3个目标，攻击附带20%攻击力的灼燃损伤，周围敌人受到20%的元素脆弱，周期性使用“祛恶之焰”\n<在场9名不同【炎】干员>改为召唤2只“炎佑”；“炎佑”攻击力提升至1.5倍，受到的伤害-90%","effectDescRaw":"【炎】干员攻击力<@ba.vup>+{0:0%}</><@ba.acrem>（受层数影响）</>\n<在场<@ba.vup>6</>名不同【炎】干员>战斗开始时收集【炎】干员部分属性召唤“炎佑”（其攻击力和生命值为【炎】干员攻击力和生命值总和的30%）；“炎佑”同时攻击3个目标，攻击附带20%<@ba.vup>攻击力</>的<@ba.vup>灼燃损伤</>，周围敌人受到20%的<@ba.vup>元素脆弱</>，周期性使用“祛恶之焰”\n<在场<@ba.vup>9</>名不同【炎】干员>改为召唤2只“炎佑”；“炎佑”攻击力提升至1.5倍，受到的伤害-90%","effectDescParams":[{"index":0,"format":"0%","base":"base_atk","perStack":"atk_per_stack"}],"bb":{"base_atk":0.23,"atk_per_stack":0.009,"power_bond_char_cnt":6,"ex_bond_char_cnt":9,"damage_resistance":0.9,"atk":1.5},"bbStr":{"key":"act1autochess_bond_eff_yan"},"buffs":[{"key":"env_gbuff_new","bb":{"base_atk":0.23,"atk_per_stack":0.009,"power_bond_char_cnt":6,"ex_bond_char_cnt":9,"damage_resistance":0.9,"atk":1.5},"bbStr":{"key":"act1autochess_bond_eff_yan"}}],"baseParams":["base_atk"],"perStackParams":["atk_per_stack"],"members":["chess_char_1_03_a","chess_char_2_04_a","chess_char_3_03_a","chess_char_3_04_a","chess_char_4_15_a","chess_char_4_17_a","chess_char_5_03_a","chess_char_5_12_a","chess_char_5_23_a","chess_char_6_03_a","chess_char_6_15_a"],"visibleMembers":["chess_char_1_03_a","chess_char_2_04_a","chess_char_3_03_a","chess_char_3_04_a","chess_char_4_17_a","chess_char_5_03_a","chess_char_5_12_a","chess_char_5_23_a","chess_char_6_03_a","chess_char_6_15_a"],"spec":{"tiers":[{"need":"3 distinct 炎 on board","effect":"炎 members (+调和 members) ATK x(1 + 0.23 + 0.009*L)."},{"need":"6 distinct","effect":"At battle start spawn 1 \"炎佑\" (enemy_9012_acloon template, allied flying ranged unit, not blockable, moves on its own). ATK = 0.30 x sum(ATK of 炎 operators on board at battle start), maxHP = 0.30 x sum(maxHP of those operators). Template: DEF 200, RES 0, BAT 2.5 s, ASPD 100, attack range radius 2.0 tiles, magic damage, hits up to 3 targets; every hit adds 灼燃损伤 (burn elemental damage) = 20% of its ATK and applies 元素脆弱 (elemental damage taken x1.2) to enemies within 0.8 tiles of the target. Skill \"祛恶之焰\": cooldown 15 s (first cast 15 s after spawn), channels a flame on one enemy in range dealing 60% ATK magic damage per second to it and to enemies within 1.0 tile, for up to 20 s."},{"need":"9 distinct","effect":"Spawn 2 炎佑 instead; each has ATK x1.5 and takes 90% less damage (damage_resistance 0.9)."}],"formulas":{"atkMultiplier":"1 + 0.23 + 0.009*L"},"caps":"none","layerGain":"Economy-driven: 惊蛰 获得时 +shop level (no activation needed); 小满 休整期结束 +1 per operator gained this rouLine truncated

docs/SIM.md

@@ -788,7 +788,7 @@ registration order. `battle.off(handle)` / `battle.off(name, fn)` / `battle.offO
 | `dollSwitch` | `{ unit, reason, done }` | content switches a 傀儡师 to its <替身> now (归溟幽灵鲨 S2 "技能结束后立刻切换为<替身>": no lethal HP loss); its trait does it unless it already is one or is not on the field, and sets `done` |
 | `dollSwap` | `{ unit, form }` | a 傀儡师 starts a switch — to its <替身> (`form` `'doll'`) or back to its <本体> (`null`); not when it is knocked out as the 替身 (不屈 rolls on it: "切换<替身>与<本体>时") |
 | `kill` | `{ killer, victim }` | victim HP reached 0 (a handler may revive by restoring HP) |
-| `death` | `{ unit, reason:'killed'|'leak'|'retreat'|'merchant'|'expired'|'forcedExit', killer, dying, revivedBy? }` | unit removed (`'forcedExit'`: an operator entering 联防 knocked out, §1.1; `dying`: a `retreat` that plays the death animation — 史尔特尔's 余烬, 骑士戒律 + 竞技旗). Revives of a knock-out redeploy the operator inside it, free, where it lies — PRTS "“复活”的实现方式为：受益者因移动之外的原因退场时下次部署的再部署时间和费用归零", so the 被击倒时 and 部署时 effects both run (a deploy-timed skill — `activateOnDeploy` — starts anew: a 突袭 member with one jumps at once, DESIGN §25.17.5): M3茧甲 (`PRIO_RESPAWN` 13) → 埃芒加德 (`PRIO_BAND_REVIVE` 12) — `items/battle.js reviveNow`, which sets `revivedBy` ('item' / 'band'; 阿戈尔 5 does not count such a knock-out as the member's first) — → 阿戈尔 5 (11) → 不屈 (10); until 0.2.0 the two 复活 were `fatal` savers that kept the unit standing |
+| `death` | `{ unit, reason:'killed'|'leak'|'retreat'|'merchant'|'expired'|'forcedExit', killer, dying, revivedBy? }` | unit removed (`'forcedExit'`: an operator entering 联防 knocked out, §1.1; `dying`: a `retreat` that plays the death animation — 史尔特尔's 余烬, 骑士戒律 + 竞技旗). Revives of a knock-out redeploy the operator inside it, free, where it lies — PRTS "“复活”的实现方式为：受益者因移动之外的原因退场时下次部署的再部署时间和费用归零", so the 被击倒时 and 部署时 effects both run (a deploy-timed skill — `activateOnDeploy` — starts anew: a 突袭 member with one jumps at once, DESIGN §25.17.5): M3茧甲 (`PRIO_RESPAWN` 13) → 埃芒加德 (`PRIO_BAND_REVIVE` 12) — `items/battle.js reviveNow`, which sets `revivedBy` ('item' / 'band'; 阿戈尔 5 does not count such a knock-out as the member's first) — → 阿戈尔 5 (11; a knock-out by the battle-start devour waits for the last devour pass, then the knocked-out members go by board position, DESIGN §25.22.5) → 不屈 (10); until 0.2.0 the two 复活 were `fatal` savers that kept the unit standing |
 | `skillStart` / `skillEnd` | `{ unit, skill, reason }` | mutate `skill.ammoLeft` / `skill.timeLeft` in skillStart (bullets added there raise `skill.ammoMax`, the ammo bar's full mark) |
 | `ammoUsed` | `{ unit, left, skill }` | per ammo consumed |
 | `spGain` | `{ unit, amount, reason:'time'|'attack'|'hurt'|'init'|…, skill }` | mutable `amount` (time gains fire every tick) |

docs/design/engine.md

@@ -102,7 +102,7 @@ Base stats (from data): `maxHp, atk, def, res` (0–100), `aspd` (100 base), `ba
 | `heal` | `{ source, target, amount }` | before application (mutable amount) |
 | `fatal` | `{ unit, source, credit, dmg, amount, prevented }` | HP would reach 0 — fired by every HP loss of a unit without a boss pool (hits of any type, element bursts, 无来源 damage, `loseHp`); set `prevented`. Order: kits' own savers (10 … −60) → items' 不死 (坚固维式重锤, once per deployment) `PRIO_REVIVE` −100; a running 坚固 window's hook sits at `PRIO_UNDYING_HELD` −99, before a 傀儡师's switch to its 替身 (−100, ahead of the lock — a 本体 holding 不死 does not switch, §22.11). The 复活 are no `fatal` savers since 0.2.0: they answer the knock-out (`death`, below) |
 | `kill` | `{ killer, victim }` | victim hp reached 0; a `killed` ability that keeps the enemy alive (a knock-out into a 重生 / form change, §21.4) hides it from every later handler, the kill count, credit and the bounty |
-| `death` | `{ unit }` | unit removed (ops may redeploy later); the `die` event and the death hooks fire only on removal. Knock-out revives redeploy the operator at once inside it, free, where it lies (PRTS "“复活”的实现方式为：…下次部署的再部署时间和费用归零": the 被击倒时 and 部署时 effects both run, a deploy-timed skill (`activateOnDeploy`) started anew: §25.17.5): items' 复活 (M3茧甲) `PRIO_RESPAWN` 13 → 埃芒加德 `PRIO_BAND_REVIVE` 12 (both `items/battle.js reviveNow`, ctx `revivedBy`) → 阿戈尔 5's first-knock-out revive 11 → 不屈 10 |
+| `death` | `{ unit }` | unit removed (ops may redeploy later); the `die` event and the death hooks fire only on removal. Knock-out revives redeploy the operator at once inside it, free, where it lies (PRTS "“复活”的实现方式为：…下次部署的再部署时间和费用归零": the 被击倒时 and 部署时 effects both run, a deploy-timed skill (`activateOnDeploy`) started anew: §25.17.5): items' 复活 (M3茧甲) `PRIO_RESPAWN` 13 → 埃芒加德 `PRIO_BAND_REVIVE` 12 (both `items/battle.js reviveNow`, ctx `revivedBy`) → 阿戈尔 5's first-knock-out revive 11 (a knock-out by the battle-start devour waits for the last devour pass, then the knocked-out members go by board position: §25.22.5) → 不屈 10 |
 | `skillStart` / `skillEnd` | `{ unit, skill }` | |
 | `ammoUsed` | `{ unit, left }` | per ammo consumed |
 | `spGain` | `{ unit, amount }` | mutable |

docs/history/0.1.4.md

@@ -74,7 +74,7 @@ Reports after the 0.1.3 release. Each was checked against the official data and
   高台; the bots plan each record on a 高台 that covers the road, a 重装 on the road, no 高台 fallback for it);
   `test/ui/gameLogic.test.js` (the drag mirror under four loadouts).
 
-### 24.3 阿戈尔 5: the 3 revives go to the first 3 members knocked out (GitHub #105, #140; the owner's decision of 2026-10-05) — `content/bonds/core.js installEgir`
+### 24.3 阿戈尔 5: the 3 revives go to the first 3 members knocked out (GitHub #105, #140; the owner's decision of 2026-10-05) — refined in 0.2.0: the battle-start devour's knock-outs revive by board position once the devour is over, see §25.22.5 — `content/bonds/core.js installEgir`
 
 - **Seen**: GitHub #105 (comment 2) and #140 (comment 3), and a report the owner quoted: 「没被吃的阿戈尔干员也会占用复活名额」
   — with 5 阿戈尔, "whatever the food chain eats, only 3 阿戈尔 stand at the end". #140 item 3 (screenshot): the chain ends

docs/history/0.2.0.md

@@ -1980,3 +1980,66 @@ here, each reproduced first; the rest were answered (not a bug, already fixed in
   the parent), `test/match/playtest6-matchflow.test.js` #235 (2; the 联防 one fails on the parent: losses = the LP
   settled, no result ticker, gone in the next phase), SP_E2E `test/ui/resultbox.e2e.test.js` (3, mock variants
   `unite[,through][,helper|,dead]`). Docs: PLAYING.md §1 / §5, design/network.md, design/client.md, design/match.md.
+
+#### 25.22.5 「阿戈尔盟约的二阶复活逻辑应该有些bug」 (a community report the owner relayed on 2026-10-07, two screenshots not yet seen): the 5-阿戈尔 revives of the battle-start devour's knock-outs go by board position once the devour is over — `content/bonds/core.js installEgir` (`egirReviveScan`, `egirStart`)
+
+- **Seen**: the player's model of the official game: 「原作里是第一步给所有鱼加盟约的血量，第二步是开始一个个大鱼吃小鱼，
+  第三步是检测左下到右上哪些鱼睡着了给他复活」 — a fish that survives the devour on the bond's HP takes no revive; in the
+  remake 「蓝蒂的位置肯定是比水月要更优先复活的」 and 「中间位的小鱼（蓝蒂、小鲨）已经超5000血量了还是被吞死了」; in an
+  official game they recorded an elite 深巡 (under 3000 HP in prep) stood its devour, 「所以肯定是部署后先经过盟约加血才
+  活了下来」. Reproduced on 0255afd (real chess, scratchpad w5-r19d-notes/repro.mjs): (a) one row 浊心斯卡蒂 → 乌尔比安 →
+  斯卡蒂 → 幽灵鲨 → 水月 → 深巡, all elite, 60 layers: 斯卡蒂 at 7513 HP and 幽灵鲨 at 4965 each take two marks (浊心斯卡蒂's
+  and 乌尔比安's, 2 × 4751 and 2 × 4635); 斯卡蒂 is saved only by her module DRE-Y. (b) 乌尔比安 → elite 深巡 (2904 HP, DEF
+  655), one mark of 4345: knocked out at 0 and 14 layers (3920 / 4327 HP), standing at 15 (4356 → 11 HP). (c) Two rows,
+  乌尔比安 → 水月 → 海霓 on the top row and 浊心斯卡蒂 → 幽灵鲨 → 深巡 on the bottom one: four knocked out at t = 0 in the
+  order 水月, 海霓, 幽灵鲨, 深巡 — the first three revived, 深巡 down.
+- **Official**: PRTS 卫戍协议：盟约 下半/PRTS盟约记录, 阿戈尔 (fetched 2026-10-07, unchanged since the 2026-10-03 copy): the
+  3-tier gives the members 生命值 +(35+1×层数)% (bonds.json `base_max_hp` 0.35, `max_hp_per_stack` 0.01; 直接乘算, the
+  page's 「盟约效果…提供的属性加成均为直接乘算」) and the devour; the 5-tier the revives (`max_free_respawn_cnt` 3). The devour
+  is 「5000点物理流失」 (the in-game text says 物理伤害; PRTS corrects it), one per mark (「每个标记令目标受到一次5000点物理流失」),
+  and the marks chain (「以及被自身吞噬的【阿戈尔】干员身前一格干员」), so a member is marked by every 阿戈尔 behind it in its
+  chain. PRTS 作战机制 §伤判效果与生命流失: a 物理流失 「会受到目标当前防御力…影响而相应衰减」 and skips every other step
+  (no 脆弱 / 庇护, no dodge, block, shield or barrier). No source gives the moment of the HP bonus or the order of the
+  revives; PRTS 卫戍协议/帮助: 「满足再部署条件时…自动部署」.
+- **Steps 1 and 2 hold (not changed)**: the bond's HP is a match-long buff put on the members when the battle is built, so
+  each is deployed with it at full HP and the devour finds it — (b) is the player's official 深巡 exactly: it stands from 15
+  layers on. The prep card's 「开战时」 生命上限 comes from a started preview battle (match/intents.js `_unitStatsOf`), so it
+  includes the bond's HP as the battle does. The devours resolve one by one in marking order, one 5000 物理流失 less DEF
+  per mark, as PRTS says; a fish over 5000 HP stands one mark and falls to a second — that is (a)'s 「中间位的小鱼」: in a
+  chain each 阿戈尔 behind it marks it. So the HP was real; what killed 蓝蒂 and 小鲨 was the second mark.
+- **Cause (step 3)**: §24.3's rule gave the 3 slots to the first 3 members knocked out, at the knock-out, so inside the
+  devour the knock-out order decided — the food the first marks reach (often the far end of a chain, or the row whose big
+  fish marks first) took the slots while a member further left fell to a later mark and stayed down.
+- **Now**: the members the battle-start devour knocks out wait until every player's devour pass on the field is over (the
+  window `egirStart`: the passes counted at install, a depth while one resolves, the 5-tier players' batches run after the
+  last pass); then those still down are revived by board position (`egirReviveScan`) while slots last; the rest stay down,
+  their first knock-out spent. Unchanged from §24.3: a member takes one slot at most, on its first knock-out; a member never
+  knocked out takes none (survivors = uneaten + up to 3 eaten); a knock-out later in the fight takes a slot left at once,
+  in time order; a save by its own kit / item / band is no knock-out; a member entering 联防 down is not knocked out; each
+  battle counts its own; a mirrored boss player scans its own board. (c) now: 幽灵鲨, 水月 and 深巡 revive (left column
+  first, bottom first), 海霓 stays down. A member a teammate's devour knocks out on a shared field waits for its owner's
+  scan too (before: back at once, so it was standing — and marking — in its owner's pass).
+- **Changed from §24.3**: only which battle-start knock-outs take the slots and when they come back (after the last devour
+  pass instead of inside it). With three or fewer knocked out at t = 0 the same members revive; the order of their
+  redeploys (the later deployed is attacked first) is now the scan order.
+- [ASSUMED]: (1) 「左下到右上」 on the player's own board as seen in prep — row 0 at the bottom of the screen
+  (render/projection.js), col 0 at the left, a mirrored player from its own left as `egirOrder` — read as the columns from
+  the left, bottom first inside a column, like the act-2 positional orders (the deployment, the devour order). The other
+  reading, the rows from the bottom with left first inside a row (act 1's deployment order), is the one-line comparator in
+  the comment above `egirReviveScan`; `test/content/bonds_core.test.js` '阿戈尔 5 (community report, 2026-10-07) step 3'
+  pins the choice — under the other reading its F1 stays down instead of F4. The screenshots should settle it. (2) Inside
+  the window a devour knock-out is otherwise any knock-out: 被击倒 triggers fire and 不屈 rolls (before, the 阿戈尔 revive
+  answered first and 不屈 never rolled); a member 不屈 redeploys is awake at the scan and takes no slot (「哪些鱼睡着了」).
+  (3) Each player's devour stays its own pass (§24.4 [ASSUMED] (2)).
+- Golden: unchanged — traced with an instrumented copy: the corpus's only 5-阿戈尔 battle (bond-egirShip-high, 999 layers)
+  has no devour knock-out, and no 5-阿戈尔 member is knocked out later in any scenario.
+- Tests: `test/content/bonds_core.test.js` +3 — step 1 / 2 (the elite 深巡 at 14 / 15 layers, the HP before the devour; an
+  elite 幽灵鲨 at 5013.54 HP stands one mark and falls to a second in a chain; passes on the parent too: those steps held),
+  step 3 (four food knocked out in the order F1, F2, F4, F3: all marks first, then F3, F2, F1 revive and F4 stays down —
+  normal, 联防 with a marker entering down, the mirrored boss player; the parent revives F1, F2, F4 inside the pass), later
+  knock-outs / uneaten members / 不屈 (fail on the parent); three titles of the older 阿戈尔 tests reworded.
+  `test/content/feedback4-egir-unite.test.js` +1 (a teammate's mark knocks out p2's 幽灵鲨: revived after p2's own pass,
+  fails on the parent). Docs: research 02 §3.6 and its JSON spec (data/bonds.json `egirShip.spec` regenerated with
+  `build-data --offline`; only `tiers[0]` / `tiers[2]` / `algorithm[3]` / `assumed[0]` changed — the stale assumption
+  「5000 physical 流失 ignores DEF and shields」, wrong since 0.1.1, gave way to the scan reading), DESIGN §5's `death` row
+  (design/engine.md), docs/SIM.md (`death` hook), the core.js comments; §24.3's title points here.

docs/research/02-bonds.json

@@ -2719,7 +2719,7 @@
     "tiers": [
      {
       "need": "3 distinct",
-      "effect": "阿戈尔 members maxHP x(1 + 0.35 + 0.01*L)."
+      "effect": "阿戈尔 members maxHP x(1 + 0.35 + 0.01*L) (直接乘算), on the members from their deployment, so before the battle-start devour."
      },
      {
       "need": "3 distinct (battle start)",
@@ -2727,14 +2727,14 @@
      },
      {
       "need": "5 distinct",
-      "effect": "The first 3 阿戈尔 members to be knocked out, in knock-out order (the battle-start devour's food included; a member never knocked out takes none), each revive immediately on that first knock-out; a member takes at most one, and a save by its own kit / item / band revive is no knock-out (max_free_respawn_cnt 3; the owner's decision of 2026-10-05)."
+      "effect": "3 revives (max_free_respawn_cnt), one per member at most, on its first knock-out; a member never knocked out takes none, and a save by its own kit / item / band revive is no knock-out (the owner's decision of 2026-10-05). The members the battle-start devour knocks out are revived once every devour pass is over, by board position on the player's own board from the bottom-left (columns from the left, bottom first inside a column; a community report relayed on 2026-10-07), while slots last; a later knock-out takes a slot left at once, in time order."
      }
     ],
     "algorithm": [
      "Order: 阿戈尔 members sorted leftmost first, then topmost (\"更靠左和靠上\").",
      "Each 阿戈尔 in order marks the unit on the tile directly in front of it (its facing direction) and also the front-tile unit of every 阿戈尔 it has marked (chain). It never marks itself, a unit it already marked, or a unit that marked it.",
      "The marker immediately gains the base ATK of every unit it marked (a 最终加算: added after its ATK percentages, PRTS \"基础攻击力（最终加算）\") and their block counts.",
-     "After all marks are placed, each mark makes its target suffer one 5000-point physical 流失 (HP loss, source = the target itself; if it dies, the kill is credited to the marker), resolved in marking order. A target that dies cancels its remaining pending marks; a marker knocked out earlier in the pass still resolves its own marks (only the target's state cancels a mark).",
+     "After all marks are placed, each mark makes its target suffer one 5000-point physical 流失 (HP loss less the target's DEF, no shields, dodge or damage multipliers; source = the target itself; if it dies, the kill is credited to the marker), resolved in marking order — a member in a chain takes one from every 阿戈尔 behind it. A target that dies cancels its remaining pending marks; a marker knocked out earlier in the pass still resolves its own marks (only the target's state cancels a mark).",
      "Each devoured unit adds layers to 阿戈尔 equal to its tier (1-6), once per unit per battle.",
      "(5-member tier) Revive is implemented as: when the unit leaves the field for any reason other than being moved, its next deployment has 0 redeploy time and 0 cost (PRTS). Devour layers: each devoured unit adds its tier once per battle (refreshes next round)."
     ],
@@ -2747,7 +2747,7 @@
     "layerGain": "Devour (tier per devoured unit, every battle); 幽灵鲨 被击倒 +3; 归溟幽灵鲨 被击倒/替身切换 +5 阿戈尔 +5 不屈; 斯卡蒂 each 2 kills +1 阿戈尔/坚守/突袭; 海霓 first kill (enemy or ally) +3 阿戈尔/奥术; 机变 \"斯卡蒂的盟誓\" +8. Strategy 克莱门莎: an 阿戈尔 knocked out adds layers = its tier.",
     "howToPlay": "Put cheap/high-tier fodder in front of 阿戈尔 carries: they steal base ATK and block, gain layers, and (5) revive. Tier-6 fodder gives +6 layers per battle.",
     "assumed": [
-     "5000 physical 流失 ignores DEF and shields",
+     "the 5-tier revive scan of the battle-start devour's knock-outs, 「左下到右上」: columns from the left, bottom first inside a column (the other reading: rows from the bottom, left first inside a row)",
      "marked allied units are operators of any player (devour hits allies): on a shared field a teammate's operator in front, standing or entering 联防 knocked out, is devoured too and the chain continues through a teammate's 阿戈尔 (the owner's decision of 2026-10-05: PRTS has no own-side limit)"
     ]
    },

docs/research/02-bonds.md

@@ -372,14 +372,14 @@ Members (11 chess, 10 in current shop pool; by tier in shop: {'1': 1, '2': 1, '3
 
 **Implementable spec**
 
-- **[3 distinct]** 阿戈尔 members maxHP x(1 + 0.35 + 0.01*L).
+- **[3 distinct]** 阿戈尔 members maxHP x(1 + 0.35 + 0.01*L) (直接乘算). The members carry it from their deployment, so the battle-start devour finds it (a community report relayed on 2026-10-07: 「第一步给所有鱼加盟约的血量」; an elite 深巡, 2904 HP and DEF 655, stands a mark from 15 layers on — DESIGN §25.22.5).
 - **[3 distinct (battle start)]** Devour (吞噬): see algorithm.
-- **[5 distinct]** The first 3 阿戈尔 members to be knocked out, in knock-out order, each revive immediately on that first knock-out (max_free_respawn_cnt 3; the owner's decision of 2026-10-05, following players' reports — GitHub #105, #140). The battle-start devour's knock-outs count, so the food usually takes them at t = 0 (it stands again, step 4) and survivors = uneaten members + 3. A member takes at most one, on its first knock-out of the battle, however many 阿戈尔 mark it (step 4 cancels its pending marks); a save by its own kit / item / band revive (斯卡蒂's DRE-Y, M3茧甲, 埃芒加德 [ASSUMED for the band]) is no knock-out and takes none. 0.1.3 gave them to the first 3 members by position, fixed at battle start (from PRTS's devour note "从最先部署（更靠左和靠上的）的【阿戈尔】干员开始" and players' videos), so uneaten front members held them.
+- **[5 distinct]** 3 revives (max_free_respawn_cnt), one per member at most, on its first knock-out of the battle; a member never knocked out takes none (the owner's decision of 2026-10-05, following players' reports — GitHub #105, #140). The members the battle-start devour knocks out wait until every devour pass is over, then those still down are revived by board position while slots last — a community report relayed on 2026-10-07, 「第三步是检测左下到右上哪些鱼睡着了给他复活」, read as the columns of the player's own board from the left, bottom first inside a column [ASSUMED; the other reading is the rows from the bottom, left first] (DESIGN §25.22.5). A knock-out later in the fight takes a slot left at once, in time order. However many 阿戈尔 mark a member, it spends one slot at most (step 4 cancels its pending marks); a save by its own kit / item / band revive (斯卡蒂's DRE-Y, M3茧甲, 埃芒加德 [ASSUMED for the band]) is no knock-out and takes none. 0.1.4 gave the slots to the devour's knock-outs in knock-out order; 0.1.3 to the first 3 members by position, fixed at battle start (from PRTS's devour note "从最先部署（更靠左和靠上的）的【阿戈尔】干员开始" and players' videos), so uneaten front members held them.
 - Algorithm:
   1. Order: 阿戈尔 members sorted leftmost first, then topmost ("更靠左和靠上").
   2. Each 阿戈尔 in order marks the unit on the tile directly in front of it (its facing direction) and also the front-tile unit of every 阿戈尔 it has marked (chain). It never marks itself, a unit it already marked, or a unit that marked it.
   3. The marker immediately gains the base ATK of every unit it marked — a 最终加算, added after its ATK percentages (PRTS "该付与来源获得所有标记单位的基础攻击力（最终加算）和阻挡数"; until 0.1.3 the engine added it before them, so a skill's ATK +% scaled it — DESIGN §24.7) — and their block counts.
-  4. After all marks are placed, each mark makes its target suffer one 5000-point physical 流失 (HP loss, source = the target itself; if it dies, the kill is credited to the marker), resolved in marking order. A target knocked out for the first time has its pending marks cancelled ("目标首次被击倒后解除自身被付与但还未触发的【吞噬】效果") — also when it is back at once (the 5-tier revive, 不屈's 立刻重新部署, 埃芒加德, M3茧甲), so a revived member is not devoured again. DESIGN §22.3. Only the target's state cancels a mark: a marker knocked out earlier in the pass still resolves its own marks, credited to it (DESIGN §24.7; until 0.1.3 they were dropped).
+  4. After all marks are placed, each mark makes its target suffer one 5000-point physical 流失 (HP loss, source = the target itself; if it dies, the kill is credited to the marker), resolved in marking order — a member in a chain loses one to every 阿戈尔 behind it. A target knocked out for the first time has its pending marks cancelled ("目标首次被击倒后解除自身被付与但还未触发的【吞噬】效果") — also when it is back at once (不屈's 立刻重新部署, 埃芒加德, M3茧甲; the 5-tier revive comes after the last devour pass), so a revived member is not devoured again. DESIGN §22.3. Only the target's state cancels a mark: a marker knocked out earlier in the pass still resolves its own marks, credited to it (DESIGN §24.7; until 0.1.3 they were dropped).
   5. Each devoured unit adds layers to 阿戈尔 equal to its tier (1-6), once per unit per battle.
   6. (5-member tier) Revive is implemented as: when the unit leaves the field for any reason other than being moved, its next deployment has 0 redeploy time and 0 cost (PRTS). Devour layers: each devoured unit adds its tier once per battle (refreshes next round).
 - Formulas: `hpMultiplier = 1.35 + 0.01*L`; `devourDamage = 5000`; `layersPerDevoured = tier of devoured unit`

server/sim/content/bonds/core.js

@@ -17,8 +17,8 @@
 //                        6: every ammo used by a member → all members ATK +atk_per_consume (≤ max_atk_for_consume)
 //   阿戈尔 egirShip      members max HP +(base_max_hp + max_hp_per_stack·L) (直接乘算); battle start devour (see devour():
 //                        the marker's gained base ATK is a 最终加算, `atkFinal`, not scaled by its ATK +%);
-//                        5: the first max_free_respawn_cnt members knocked out (in knock-out order, the devour's food
-//                        included) each redeploy at once (free) on that first knock-out
+//                        5: max_free_respawn_cnt free redeploys, one per member on its first knock-out — the devour's
+//                        knock-outs by board position once every devour is over (egirReviveScan), later ones at once
 //   叙拉古 siracusaShip  every member deployment: ASPD +(base + per·L) for (base_duration + per·L) s; 6: 隐匿 for the same
 //                        time, and while hidden / end_duration s after, every 普通伤害 hit (siracusaRolls) procs (PRD,
 //                        nominal `prob`) base_damage + damage_per_stack·L true damage + fear `fear` s
@@ -340,6 +340,25 @@ function installLaterano(battle, pid, bb, members) {
 const boardCol = (u) => (u.player && u.player.mirror ? -u.tileC : u.tileC);
 const egirOrder = (a, b) => boardCol(a) - boardCol(b) || b.tileR - a.tileR || a.id - b.id;
 
+// 5-tier revives of the battle-start devour's knock-outs: the player's scan 「检测左下到右上哪些鱼睡着了给他复活」 (a
+// community report the owner relayed on 2026-10-07, DESIGN §25.22.5) — on the player's own board as the player sees it:
+// row 0 is the bottom of the screen (render/projection.js: nearest the camera), col 0 its left; a mirrored player from its
+// own left, the field's right, as egirOrder. [ASSUMED] the columns from the left, bottom first inside a column (the
+// act-2 positional orders — the deployment and egirOrder — go column by column from the left). The other reading, the
+// rows from the bottom with left first inside a row (act 1's deployment order), is
+// `a.tileR - b.tileR || boardCol(a) - boardCol(b) || a.id - b.id`; test/content/bonds_core.test.js '阿戈尔 5 (community
+// report, 2026-10-07) step 3: …' pins this one (its layout leaves a different member down under each reading).
+const egirReviveScan = (a, b) => boardCol(a) - boardCol(b) || a.tileR - b.tileR || a.id - b.id;
+
+/**
+ * The battle-start devour window, shared by every player's 阿戈尔 on the field: `passes` = devour passes still to run
+ * (one per player with the bond active, counted at install), `depth` > 0 while one resolves, `flush` = the 5-tier
+ * players' revive batches, run once the last pass is over.
+ */
+function egirStart(battle) {
+  return S.battleStore(battle, 'bonds:egir:start', () => ({ passes: 0, depth: 0, flush: [] }));
+}
+
 /**
  * 联防: an operator forced out at the deployment (carry.down, Battle.start, before battleStart) still stands on its
  * deploy position for the devour (PRTS 盟约记录 最先部署). The forced exit is not a knock-out, so it takes no 5-tier slot.
@@ -362,8 +381,10 @@ function egirDownAtStart(battle, u) {
  * 物理流失 (PRTS 盟约记录: "造成5000点物理流失", 修正 "【吞噬】的物理流失来源为被付与目标自身；单位被【吞噬】击杀时，击杀来源始终为
  * 对应标记的付与来源"; PRTS 作战机制: a 物理流失 "会受到目标当前防御力…影响而相应衰减") — less the target's DEF as a physical hit
  * (its own source: no DEF ignore), then battle.loseHp: no shields, dodge or damage multipliers (DEF-free until 0.1.1); the
- * kill is credited to the marker — in marking order. A target knocked out during the pass has its remaining marks
- * cancelled, also when it is back at once (the 5-tier 立刻复活, 不屈's 立刻重新部署, 埃芒加德 / M3茧甲): PRTS 盟约记录 "目标首次被
+ * kill is credited to the marker — in marking order. One 物理流失 per mark ("每个标记令目标受到一次5000点物理流失"): a member
+ * in a chain loses one to every 阿戈尔 behind it (DESIGN §25.22.5: an elite 斯卡蒂 behind two of them, 7513 HP at 60
+ * layers, loses 2 × 4751). A target knocked out during the pass has its remaining marks cancelled, also when it is back at
+ * once (不屈's 立刻重新部署, 埃芒加德 / M3茧甲; the 5-tier revive waits for the last pass, installEgir): PRTS 盟约记录 "目标首次被
  * 击倒后解除自身被付与但还未触发的【吞噬】效果". Only the target's state cancels a mark: a marker knocked out by an earlier
  * mark still resolves its own, credited to it (PRTS names only the target; "击杀来源始终为对应标记的付与来源") — GitHub #165
  * point 3, PR #176, the owner's decision of 2026-10-06; until 0.1.3 a marker off the field gave no further mark.
@@ -424,8 +445,9 @@ function devour(battle, pid, bb, members) {
   const amount = num(bb.damage_value, 0);
   const layered = new Set();
   // a target knocked out during the pass = off the field, or in another deployment than when the marks were placed (items
-  // deploymentOf: the 5-tier revive, 不屈 and the 复活 of 埃芒加德 / M3茧甲 redeploy it) — a revived member was
-  // standing again when its pending marks used to knock it out a second time and spend every revive at t = 0 (GitHub #33)
+  // deploymentOf: 不屈 and the 复活 of 埃芒加德 / M3茧甲 redeploy it at once; the 5-tier revive did until 0.2.0) — a
+  // revived member was standing again when its pending marks used to knock it out a second time and spend every revive
+  // at t = 0 (GitHub #33)
   const dep = new Map();
   for (const [, t] of marks) if (!dep.has(t)) dep.set(t, items.deploymentOf(t));
   const knocked = (t) => !t.alive || items.deploymentOf(t) !== dep.get(t);
@@ -444,20 +466,30 @@ function devour(battle, pid, bb, members) {
 }
 
 function installEgir(battle, pid, bb, members) {
+  // HP (every tier): a match-long buff put on the members when the battle is built, so each one is deployed with it
+  // (Battle._deploy: full HP of the raised max HP) and the battle-start devour finds it — the community report's step 1,
+  // 「第一步给所有鱼加盟约的血量」 (DESIGN §25.22.5: an elite 深巡, 2904 HP and DEF 655, loses 5000 − 655 = 4345 to a mark and
+  // stands from 15 layers on, 2904 × 1.50 = 4356). The layers the devour adds raise it one tick later (onLayers; the HP
+  // ratio is kept).
   const apply = () => {
     const mods = S.directMods({ hp: num(bb.base_max_hp, 0) + num(bb.max_hp_per_stack, 0) * S.bondLayers(battle, pid, 'egirShip') });
     for (const u of members) S.passiveBuff(battle, u, 'bond:egir', mods);
   };
   apply();
   onLayers(battle, pid, 'egirShip', apply);
-  // 5: "前3名【阿戈尔】干员首次被击倒时立刻复活" — the 3 (bonds.json max_free_respawn_cnt) slots go to the first 3 members
-  // knocked out, in knock-out order: the owner's decision of 2026-10-05, following players' reports (GitHub #105, #140:
-  // "没被吃的阿戈尔干员也会占用复活名额" — with 0.1.3's fixed holders by position the uneaten front members held the
-  // slots, so whatever the food chain ate only 3 阿戈尔 stood). A knock-out by the battle-start devour counts like any
-  // other, so the eaten food usually takes them at t = 0 and survivors = uneaten members + 3. A member takes at most one
-  // slot, on its first knock-out ('killed') in the battle: its later knock-outs never take one, and a first knock-out
-  // after the 3 are gone stays down. However many members mark it, its pending marks are cancelled once it is knocked
-  // out (devour), so a multi-devoured member spends one slot at most. Its own saver acts first: a kit or item saver that
+  // 5: "前3名【阿戈尔】干员首次被击倒时立刻复活" — 3 slots (bonds.json max_free_respawn_cnt), one per member at most, on its first
+  // knock-out ('killed') of the battle; a member never knocked out takes none (GitHub #105, #140 "没被吃的阿戈尔干员也会占用
+  // 复活名额"; the owner's decision of 2026-10-05). Which knock-outs take them — a community report the owner relayed on
+  // 2026-10-07 (DESIGN §25.22.5): 「第一步给所有鱼加盟约的血量，第二步是开始一个个大鱼吃小鱼，第三步是检测左下到右上哪些鱼睡着了
+  // 给他复活」. The members the battle-start devour knocks out wait until every player's devour pass on the field is over
+  // (`egirStart`); then those still down are revived by board position (egirReviveScan) while slots last, and the others
+  // stay down, their first knock-out spent. A knock-out later in the fight takes a slot left, at once, in time order.
+  // Until 0.2.0 the devour's knock-outs took the slots in knock-out order (DESIGN §24.3), so the food knocked out first
+  // — often the end of a chain, marked by every 阿戈尔 behind it — took them while a member further left stayed down.
+  // Within the window a knock-out is otherwise like any other: 被击倒 triggers fire (克莱门莎, 幽灵鲨 …) and 不屈 rolls
+  // (priority 10); a member it redeploys is awake at the scan and takes no slot [ASSUMED: the scan takes the members
+  // still down, 「哪些鱼睡着了」]. However many members mark one, its pending marks are cancelled once it is knocked out
+  // (devour), so a multi-devoured member spends one slot at most. Its own saver acts first: a kit or item saver that
   // prevents the knock-out is a `fatal` hook (斯卡蒂's DRE-Y −50, kit savers 10 … −60, 坚固维式重锤 PRIO_REVIVE −100), so the
   // unit is never knocked out and no slot is used; a 复活 (M3茧甲 13, 埃芒加德 12 — items reviveNow, a knock-out and a free
   // redeploy since 0.2.0) answers the knock-out before this hook and marks it `revivedBy`: that knock-out is not the
@@ -465,27 +497,48 @@ function installEgir(battle, pid, bb, members) {
   // operator's own revive uses no slot; [ASSUMED] for 埃芒加德, a band, as for M3茧甲, the item revive the owner named).
   // An operator entering 联防 down (FORCED_EXIT) is not knocked out either; a 调和 member counts like any other. Each
   // battle (normal, 联防, boss) counts its own. PRTS: the knocked-out unit's next deployment has 0 redeploy time and 0
-  // cost, i.e. it IS knocked out (被击倒 triggers, 克莱门莎, 幽灵鲨 … fire) and redeploys at once where it lies (the
-  // engine's rest tile, Battle._layBody: the tile it was knocked out on — a raid-relocated member comes back where it
-  // fell —, or its own home when it fell on another board piece's home; PRTS 卫戍协议/帮助 §作战阶段 单位部署) with full
-  // HP, SP reset and `deploy` effects (卡西米尔 / 叙拉古). Death priority 11: before 不屈 (10), whose redeploy "also
-  // consumes a 复活 charge" — with this order the slot is always the one used, same outcome. Until 0.1.3 the slots were
-  // fixed at battle start for the first 3 members by position (§23.20); until 0.1.2 the first 3 knocked out took them
-  // but a revived member's pending marks could knock it out again (GitHub #33, fixed in devour since).
+  // cost, i.e. it IS knocked out (被击倒 triggers fire) and redeploys where it lies (the engine's rest tile,
+  // Battle._layBody: the tile it was knocked out on — a raid-relocated member comes back where it fell —, or its own home
+  // when it fell on another board piece's home; PRTS 卫戍协议/帮助 §作战阶段 单位部署) with full HP, SP reset and `deploy`
+  // effects (卡西米尔 / 叙拉古). Death priority 11: before 不屈 (10), whose redeploy "also consumes a 复活 charge" — for a
+  // knock-out in the fight the slot is always the one used. Until 0.1.3 the slots were fixed at battle start for the
+  // first 3 members by position (§23.20); until 0.1.2 the first 3 knocked out took them but a revived member's pending
+  // marks could knock it out again (GitHub #33, fixed in devour since).
   const max = reached(battle, pid, 'egirShip', bb.power_bond_char_cnt) ? Math.max(0, Math.floor(num(bb.max_free_respawn_cnt, 0))) : 0;
-  battle.on('battleStart', () => devour(battle, pid, bb, members), { once: true });
+  const start = egirStart(battle);
+  start.passes++;
+  battle.on('battleStart', () => {
+    start.depth++;
+    try {
+      devour(battle, pid, bb, members);
+    } finally {
+      start.depth--;
+      if (--start.passes <= 0) for (const flush of start.flush.splice(0)) flush();
+    }
+  }, { once: true });
   if (!(max > 0)) return;
   const memberOps = new Set(members.filter(S.isOp));
   const knockedOut = new Set(); // members whose first knock-out of this battle has happened
+  const batch = []; // members knocked out by a battle-start devour, revived (or not) once every pass is over
   let revives = 0;
+  const revive = (u) => {
+    if (!battle.redeploy(u, { free: true })) return;
+    revives++;
+    S.fxOn(battle, 'revive', u, 'bond:egirShip', 'respawn', { n: revives });
+  };
+  start.flush.push(() => {
+    for (const u of batch.splice(0).filter((x) => !x.alive && !x.removed).sort(egirReviveScan)) {
+      if (revives >= max) break;
+      revive(u);
+    }
+  });
   battle.on('death', (c) => {
     const u = c.unit;
     if (c.reason !== 'killed' || c.revivedBy || !memberOps.has(u) || knockedOut.has(u)) return;
     knockedOut.add(u);
+    if (start.depth > 0) { batch.push(u); return; }
     if (revives >= max || u.alive || u.removed) return;
-    if (!battle.redeploy(u, { free: true })) return;
-    revives++;
-    S.fxOn(battle, 'revive', u, 'bond:egirShip', 'respawn', { n: revives });
+    revive(u);
   }, { priority: 11 });
 }
 

test/content/bonds_core.test.js

@@ -9,6 +9,7 @@ import * as items from '../../server/sim/content/items.js';
 import { TOKEN_IDS } from '../../server/sim/content/tokens.js';
 import { createRegistry } from '../../server/match/effectsMeta.js';
 import { makeMatch, DATA, give, legalTileFor } from '../match/harness.js';
+import { FORCED_EXIT } from '../../server/sim/constants.js';
 
 const close = (a, b, eps = 1e-6, msg) => assert.ok(Math.abs(a - b) <= eps, `${msg ?? ''} expected ${b}, got ${a}`);
 const op = (id, bonds, extra = {}) => chessRec({
@@ -418,7 +419,7 @@ test('阿戈尔 devour order: left first, then top first (row 0 is the bottom: t
   checkInvariants(h.b);
 });
 
-test('阿戈尔 5: the 3 slots go to the first 3 members knocked out, wherever they stand; a later first knock-out stays down; a second knock-out is final; 3 members: none', () => {
+test('阿戈尔 5: in the fight the 3 slots go to the first 3 members knocked out, wherever they stand; a later first knock-out stays down; a second knock-out is final; 3 members: none', () => {
   const list = [];
   for (let i = 0; i < 5; i++) list.push([`g${i}_a`, ['egirShip'], { skill: { spCost: 30, initSp: 5, duration: 10 } }]);
   // one per row pair so nobody devours anybody: col 3 rows 9–12 (g0 bottom … g3 top), g4 at (9,5). PRTS 盟约记录 阿戈尔
@@ -469,7 +470,7 @@ test('阿戈尔 5: the 3 slots go to the first 3 members knocked out, wherever t
   assert.ok(!h3.unit('g3_a').alive);
 });
 
-test('阿戈尔 5 + the devour chain (GitHub #33, #105, #140): the eaten members take the 3 slots in knock-out order, uneaten ones keep none — survivors = uneaten + 3 (normal and 联防)', () => {
+test('阿戈尔 5 + the devour chain (GitHub #33, #105, #140): the eaten members take the 3 slots (by position once the devour is over — here also the knock-out order), uneaten ones keep none — survivors = uneaten + 3 (normal and 联防)', () => {
   // row 10, all facing right: 浊心斯卡蒂 → 幽灵鲨 → 海霓 → 深巡 → 歌蕾蒂娅 → 隐现; 乌尔比安 on row 12 faces an empty tile.
   // PRTS 盟约记录 阿戈尔 备注 "标记按付与顺序触发【吞噬】效果，目标首次被击倒后解除自身被付与但还未触发的【吞噬】效果". Until 0.1.3
   // the slots belonged to the first 3 by position (浊心斯卡蒂, 乌尔比安, 幽灵鲨: two uneaten members held them, so only 幽灵鲨
@@ -490,8 +491,8 @@ test('阿戈尔 5 + the devour chain (GitHub #33, #105, #140): the eaten members
     const kos = (u) => h.hooksOf('death').filter((c) => c.unit === u && c.reason === 'killed').length;
     const revived = (u) => h.hooksOf('deploy').filter((c) => c.unit === u && !c.initial).length;
     for (const u of [ghost, hn, deep, glady]) assert.equal(kos(u), 1, `${kind}: ${u.defId} knocked out once`);
-    for (const u of [ghost, hn, deep]) assert.equal(revived(u), 1, `${kind}: ${u.defId} (knocked out 1st–3rd) revived at once`);
-    assert.equal(revived(glady), 0, `${kind}: 歌蕾蒂娅 (knocked out 4th) stays down`);
+    for (const u of [ghost, hn, deep]) assert.equal(revived(u), 1, `${kind}: ${u.defId} (knocked out 1st–3rd, the first 3 by position) revived at t = 0`);
+    assert.equal(revived(glady), 0, `${kind}: 歌蕾蒂娅 (knocked out 4th, 4th by position) stays down`);
     assert.equal(kos(skadi) + kos(ulpia) + revived(skadi) + revived(ulpia), 0, `${kind}: the uneaten members take no slot`);
     h.run(3);
     const members = [skadi, ghost, hn, deep, glady, ulpia];
@@ -633,7 +634,7 @@ test('阿戈尔 5 slots in 联防 and on the boss field: a member entering down
   checkInvariants(hb.b);
 });
 
-test('阿戈尔 devour, a unit back during the pass: a marker revived by the 5-tier revive still gives its marks; a target revived in place (埃芒加德) or redeployed (不屈) takes none', () => {
+test('阿戈尔 devour, a unit back during the pass: a knocked-out marker (revived by the 5-tier once the devour is over) still gives its marks; a target revived in place (埃芒加德) or redeployed (不屈) takes none', () => {
   // g1 (10,3) → g2 (10,4, 3000 × 1.35 HP: knocked out by g1's mark, revived) → g3 (10,5) → fodder (10,6); g4 / g5 face empty tiles
   const list = [
     ['g1_a', ['egirShip']], ['g2_a', ['egirShip'], { stats: { maxHp: 3000 } }], ['g3_a', ['egirShip'], { stats: { maxHp: 20000 } }],
@@ -647,7 +648,8 @@ test('阿戈尔 devour, a unit back during the pass: a marker revived by the 5-t
   h.step(1);
   const [g2, f] = ['g2_a', 'fod_a'].map((id) => h.unit(id));
   assert.ok(g2.alive && h.hooksOf('deploy').some((c) => c.unit === g2 && !c.initial), 'g2 knocked out and revived');
-  // every mark resolves whatever became of its marker (DESIGN §24.7): g2, back at once, still devours g3 and the fodder
+  // every mark resolves whatever became of its marker (DESIGN §24.7): g2, knocked out (back once the pass is over), still
+  // devours g3 and the fodder
   assert.deepEqual(tagged(h, 'bond:egir:devour').map((c) => [c.source.defId, c.target.defId]),
     [['g1_a', 'g2_a'], ['g1_a', 'g3_a'], ['g1_a', 'fod_a'], ['g2_a', 'g3_a'], ['g2_a', 'fod_a'], ['g3_a', 'fod_a']]);
   close(f.hp, 20000 - 3 * 5000, 1e-6, 'the fodder: g1, g2 and g3');
@@ -684,6 +686,138 @@ test('阿戈尔 devour, a unit back during the pass: a marker revived by the 5-t
   checkInvariants(u.b);
 });
 
+// A community report the owner relayed on 2026-10-07 (DESIGN §25.22.5): 「原作里是第一步给所有鱼加盟约的血量，第二步是开始
+// 一个个大鱼吃小鱼，第三步是检测左下到右上哪些鱼睡着了给他复活」.
+
+test('阿戈尔 (community report, 2026-10-07) step 1: the bond HP is on every member before the devour — an elite 深巡 (2904 HP, DEF 655) in front of one 阿戈尔 stands from 15 layers on; step 2: one 5000 物理流失 per mark — over 5000 HP survives one mark, falls to a second', () => {
+  const ULPIA = 'chess_char_5_05_b', DEEP = 'chess_char_1_04_b', GHOST = 'chess_char_2_07_b', SKADI2 = 'chess_char_6_04_b';
+  const rest = [{ chessId: 'chess_char_4_09_b', row: 12, col: 3 }, { chessId: 'chess_char_3_09_b', row: 12, col: 5 }, { chessId: 'chess_char_4_12_b', row: 12, col: 7 }];
+  const fight = (units, layers) => {
+    const pre = new Map(), post = new Map();
+    const look = (b, into) => () => { for (const u of b.allyUnits) into.set(u.defId, { hp: u.hp, maxHp: u.s.maxHp, def: u.s.def }); };
+    const h = makeBattle({
+      units: [...units, ...rest], autoFinish: false, timeLimit: 60, hooks: ['damaged', 'death', 'kill'], captureNoisy: true,
+      bonds: { egirShip: bondOn(5, layers, null, [3, 5]) },
+      // before (priority 100) and after (−100) the devour, which runs at the default 0
+      setup: (b) => { b.on('battleStart', look(b, pre), { priority: 100 }); b.on('battleStart', look(b, post), { priority: -100 }); },
+    });
+    h.step(1);
+    return { h, pre, post };
+  };
+  // the player's official game: 「深巡是精二的，休整期的原始血量只有不到三千，所以肯定是部署后先经过盟约加血才活了下来」
+  for (const [L, stands] of [[14, false], [15, true]]) {
+    const { h, pre, post } = fight([{ chessId: ULPIA, row: 10, col: 3 }, { chessId: DEEP, row: 10, col: 4 }], L);
+    const p = pre.get(DEEP);
+    close(p.maxHp, 2904 * (1 + 0.35 + 0.01 * L), 1e-6, `L ${L}: the bond's +(35 + L) % is there before the devour`);
+    close(p.hp, p.maxHp, 1e-6, `L ${L}: deployed at full HP`);
+    assert.equal(p.def, 655);
+    assert.deepEqual(tagged(h, 'bond:egir:devour').map((c) => [c.source.defId, c.target.defId, c.amount]), [[ULPIA, DEEP, 5000 - 655]]);
+    assert.equal(h.hooksOf('death').filter((c) => c.unit === h.unit(DEEP) && c.reason === 'killed').length, stands ? 0 : 1, `L ${L}`);
+    if (stands) close(post.get(DEEP).hp, 2904 * 1.5 - 4345, 1e-6, 'L 15: 4356 − 4345 = 11 HP left');
+  }
+  // an elite 幽灵鲨 at 62 layers: 2422 × (1 + 0.35 + 0.62 + 0.10 her talent) = 5013.54 HP, DEF 365 — one mark (4635) leaves
+  // 378.54; behind 浊心斯卡蒂 and 乌尔比安 she takes both marks and falls to the second (the kill is 乌尔比安's)
+  const one = fight([{ chessId: ULPIA, row: 10, col: 3 }, { chessId: GHOST, row: 10, col: 4 }], 62);
+  close(one.pre.get(GHOST).maxHp, 2422 * 2.07, 1e-6, 'over 5000 HP');
+  close(one.post.get(GHOST).hp, 2422 * 2.07 - (5000 - 365), 1e-6, 'one mark: she stands');
+  assert.equal(one.h.hooksOf('death').length, 0);
+  const two = fight([{ chessId: SKADI2, row: 10, col: 3 }, { chessId: ULPIA, row: 10, col: 4 }, { chessId: GHOST, row: 10, col: 5 }], 62);
+  assert.deepEqual(tagged(two.h, 'bond:egir:devour').filter((c) => c.target.defId === GHOST).map((c) => [c.source.defId, c.amount]),
+    [[SKADI2, 4635], [ULPIA, 4635]], 'marked by each 阿戈尔 behind her (PRTS 盟约记录 "每个标记令目标受到一次5000点物理流失")');
+  assert.deepEqual(two.h.hooksOf('kill').filter((c) => c.victim.defId === GHOST).map((c) => c.killer?.defId), [ULPIA], 'the second mark knocks her out');
+  checkInvariants(two.h.b);
+});
+
+/**
+ * Nine members, all facing RIGHT unless noted (row 12 is the top of the board, row 9 the bottom). The four food F1 (12,4),
+ * F2 (11,4), F3 (10,4) and F4 (9,5) face LEFT, back at their marker (which marked them), so they mark nothing; B1 (12,3)
+ * → F1, B2 (11,3) → F2, B3 (10,3) → F3, B4 (9,4) → F4, and B5 (10,5) facing LEFT → F3 and, through F3, B3. Marks in
+ * order (left first, then top first): B1→F1, B2→F2, B3→F3, B4→F4, B5→F3, B5→B3. HP ×1.35: F1 / F2 / F4 4050 fall to
+ * one mark, F3 6750 to its second (B5's), the B's 13500 stand. Knocked out: F1, F2, F4, F3 — in that order.
+ */
+function egirFood({ downB4 = false } = {}) {
+  const list = [
+    ...['B1_a', 'B2_a', 'B3_a', 'B4_a', 'B5_a'].map((id) => [id, ['egirShip']]),
+    ['F1_a', ['egirShip'], { stats: { maxHp: 3000 } }], ['F2_a', ['egirShip'], { stats: { maxHp: 3000 } }],
+    ['F3_a', ['egirShip'], { stats: { maxHp: 5000 } }], ['F4_a', ['egirShip'], { stats: { maxHp: 3000 } }],
+  ];
+  const units = [
+    { uid: 11, chessId: 'B1_a', row: 12, col: 3 }, { uid: 1, chessId: 'F1_a', row: 12, col: 4, dir: 'LEFT' },
+    { uid: 12, chessId: 'B2_a', row: 11, col: 3 }, { uid: 2, chessId: 'F2_a', row: 11, col: 4, dir: 'LEFT' },
+    { uid: 13, chessId: 'B3_a', row: 10, col: 3 }, { uid: 3, chessId: 'F3_a', row: 10, col: 4, dir: 'LEFT' },
+    { uid: 14, chessId: 'B4_a', row: 9, col: 4, ...(downB4 ? { carryState: { down: true } } : {}) }, { uid: 4, chessId: 'F4_a', row: 9, col: 5, dir: 'LEFT' },
+    { uid: 15, chessId: 'B5_a', row: 10, col: 5, dir: 'LEFT' },
+  ];
+  return { defs: defsOf(list), units };
+}
+
+test('阿戈尔 5 (community report, 2026-10-07) step 3: the battle-start devour\'s knock-outs revive once every devour is over, by position from the bottom-left (columns from the left, bottom first) — not in knock-out order; normal, 联防, the mirrored boss player', () => {
+  for (const kind of ['normal', 'unite', 'bossR']) {
+    const { defs, units } = egirFood({ downB4: kind === 'unite' });
+    const seq = [];
+    const setup = (b) => {
+      b.on('damaged', (c) => { if (c.dmg?.tags?.includes('bond:egir:devour')) seq.push(`mark ${c.source.uid}→${c.target.uid}`); }, { priority: -1000 });
+      b.on('deploy', (c) => { if (!c.initial) seq.push(`revive ${c.unit.uid}`); }, { priority: -1000 });
+    };
+    const bonds = { egirShip: bondOn(5, 0, null, [3, 5]) };
+    const opts = { defs, autoFinish: false, timeLimit: 60, hooks: ['death', 'deploy'], setup };
+    const h = kind === 'bossR'
+      ? makeBattle({ ...opts, kind: 'boss', players: [{ playerId: 'R1', side: 'R', colOffset: 8, units, bonds }] })
+      : makeBattle({ ...opts, kind, units, bonds });
+    h.step(1);
+    const uid = (u) => u.uid;
+    const kos = h.hooksOf('death').filter((c) => c.reason === 'killed').map((c) => uid(c.unit));
+    assert.deepEqual(kos, [1, 2, 4, 3], `${kind}: knocked out F1, F2, F4, F3`);
+    // every mark resolves first, then the revives — F3 (10,4), F2 (11,4), F1 (12,4) of the left column, bottom first; F4
+    // (9,5), in the next column, finds no slot. Until 0.2.0 (knock-out order, DESIGN §24.3): F1, F2, F4 at once, F3 down.
+    // The other reading of 「左下到右上」 (rows from the bottom) would revive F4, F3, F2 and leave F1 down.
+    assert.deepEqual(seq, ['mark 11→1', 'mark 12→2', 'mark 13→3', 'mark 14→4', 'mark 15→3', 'mark 15→13', 'revive 3', 'revive 2', 'revive 1'], kind);
+    const by = (id) => h.b.allyUnits.find((u) => u.uid === id);
+    assert.deepEqual([1, 2, 3, 4].map((id) => by(id).alive), [true, true, true, false], `${kind}: F4 stays down`);
+    assert.ok(by(13).alive && !kos.includes(13), `${kind}: B3, marked but standing, takes no slot`);
+    assert.equal(h.eventsOf('fx').filter((x) => x[1] === 'revive' && x[4]?.src === 'bond:egirShip').length, 3, `${kind}: the 3 slots`);
+    if (kind === 'unite') assert.ok(!by(14).alive && by(14).removeReason === FORCED_EXIT, '联防: B4 entered down — its mark resolved, it stays forced out');
+    // the slots are gone: B1's first knock-out in the fight stays down, F4 stays down
+    h.b.dealDamage(null, by(11), { amount: 1e9, type: 'true' });
+    assert.ok(!by(11).alive && !by(4).alive, `${kind}: no slot left`);
+    checkInvariants(h.b);
+  }
+});
+
+test('阿戈尔 5 (community report, 2026-10-07): the slots the devour leaves go to later knock-outs in time order; an uneaten member takes one only by being knocked out; a member 不屈 redeploys during the devour is awake at the scan and takes none [ASSUMED]', () => {
+  const { defs } = egirFood();
+  // only F1 and F2 are eaten: B1 → F1, B2 → F2; B3 (10,3), B4 (9,4), B5 (9,6) face empty tiles
+  const units = [
+    { uid: 11, chessId: 'B1_a', row: 12, col: 3 }, { uid: 1, chessId: 'F1_a', row: 12, col: 4, dir: 'LEFT' },
+    { uid: 12, chessId: 'B2_a', row: 11, col: 3 }, { uid: 2, chessId: 'F2_a', row: 11, col: 4, dir: 'LEFT' },
+    { uid: 13, chessId: 'B3_a', row: 10, col: 3, dir: 'DOWN' }, { uid: 14, chessId: 'B4_a', row: 9, col: 5 }, { uid: 15, chessId: 'B5_a', row: 9, col: 7 },
+  ];
+  const run = (extra = {}) => {
+    const h = makeBattle({ defs, units, autoFinish: false, timeLimit: 60, hooks: ['death', 'deploy'], bonds: { egirShip: bondOn(5, 0, null, [3, 5]), ...extra } });
+    h.step(1);
+    const by = (id) => h.b.allyUnits.find((u) => u.uid === id);
+    const kill = (id) => { h.b.dealDamage(null, by(id), { amount: 1e9, type: 'true' }); return by(id).alive; };
+    const egirRevives = () => h.eventsOf('fx').filter((x) => x[1] === 'revive' && x[4]?.src === 'bond:egirShip').map((x) => x[4].n);
+    return { h, by, kill, egirRevives };
+  };
+  const a = run();
+  assert.deepEqual(a.h.hooksOf('deploy').filter((c) => !c.initial).map((c) => c.unit.uid), [2, 1], 'F2 (11,4) before F1 (12,4): bottom first');
+  assert.deepEqual(a.egirRevives(), [1, 2]);
+  // the third slot: the first member knocked out in the fight — B5, never eaten; then none (B3), and F1's second knock-out
+  assert.deepEqual([15, 13, 1].map(a.kill), [true, false, false], 'B5 takes the last slot; B3 and F1 (a second knock-out) stay down');
+  checkInvariants(a.h.b);
+  // 不屈 at p = 1 (0.18 + 0.004 × 300): it rolls on each devour knock-out (a 被击倒 like any other) and redeploys F1 and F2 at
+  // once; awake at the scan, they take no slot — all 3 are left for the fight, where 阿戈尔 (death priority 11) comes first.
+  // Until 0.2.0 the 阿戈尔 revive answered both knock-outs at once (2 slots) and 不屈 never rolled.
+  const b = run({ indomShip: bondOn(2, 300, 1, [2, 3]) });
+  assert.ok(b.by(1).alive && b.by(2).alive, 'F1 and F2 stand again');
+  assert.equal(b.h.eventsOf('fx').filter((x) => x[1] === 'revive' && x[4]?.src === 'bond:indomShip').length, 2, 'by 不屈');
+  assert.deepEqual(b.egirRevives(), [], 'no 阿戈尔 slot at the battle start');
+  assert.deepEqual([15, 13, 14].map(b.kill), [true, true, true]);
+  assert.deepEqual(b.egirRevives(), [1, 2, 3], 'the 3 slots, in the fight');
+  checkInvariants(b.h.b);
+});
+
 // ---------------------------------------------------------------------------------------------------------------------
 // 叙拉古
 

test/content/feedback4-egir-unite.test.js

@@ -103,6 +103,31 @@ test('联防: the chain goes on through a teammate\'s 阿戈尔 — the gains eq
   checkInvariants(mate.b);
 });
 
+test('联防: a member a teammate\'s devour knocks out waits for every devour pass, then takes its owner\'s slot by position (community report, 2026-10-07; DESIGN §25.22.5)', () => {
+  // p1's 乌尔比安 → p2's 幽灵鲨 (field 10,10) → p2's fodder (10,11); on p2's board 海霓 (12,3) → 水月 (12,4); p2 holds 5
+  // 阿戈尔. p1's pass runs first (players' order): it knocks 幽灵鲨 out; p2's pass knocks 水月 out; then p2's revives —
+  // 幽灵鲨 (field col 10) before 水月 (col 12). Until 0.2.0 she stood again right after p1's mark, before p2's pass.
+  const seq = [];
+  const p2Units = [
+    { uid: 200, kind: 'chess', chessId: HN, row: 12, col: 3, dir: 'RIGHT' }, { uid: 201, kind: 'chess', chessId: MIZUKI, row: 12, col: 4, dir: 'RIGHT' },
+    { uid: 202, kind: 'chess', chessId: GLADY, row: 12, col: 7, dir: 'RIGHT' }, { uid: 203, kind: 'chess', chessId: DEEP, row: 12, col: 9, dir: 'RIGHT' },
+  ];
+  const lane = [GHOST, FODDER].map((chessId, i) => ({ uid: 100 + i, kind: 'chess', chessId, row: 10, col: 2 + i, dir: 'RIGHT' }));
+  const h = makeBattle({
+    kind: 'unite', autoFinish: false, timeLimit: 60, hooks: ['death', 'deploy'],
+    players: [player('p1', 0, 0, p1Units(), { egirShip: bondOn(3, 10) }), player('p2', 1, 8, [...lane, ...p2Units], { egirShip: bondOn(5) })],
+    setup: (b) => {
+      b.on('damaged', (c) => { if (c.dmg?.tags?.includes('bond:egir:devour')) seq.push(`mark ${c.source.uid}→${c.target.uid}`); }, { priority: -1000 });
+      b.on('deploy', (c) => { if (!c.initial) seq.push(`revive ${c.unit.uid}`); }, { priority: -1000 });
+    },
+  });
+  h.step();
+  assert.deepEqual(seq, ['mark 1→100', 'mark 1→101', 'mark 200→201', 'revive 100', 'revive 201']);
+  assert.ok(h.unit(100).alive && h.unit(201).alive, 'both stand again, on p2\'s slots');
+  assert.equal(h.eventsOf('fx').filter((x) => x[1] === 'revive' && x[4]?.src === 'bond:egirShip').length, 2);
+  checkInvariants(h.b);
+});
+
 // ---------------------------------------------------------------------------------------------------------------------
 // the own board through unite.js: a chain whose food is down since the own combat