feedback3: merge W3A — 联防 carries HP ratio and SP only (GitHub #82); down operators take part in the 联防 devour (players' reports, owner's decision); 不屈 on 撤退 / 替身 switches; SP recovers during stun (洛洛 S2)

docs/DESIGN.md

@@ -186,7 +186,7 @@ b.on(event, fn, { priority=0, owner } ) / b.off(...)   // hook bus (§5.4)
   colOffset,                 // 0 for own field; +8 for the right half in unite/boss
   units: [ { uid, kind: 'chess'|'token', chessId /* golden id if elite */, tokenId?, row, col,
              items: [itemId...],                  // equipped items (golden ids when merged)
-             carryState?: { hpPct, sp, skillActive } | { down: true } } ],   // unite: helper units keep end-of-combat state;
+             carryState?: { hpPct, sp } | { sp } | { down: true } } ],   // unite: an operator keeps its end-of-combat HP ratio + SP, a summon its SP (no running skill);
                                                   // { down: true } = knocked out at its end: deployed, then forced out (§19.3)
   bonds: { [bondId]: { count, active, tier, layers } },   // snapshot from bondsMeta at combat start
   bandId, playerEffects: [ EffectRef ],                   // active band/choice/team effects with battle parts
@@ -206,7 +206,7 @@ b.on(event, fn, { priority=0, owner } ) / b.off(...)   // hook bus (§5.4)
                                           // the bond's room under BOND_LAYER_CAP 999 (§6.3, §20.12)
      coins: n,                            // bounty coins earned
      damageDealt: n, bossDamage: n, healingDone: n, deaths: n,
-     unitsEnd: [ { uid, hpPct, sp, alive } ] } },
+     unitsEnd: [ { uid, hpPct, sp, alive } ] } },   // operators + board summon pieces; sp = 技力 incl. stored charges
   bossHpLeft? }
 ```
 
@@ -731,7 +731,7 @@ Ten reports after playing v2.3 (绝境 on desktop, 标准 on an Android phone in
 - **Cause**: `unite.js uniteBattleOpts` dropped every operator that `unitsEnd` reported `alive: false` — and its summons — from the 联防 input (an old [ASSUMED] rule). Every client and the server build the unite field from that input, so the operator was missing for the authority, the partners, observers and the `SP_COMBAT=server` fallback alike.
 - **Official** (PRTS 卫戍协议/帮助 §联防阶段): "部署完成后，将对应单位的生命比例、技力修改至与上一阶段结束时相同（召唤物仅修改技力，上一阶段为退场状态的干员强制退场）".
 - **Now**: the operator is fielded with `carryState: { down: true }` (§5.1); its summons are fielded as the board has them. `Battle.start` deploys everyone (the initial `deploy` hook fires), then before `battleStart` sets its HP to 0 (the end-of-phase ratio, as `kill()`) and withdraws it with removal reason `FORCED_EXIT` = `'forcedExit'`. `Battle.isDown` accepts that reason, so it is in b.snap `down` and `fieldMeta` with its ring, shows 0 HP on the live card, and redeploys by §5.5 (timer done, own tile free, DP ≥ cost) at full HP. The forced exit is no new knock-out: no `kill` hook, no `death` with reason `'killed'`, no `deaths` count — 深海 / 不屈 revives, 崇高牺牲 layers and selfdead garrisons fired in the own combat. The client's `'die'` with that reason goes straight to the held knocked-down pose (`UnitView.die(true)`: no fall, no burst, no sound).
-- The timer restarts at the operator's **full** redeploy time (70 s for most chess): the official setup carries only `hp` / `tech` per operator (research 09 §3 `HelpBattleInfo`), and the user confirmed it after the v2.4 follow-up ("进联防复活时间确实是重新算" — a request to carry the remainder was withdrawn). A short 联防 may therefore end before it comes back (a real-sim reproduction ended at 28 s; in the integration QA's real matches 43 % of 1,564 knocked-out operators were still counting when their 联防 ended). Also [ASSUMED]: the forced exit happens before `battleStart`; the timer is re-read after it, so a redeploy-time effect that starts with the battle covers it (机变 征召 "所有干员的再部署时间-50%": 70 → 35 s, as for a later knock-out — it read 70 s before the integration QA), while 征召's own row check ("场上至少有一行存在3名干员") does not count it [ASSUMED]. Not covered: 召唤物仅修改技力 (summons enter 联防 fresh; `unitsEnd` lists operators only — carrying their SP would extend the client-reported result, `spec.js` digests and `fields.js` validation).
+- The timer restarts at the operator's **full** redeploy time (70 s for most chess): the official setup carries only `hp` / `tech` per operator (research 09 §3 `HelpBattleInfo`), and the user confirmed it after the v2.4 follow-up ("进联防复活时间确实是重新算" — a request to carry the remainder was withdrawn). A short 联防 may therefore end before it comes back (a real-sim reproduction ended at 28 s; in the integration QA's real matches 43 % of 1,564 knocked-out operators were still counting when their 联防 ended). Also [ASSUMED]: the forced exit happens before `battleStart` (since 0.1.3 the 阿戈尔 devour still counts the operator as standing for its marking — players' reports, owner's decision 2026-10-04); the timer is re-read after it, so a redeploy-time effect that starts with the battle covers it (机变 征召 "所有干员的再部署时间-50%": 70 → 35 s, as for a later knock-out — it read 70 s before the integration QA), while 征召's own row check ("场上至少有一行存在3名干员") does not count it [ASSUMED]. 召唤物仅修改技力: since 0.1.3 `unitsEnd` lists the board's summon pieces too and they carry `{ sp }` (one off the field at the end enters fresh [ASSUMED]); until then summons entered 联防 fresh.
 - Tests: `test/match/unitedown.test.js` (both combat modes, both helper halves, the real sim), `test/sim/downelem.test.js` (incl. 征召), `test/render/downring.test.js`, `test/match/combat.test.js`; browser (opt-in) `test/render/unitedown.browser.test.js`.
 
 ### 19.4 Huge bosses: hit area, 自缚 (#10) — `tools/build-data.mjs HIT_AREAS`, `sim/body.js`, `content/bosses.js SELF_BOUND`, `render/pick.js`

docs/META.md

@@ -651,12 +651,13 @@ chosen by most units on the field (downed included) > an active bond > most stan
 units > active bond > Σ active layers > standing > seat (LP plays no part), the first one on the right-hand field
 (colOffset +8, where escaped_multi enters), the other colOffset 0; the escaped template of that size routes the leaked
 enemies by slot class; helpers' operators carry
-`{ hpPct, sp, skillActive }` from `unitsEnd` ("阵地以其当前状态"); an operator knocked out at the end of the helper's own
+`{ hpPct, sp }` from `unitsEnd` ("阵地以其当前状态": the HP ratio and the 技力 only — a skill running at the end enters
+switched off; summon pieces `{ sp }`, "召唤物仅修改技力"); an operator knocked out at the end of the helper's own
 combat carries `{ down: true }` (PRTS 卫戍协议/帮助: "部署完成后…上一阶段为退场状态的干员强制退场"): deployed, then forced out
 at once, it lies on its tile with the redeploy ring and redeploys like after any knock-out (docs/SIM.md §1.1; user
 playtest #5 item 2 — it used to stay out and vanish); its timer is its full redeploy time (the official setup carries
 only hp / tech per operator; confirmed by the user), with the redeploy-time effects that start with the battle (机变 征召); summons are
-fielded as the board has them; `flags.layerGainsEnabled = false`; time limit = the round's combat limit.
+fielded as the board has them (their SP carried); `flags.layerGainsEnabled = false`; time limit = the round's combat limit.
 Every enemy still alive at the end (leaked again, or never spawned before the limit) costs its **source** player 1 LP.
 A client-run 联防 result may bill a survivor only to a leaker who sent that enemy in — a split / summon only to a leaker
 who sent in its parent, ≤ the parents' data offspring count (磨砻 2, 烹泉 4 …; fields.js offspringPerParent).

docs/PLAYING.md

@@ -80,7 +80,7 @@
 
 ## 5. 联防（同盟）
 
-某回合**有人漏怪、又有人完美作战**（全歼且无漏怪）时触发：最多 2 名完美作战的队友带着自己的阵容（保持作战结束时的生命与技能状态；作战结束时已被击倒的干员在原位倒地，按官方的「强制退场」以完整的再部署时间重新倒计时，时间到且部署费用足够后照常再部署——联防较短时可能来不及再部署；机变「征召」这类开战时生效的再部署时间减免同样计入），迎击其他玩家漏掉的全部敌人。
+某回合**有人漏怪、又有人完美作战**（全歼且无漏怪）时触发：最多 2 名完美作战的队友带着自己的阵容（与官方相同，只保留作战结束时的生命比例和技力：作战结束时还开着的技能在联防开场是关着的，技力是开技能后剩下的值，通常为 0；召唤物只保留技力；作战结束时已被击倒的干员在原位倒地（阿戈尔的开场吞噬仍把它当作站着的干员计算标记与基础攻击力、阻挡数，之后它照常退场），按官方的「强制退场」以完整的再部署时间重新倒计时，时间到且部署费用足够后照常再部署——联防较短时可能来不及再部署；机变「征召」这类开战时生效的再部署时间减免同样计入），迎击其他玩家漏掉的全部敌人。
 
 - 参加者按官方规则挑选：场上单位最多 > 有已激活的盟约 > 未倒下的单位最多 > 座位靠前（与 LP 无关）；两人参加时，排在前面的一位（再比较激活盟约的层数总和）在右半场「率先迎敌」。
 

docs/SIM.md

@@ -89,8 +89,9 @@ where it fell for the `kill` / `death` handlers. "倒地干员所在地块视为
 tile and `isReservedTile` reports it, so every automatic picker skips it. The rule covers every 退场 (GitHub #60): an
 operator forced out by its own effects (`retreat` reason `'retreat'`: 史尔特尔's 余烬, 耀骑士临光 S2, 骑士戒律 + 竞技旗,
 伊内丝 S3; `'merchant'`: a 商人 that cannot pay) lies down and comes back the same way — still no kill (its death reason is
-not `'killed'`: no 被击倒 effects, 不屈, 阿戈尔 or knock-down count); only the 突袭 retreat (`'raid'`, redeployed at once on
-its landing tile) and permanent removals leave nothing.
+not `'killed'`: no 被击倒 effects, 阿戈尔 or knock-down count), but 不屈 rolls on it (PRTS 盟约记录 不屈 修正 "被击倒、撤退、
+切换<替身>与<本体>时": a hit redeploys it at once, free, where it lies; addon/battle.js); only the 突袭 retreat (`'raid'`,
+redeployed at once on its landing tile — no 不屈 roll) and permanent removals leave nothing.
 
 ### 1.1 Coordinates (PlayerBattleInput units)
 
@@ -141,8 +142,13 @@ landing tile) compare offsets in the unit's facing-RIGHT frame (`localOrder` / `
 the old tile-key order), so a rotated layout plays the same (test/sim/facing-invariance.test.js: every chess × 4
 directions on an open field). 余 S3's fire wall runs through his tile perpendicular to his direction (his column facing
 RIGHT / LEFT, his row facing UP / DOWN; fx `firewall.axis` = `'col'|'row'`).
-`carryState: { hpPct, sp, skillActive }` restores unite helpers (HP ratio, SP; `skillActive` restarts a timed skill for a
-fresh duration/ammo **without spending a charge** — `unitsEnd` reports `sp: 0` while a skill runs, so pass it through as is).
+`carryState: { hpPct, sp }` restores unite helpers' operators (HP ratio, and the SP = the official 技力, stored charges
+included: `unitsEnd` reports `skill.spTotal`, reset rebuilds the charges from it, and `skill.setSpTotal` sets it again after
+the `deploy` hook — PRTS "部署完成后…技力修改至与上一阶段结束时相同", so 独行 / 黄沙罗盘's deploy-time SP does not add to it;
+later redeploys keep those gifts); `carryState: { sp }` a board summon
+piece's SP only (PRTS "召唤物仅修改技力"). Nothing else is carried: a skill running at the end of the own combat enters
+switched off with the SP it had left — spent at its activation, 0 for a one-charge skill (`unitsEnd.skillActive` is
+reported, never carried; community report #34 — it used to restart for free).
 `carryState: { down: true }` = an operator knocked out at the end of the helper's own combat (PRTS 卫戍协议/帮助 "上一阶段为
 退场状态的干员强制退场", user playtest #5 item 2): `start()` deploys it with everyone (initial `deploy` fires), then — before
 `battleStart` — withdraws it with reason `FORCED_EXIT` (constants.js `'forcedExit'`) and HP 0 (the end-of-phase HP ratio, as after
@@ -366,7 +372,7 @@ recorded for the player whose half contains the goal it reached, with `sourcePla
   perPlayer: { [playerId]: { killed, total, perfect,
       leaked: [{ enemyKey, mods, lpr, sourcePlayerId, tag, counted, boss?, spawned }],
       layerGains: {bondId: n}, coins, damageDealt, bossDamage, healingDone, deaths,
-      unitsEnd: [{ uid, id, defId, hpPct, sp, skillActive, alive }],
+      unitsEnd: [{ uid, id, defId, hpPct, sp, skillActive, alive }],   // operators + board summon pieces; sp = skill.spTotal
       unitStats: [{ id, uid, defId, name, kind, dmg, kills, heal, taken, attacks }] } } }
 ```
 - `cleared`: no spawns pending and no enemy alive (or the shared boss pool reached 0 — a pool never holds less than
@@ -713,6 +719,7 @@ registration order. `battle.off(handle)` / `battle.off(name, fn)` / `battle.offO
 | `heal` | `{ source, target, amount, opts }` | mutable `amount` |
 | `fatal` | `{ unit, source, credit, dmg, amount, prevented }` | HP would reach 0 — set `prevented` (substitutes, kit savers, 不死 / 复活 items, 埃芒加德; 不屈 is a `death` hook). Fired by every HP loss of a unit without a boss pool — hits of any type, element bursts, 无来源 damage, `loseHp` 流失. Order: kits' own savers (10 … −60) → items' 不死 (坚固维式重锤 — once per deployment: `items/battle.js deploymentOf`, a key every deploy changes and an in-place 复活 changes too; one battle-level hook holds the running windows (`holdsUndying`), so a window outlasts a lend, DESIGN §21.21 — the lock `PRIO_REVIVE` −100 after the substitutes (−100, registered first), the running windows `PRIO_UNDYING_HELD` −99 before them: a 傀儡师 holding 不死 does not switch, PRTS 分支特性信息 傀儡师 "未持有不死的情况下", DESIGN §22.11) → items' 复活 (M3茧甲, `PRIO_RESPAWN` −101: PRTS "复活" acts on a knock-out, which a 不死 prevents) → 埃芒加德 (−110); both 复活 revive in place and call `revivedInPlace` (a new deployment for the lock) |
 | `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 }` | unit removed (`'forcedExit'`: an operator entering 联防 knocked out, §1.1) |
 | `skillStart` / `skillEnd` | `{ unit, skill, reason }` | mutate `skill.ammoLeft` / `skill.timeLeft` in skillStart |
@@ -778,7 +785,9 @@ or guard with a per-unit flag while dealing it. When the guard trips, the logged
 
 ### 7.1 Runtime rules (skills.js)
 - SP types: `time` (+`s.spRecovery`/s), `attack` (+1 per attack), `hurt` (+1 per hit taken); starts at `initSp`; **no SP
-  gain while a duration/ammo/toggle skill is active, while stunned, or with the `noSp` flag**. Attack-type SP: attacks made
+  gain while a duration/ammo/toggle skill is active, or with the `noSp` flag** (阻回); a stunned / frozen / levitated unit
+  (`canAct` false) neither attacks nor casts, but its time SP keeps recovering (PRTS 技能: only 阻回 pauses the SP cooldown;
+  PRTS 异常效果 晕眩 names no SP effect — community report #18). Attack-type SP: attacks made
   by the skill (the pending "next attack" of an instant/charge skill, every shot of a timed skill including the one that
   ends it) recover nothing, so a cost-N skill fires every **N+1** attacks (AK). Charges (`maxChargeTime > 1`):
   SP fills to cost → +1 charge (SP restarts) until charges are full (then SP stays full).

server/match/PlayerState.js

@@ -1546,7 +1546,9 @@ export class PlayerState {
         if (carry && carry.has(piece.uid)) u.carryState = carry.get(piece.uid);
         units.push(u);
       } else if (piece.kind === 'token') {
-        units.push({ uid: piece.uid, kind: 'token', tokenId: piece.id, row: r, col: c, dir: pieceDir(piece), ownerUid: piece.ownerUid });
+        const u = { uid: piece.uid, kind: 'token', tokenId: piece.id, row: r, col: c, dir: pieceDir(piece), ownerUid: piece.ownerUid };
+        if (carry && carry.has(piece.uid)) u.carryState = carry.get(piece.uid); // 联防: { sp } (unite.js)
+        units.push(u);
       }
     }
     return {

server/match/fields.js

@@ -829,10 +829,11 @@ export function validateClientResult(spec, raw, { gd = null } = {}) {
       const seen = new Set();
       for (const u of Array.isArray(p.unitsEnd) ? p.unitsEnd : []) {
         // units the sim created during the battle (no board uid) or not on this player's board carry nothing the match uses
-        if (!u || !Number.isInteger(u.uid) || !own.chess.has(u.uid) || seen.has(u.uid)) continue;
+        // (the board's operators and summon pieces: 联防 carries an operator's HP ratio and SP, a summon's SP — unite.js)
+        if (!u || !Number.isInteger(u.uid) || !own.all.has(u.uid) || seen.has(u.uid)) continue;
         seen.add(u.uid);
         if (!finiteIn(u.hpPct, 0, 1) || !finiteIn(u.sp, 0, 1e5)) return bad('unit state');
-        unitsEnd.push({ uid: u.uid, defId: own.chess.get(u.uid), hpPct: u.hpPct, sp: u.sp, skillActive: !!u.skillActive, alive: !!u.alive && u.hpPct > 0 });
+        unitsEnd.push({ uid: u.uid, defId: own.all.get(u.uid), hpPct: u.hpPct, sp: u.sp, skillActive: !!u.skillActive, alive: !!u.alive && u.hpPct > 0 });
       }
       const unitStats = [];
       for (const u of Array.isArray(p.unitStats) ? p.unitStats : []) {

server/match/unite.js

@@ -5,15 +5,17 @@
 // players chosen by most units on the field (downed included) > has an active bond (存疑) > most undowned units, then
 // seat; with 2 helpers the one ranked first by most units > active bond > Σ active bond layers (存疑) > most undowned
 // units "率先迎敌" on the RIGHT-hand field (colOffset +8, where the escaped_multi routes enter), the other keeps the
-// left half (colOffset 0); a lone helper plays escaped_single on its own field. Their operators keep HP%, SP and a
-// running timed skill from the end of their own combat (BattleResult.unitsEnd → PlayerBattleInput.units[].carryState,
-// "阵地以其当前状态"). An operator knocked out at the end of its own combat (alive false) is fielded with
+// left half (colOffset 0); a lone helper plays escaped_single on its own field. Their operators keep the HP ratio and
+// the SP (技力, stored charges included) from the end of their own combat, nothing else — a skill still running then
+// enters switched off (BattleResult.unitsEnd → PlayerBattleInput.units[].carryState `{ hpPct, sp }`, "阵地以其当前状态";
+// community report #34 / GitHub #82: it used to restart for free). An operator knocked out at the end of its own combat (alive false) is fielded with
 // `carryState: { down: true }`: PRTS "部署完成后，将对应单位的生命比例、技力修改至与上一阶段结束时相同（召唤物仅修改技力，
 // 上一阶段为退场状态的干员强制退场）" — the sim deploys it with everyone and forces it out at once (constants.js
 // FORCED_EXIT), so it lies on its own tile with the redeploy ring and comes back like after any knock-out (user
 // playtest #5 item 2: it used to be left out and vanished). Its timer is its full redeploy time (the official 联防
-// setup carries only hp / tech per operator, research 09 §3 HelpBattleInfo; the user confirmed it restarts). Summons are fielded as the board has
-// them (a summon's own end state is not carried: unitsEnd lists operators only). Enemies = the union of every leaker's
+// setup carries only hp / tech per operator, research 09 §3 HelpBattleInfo; the user confirmed it restarts). The board's summon
+// pieces are fielded as the board has them and keep only their SP ("召唤物仅修改技力": carryState `{ sp }`, unitsEnd lists
+// them beside the operators; one off the field at the end enters fresh [ASSUMED]). Enemies = the union of every leaker's
 // counted leaks (same stats: the SpawnSpec mods travel with the leak), routed on the escaped template (`escaped_single`
 // for 1 helper, `escaped_multi` for 2): walkers on its `lrsldr` action, flyers on `yokai`, tokens on `gopro_2` /
 // `lazerd` (waves.js buildUniteWave); kill bounties keep paying the killer (a helper). No IN_BATTLE layer gains. Time
@@ -105,11 +107,18 @@ export function uniteBattleOpts(m, plan, timeLimit) {
   const players = plan.helpers.map((ps, i) => {
     const carry = new Map();
     const r = m.lastResults.get(ps.playerId);
+    const summonUids = new Set();
+    for (const p of ps.board.values()) if (p && p.kind === 'token') summonUids.add(p.uid);
     for (const u of (r && r.unitsEnd) || []) {
       if (!u || u.uid == null) continue;
+      const sp = Number.isFinite(u.sp) ? Math.max(0, u.sp) : 0;
+      // a summon: its SP only ("召唤物仅修改技力"); one off the field at the end enters fresh [ASSUMED]
+      if (summonUids.has(u.uid)) { if (u.alive) carry.set(u.uid, { sp }); continue; }
       // knocked out at the end of its own combat: 强制退场 right after the deployment (see header)
       if (!u.alive) { carry.set(u.uid, { down: true }); continue; }
-      carry.set(u.uid, { hpPct: Number.isFinite(u.hpPct) ? Math.max(0.01, Math.min(1, u.hpPct)) : 1, sp: Number.isFinite(u.sp) ? u.sp : 0, skillActive: !!u.skillActive });
+      // HP ratio and SP only: a skill still running at the end is not carried (unitsEnd `skillActive` stays unused —
+      // community report #34, GitHub #82)
+      carry.set(u.uid, { hpPct: Number.isFinite(u.hpPct) ? Math.max(0.01, Math.min(1, u.hpPct)) : 1, sp });
     }
     // 2 helpers: the first one meets the enemies first on the right-hand field (escaped_multi enters at col 18)
     const colOffset = plan.helpers.length > 1 && i === 0 ? 8 : 0;

server/sim/Battle.js

@@ -124,6 +124,7 @@ export class Battle {
     this.finished = false;
     this.reason = null;
     this.started = false;
+    this._startDeploying = false;
     /** @type {Unit[]} every unit ever created */
     this.units = [];
     /** @type {Unit[]} alive enemies (compacted each tick) */
@@ -360,11 +361,15 @@ export class Battle {
     // a summon piece flagged `deferDeploy` by content (one its owner's loadout does not make — 赫默 on S1 with a drone
     // piece —, or a skill's summon when shared/constants.js SKILL_SUMMON_START_DEPLOY is off: content/tokens.js
     // dockSkillSummons) stays off the field, its tile reserved (isReservedTile), until content deploys it
+    // (_startDeploying: a board piece content brings in during this deployment — a tactician's 流形 / 狼群 comes with
+    // its owner's deploy — takes its 联防 carry on that first deployment too)
+    this._startDeploying = true;
     for (const kind of ['op', 'token']) {
       const per = lists.map((l) => l.filter((u) => u.kind === kind && !u.deferDeploy));
       const n = Math.max(0, ...per.map((l) => l.length));
       for (let i = 0; i < n; i++) for (const l of per) if (l[i]) this._safe(() => this._deploy(l[i], { initial: true }), 'initialDeploy', l[i]);
     }
+    this._startDeploying = false;
     // 仇恨 (targeting.js sortAllyTargets: the later deployed is attacked first): every summon that came in during the
     // initial deployment — also one an operator's deploy brought along (a tactician's 援军, a start-of-battle summon)
     // — ranks after all the operators (of every player on the field [ASSUMED]), in the order it came
@@ -539,10 +544,14 @@ export class Battle {
     for (const ps of this.players) {
       const pp = this._perPlayer[ps.playerId];
       pp.perfect = !pp.leaked.some((l) => l.counted !== false);
-      pp.unitsEnd = ps.units.filter((u) => u.kind === 'op').map((u) => ({
+      // the operators and the board's summon pieces (a board uid): 联防 carries an operator's HP ratio and SP, a summon's
+      // SP only (match/unite.js). `sp` is the official 技力 — stored charges included (PRTS 技能 "可充能X次…当前技力上限等于该
+      // 技能技力需求的X倍"); a running skill spent its SP at activation, so it reports what was left (0 for one charge).
+      // `skillActive` is reported, never carried.
+      pp.unitsEnd = ps.units.filter((u) => u.kind === 'op' || (u.kind === 'token' && u.uid != null)).map((u) => ({
         uid: u.uid, id: u.id, defId: u.defId,
         hpPct: u.alive ? Math.max(0, Math.min(1, u.hp / u.s.maxHp)) : 0,
-        sp: u.skill && !u.skill.noSkill ? Math.round(u.skill.sp * 100) / 100 : 0,
+        sp: u.skill && !u.skill.noSkill ? Math.round(u.skill.spTotal * 100) / 100 : 0,
         skillActive: !!(u.skill && u.skill.active && u.skill.kind !== 'passive'),
         alive: !!u.alive,
       }));
@@ -883,8 +892,10 @@ export class Battle {
     u.ground = this.grid.isLow(R0, C0) && !this._elevated?.has(k);
     u.markDirty();
     u.hp = u.s.maxHp;
-    const cs = initial ? (carry ?? u.carry) : null;
-    if (cs && Number.isFinite(cs.hpPct)) u.hp = Math.max(1, u.s.maxHp * Math.max(0.01, Math.min(1, cs.hpPct)));
+    // 联防 carry (PRTS 卫戍协议/帮助 §联防阶段 "将对应单位的生命比例、技力修改至与上一阶段结束时相同（召唤物仅修改技力…）"):
+    // an operator's HP ratio here, the SP in skill.reset and again after the `deploy` hook (below) — a summon's SP only
+    const cs = initial || (first && this._startDeploying) ? (carry ?? u.carry) : null;
+    if (cs && u.kind === 'op' && Number.isFinite(cs.hpPct)) u.hp = Math.max(1, u.s.maxHp * Math.max(0.01, Math.min(1, cs.hpPct)));
     this._occ[k] = u;
     this._refreshRange(u); // also rebuilds baseRangeKeys (initial range incl. permanent rangeExtend)
     if (!u.skill) this._setupUnit(u);
@@ -900,6 +911,9 @@ export class Battle {
     if (first) this._ev(['spawn', unitInfo(u)]);
     this._ev(['deploy', u.id]);
     if (this._hooks.deploy) this.emit('deploy', { unit: u, initial });
+    // 联防: "部署完成后，将对应单位的…技力修改至与上一阶段结束时相同" — the carried SP is set again once the deployment is
+    // done, so a deploy-time SP gift (独行, 黄沙罗盘 …) does not come on top of it; later redeploys keep those gifts
+    if (cs && Number.isFinite(cs.sp) && u.alive && u.skill) u.skill.setSpTotal(cs.sp);
     return true;
   }
 

server/sim/content/bonds/addon/battle.js

@@ -431,24 +431,42 @@ export function install(battle) {
     });
   }
 
-  // 不屈
+  // 不屈 (PRTS 卫戍协议：盟约 下半/PRTS盟约记录, its 修正: "地面干员被击倒、撤退、切换<替身>与<本体>时，有(18+0.4×层数)%概率立刻
+  // 重新部署"; "※“立刻重新部署”的实现方式为：令受益者下次部署的再部署时间和费用归零"; owner's decision 2026-10-04 to follow it).
+  // Rolls on a knock-out ('killed') and on a 撤退 ('retreat' — 史尔特尔's 余烬, 耀骑士临光 S2, 伊内丝 S3 … — and 行商's
+  // 'merchant' withdrawal): a hit redeploys it at once, free, where it lies (engine rest tile, §22.15). Not on the 突袭
+  // retreat ('raid': it redeploys at once and free anyway — the zeroed next deployment would change nothing [ASSUMED: no
+  // roll]) nor on the 联防 forced exit (FORCED_EXIT: the battle's setup, not a 撤退 — §19.3). A 傀儡师 switch (hook
+  // `dollSwap`, to the 替身 and back) rolls too; she stays on the field, so a hit only zeroes her NEXT deployment: the
+  // next time she leaves the field (knocked out, withdrawn) she is back at once and free (`u.mem.indomFreeDeploy`)
+  // [ASSUMED: one such deployment at a time, spent by her next deployment whatever brings it]. Tier 2 (+sp SP to every
+  // operator on the field) stays a knock-out effect: its own line ("地面干员被击倒时使场上所有干员技力+5") was not corrected.
   if (has(ID.indom)) {
+    const INDOM_EXITS = new Set(['killed', 'retreat', 'merchant']);
+    const stOf = (u) => { const st = isGroundOp(u) ? byPid[u.ownerId] : null; return st && st.tiers[ID.indom] ? st : null; };
     battle.on('death', (c) => {
       const u = c.unit;
-      if (c.reason !== 'killed' || !isGroundOp(u)) return;
-      const st = byPid[u.ownerId];
-      if (!st || !st.tiers[ID.indom]) return;
-      const bb = st.bb[ID.indom];
-      if (st.tiers[ID.indom] >= 2) {
+      const banked = !!(u && u.mem && u.mem.indomFreeDeploy);
+      if (!INDOM_EXITS.has(c.reason) || !(stOf(u) || (banked && u.kind === 'op'))) return;
+      const st = stOf(u);
+      const bb = st ? st.bb[ID.indom] : null;
+      if (st && c.reason === 'killed' && st.tiers[ID.indom] >= 2) {
         const sp = num(bb.sp);
         if (sp > 0) for (const o of st.ops) if (onField(o) && o.skill) o.skill.gainSp(sp, 'bond');
       }
       if (u.alive || u.removed || u.mem[ID.indom] === battle.time) return;
-      if (battle.rng() < prob(bb, L(battle, st, ID.indom))) {
+      if (banked || (st && battle.rng() < prob(bb, L(battle, st, ID.indom)))) {
         u.mem[ID.indom] = battle.time;
         if (battle.redeploy(u, { free: true })) fxOn(battle, 'revive', u, 'bond:indomShip', 'redeploy');
       }
     }, { priority: 10 });
+    battle.on('dollSwap', ({ unit: u }) => {
+      const st = stOf(u);
+      if (!st || !u.alive || u.mem.indomFreeDeploy) return;
+      if (battle.rng() < prob(st.bb[ID.indom], L(battle, st, ID.indom))) u.mem.indomFreeDeploy = true;
+    });
+    // the zeroed deployment is the next one, whatever brings it (this redeploy, the 阿戈尔 revive, the 突袭 jump …)
+    battle.on('deploy', ({ unit: u }) => { if (u && u.mem && u.mem.indomFreeDeploy) u.mem.indomFreeDeploy = false; });
   }
 
   // 坚守 (tier 2) redirect + thorns, 奥术 vulnerability

server/sim/content/bonds/core.js

@@ -40,6 +40,7 @@ import { mitigate } from '../../damage.js';
 import { spawnYanyou } from '../tokens.js';
 import { kjeragColdWind } from '../devices.js';
 import * as items from '../items.js';
+import { FORCED_EXIT } from '../../constants.js';
 
 const num = S.num;
 
@@ -343,6 +344,8 @@ function installLaterano(battle, pid, bb, members) {
  * cancelled, also when it is back at once (the 5-tier 立刻复活, 不屈's 立刻重新部署, 埃芒加德 / M3茧甲): PRTS 盟约记录 "目标首次被
  * 击倒后解除自身被付与但还未触发的【吞噬】效果". A marker off the field gives no further mark (the rule since 0.1.0; one knocked
  * out and back in the same pass still gives its marks).
+ * 联防: the operators down since the end of their own combat (forced out by Battle.start) mark, are marked and resolve
+ * their marks like standing ones, but nothing resolves on them (below; per players' reports, owner's decision 2026-10-04).
  * Each devoured operator adds its tier to 阿戈尔 once (IN_BATTLE gain, disabled in 联防 / boss fields).
  * Tokens / devices / empty tiles are never devoured.
  */
@@ -352,12 +355,22 @@ function devour(battle, pid, bb, members) {
   // first — row 0 is the BOTTOM row (DESIGN §3), so the top of the board is the highest row index. The order is a
   // board position, independent of the members' directions (only "身前" follows each member's `dir`).
   const boardCol = (u) => (u.player && u.player.mirror ? -u.tileC : u.tileC);
-  const order = members.filter(S.onField).sort((a, b) =>
+  // 联防: an operator down at the end of its own combat (carryState.down — Battle.start forced it out right before
+  // battleStart, FORCED_EXIT) takes part in the devour as if it stood on its tile, then stays out: it marks in its turn,
+  // it is "the unit in front" of another (the chain goes on through it when it is a member), its base ATK / block count
+  // for its marker and its own marks resolve (their 物理流失 lands, credited to it as usual); only the marks ON it resolve
+  // nothing — it is forced out, so it is never knocked out again, revived or devoured. Per players' reports (community
+  // report #3, GitHub #33 item 3), owner's decision 2026-10-04; until 0.1.2 the forced exit came first and the chain broke.
+  const downAtStart = (u) => S.isOp(u) && !u.alive && u.removeReason === FORCED_EXIT && !!u.carry && u.carry.down === true
+    && battle.isDown(u);
+  const order = members.filter((u) => S.onField(u) || downAtStart(u)).sort((a, b) =>
     boardCol(a) - boardCol(b) || b.tileR - a.tileR || a.id - b.id);
   const opAt = (u) => {
     const [r, c] = S.frontTile(u);
     const a = S.allyAt(battle, r, c, pid);
-    return a && S.isOp(a) && a.alive ? a : null;
+    if (a) return S.isOp(a) && a.alive ? a : null;
+    const d = battle.downOn(r, c);
+    return d && d.ownerId === pid && downAtStart(d) ? d : null;
   };
   const markedBy = new Map(); // marker → [targets]
   const marks = [];
@@ -392,7 +405,9 @@ function devour(battle, pid, bb, members) {
   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);
   for (const [m, t] of marks) {
-    if (knocked(t) || !m.alive) continue;
+    // (a member down since its own combat — downAtStart — resolves its marks as if it stood; a mark on it resolves nothing:
+    // `knocked` — it is off the field)
+    if (knocked(t) || !(m.alive || downAtStart(m))) continue;
     S.fxOn(battle, 'devour', t, 'bond:egirShip', 'devour', { from: m.id });
     if (amount > 0) battle.loseHp(t, mitigate(amount, 'phys', t.s), { source: m, tags: ['bond:egir:devour'] });
     if (!layered.has(t)) {

server/sim/professions.js

@@ -149,6 +149,7 @@ const installDollkeeper = (battle, unit) => {
     unit.markDirty();
     unit.hp = unit.s.maxHp;
     battle.fx('swap', at({ form: null }));
+    if (battle.hasHook('dollSwap')) battle.emit('dollSwap', { unit, form: null });
   };
   const enter = () => {
     if (unit.trait.doll || !unit.alive || !unit.deployed) return false;
@@ -168,6 +169,9 @@ const installDollkeeper = (battle, unit) => {
     unit.hp = unit.s.maxHp;
     // `dur`: until the switch back (the client times the 替身's closing clip with it)
     battle.fx('substitute', at({ form: 'doll', dur }));
+    // `dollSwap` { unit, form }: a switch started — to the 替身 ('doll') or back to the 本体 (null); not fired when she is
+    // knocked out as the 替身 (不屈 rolls on both switches: PRTS 盟约记录 "切换<替身>与<本体>时")
+    if (battle.hasHook('dollSwap')) battle.emit('dollSwap', { unit, form: 'doll' });
     return true;
   };
   battle.on('fatal', (ctx) => {

server/sim/skills.js

@@ -1,8 +1,9 @@
 // server/sim/skills.js — skill runtime: SP, charges, trigger rules, kinds, SkillSpec interpretation (DESIGN §5.6).
 //
 // SP types: 'time' (+spRecovery/s), 'attack' (+1 per attack), 'hurt' (+1 per hit taken), 'none'.
-// No SP gain while a duration/ammo/toggle skill is active, while stunned, or while the unit has the noSp flag (阻回: no SP
-// gain of any kind — time, attack, hurt or granted).
+// No SP gain while a duration/ammo/toggle skill is active, or while the unit has the noSp flag (阻回: no SP gain of any
+// kind — time, attack, hurt or granted). A stunned / frozen / levitated unit (canAct false) neither attacks nor casts, but
+// its time SP keeps recovering (PRTS: only 阻回 pauses the SP cooldown; 晕眩 does not — community report #18).
 // Charges (maxCharges > 1): SP fills to spCost → +1 charge (SP restarts) until charges == max (SP stays full).
 // Trigger rules (the official 技能策略, PRTS 卫戍协议/帮助 §作战阶段 技能操作; data: tools/build-data.mjs resolveTrigger):
 //   DEFAULT — the basic strategy: ready + about to attack/heal + enemy / injured ally in the INITIAL range (or blocked by
@@ -161,7 +162,34 @@ export class SkillRuntime {
     return this.battle._safe(() => fn(this._ctx(extra)), `skill.${fnName}`, this.unit);
   }
 
-  /** Called on every (re)deployment. `carry` = { sp, skillActive } for unite helpers. */
+  /**
+   * The official 技力 (PRTS 技能: "可充能X次…当前技力上限等于该技能技力需求的X倍"): the stored charges × cost plus the SP
+   * towards the next one — what 联防 carries (BattleResult unitsEnd `sp`; reset rebuilds the charges from it).
+   */
+  get spTotal() {
+    if (this.noSkill || this.kind === 'passive') return 0;
+    const cost = this.spCost;
+    return this.charges >= this.maxCharges ? this.maxCharges * cost : this.charges * cost + this.sp;
+  }
+
+  /**
+   * Set the official 技力 to `total` (charges rebuilt, nothing fired — a 修改, not a gain): the 联防 carry, applied again
+   * once the deployment is done (Battle._deploy). A passive skill, or a timed one that runs already, is left as it is.
+   */
+  setSpTotal(total) {
+    if (this.noSkill || this.kind === 'passive' || (this.active && this.isTimed) || !Number.isFinite(total)) return;
+    this.sp = 0;
+    this.charges = 0;
+    this.gainSp(Math.max(0, total), 'init', true);
+    if (this.spCost <= 0) this.charges = this.maxCharges;
+  }
+
+  /**
+   * Called on every (re)deployment. `carry` = { sp } for unite (联防) helpers: their 技力 at the end of their own combat
+   * (unitsEnd `sp` = spTotal, rebuilt into charges here). Nothing else of the skill is carried — PRTS 卫戍协议/帮助 §联防阶段
+   * "将对应单位的生命比例、技力修改至与上一阶段结束时相同": a skill that was running enters 联防 switched off, with the SP it
+   * had left (spent at its activation: 0 for a one-charge skill — PRTS 技能 "触发技能后…消耗相应的技力").
+   */
   reset(carry = null) {
     this.active = false;
     this.pending = false;
@@ -181,9 +209,6 @@ export class SkillRuntime {
     this.gainSp(carry && Number.isFinite(carry.sp) ? carry.sp : this.initSp, 'init', true);
     // a free (spCost 0) non-passive skill is available once per deployment
     if (this.spCost <= 0) this.charges = this.maxCharges;
-    // unite helpers whose timed skill was running when their combat ended: it keeps running (a fresh duration/ammo),
-    // without spending a charge — the carried SP is what they had accumulated (0 while a skill runs).
-    if (carry && carry.skillActive && this.isTimed) this.activate('carry', { free: true });
   }
 
   _startPassive() {
@@ -262,11 +287,14 @@ export class SkillRuntime {
     } else if (this.active && this.kind === 'passive' && this.spec.onTick) {
       this._call('onTick', { dt });
     }
-    if (!u.canAct) return;
-    if (this.spType === 'time' && !(this.active && this.isTimed) && !u.s.flags.noSp) {
+    // natural SP recovery stops only under 阻回 (noSp; a running timed skill holds it too) — not while 晕眩 / 冻结 / 浮空
+    // keep the unit from acting: PRTS 技能 "在阻回状态或技力条已满时，保留剩余冷却时间，计时暂停"; PRTS 异常效果 STUNNED
+    // "无法攻击、释放技能、阻挡敌人类单位" says nothing of SP (community report #18: 洛洛's S2 self-stun froze her SP)
+    if (this.spType === 'time' && !(this.active && this.isTimed) && !u.s.flags.noSp && u.alive && u.deployed && !u.hidden) {
       const rate = u.s.spRecovery;
       if (rate > 0) this.gainSp(rate * dt, 'time');
     }
+    if (!u.canAct) return;
     // a DEFAULT cast bound to an ally condition (塞雷娅 S1) replaces the attack about to be made: should the condition
     // have failed before that attack (the ally healed meanwhile), the cast is withdrawn — no heal mode stays behind
     if (this.pending && this.triggerAllies && this.rule !== 'SKILL_RANGE' && !this._allyTriggerSatisfied()) {
@@ -396,7 +424,7 @@ export class SkillRuntime {
     this.activations++;
     this.lastStart = this.battle.time;
     const b = this.battle;
-    if (this.manual && reason !== 'carry') this.opReadyAt = b.time + AUTO_OP_COOLDOWN;
+    if (this.manual) this.opReadyAt = b.time + AUTO_OP_COOLDOWN;
     if (this.isTimed) {
       this.active = true;
       this.timeLeft = this.kind === 'duration' ? Math.max(0.01, this.duration) : (this.kind === 'ammo' && this.duration > 0 ? this.duration : Infinity);

test/content/feedback3-egir-down.test.js

@@ -0,0 +1,108 @@
+// test/content/feedback3-egir-down.test.js — 阿戈尔 in 联防 (community report #3, GitHub #33 item 3; per players' reports,
+// owner's decision 2026-10-04): an operator down at the end of its own combat still takes part in the battle-start devour
+// as if it stood (marking order, the unit in front, base ATK / block gains, its own marks' 物理流失) and is then forced
+// out — it used to be forced out first, which broke the chain at its tile. Nothing lands on it (it is never knocked out
+// again, revived or devoured).
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { makeBattle, checkInvariants } from '../helpers/battleHarness.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 bondOn = (count, layers = 0, tier = null, thresholds = [3, 6, 9]) => ({
+  count, active: count >= thresholds[0], tier: tier ?? thresholds.filter((t) => count >= t).length, layers,
+});
+const buffOf = (u, key) => u.buffs.find((b) => b.key === key) ?? null;
+const devours = (h) => h.hooksOf('damaged').filter((c) => c.dmg && c.dmg.tags && c.dmg.tags.includes('bond:egir:devour'));
+
+// ---------------------------------------------------------------------------------------------------------------------
+// 阿戈尔 devour in 联防 with an operator down since its own combat
+
+const ULPIA = 'chess_char_5_05_a', GHOST = 'chess_char_2_07_a', GLADY = 'chess_char_4_12_a', FODDER = 'chess_char_1_01_a';
+
+function chain(ghostDown, order = [ULPIA, GHOST, GLADY, FODDER]) {
+  const h = makeBattle({
+    kind: 'unite', autoFinish: false, timeLimit: 60, captureNoisy: true, hooks: ['damaged', 'death', 'deploy'],
+    units: order.map((chessId, i) => ({ chessId, row: 10, col: 3 + i, ...(chessId === GHOST && ghostDown ? { carryState: { down: true } } : {}) })),
+    bonds: { egirShip: bondOn(3, 0, null, [3, 5]) },
+  });
+  h.step();
+  return h;
+}
+
+test('联防 阿戈尔 chain 乌尔比安 → 幽灵鲨 (down) → 歌蕾蒂娅 → fodder: 乌尔比安 gains as if 幽灵鲨 stood, then 幽灵鲨 is forced out', () => {
+  const up = chain(false);
+  const down = chain(true);
+  const [ulpia, ghost, glady, fodder] = [ULPIA, GHOST, GLADY, FODDER].map((id) => down.unit(id));
+  const ref = buffOf(up.unit(ULPIA), 'bond:egir:devour');
+  const got = buffOf(ulpia, 'bond:egir:devour');
+  assert.ok(ref && got, 'both 乌尔比安 devour');
+  const base = (id) => down.unit(id).base;
+  close(got.mods.atkFlat, base(GHOST).atk + base(GLADY).atk + base(FODDER).atk, 1e-6, 'the base ATK of 幽灵鲨, 歌蕾蒂娅 and the fodder');
+  assert.equal(got.mods.blockCnt, base(GHOST).blockCnt + base(GLADY).blockCnt + base(FODDER).blockCnt);
+  assert.deepEqual(got.mods, ref.mods, 'exactly the gains of the chain with 幽灵鲨 standing');
+  close(ulpia.s.atk, up.unit(ULPIA).s.atk, 1e-6, '乌尔比安 ATK');
+  // then she is out: forced out (not knocked out again), never devoured, never revived
+  assert.ok(!ghost.alive && ghost.removeReason === FORCED_EXIT && down.b.isDown(ghost), '幽灵鲨 lies on her tile, forced out');
+  assert.equal(down.hooksOf('death').filter((c) => c.unit === ghost && c.reason === 'killed').length, 0, 'no knock-out');
+  assert.equal(down.hooksOf('deploy').filter((c) => c.unit === ghost && !c.initial).length, 0, 'no revive');
+  assert.ok(!devours(down).some((c) => c.target === ghost), 'no 物理流失 on her');
+  // standing, 乌尔比安's first mark knocks her out, so her own marks give nothing; down, her marks resolve but find
+  // 歌蕾蒂娅 and the fodder already knocked out by 乌尔比安's (cancelled) — the rest resolves alike
+  const pairs = (h) => devours(h).map((c) => [c.source.defId, c.target.defId]);
+  assert.deepEqual(pairs(up), [[ULPIA, GHOST], [ULPIA, GLADY], [ULPIA, FODDER]]);
+  assert.deepEqual(pairs(down), [[ULPIA, GLADY], [ULPIA, FODDER]]);
+  assert.equal(glady.alive, up.unit(GLADY).alive);
+  assert.equal(fodder.alive, up.unit(FODDER).alive);
+  // her own marks (歌蕾蒂娅, the fodder) still give her their base ATK / block for when she is back
+  const own = buffOf(ghost, 'bond:egir:devour');
+  close(own ? own.mods.atkFlat : 0, base(GLADY).atk + base(FODDER).atk, 1e-6, '幽灵鲨 keeps her marking gains (a persistent buff)');
+  checkInvariants(down.b);
+  assert.equal(down.result().perPlayer.p1.deaths, up.result().perPlayer.p1.deaths - 1, 'no knock-out counted for her (standing, the devour knocks her out)');
+});
+
+/** 幽灵鲨 (down or standing) → 歌蕾蒂娅 → fodder on row 10; 乌尔比安 (+ 深巡, 海霓 for 5 members) on row 12 facing empty tiles. */
+function head(ghostDown, five) {
+  const units = [
+    { chessId: GHOST, row: 10, col: 3, ...(ghostDown ? { carryState: { down: true } } : {}) }, { chessId: GLADY, row: 10, col: 4 },
+    { chessId: FODDER, row: 10, col: 5 }, { chessId: ULPIA, row: 12, col: 3 },
+    ...(five ? [{ chessId: 'chess_char_1_04_a', row: 12, col: 5 }, { chessId: 'chess_char_3_09_a', row: 12, col: 7 }] : []),
+  ];
+  const h = makeBattle({
+    kind: 'unite', autoFinish: false, timeLimit: 60, captureNoisy: true, hooks: ['damaged', 'death', 'deploy'],
+    units, bonds: { egirShip: bondOn(five ? 5 : 3, 0, null, [3, 5]) },
+  });
+  h.step();
+  return h;
+}
+
+test('联防 阿戈尔: a down member at the head of the chain devours as if it stood — its 物理流失 lands (credited to it), then it stays out', () => {
+  for (const five of [false, true]) {
+    const tag = five ? '5 members' : '3 members';
+    const up = head(false, five);
+    const down = head(true, five);
+    const [ghost, glady, fodder] = [GHOST, GLADY, FODDER].map((id) => down.unit(id));
+    const g = buffOf(ghost, 'bond:egir:devour');
+    close(g.mods.atkFlat, glady.base.atk + fodder.base.atk, 1e-6, `${tag}: marks 歌蕾蒂娅 and, through her, the fodder`);
+    const pairs = (h) => devours(h).map((c) => [c.source.defId, c.target.defId]);
+    assert.deepEqual(pairs(down), pairs(up), `${tag}: the marks resolve as with 幽灵鲨 standing`);
+    assert.deepEqual(pairs(down), [[GHOST, GLADY], [GHOST, FODDER]], `${tag}: her two marks; 歌蕾蒂娅's on the fodder is cancelled (knocked out first)`);
+    assert.ok(!fodder.alive, `${tag}: the fodder falls`);
+    assert.equal(ghost.stats.kills, up.unit(GHOST).stats.kills, `${tag}: the kills are hers, as standing`);
+    assert.ok(!ghost.alive && ghost.removeReason === FORCED_EXIT && down.b.isDown(ghost), `${tag}: 幽灵鲨 stays forced out`);
+    const revived = (h, u) => h.hooksOf('deploy').filter((c) => c.unit === u && !c.initial).length;
+    if (five) {
+      // the 5-tier revive: 歌蕾蒂娅's first knock-out (by the down 幽灵鲨's mark) spends a charge, as standing
+      assert.equal(revived(down, glady), 1, '歌蕾蒂娅 revived once');
+      assert.equal(revived(up, up.unit(GLADY)), 1);
+      assert.ok(glady.alive, '歌蕾蒂娅 stands again');
+      close(glady.hp, glady.s.maxHp, 1e-6, 'at full HP: no further mark on her');
+      assert.equal(revived(down, ghost), 0, 'the down 幽灵鲨 spends nothing');
+    } else {
+      assert.ok(!glady.alive, '歌蕾蒂娅 falls to 幽灵鲨\'s mark (3 members: no revive)');
+    }
+    assert.equal(down.result().perPlayer.p1.deaths, up.result().perPlayer.p1.deaths, `${tag}: the same knock-outs`);
+    checkInvariants(down.b);
+  }
+});

test/content/feedback3-indom-exits.test.js

@@ -0,0 +1,114 @@
+// test/content/feedback3-indom-exits.test.js — 不屈 (owner's decision 2026-10-04, PRTS 卫戍协议：盟约 下半/PRTS盟约记录 不屈
+// 修正: "被击倒、撤退、切换<替身>与<本体>时，有(18+0.4×层数)%概率立刻重新部署"; "※“立刻重新部署”的实现方式为：令受益者下次
+// 部署的再部署时间和费用归零"): retreats and 傀儡师 switches roll too, not only knock-outs.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { makeBattle, chessRec, checkInvariants } from '../helpers/battleHarness.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 bondOn = (count, layers = 0, tier = null, thresholds = [3, 6, 9]) => ({
+  count, active: count >= thresholds[0], tier: tier ?? thresholds.filter((t) => count >= t).length, layers,
+});
+
+// ---------------------------------------------------------------------------------------------------------------------
+// 不屈 on 撤退 and on 替身 switches
+
+const groundOp = (id, extra = {}) => chessRec({ id, profession: 'WARRIOR', skill: null, bonds: ['indomShip'], stats: { atk: 100, maxHp: 5000, def: 0, respawnTime: 70 }, ...extra });
+const spOp = (id) => groundOp(id, { skill: { duration: 5, spCost: 50, initSp: 0, bb: { atk: 1 } } });
+const INDOM = (layers, count = 2) => ({ indomShip: bondOn(count, layers, null, [2, 3]) }); // p = min(1, 0.18 + 0.004 × layers)
+const GH2 = 'chess_char_5_13_a'; // 归溟幽灵鲨: 傀儡师, a member of 阿戈尔 and 不屈
+
+test('不屈: a 撤退 rolls like a knock-out — at p = 1 it is back at once, free, on its tile (行商\'s withdrawal too); tier 2\'s +5 SP stays a knock-out effect', () => {
+  const h = makeBattle({
+    defs: { chess: { t_a: groundOp('t_a'), t_b: spOp('t_b'), t_c: groundOp('t_c') } },
+    units: [{ chessId: 't_a', row: 10, col: 4 }, { chessId: 't_b', row: 10, col: 6 }, { chessId: 't_c', row: 10, col: 8 }],
+    bonds: INDOM(300, 3), autoFinish: false, timeLimit: 60, hooks: ['death', 'deploy'],
+  });
+  h.step();
+  const [a, b] = [h.unit('t_a'), h.unit('t_b')];
+  const dp0 = h.b.getPlayer('p1').dp;
+  const sp0 = b.skill.sp;
+  h.b.retreat(a, { reason: 'retreat' });
+  assert.ok(a.alive && a.deployed, 'back at once');
+  assert.equal(h.hooksOf('deploy').filter((c) => c.unit === a && !c.initial).length, 1);
+  assert.deepEqual([a.tileR, a.tileC], [a.homeR, a.homeC], 'on its tile');
+  close(h.b.getPlayer('p1').dp, dp0, 1e-9, 'free');
+  close(b.skill.sp, sp0, 1e-9, 'no +5 SP for a retreat');
+  h.step(); // (不屈 fires once per unit and instant)
+  h.b.retreat(a, { reason: 'merchant' });
+  assert.ok(a.alive, '行商\'s automatic withdrawal is a 撤退 too');
+  h.step();
+  const sp1 = b.skill.sp;
+  h.b.dealDamage(null, a, { amount: 1e9, type: 'true' });
+  assert.ok(a.alive, 'a knock-out: back too');
+  close(b.skill.sp, sp1 + 5, 1e-9, 'a knock-out gives the tier-2 +5 SP');
+  checkInvariants(h.b);
+});
+
+test('不屈: no roll on the 突袭 retreat (it redeploys at once anyway) nor on the 联防 forced exit; a missed roll leaves the withdrawn operator down', () => {
+  const h = makeBattle({
+    kind: 'unite', defs: { chess: { t_a: groundOp('t_a'), t_b: groundOp('t_b') } },
+    units: [{ chessId: 't_a', row: 10, col: 4, carryState: { down: true } }, { chessId: 't_b', row: 10, col: 6 }], bonds: INDOM(300),
+    autoFinish: false, timeLimit: 60,
+  });
+  h.step();
+  const a = h.unit('t_a');
+  assert.ok(!a.alive && a.removeReason === FORCED_EXIT && h.b.isDown(a), 'the 联防 forced exit is no 撤退: it stays down with its timer');
+  const b = h.unit('t_b');
+  h.b.retreat(b, { reason: 'raid' });
+  assert.ok(!b.alive, 'the 突袭 retreat: 不屈 leaves it to the raid\'s own redeploy');
+  // p = 0.18: a seed whose roll misses leaves it down where it stood (§22.15)
+  let missed = false;
+  for (let seed = 1; seed < 40 && !missed; seed++) {
+    const m = makeBattle({
+      seed, defs: { chess: { t_a: groundOp('t_a'), t_b: groundOp('t_b') } },
+      units: [{ chessId: 't_a', row: 10, col: 4 }, { chessId: 't_b', row: 10, col: 6 }], bonds: INDOM(0), autoFinish: false, timeLimit: 60,
+    });
+    m.step();
+    const x = m.unit('t_a');
+    m.b.retreat(x, { reason: 'retreat' });
+    if (!x.alive) { missed = true; assert.ok(m.b.isDown(x), 'down on its tile with its timer'); }
+  }
+  assert.ok(missed, 'a missed roll within 39 seeds at p = 0.18');
+});
+
+test('不屈: a 傀儡师 switch to the 替身 rolls — she stays on the field, and a hit makes her next deployment immediate and free', () => {
+  const h = makeBattle({ units: [{ chessId: GH2, row: 10, col: 4 }], bonds: INDOM(300), autoFinish: false, timeLimit: 120, captureNoisy: true, hooks: ['deploy'] });
+  h.step();
+  const u = h.unit(GH2);
+  assert.ok(u.ground, 'a ground operator');
+  h.b.dealDamage(null, u, { amount: 1e9, type: 'true' });
+  assert.ok(u.alive && u.trait.doll, 'switched to her 替身, still on the field');
+  assert.equal(h.hooksOf('deploy').filter((c) => c.unit === u && !c.initial).length, 0, 'no redeploy for the switch itself');
+  assert.equal(u.mem.indomFreeDeploy, true, 'the roll hit: her next deployment is zeroed');
+  h.run(2);
+  const dp0 = h.b.getPlayer('p1').dp;
+  h.b.dealDamage(null, u, { amount: 1e9, type: 'true' }); // a lethal hit on the 替身 knocks her out
+  assert.ok(u.alive && u.deployed && !u.trait.doll, 'back at once as her 本体');
+  close(h.b.getPlayer('p1').dp, dp0, 1e-9, 'free');
+  assert.equal(u.mem.indomFreeDeploy, false, 'spent by that deployment');
+  checkInvariants(h.b);
+});
+
+test('不屈: the switch back to the 本体 rolls too; a zeroed deployment brings her back even when the knock-out roll misses', () => {
+  const h = makeBattle({ units: [{ chessId: GH2, row: 10, col: 4 }], bonds: INDOM(300), autoFinish: false, timeLimit: 120, captureNoisy: true });
+  h.step();
+  const u = h.unit(GH2);
+  h.b.dealDamage(null, u, { amount: 1e9, type: 'true' });
+  u.mem.indomFreeDeploy = false; // forget the first switch's roll: the switch back must roll on its own
+  h.runUntil(() => !u.trait.doll, 30);
+  assert.ok(u.alive && !u.trait.doll, 'back to her 本体');
+  assert.equal(u.mem.indomFreeDeploy, true, 'the switch back rolled (p = 1)');
+  // p = 0.18 (no layers): with a zeroed deployment banked she comes back after any knock-out, rolled or not
+  for (let seed = 1; seed <= 5; seed++) {
+    const m = makeBattle({ seed, defs: { chess: { t_a: groundOp('t_a') } }, units: [{ chessId: 't_a', row: 10, col: 4 }], bonds: INDOM(0), autoFinish: false, timeLimit: 60 });
+    m.step();
+    const x = m.unit('t_a');
+    x.mem.indomFreeDeploy = true;
+    m.b.dealDamage(null, x, { amount: 1e9, type: 'true' });
+    assert.ok(x.alive && !x.mem.indomFreeDeploy, `seed ${seed}: back at once`);
+  }
+  checkInvariants(h.b);
+});

test/docs-consistency.test.js

@@ -339,7 +339,7 @@ test('user playtest #5 (DESIGN §19): blocking, 联防 forced exit, huge bosses,
   assert.match(SIM, /taken over by another operator in contact with room, else they walk on/);
   // #2 联防: carryState { down: true } → FORCED_EXIT (code = §5.1 / §5.5 / §6.1 / §18.3)
   assert.equal(FORCED_EXIT, 'forcedExit');
-  assert.match(DESIGN, /carryState\?: \{ hpPct, sp, skillActive \} \| \{ down: true \}/);
+  assert.match(DESIGN, /carryState\?: \{ hpPct, sp \} \| \{ sp \} \| \{ down: true \}/);
   assert.match(DESIGN, /or `FORCED_EXIT`, entering 联防 knocked out/);
   assert.match(sec(6), /knocked out at the end of its own combat enters down/);
   assert.match(PLAYING, /作战结束时已被击倒的干员在原位倒地/);

test/match/clientCombat.test.js

@@ -348,7 +348,7 @@ test('联防 under client-side combat: helpers\' reported end state (HP%, SP) ca
   assert.equal(f.authority, 'p_1');
   const carried = f.spec.players[0].units.find((u) => u.uid === unit.uid);
   const reported = m.lastResults.get('p_1').unitsEnd.find((u) => u.uid === unit.uid);
-  assert.deepEqual(carried.carryState, { hpPct: reported.hpPct, sp: reported.sp, skillActive: reported.skillActive });
+  assert.deepEqual(carried.carryState, { hpPct: reported.hpPct, sp: reported.sp });
   const got = h.sent.filter(([, x]) => x.t === 'b.start' && x.fieldId === 'u').map(([pid, x]) => `${pid}:${x.authoritative ? 'A' : x.watch ? 'w' : 'r'}`).sort();
   assert.deepEqual(got, ['p_0:w', 'p_1:A', 'p_2:r']);
   h.drive(() => m.phase === PHASE.SETTLE);

test/match/combat.test.js

@@ -148,7 +148,7 @@ test('联防: trigger, helpers (≤ 2, highest LP then seat), carry state, sourc
   // unite.js (research 08 §5): the first-ranked helper "率先迎敌" on the right-hand field (colOffset +8)
   assert.deepEqual(u.opts.players.map((p) => [p.playerId, p.colOffset]), [['p_1', 8], ['p_2', 0]]);
   const carried = u.opts.players[0].units.find((x) => x.uid === unit.uid);
-  assert.deepEqual(carried.carryState, { hpPct: 0.5, sp: 3, skillActive: false }, 'HP%/SP from the end of the own combat');
+  assert.deepEqual(carried.carryState, { hpPct: 0.5, sp: 3 }, 'HP%/SP from the end of the own combat');
   assert.equal(u.opts.spawns.length, 18, 'union of every counted leak');
   assert.equal(u.opts.spawns.filter((s) => s.sourcePlayerId === 'p_0').length, 6);
   assert.equal(u.opts.spawns.filter((s) => s.sourcePlayerId === 'p_3').length, 12);
@@ -198,7 +198,7 @@ test('联防: an operator knocked out at the end of the helper\'s own combat is
   // timer (user playtest #5 item 2: it used to be left out and vanished); its summons are fielded as the board has them
   assert.deepEqual(units.find((x) => x.uid === hemo.uid)?.carryState, { down: true }, 'the knocked-out operator enters 联防 down');
   assert.ok(units.some((x) => x.kind === 'token' && x.ownerUid === hemo.uid), 'its summons are fielded');
-  assert.deepEqual(units.find((x) => x.uid === alive.uid).carryState, { hpPct: 0.5, sp: 3, skillActive: false });
+  assert.deepEqual(units.find((x) => x.uid === alive.uid).carryState, { hpPct: 0.5, sp: 3 });
   assert.ok(helper.board.has(`${t0[0]},${t0[1]}`) && helper.board.has(placed), 'the board itself is untouched (next round as usual)');
   // during 联防 an 'n:<pid>' id names no field: refused, and the viewer keeps streaming the 联防 field
   assert.equal(m.watchers.get('p_0'), 'u');

test/match/feedback3-unitecarry.test.js

@@ -0,0 +1,152 @@
+// test/match/feedback3-unitecarry.test.js — community report #34 / GitHub #82: 联防 carried a skill that was running at
+// the end of a helper's own combat and restarted it for free (圣聆初雪's S2 on at the 联防 start with SP 0, an empty bar).
+// Official (PRTS 卫戍协议/帮助 §联防阶段): "部署完成后，将对应单位的生命比例、技力修改至与上一阶段结束时相同（召唤物仅修改技力，
+// 上一阶段为退场状态的干员强制退场）"; the official setup message carries `charBattleStatusList: [{ instId, hp, tech }]` only
+// (research 09 §3 HelpBattleInfo). So: an operator's HP ratio and 技力, a summon's 技力, nothing of the skill state.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { uniteBattleOpts } from '../../server/match/unite.js';
+import { makeBattle, chessRec, enemyRec } from '../helpers/battleHarness.js';
+import { makeMatch } from './harness.js';
+
+const close = (a, b, eps = 1e-6, msg = '') => assert.ok(Math.abs(a - b) <= eps, `${msg} expected ${b}, got ${a}`);
+
+let gdCache = null;
+/** A real GameData (unite templates for buildUniteWave). */
+function gd() {
+  if (!gdCache) gdCache = makeMatch({ mode: 'coop', humans: 3, seed: 1, fake: true }).start().m.gd;
+  return gdCache;
+}
+
+/**
+ * unite.js's carry for one helper, from the given end-of-combat report: board = [[uid, 'chess'|'token', chessId?]],
+ * the helper's battle input lists those pieces (board row 10, from col 3) with the carry unite.js attached.
+ */
+function uniteInput(board, unitsEnd) {
+  const ps = {
+    playerId: 'p1', seat: 0,
+    board: new Map(board.map(([uid, kind], i) => [`10,${3 + i}`, { uid, kind }])),
+    battleInput: ({ side, colOffset, carry }) => ({
+      playerId: 'p1', seat: 0, side, colOffset, bonds: {}, bandId: null, playerEffects: [],
+      units: board.map(([uid, kind, id, extra], i) => ({
+        uid, kind, ...(kind === 'token' ? { tokenId: id } : { chessId: id }), row: 10, col: 3 + i, dir: 'RIGHT', items: [],
+        ...(extra || {}), ...(carry.has(uid) ? { carryState: carry.get(uid) } : {}),
+      })),
+    }),
+  };
+  const m = { gd: gd(), round: 3, lastResults: new Map([['p1', { unitsEnd }]]), dispatch() {} };
+  const { players } = uniteBattleOpts(m, { helpers: [ps], leaked: [] }, 60);
+  return players[0];
+}
+
+test('unite.js carry: HP ratio + SP for an operator (never skillActive), SP only for a summon on the field, down for a knocked-out operator', () => {
+  const input = uniteInput(
+    [[1, 'chess', 't_run'], [2, 'token', 'tok'], [3, 'chess', 't_down'], [4, 'token', 'tok2']],
+    [
+      { uid: 1, hpPct: 0.4, sp: 0, skillActive: true, alive: true },
+      { uid: 2, hpPct: 0.3, sp: 40, skillActive: false, alive: true },
+      { uid: 3, hpPct: 0, sp: 7, skillActive: false, alive: false },
+      { uid: 4, hpPct: 0, sp: 12, skillActive: false, alive: false },
+    ],
+  );
+  const cs = (uid) => input.units.find((u) => u.uid === uid).carryState;
+  assert.deepEqual(cs(1), { hpPct: 0.4, sp: 0 }, 'the running skill is not carried');
+  assert.deepEqual(cs(2), { sp: 40 }, '召唤物仅修改技力');
+  assert.deepEqual(cs(3), { down: true });
+  assert.equal(cs(4), undefined, 'a summon off the field at the end enters fresh [ASSUMED]');
+});
+
+test('PlayerState.battleInput hands a summon piece its carryState', () => {
+  const h = makeMatch({ mode: 'coop', humans: 3, seed: 5, fake: true }).start();
+  h.toPrep(1);
+  const ps = h.ps('p_1');
+  const tok = ps.newPiece('token', 'token_10030_mlyss_wtrman', { ownerUid: 999 });
+  ps.board.set('10,4', tok);
+  const input = ps.battleInput({ carry: new Map([[tok.uid, { sp: 40 }]]) });
+  assert.deepEqual(input.units.find((u) => u.uid === tok.uid).carryState, { sp: 40 });
+});
+
+test('an operator whose skill runs at the end of its own combat enters 联防 with the skill off and the carried SP; stored charges come back', () => {
+  const defs = {
+    chess: {
+      // a 30 s skill (cost 10, ready at once) cast on the dummy in range: running when the own combat ends
+      t_run: chessRec({ id: 't_run', profession: 'SNIPER', rangeGrid: [[0, 0], [0, 1], [0, 2]], stats: { atk: 100 },
+        skill: { duration: 30, spCost: 10, initSp: 10, bb: { atk: 1 } } }),
+      // 2 charges of a cost-5 skill, nothing in range: both charges stored at the end (技力 10 = 2 × 5)
+      t_chg: chessRec({ id: 't_chg', profession: 'SNIPER', rangeGrid: [[0, 0]], stats: { atk: 100 },
+        skill: { duration: 5, spCost: 5, initSp: 0, maxChargeTime: 2, bb: { atk: 1 } } }),
+    },
+    enemies: { e_dummy: enemyRec({ key: 'e_dummy', hp: 1e9, speed: 0 }) },
+  };
+  const own = makeBattle({
+    defs, content: 'generic', autoFinish: false, timeLimit: 60,
+    units: [{ uid: 1, chessId: 't_run', row: 10, col: 3 }, { uid: 2, chessId: 't_chg', row: 12, col: 3 }],
+    enemies: [{ key: 'e_dummy', pos: [10, 5] }],
+  });
+  own.runUntil(() => own.unit('t_run').skill.active, 10);
+  own.run(12);
+  assert.ok(own.unit('t_run').skill.active, 'still running at the end');
+  const unitsEnd = own.result().perPlayer.p1.unitsEnd;
+  const end = (uid) => unitsEnd.find((u) => u.uid === uid);
+  assert.equal(end(1).skillActive, true);
+  assert.equal(end(1).sp, 0, 'spent at the activation (PRTS 技能 "触发技能后…消耗相应的技力")');
+  assert.equal(own.unit('t_chg').skill.charges, 2);
+  assert.equal(end(2).sp, 10, 'the official 技力: both charges (PRTS 技能 "当前技力上限等于该技能技力需求的X倍")');
+
+  const input = uniteInput([[1, 'chess', 't_run'], [2, 'chess', 't_chg']], unitsEnd);
+  input.units[1].row = 12; // as on the own field
+  const u = makeBattle({ kind: 'unite', defs, content: 'generic', autoFinish: false, players: [input] });
+  u.step();
+  const run = u.unit('t_run'), chg = u.unit('t_chg');
+  close(run.hpRatio, end(1).hpPct, 1e-6, 'HP ratio');
+  assert.equal(run.skill.active, false, 'the skill enters 联防 switched off (it used to restart for free)');
+  assert.equal(run.skill.activations, 0);
+  assert.ok(run.skill.sp < 0.1, `SP from 0, got ${run.skill.sp}`);
+  close(run.s.atk, 100, 1e-6, 'no skill ATK');
+  assert.equal(chg.skill.charges, 2, 'the stored charges are back');
+});
+
+test('a summon piece enters 联防 with its carried SP only (流形: SP set, HP full)', () => {
+  // 缪尔赛思 (chess_char_6_11_a) and her board 流形 (token_10030_mlyss_wtrman: cost 100, initial SP 95)
+  const players = [{
+    playerId: 'p1', seat: 0, side: 'L', colOffset: 0, bonds: {}, bandId: null, playerEffects: [],
+    units: [
+      { uid: 1, kind: 'chess', chessId: 'chess_char_6_11_a', row: 10, col: 3, dir: 'RIGHT', items: [], carryState: { hpPct: 0.5, sp: 3 } },
+      { uid: 2, kind: 'token', tokenId: 'token_10030_mlyss_wtrman', ownerUid: 1, row: 10, col: 4, dir: 'RIGHT', carryState: { sp: 40, hpPct: 0.3 } },
+    ],
+  }];
+  const h = makeBattle({ kind: 'unite', players, autoFinish: false });
+  h.step();
+  const tok = h.b.allyUnits.find((x) => x.uid === 2);
+  assert.ok(tok && tok.alive && tok.deployed, 'the 流形 is on the field');
+  assert.ok(tok.skill.sp >= 40 && tok.skill.sp < 41, `its SP is the carried 40 (fresh it would be 95), got ${tok.skill.sp}`);
+  close(tok.hp, tok.s.maxHp, 1e-6, 'a summon keeps no HP ratio (召唤物仅修改技力)');
+});
+
+test('联防: the carried SP is set after the deployment ("部署完成后…技力修改") — 独行 / 黄沙罗盘 deploy-time SP does not come on top; a later redeploy keeps it', () => {
+  const caster = (id, bonds = []) => chessRec({ id, bonds, profession: 'CASTER', stats: { maxHp: 1000, atk: 100 }, skill: { spCost: 40, initSp: 10, duration: 10 } });
+  const cases = [
+    // 独行 (bonds.json soloShip bb.sp 15: "初始技力+15") on its lone member
+    { name: '独行', unit: { chessId: 't_solo' }, defs: { t_solo: caster('t_solo', ['soloShip']) }, bonds: { soloShip: { count: 1, active: true, tier: 1, layers: 0 } }, gift: 15 },
+    // 黄沙罗盘 (chess_item_6_07_e "初始技力+30")
+    { name: '黄沙罗盘', unit: { chessId: 't_comp', items: ['chess_item_6_07_e_a'] }, defs: { t_comp: caster('t_comp') }, bonds: {}, gift: 30 },
+  ];
+  for (const c of cases) {
+    for (const sp of [0, 30]) {
+      const h = makeBattle({
+        kind: 'unite', defs: { chess: c.defs }, bonds: c.bonds, autoFinish: false, timeLimit: 60,
+        units: [{ ...c.unit, row: 10, col: 4, carryState: { hpPct: 0.5, sp } }],
+      });
+      h.b.start();
+      const u = h.unit(c.unit.chessId);
+      close(u.skill.sp, sp, 1e-9, `${c.name}, carried ${sp}: the bar comes back as it ended`);
+      assert.equal(u.skill.ready, false, `${c.name}, carried ${sp}: not ready`);
+      // a later redeploy in the same 联防 battle: initial SP 10 + the gift, as usual
+      h.step();
+      h.b.retreat(u, { reason: 'retreat' });
+      assert.ok(h.b.redeploy(u, { free: true }));
+      close(u.skill.sp, 10 + c.gift, 1e-9, `${c.name}: a later redeploy keeps the deploy-time SP`);
+    }
+  }
+});

test/match/unitedown.test.js

@@ -71,8 +71,8 @@ for (const clientCombat of [true, false]) {
     const inp = (pid, uid) => players.find((p) => p.playerId === pid).units.find((x) => x.uid === uid);
     assert.deepEqual(inp('p_1', down1.uid)?.carryState, { down: true }, 'the right-hand helper\'s knocked-out operator is in the 联防 battle');
     assert.deepEqual(inp('p_2', down2.uid)?.carryState, { down: true }, 'the left-hand helper\'s too');
-    assert.deepEqual(inp('p_1', up1.uid).carryState, { hpPct: 0.5, sp: 3, skillActive: false });
-    assert.deepEqual(inp('p_2', up2.uid).carryState, { hpPct: 0.5, sp: 3, skillActive: false });
+    assert.deepEqual(inp('p_1', up1.uid).carryState, { hpPct: 0.5, sp: 3 });
+    assert.deepEqual(inp('p_2', up2.uid).carryState, { hpPct: 0.5, sp: 3 });
 
     b.step();
     const unitOf = (uid, pid) => b.allyUnits.find((u) => u.uid === uid && u.ownerId === pid);

test/sim/combat.test.js

@@ -33,7 +33,7 @@ test('stun stops enemy movement and attacks; immunity honoured; statusApplied fi
   assert.ok(h.eventsOf('status').some((ev) => ev[1] === e.id && ev[2] === 'stun' && ev[3] === 0));
 });
 
-test('stunned operator neither attacks nor gains SP; silence blocks skill activation', () => {
+test('stunned operator neither attacks nor casts but keeps its natural SP recovery; silence blocks skill activation', () => {
   const h = makeBattle({
     defs: { chess: { t_guard: guard({ skill: { spCost: 5, initSp: 0, duration: 3, bb: { atk: 0.5 } } }) }, enemies: { enemy_dummy: dummy() } },
     units: [{ chessId: 't_guard', row: 9, col: 5 }], enemies: [{ key: 'enemy_dummy', pos: [9, 6] }], content: 'generic',
@@ -42,9 +42,12 @@ test('stunned operator neither attacks nor gains SP; silence blocks skill activa
   const u = h.unit('t_guard');
   h.b.applyStatus(u, 'stun', { duration: 2 });
   const atk0 = u.stats.attacks;
+  const sp0 = u.skill.sp;
   h.run(1.9);
   assert.equal(u.stats.attacks, atk0);
-  assert.ok(u.skill.sp < 0.2);
+  // PRTS 技能: only 阻回 pauses the SP cooldown ("在阻回状态或技力条已满时…计时暂停"); 晕眩 (PRTS 异常效果 STUNNED) does not
+  approx(u.skill.sp - sp0, 1.9, 0.02);
+  assert.equal(u.skill.activations, 0, 'no cast while stunned');
   h.b.applyStatus(u, 'silence', { duration: 20 });
   h.run(8);
   assert.ok(u.stats.attacks > atk0, 'attacks after stun');

test/sim/feedback3-stunsp.test.js

@@ -0,0 +1,76 @@
+// test/sim/feedback3-stunsp.test.js — community report #18: 洛洛's S2 self-stun lasted the right time, but her SP did not
+// recover while she was stunned (skills.js returned before the natural recovery when the unit could not act).
+// Official: PRTS 技能 "在阻回状态或技力条已满时，保留剩余冷却时间，计时暂停" — only 阻回 pauses natural recovery; PRTS 异常效果
+// STUNNED "无法攻击、释放技能、阻挡敌人类单位" (gamedata_const ba.stun "无法移动、阻挡、攻击及使用技能") names no SP effect.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { makeBattle, chessRec, enemyRec } from '../helpers/battleHarness.js';
+import { getDefaultSource } from '../../server/sim/simdata.js';
+
+const close = (a, b, eps, msg = '') => assert.ok(Math.abs(a - b) <= eps, `${msg} expected ${b} ± ${eps}, got ${a}`);
+const dummy = enemyRec({ key: 'e_dummy', hp: 1e9, speed: 0 });
+
+test('洛洛 S2 自负此轭: the data matches skill_table (lv 4 / 7), the stun lasts the overload, and her SP recovers while she is stunned', () => {
+  const ds = getDefaultSource();
+  // skill_table skchr_rockr_2: level 4 duration 40, spCost 45, initSp 15, atk 0.4, attack_speed 45, scale 1.6; level 7
+  // (the elite piece) 40 / 40 / 20, 0.5 / 60 / 1.7 — the chess status skillLevel 4 / 7
+  for (const [id, lv, cost, init, atk, aspd, scale] of [['chess_char_2_10_a', 4, 45, 15, 0.4, 45, 1.6], ['chess_char_2_10_b', 7, 40, 20, 0.5, 60, 1.7]]) {
+    const sk = ds.rawChess(id).skill;
+    assert.equal(sk.skillId, 'skchr_rockr_2', id);
+    assert.equal(sk.level, lv, id);
+    assert.deepEqual([sk.duration, sk.spCost, sk.initSp, sk.bb.atk, sk.bb.attack_speed, sk.bb.scale], [40, cost, init, atk, aspd, scale], id);
+  }
+  const h = makeBattle({
+    defs: { enemies: { e_dummy: dummy } }, units: [{ chessId: 'chess_char_2_10_a', row: 10, col: 4, carryState: { sp: 999 } }],
+    enemies: [{ key: 'e_dummy', pos: [10, 6] }], autoFinish: false, timeLimit: 200, hooks: ['statusApplied', 'skillStart'],
+  });
+  const u = h.unit('chess_char_2_10_a');
+  h.step();
+  assert.ok(u.skill.active, 'cast at once');
+  h.runUntil(() => !u.skill.active, 45);
+  h.step();
+  const stun = h.hooksOf('statusApplied').find((c) => c.status === 'stun' && c.target === u);
+  close(stun.duration, 20, 0.05, 'stunned as long as the overload (the second half of the 40 s)');
+  assert.ok(!u.canAct);
+  const sp0 = u.skill.sp;
+  assert.ok(sp0 < 0.2, `the cast spent the SP, got ${sp0}`);
+  h.run(10);
+  assert.ok(!u.canAct, 'still stunned');
+  close(u.skill.sp - sp0, 10, 0.1, 'SP +1/s while stunned (it stayed at 0 before)');
+  h.run(10.5);
+  assert.ok(u.canAct, 'the stun is over after 20 s');
+  close(u.skill.sp, 20.5, 0.2);
+  // ready 45 s after the skill end (not 45 s after the stun): cast again then
+  const casts = () => h.hooksOf('skillStart').filter((c) => c.unit === u).length;
+  assert.equal(casts(), 1);
+  h.run(25);
+  assert.equal(casts(), 2, 'recast 45 s after the end of the skill');
+});
+
+test('frozen or stunned operators keep their natural SP recovery; 阻回 (noSp) still stops it; no cast while stunned', () => {
+  const op = (id) => chessRec({ id, profession: 'SNIPER', rangeGrid: [[0, 0], [0, 1], [0, 2]], stats: { atk: 100 }, skill: { duration: 5, spCost: 30, initSp: 0, bb: { atk: 1 } } });
+  const h = makeBattle({
+    defs: { chess: { t_a: op('t_a'), t_b: op('t_b'), t_c: op('t_c') }, enemies: { e_dummy: dummy } },
+    units: [{ chessId: 't_a', row: 9, col: 3 }, { chessId: 't_b', row: 10, col: 3 }, { chessId: 't_c', row: 11, col: 3, carryState: { sp: 25 } }],
+    enemies: [{ key: 'e_dummy', pos: [11, 4] }], content: 'generic', autoFinish: false, timeLimit: 60,
+  });
+  h.step();
+  const [a, b, c] = ['t_a', 't_b', 't_c'].map((id) => h.unit(id));
+  h.b.applyStatus(a, 'cold', { duration: 10 });
+  h.b.applyStatus(a, 'cold', { duration: 10 }); // cold on cold → 冻结 (3 s)
+  assert.ok(a.findBuff('freeze'), 'frozen');
+  h.b.addBuff(b, { key: 't:noSp', duration: 3, flags: { noSp: true } });
+  h.b.applyStatus(c, 'stun', { duration: 8 });
+  const [a0, b0] = [a.skill.sp, b.skill.sp];
+  h.run(2.9);
+  close(a.skill.sp - a0, 2.9, 0.05, 'frozen: +1/s');
+  close(b.skill.sp - b0, 0, 1e-9, '阻回: nothing');
+  // t_c fills its 30 SP while stunned (25 + 5 s) but casts only once the stun is over (no cast while stunned)
+  h.run(4.5);
+  assert.ok(!c.canAct && c.skill.ready && c.skill.activations === 0, 'ready, stunned, no cast');
+  h.run(1);
+  assert.ok(c.canAct);
+  h.run(1);
+  assert.equal(c.skill.activations, 1, 'cast once it can act again');
+});

test/sim/fidelity.test.js

@@ -42,23 +42,28 @@ test('attack-SP ammo skill: no SP from any ammo shot, including the last one', (
   assert.equal(u.skill.sp, 1);
 });
 
-test('unite carryState {sp: 0, skillActive: true} (what unitsEnd reports) resumes the timed skill without a charge', () => {
+test('unite carryState: a skill running at the end of the own combat is not carried — unitsEnd reports sp 0 and the skill enters 联防 off', () => {
+  // community report #34 / GitHub #82: the carried skillActive used to restart the skill for free (bar empty, skill on)
   const h = makeBattle({
-    defs: { chess: { t_sn: sniper({ duration: 10, spCost: 10, initSp: 0, bb: { atk: 1 } }) } },
-    units: [{ chessId: 't_sn', row: 10, col: 4, carryState: { hpPct: 0.6, sp: 0, skillActive: true } }], content: 'generic',
+    defs: { chess: { t_sn: sniper({ duration: 10, spCost: 10, initSp: 10, bb: { atk: 1 } }) }, enemies: { e_dummy: enemyRec({ key: 'e_dummy', hp: 1e9, speed: 0 }) } },
+    units: [{ chessId: 't_sn', row: 10, col: 4 }], enemies: [{ key: 'e_dummy', pos: [10, 6] }], content: 'generic', autoFinish: false,
   });
-  h.step();
-  const u = h.unit('t_sn');
-  approx(u.hpRatio, 0.6, 1e-9);
-  assert.equal(u.skill.active, true);
-  assert.equal(u.skill.charges, 0);
-  assert.ok(u.skill.sp < 0.01);
-  approx(u.s.atk, 200);
-  // and a real end-of-battle report round-trips: unitsEnd of a running skill carries sp 0 + skillActive
+  h.runUntil(() => h.unit('t_sn').skill.active, 10);
   h.run(1);
   const end = h.result().perPlayer.p1.unitsEnd[0];
-  assert.equal(end.skillActive, true);
-  assert.equal(end.sp, 0);
+  assert.equal(end.skillActive, true, 'reported');
+  assert.equal(end.sp, 0, 'the SP was spent at the activation (PRTS 技能 "触发技能后…消耗相应的技力")');
+  const u2 = makeBattle({
+    defs: { chess: { t_sn: sniper({ duration: 10, spCost: 10, initSp: 0, bb: { atk: 1 } }) } },
+    units: [{ chessId: 't_sn', row: 10, col: 4, carryState: { hpPct: 0.6, sp: end.sp, skillActive: end.skillActive } }], content: 'generic',
+  });
+  u2.step();
+  const u = u2.unit('t_sn');
+  approx(u.hpRatio, 0.6, 1e-9);
+  assert.equal(u.skill.active, false);
+  assert.equal(u.skill.charges, 0);
+  assert.ok(u.skill.sp < 0.2);
+  approx(u.s.atk, 100);
 });
 
 // ---------------------------------------------------------------------------------------------------------------

test/sim/skills.test.js

@@ -195,7 +195,7 @@ test('SkillSpec from a kit: mods, targeting override, attack override, onStart/o
   assert.equal(u.s.aspd, 100);
 });
 
-test('passive and toggle kinds; carryState restores hp/sp/skill', () => {
+test('passive and toggle kinds; carryState restores hp/sp, never a running skill', () => {
   const h = makeBattle({
     defs: {
       chess: {
@@ -224,7 +224,10 @@ test('passive and toggle kinds; carryState restores hp/sp/skill', () => {
   h2.step();
   const c2 = h2.unit('t_c');
   approx(c2.hpRatio, 0.5, 1e-9);
-  assert.equal(c2.skill.active, true);
+  // PRTS 卫戍协议/帮助 §联防阶段: only the HP ratio and the SP are set — the (old) skillActive flag starts nothing
+  assert.equal(c2.skill.active, false);
+  assert.equal(c2.skill.ready, true, 'the carried 10 SP fill the bar');
+  assert.equal(c2.skill.activations, 0);
 });
 
 test('generic kit maps blackboards of every real chess to a sane SkillSpec', () => {