diff --git a/src/game/engine/combat-pipeline.ts b/src/game/engine/combat-pipeline.ts
index 85b519a..0912373 100644
--- a/src/game/engine/combat-pipeline.ts
+++ b/src/game/engine/combat-pipeline.ts
@@ -581,12 +581,20 @@ export function executeSUnitDmg(
   const remRawPhys256 = Math.max(0, rawPhys256 - reactive.absorbedPhys256)
   const remRawElem256 = Math.max(0, rawElem256 - reactive.absorbedElem256)
 
+  // 1.13c Fire Golem Fire Absorption: 100% healed by fire damage taken (absorbs even if naturally immune)
+  const isFireGolemAbsorb = elemType === 'fire' && defender.statList.getAccruedStat('fire_golem_absorb') > 0
+  if (isFireGolemAbsorb && remRawElem256 > 0) {
+    const curHp = defender.statList.getHp256()
+    const maxHp = defender.statList.getMaxHp256()
+    defender.statList.setHp256(Math.min(maxHp, curHp + remRawElem256))
+  }
+
   // 7. Resistances & 1/5 Immunity Breaking applied to unabsorbed damage
   let finalPhys256 = physResRec.isImmune
     ? 0
     : Math.max(0, Math.trunc((remRawPhys256 * (100 - physResRec.effectiveRes)) / 100))
 
-  let finalElem256 = elemResRec.isImmune
+  let finalElem256 = isFireGolemAbsorb || elemResRec.isImmune
     ? 0
     : Math.max(0, Math.trunc((remRawElem256 * (100 - elemResRec.effectiveRes)) / 100))
 
@@ -606,7 +614,7 @@ export function executeSUnitDmg(
   }
 
   // 8. Elemental Absorb (% and flat)
-  if (finalElem256 > 0) {
+  if (finalElem256 > 0 && !isFireGolemAbsorb) {
     const absorbPct = Math.min(40, Math.max(0, defender.statList.getAccruedStat(`absorb_${elemType}_percent`)))
     const absorbFlat256 = Math.max(0, defender.statList.getAccruedStat(`absorb_${elemType}`)) * FIXED_ONE
     if (absorbPct > 0 || absorbFlat256 > 0) {
@@ -618,11 +626,41 @@ export function executeSUnitDmg(
   }
 
   const totalDamage256 = finalPhys256 + finalElem256
-  const hpAfter256 = Math.max(0, hpBefore256 - totalDamage256)
+  const currentDefenderHp256 = defender.statList.getHp256()
+  const hpAfter256 = Math.max(0, currentDefenderHp256 - totalDamage256)
   defender.statList.setHp256(hpAfter256)
 
   // 9. Reactive events post-damage (damagedinmelee for melee, hitbymissile for missile)
   if (attackKind === 'melee') {
+    // Clay Golem: attacker in melee is also slowed!
+    const claySlowPct = defender.statList.getAccruedStat('clay_golem_slow')
+    if (claySlowPct > 0) {
+      attacker.stateBus.applyState({
+        stateNameOrId: 'slowed',
+        slvl: 1,
+        durationFrames: 150,
+        stats: { item_slow: claySlowPct },
+      })
+      attackerStatesApplied.push('slowed')
+    }
+
+    // Iron Golem Thorns reflection
+    const thornsReturnPct = defender.statList.getAccruedStat('thorns_return_pct')
+    if (thornsReturnPct > 0 && finalPhys256 > 0) {
+      const rawThorns256 = Math.trunc((finalPhys256 * thornsReturnPct) / 100)
+      const attackerPhysRes = computeEffectiveResistance({
+        baseRes: attacker.statList.getAccruedStat('damageresist'),
+      })
+      const reflected256 = attackerPhysRes.isImmune
+        ? 0
+        : Math.max(0, Math.trunc((rawThorns256 * (100 - attackerPhysRes.effectiveRes)) / 100))
+      if (reflected256 > 0) {
+        reflectedPhys256 += reflected256
+        const curHp = attacker.statList.getHp256()
+        attacker.statList.setHp256(Math.max(0, curHp - reflected256))
+      }
+    }
+
     const reactiveDamage = defender.stateBus.triggerReactiveEvents({
       event: 'damagedinmelee',
       incomingPhys256: finalPhys256,
diff --git a/src/game/engine/missile-engine.ts b/src/game/engine/missile-engine.ts
index 2e7fbdc..523f8a6 100644
--- a/src/game/engine/missile-engine.ts
+++ b/src/game/engine/missile-engine.ts
@@ -3968,3 +3968,268 @@ export function calculateCurseEffect(
   }
 }
 
+// =========================================================================
+// Milestone M4: Necromancer Summoning Spells Tree Formulas (1.13c Parity)
+// Skills: 69, 70, 75, 79, 80, 85, 89, 90, 94, 95
+// =========================================================================
+
+export interface SkeletonMasteryStats {
+  readonly skeletonHp: number
+  readonly skeletonDamage: number
+  readonly reviveHpPct: number
+  readonly damagePct: number
+  readonly defense: number
+}
+
+export interface GolemMasteryStats {
+  readonly hpBonusPct: number
+  readonly speedBonusPct: number
+}
+
+export interface ClayGolemStats {
+  readonly slowPct: number
+  readonly baseHp: number
+  readonly hpBonusPct: number
+  readonly attackRatingBonusPct: number
+}
+
+export interface BloodGolemStats {
+  readonly lifeLeechPct: number
+  readonly damageSharePct: number
+  readonly baseHp: number
+  readonly hpBonusPct: number
+}
+
+export interface IronGolemItemProps {
+  readonly baseDamage?: number
+  readonly defense?: number
+  readonly isEthereal?: boolean
+  readonly auras?: number[]
+}
+
+export interface IronGolemStats {
+  readonly thornsReturnPct: number
+  readonly defenseBonus: number
+  readonly baseHp: number
+  readonly hpBonusPct: number
+  readonly inheritedDamage: number
+  readonly inheritedDefense: number
+  readonly inheritedAuras: number[]
+}
+
+export interface FireGolemStats {
+  readonly holyFireAuraLevel: number
+  readonly holyFirePulseDmg: number
+  readonly fireAbsorbPct: number
+  readonly deathExplosionDmg: number
+  readonly baseHp: number
+  readonly hpBonusPct: number
+}
+
+export interface ReviveStats {
+  readonly hpMultiplier: number
+  readonly damageMultiplier: number
+  readonly durationFrames: number
+}
+
+/**
+ * 1.13c Raise Skeleton (Skill 70) and Skeletal Mage (Skill 80) Max Count Formula:
+ * (slvl < 4) ? slvl : (2 + floor(slvl / 3))
+ * Levels: 1->1, 2->2, 3->3, 4->3, 5->3, 6->4, 10->5, 20->8.
+ */
+export function calculateSkeletonMaxCount(slvl: number): number {
+  if (!Number.isFinite(slvl) || slvl <= 0) return 0
+  const lvl = Math.floor(slvl)
+  return lvl < 4 ? lvl : 2 + Math.floor(lvl / 3)
+}
+
+/**
+ * 1.13c Raise Skeletal Mage (Skill 80) Max Count Formula:
+ * Same progression as Raise Skeleton: (slvl < 4) ? slvl : (2 + floor(slvl / 3))
+ */
+export function calculateSkeletalMageMaxCount(slvl: number): number {
+  return calculateSkeletonMaxCount(slvl)
+}
+
+/**
+ * 1.13c Revive (Skill 95) Max Count Formula:
+ * Exactly slvl (1 at lvl 1, 10 at lvl 10, 20 at lvl 20).
+ */
+export function calculateReviveMaxCount(slvl: number): number {
+  if (!Number.isFinite(slvl) || slvl <= 0) return 0
+  return Math.floor(slvl)
+}
+
+/**
+ * 1.13c Skeleton Mastery (Skill 69) Passive Bonuses:
+ * - Flat HP to Skeletons: +8 * slvl
+ * - Flat Dmg to Skeletons & Mages: +2 * slvl
+ * - Life % to Revives: +5% * slvl (par3 = 5)
+ * - Dmg % to Skeletons, Mages, Revives: +10% * slvl (par4 = 10)
+ * - Defense: +10 * slvl
+ */
+export function calculateSkeletonMasteryStats(slvl: number): SkeletonMasteryStats {
+  if (!Number.isFinite(slvl) || slvl <= 0) {
+    return { skeletonHp: 0, skeletonDamage: 0, reviveHpPct: 0, damagePct: 0, defense: 0 }
+  }
+  const lvl = Math.floor(slvl)
+  return {
+    skeletonHp: 8 * lvl,
+    skeletonDamage: 2 * lvl,
+    reviveHpPct: 5 * lvl,
+    damagePct: 10 * lvl,
+    defense: 10 * lvl,
+  }
+}
+
+/**
+ * 1.13c Golem Mastery (Skill 79) Passive Bonuses:
+ * - HP % to all Golems: 20 + (slvl - 1) * 25 % (slvl 1: 20%, 10: 245%, 20: 495%)
+ * - Run/Walk speed %: dm34 curve (slvl 1: 20%, slvl 10: 33%, slvl 20: 36%)
+ */
+export function calculateGolemMasteryStats(slvl: number): GolemMasteryStats {
+  if (!Number.isFinite(slvl) || slvl <= 0) {
+    return { hpBonusPct: 0, speedBonusPct: 0 }
+  }
+  const lvl = Math.floor(slvl)
+  const hpBonusPct = 20 + (lvl - 1) * 25
+  const speedBonusPct = Math.floor(20 + (20 * (lvl - 1)) / (lvl + 5))
+  return { hpBonusPct, speedBonusPct }
+}
+
+/**
+ * 1.13c Summon Resist (Skill 89) Diminishing Passive Resistances:
+ * dm12 curve with Param1=20, Param2=75: computeDiminishingReturns(20, 75, slvl)
+ * slvl 1: 28%, slvl 5: 47%, slvl 10: 57%, slvl 20: 66%, slvl 60: 75%. Hard cap at 75%.
+ */
+export function calculateSummonResistPct(slvl: number): number {
+  if (!Number.isFinite(slvl) || slvl <= 0) return 0
+  const lvl = Math.floor(slvl)
+  const num = 110 * lvl * (75 - 20)
+  const den = 100 * (lvl + 6)
+  return Math.min(75, Math.trunc(num / den) + 20)
+}
+
+/**
+ * 1.13c Clay Golem (Skill 75) Stats & Synergies:
+ * - Slow-on-hit %: Math.min(75, floor(11 + 40 * (slvl - 1) / (slvl + 6)))
+ * - Base HP: 175 + (slvl - 1) * 35
+ * - HP Bonus %: Golem Mastery HP % + Blood Golem synergy (5% per base pt)
+ * - Attack Rating %: 20 + (slvl - 1) * 20
+ */
+export function calculateClayGolemStats(
+  slvl: number,
+  golemMasteryLvl = 0,
+  bloodGolemSynergyLvl = 0,
+): ClayGolemStats {
+  const lvl = Number.isFinite(slvl) ? Math.max(1, Math.floor(slvl)) : 1
+  const gmStats = calculateGolemMasteryStats(golemMasteryLvl)
+  const slowPct = Math.min(75, Math.floor(11 + (40 * (lvl - 1)) / (lvl + 6)))
+  const baseHp = 175 + (lvl - 1) * 35
+  const bloodSyn = Math.max(0, Math.floor(bloodGolemSynergyLvl)) * 5
+  const hpBonusPct = (golemMasteryLvl > 0 ? gmStats.hpBonusPct : 0) + bloodSyn
+  const attackRatingBonusPct = 20 + (lvl - 1) * 20
+  return { slowPct, baseHp, hpBonusPct, attackRatingBonusPct }
+}
+
+/**
+ * 1.13c Blood Golem (Skill 85) Stats:
+ * - Life Link: 70% of damage dealt returned as player healing
+ * - Damage Share: 30% of damage taken transferred to player
+ * - Base HP: 201 + (slvl - 1) * 45
+ * - HP Bonus %: Golem Mastery HP %
+ */
+export function calculateBloodGolemStats(slvl: number, golemMasteryLvl = 0): BloodGolemStats {
+  const lvl = Number.isFinite(slvl) ? Math.max(1, Math.floor(slvl)) : 1
+  const gmStats = calculateGolemMasteryStats(golemMasteryLvl)
+  const baseHp = 201 + (lvl - 1) * 45
+  const hpBonusPct = golemMasteryLvl > 0 ? gmStats.hpBonusPct : 0
+  return {
+    lifeLeechPct: 70,
+    damageSharePct: 30,
+    baseHp,
+    hpBonusPct,
+  }
+}
+
+/**
+ * 1.13c Iron Golem (Skill 90) Stats:
+ * - Innate Thorns reflection: 150 + (slvl - 1) * 15 %
+ * - Defense bonus: (slvl - 1) * 35
+ * - Base HP: 306 + (slvl - 1) * 55
+ * - Inherits metallic weapon/armor item damage, defense, and auras
+ */
+export function calculateIronGolemStats(
+  slvl: number,
+  itemProps?: IronGolemItemProps,
+  golemMasteryLvl = 0,
+): IronGolemStats {
+  const lvl = Number.isFinite(slvl) ? Math.max(1, Math.floor(slvl)) : 1
+  const gmStats = calculateGolemMasteryStats(golemMasteryLvl)
+  const thornsReturnPct = 150 + (lvl - 1) * 15
+  const defenseBonus = (lvl - 1) * 35
+  const baseHp = 306 + (lvl - 1) * 55
+  const hpBonusPct = golemMasteryLvl > 0 ? gmStats.hpBonusPct : 0
+  const inheritedDamage = Math.max(0, itemProps?.baseDamage ?? 0)
+  const inheritedDefense = Math.max(0, itemProps?.defense ?? 0)
+  const inheritedAuras = itemProps?.auras ? [...itemProps.auras] : []
+  return {
+    thornsReturnPct,
+    defenseBonus,
+    baseHp,
+    hpBonusPct,
+    inheritedDamage,
+    inheritedDefense,
+    inheritedAuras,
+  }
+}
+
+/**
+ * 1.13c Fire Golem (Skill 94) Stats:
+ * - Holy Fire aura level: slvl
+ * - Holy Fire radial pulse damage: 2 + slvl * 2
+ * - Fire Absorption: 100% healed by fire damage taken
+ * - Death Explosion: 100 + (slvl - 1) * 20 radial fire damage
+ * - Base HP: 326 + (slvl - 1) * 50
+ */
+export function calculateFireGolemStats(slvl: number, golemMasteryLvl = 0): FireGolemStats {
+  const lvl = Number.isFinite(slvl) ? Math.max(1, Math.floor(slvl)) : 1
+  const gmStats = calculateGolemMasteryStats(golemMasteryLvl)
+  const holyFireAuraLevel = lvl
+  const holyFirePulseDmg = 2 + lvl * 2
+  const fireAbsorbPct = 100
+  const deathExplosionDmg = 100 + (lvl - 1) * 20
+  const baseHp = 326 + (lvl - 1) * 50
+  const hpBonusPct = golemMasteryLvl > 0 ? gmStats.hpBonusPct : 0
+  return {
+    holyFireAuraLevel,
+    holyFirePulseDmg,
+    fireAbsorbPct,
+    deathExplosionDmg,
+    baseHp,
+    hpBonusPct,
+  }
+}
+
+/**
+ * 1.13c Revive (Skill 95) Stats:
+ * - Lifespan: exactly 180 seconds (4500 frames @ 25Hz)
+ * - Base HP multiplier: +200% (+ 5%/lvl Skeleton Mastery) -> 3.0 + skelMastery * 0.05
+ * - Base Damage multiplier: +215% (+ 10%/lvl Skeleton Mastery) -> 3.15 + skelMastery * 0.10
+ */
+export function calculateReviveStats(
+  slvl: number,
+  skeletonMasteryLvl = 0,
+): ReviveStats {
+  const smLvl = Math.max(0, Math.floor(skeletonMasteryLvl))
+  const hpMultiplier = 3.0 + smLvl * 0.05
+  const damageMultiplier = 3.15 + smLvl * 0.10
+  const durationFrames = 4500
+  return {
+    hpMultiplier,
+    damageMultiplier,
+    durationFrames,
+  }
+}
+
+
diff --git a/src/game/engine/summon-manager.ts b/src/game/engine/summon-manager.ts
index 782d770..a180c2b 100644
--- a/src/game/engine/summon-manager.ts
+++ b/src/game/engine/summon-manager.ts
@@ -19,6 +19,17 @@ import { StateBus } from './state-bus.ts'
 import { executeSUnitDmg, type CombatUnitContext } from './combat-pipeline.ts'
 import type { MissileEngine } from './missile-engine.ts'
 import type { AuraScanner } from './aura-scanner.ts'
+import {
+  calculateSummonResistPct,
+  calculateSkeletonMasteryStats,
+  calculateGolemMasteryStats,
+  calculateClayGolemStats,
+  calculateBloodGolemStats,
+  calculateIronGolemStats,
+  calculateFireGolemStats,
+  calculateReviveStats,
+  type IronGolemItemProps,
+} from './missile-engine.ts'
 
 export interface SummonedPetUnit {
   readonly uid: string
@@ -38,11 +49,21 @@ export interface SummonedPetUnit {
   maxHp: number
   shotsRemaining: number
   rageBuffActive: boolean
+  // M4 Necromancer Summoning Properties
+  kind?: 'skeleton' | 'skeleton_mage' | 'clay_golem' | 'blood_golem' | 'iron_golem' | 'fire_golem' | 'revive' | undefined
+  mageElement?: 'fire' | 'cold' | 'lightning' | 'poison' | undefined
+  lifespanTicks?: number | undefined
+  slowPct?: number | undefined
+  lifeLink?: { healCasterPct: number; shareDamagePct: number } | undefined
+  thornsReturnPct?: number | undefined
+  fireAbsorbPct?: number | undefined
+  deathExplosionDmg?: number | undefined
+  inheritedAuras?: number[] | undefined
 }
 
 export interface CreatePetOutcome {
   readonly created: boolean
-  readonly reason?: 'missing_corpse' | 'invalid_skill'
+  readonly reason?: 'missing_corpse' | 'invalid_skill' | 'invalid_item'
   readonly pet?: SummonedPetUnit
   readonly evictedPetUids: string[]
   readonly activeCountForType: number
@@ -66,7 +87,8 @@ export class SummonManager {
     slvl: number
     x?: number
     y?: number
-    corpses?: { id: string; consumed: boolean; baseMaxHp?: number }[]
+    corpses?: { id: string; consumed: boolean; baseMaxHp?: number; isBoss?: boolean }[]
+    ironGolemItem?: IronGolemItemProps
   }): CreatePetOutcome {
     const skill = this.registry.getSkillById(params.skillId)
     if (!skill) {
@@ -75,12 +97,15 @@ export class SummonManager {
 
     // Corpse-consuming Necromancer summons (`Raise Skeleton` 70, `Raise Skeletal Mage` 80, `Revive` 95)
     const requiresCorpse = params.skillId === 70 || params.skillId === 80 || params.skillId === 95
+    let consumedCorpse: { id: string; consumed: boolean; baseMaxHp?: number; isBoss?: boolean } | undefined
     if (requiresCorpse && params.corpses) {
-      const availCorpse = params.corpses.find(c => !c.consumed)
+      // 1.13c Invariant: Boss corpses cannot be used for summons
+      const availCorpse = params.corpses.find(c => !c.consumed && !c.isBoss)
       if (!availCorpse) {
         return { created: false, reason: 'missing_corpse', evictedPetUids: [], activeCountForType: 0 }
       }
       availCorpse.consumed = true
+      consumedCorpse = availCorpse
     }
 
     const petTypeName = (
@@ -93,26 +118,30 @@ export class SummonManager {
     ).toLowerCase()
 
     const petTypeRec = this.registry.getPetType(petTypeName)
+    const isGolemSkill = [75, 85, 90, 94].includes(params.skillId)
     const petGroup =
-      petTypeRec?.group ??
-      ([227, 237, 247].includes(params.skillId)
-        ? 1 // Druid Spirit Wolf / Dire Wolf / Grizzly group
-        : [226, 236, 246].includes(params.skillId)
-          ? 2 // Druid Oak Sage / Wolverine / Barbs spirit group
-          : [222, 231, 241].includes(params.skillId)
-            ? 3 // Druid Vine group
-            : [268, 279].includes(params.skillId)
-              ? 4 // Assassin Shadow Warrior / Master group
-              : 0)
+      isGolemSkill
+        ? 3 // Golem Group 3 exclusivity
+        : (petTypeRec?.group ??
+          ([227, 237, 247].includes(params.skillId)
+            ? 1 // Druid Spirit Wolf / Dire Wolf / Grizzly group
+            : [226, 236, 246].includes(params.skillId)
+              ? 2 // Druid Oak Sage / Wolverine / Barbs spirit group
+              : [222, 231, 241].includes(params.skillId)
+                ? 3 // Druid Vine group
+                : [268, 279].includes(params.skillId)
+                  ? 4 // Assassin Shadow Warrior / Master group
+                  : 0))
 
     const evictedPetUids: string[] = []
 
     // 1. Evict any existing pets in the same `petGroup` (`group > 0`) that have a different `petType`
     // (e.g. summoning Grizzly evicts Spirit Wolves / Dire Wolves; summoning Shadow Master evicts Shadow Warrior)
+    // For Golems (Group 3): Any new Golem evicts any existing Golem!
     if (petGroup > 0) {
       for (let i = this.pets.length - 1; i >= 0; i -= 1) {
         const p = this.pets[i]!
-        if (p.petGroup === petGroup && p.petType !== petTypeName) {
+        if (p.petGroup === petGroup && (p.petType !== petTypeName || isGolemSkill)) {
           evictedPetUids.push(p.uid)
           this.pets.splice(i, 1)
         }
@@ -132,6 +161,12 @@ export class SummonManager {
     let maxPets = 1
     if (petTypeName === 'assassintrap') {
       maxPets = 5 // 1.13c Assassin trap cap = 5 active traps
+    } else if (isGolemSkill) {
+      maxPets = 1 // Golems: exactly 1 active golem
+    } else if (params.skillId === 70 || params.skillId === 80) {
+      maxPets = params.slvl < 4 ? params.slvl : 2 + Math.floor(params.slvl / 3)
+    } else if (params.skillId === 95) {
+      maxPets = Math.max(1, params.slvl)
     } else if (skill.petMax) {
       maxPets = Math.max(1, evaluateCalc(skill.petMax, calcCtx))
     } else if (petTypeRec && petTypeRec.baseMax > 0) {
@@ -154,19 +189,79 @@ export class SummonManager {
     const monRec = this.registry.getMonStats(monId)
     const code = monRec?.code || (petTypeName === 'assassintrap' ? 'lg' : 'sk')
 
-    // Compute 1.13c Skeleton Mastery (`69`) / Golem Mastery (`79`) / Summon Resist (`89`) / Lycanthropy (`224`) bonuses
+    // Compute 1.13c Skeleton Mastery (`69`) / Golem Mastery (`79`) / Summon Resist (`89`) / Synergies
     const skelMasteryLvl = params.owner.statList.getEffectiveSkillLevel(69)
     const golemMasteryLvl = params.owner.statList.getEffectiveSkillLevel(79)
     const summonResLvl = params.owner.statList.getEffectiveSkillLevel(89)
-    const baseHp = (monRec?.maxHP || 150) + params.slvl * 35 + skelMasteryLvl * 16 + golemMasteryLvl * 25
+    const smStats = calculateSkeletonMasteryStats(skelMasteryLvl)
+    const gmStats = calculateGolemMasteryStats(golemMasteryLvl)
+    const sumResPct = calculateSummonResistPct(summonResLvl)
+
+    let kind: SummonedPetUnit['kind']
+    let mageElement: SummonedPetUnit['mageElement']
+    let lifespanTicks: number | undefined
+    let slowPct: number | undefined
+    let lifeLink: SummonedPetUnit['lifeLink']
+    let thornsReturnPct: number | undefined
+    let fireAbsorbPct: number | undefined
+    let deathExplosionDmg: number | undefined
+    let inheritedAuras: number[] | undefined
+
+    let baseHp = (monRec?.maxHP || 150) + params.slvl * 35
+
+    if (params.skillId === 70) {
+      kind = 'skeleton'
+      // Skeletons: (base + 8*skelMastery) * (1 + 10%*skelMastery)
+      const baseSkelHp = (monRec?.maxHP || 21) + params.slvl * 15 + smStats.skeletonHp
+      baseHp = Math.floor(baseSkelHp * (1 + smStats.damagePct / 100))
+    } else if (params.skillId === 80) {
+      kind = 'skeleton_mage'
+      const baseMageHp = (monRec?.maxHP || 21) + params.slvl * 12 + smStats.skeletonHp
+      baseHp = Math.floor(baseMageHp * (1 + smStats.damagePct / 100))
+      const elements: ('fire' | 'cold' | 'lightning' | 'poison')[] = ['fire', 'cold', 'lightning', 'poison']
+      mageElement = elements[this.uidCounter % 4]
+    } else if (params.skillId === 75) {
+      kind = 'clay_golem'
+      const bloodGolemSyn = params.owner.statList.getBaseSkillLevel(85)
+      const clayStats = calculateClayGolemStats(params.slvl, golemMasteryLvl, bloodGolemSyn)
+      slowPct = clayStats.slowPct
+      baseHp = Math.floor(clayStats.baseHp * (1 + clayStats.hpBonusPct / 100))
+    } else if (params.skillId === 85) {
+      kind = 'blood_golem'
+      const bgStats = calculateBloodGolemStats(params.slvl, golemMasteryLvl)
+      lifeLink = { healCasterPct: bgStats.lifeLeechPct, shareDamagePct: bgStats.damageSharePct }
+      baseHp = Math.floor(bgStats.baseHp * (1 + bgStats.hpBonusPct / 100))
+    } else if (params.skillId === 90) {
+      kind = 'iron_golem'
+      const igStats = calculateIronGolemStats(params.slvl, params.ironGolemItem, golemMasteryLvl)
+      thornsReturnPct = igStats.thornsReturnPct
+      inheritedAuras = igStats.inheritedAuras
+      baseHp = Math.floor(igStats.baseHp * (1 + igStats.hpBonusPct / 100))
+    } else if (params.skillId === 94) {
+      kind = 'fire_golem'
+      const fgStats = calculateFireGolemStats(params.slvl, golemMasteryLvl)
+      fireAbsorbPct = fgStats.fireAbsorbPct
+      deathExplosionDmg = fgStats.deathExplosionDmg
+      baseHp = Math.floor(fgStats.baseHp * (1 + fgStats.hpBonusPct / 100))
+    } else if (params.skillId === 95) {
+      kind = 'revive'
+      const revStats = calculateReviveStats(params.slvl, skelMasteryLvl)
+      lifespanTicks = revStats.durationFrames
+      const corpseBaseHp = consumedCorpse?.baseMaxHp ?? 1000
+      baseHp = Math.floor(corpseBaseHp * revStats.hpMultiplier)
+    }
+
     const petStatList = new UnitStatList(this.registry, {
       level: params.owner.statList.getAccruedStat('level'),
       maxhp: baseHp * FIXED_ONE,
       hitpoints: baseHp * FIXED_ONE,
-      fireresist: summonResLvl > 0 ? Math.min(75, 20 + summonResLvl * 3) : 0,
-      lightresist: summonResLvl > 0 ? Math.min(75, 20 + summonResLvl * 3) : 0,
-      coldresist: summonResLvl > 0 ? Math.min(75, 20 + summonResLvl * 3) : 0,
-      poisonresist: summonResLvl > 0 ? Math.min(75, 20 + summonResLvl * 3) : 0,
+      fireresist: sumResPct,
+      lightresist: sumResPct,
+      coldresist: sumResPct,
+      poisonresist: sumResPct,
+      ...(slowPct ? { clay_golem_slow: slowPct } : {}),
+      ...(thornsReturnPct ? { thorns_return_pct: thornsReturnPct } : {}),
+      ...(fireAbsorbPct ? { fire_golem_absorb: fireAbsorbPct } : {}),
     })
     const petStateBus = new StateBus(petStatList, this.registry)
 
@@ -207,6 +302,15 @@ export class SummonManager {
       maxHp: baseHp,
       shotsRemaining: petTypeName === 'assassintrap' ? (params.skillId === 262 ? 5 : 10) : 999,
       rageBuffActive: false,
+      kind,
+      mageElement,
+      lifespanTicks,
+      slowPct,
+      lifeLink,
+      thornsReturnPct,
+      fireAbsorbPct,
+      deathExplosionDmg,
+      inheritedAuras,
     }
 
     this.pets.push(pet)
@@ -246,7 +350,7 @@ export class SummonManager {
     owner: CombatUnitContext
     enemies: readonly CombatUnitContext[]
     enemyPositions: ReadonlyMap<string, { x: number; y: number }>
-    corpses?: { id: string; consumed: boolean; baseMaxHp?: number }[]
+    corpses?: { id: string; consumed: boolean; baseMaxHp?: number; isBoss?: boolean }[]
     missileEngine: MissileEngine
     auraScanner: AuraScanner
   }): {
@@ -264,9 +368,41 @@ export class SummonManager {
     const primaryTarget = aliveEnemies[0]
     const primaryPos = primaryTarget ? (params.enemyPositions.get(primaryTarget.id) ?? { x: 0, y: 120 }) : { x: 0, y: 120 }
 
-    for (const pet of [...this.pets]) {
+    for (let i = this.pets.length - 1; i >= 0; i -= 1) {
+      const pet = this.pets[i]!
       if (pet.hp <= 0 || pet.shotsRemaining <= 0) continue
 
+      // Revive lifespan countdown (180s / 4500 frames)
+      if (pet.lifespanTicks !== undefined) {
+        pet.lifespanTicks -= 1
+        if (pet.lifespanTicks <= 0) {
+          this.pets.splice(i, 1)
+          continue
+        }
+      }
+
+      // Fire Golem Holy Fire pulse every 50 ticks (2.0s)
+      if (pet.kind === 'fire_golem' && params.currentTick % 50 === 0) {
+        const pulseDmg = 2 + pet.slvl * 2
+        for (const enemy of aliveEnemies) {
+          const ePos = params.enemyPositions.get(enemy.id) ?? { x: 0, y: 120 }
+          const dx = ePos.x - pet.x
+          const dy = ePos.y - pet.y
+          // 2:1 isometric ground geometry
+          if (dx * dx + 4 * dy * dy <= 160000) { // 400px radius
+            const out = executeSUnitDmg(params.owner, enemy, {
+              skillId: 94,
+              attackKind: 'spell',
+              elemType: 'fire',
+              elemMin256: pulseDmg * FIXED_ONE,
+              elemMax256: pulseDmg * FIXED_ONE,
+              autoHit: true,
+            })
+            damageDealt += out.totalDamage
+          }
+        }
+      }
+
       // Execute pet's AI sub-skills (`IDs 281..338`)
       for (const subId of pet.subSkillIds) {
         const subSkill = this.registry.getSkillById(subId)
@@ -284,7 +420,7 @@ export class SummonManager {
 
         // Corpse-consuming vines & dire wolves (`307` CorpseCycler, `325` VineCycler, `314` fenris rage)
         if ((subId === 307 || subId === 325 || subId === 314) && params.corpses) {
-          const corpse = params.corpses.find(c => !c.consumed)
+          const corpse = params.corpses.find(c => !c.consumed && !c.isBoss)
           if (corpse) {
             corpse.consumed = true
             corpsesConsumedByPets += 1
@@ -306,7 +442,7 @@ export class SummonManager {
 
         // Death Sentry (`312` `mon death sentry`): explodes an available corpse if present!
         if (subId === 312 && params.corpses) {
-          const corpse = params.corpses.find(c => !c.consumed)
+          const corpse = params.corpses.find(c => !c.consumed && !c.isBoss)
           if (corpse && primaryTarget) {
             corpse.consumed = true
             corpsesConsumedByPets += 1
@@ -340,16 +476,37 @@ export class SummonManager {
             subId === 337 ||
             subId === 338)
         ) {
+          const elem =
+            pet.kind === 'skeleton_mage'
+              ? (pet.mageElement === 'lightning' ? 'ltng' : pet.mageElement === 'poison' ? 'pois' : pet.mageElement ?? 'fire')
+              : subId === 281 || subId === 311 || subId === 337
+                ? 'fire'
+                : 'ltng'
+
           const mslName =
-            subSkill.srvMissile ||
-            subSkill.srvMissileA ||
-            (subId === 281
-              ? 'wake of destruction maker'
-              : subId === 306
-                ? 'chargedbolt'
-                : subId === 311
-                  ? 'inferno1'
-                  : 'sentrylightningbolt')
+            pet.kind === 'skeleton_mage'
+              ? (pet.mageElement === 'cold'
+                  ? 'icebolt'
+                  : pet.mageElement === 'lightning'
+                    ? 'chargedbolt'
+                    : pet.mageElement === 'poison'
+                      ? 'poisonexplosioncloud'
+                      : 'firebolt')
+              : subSkill.srvMissile ||
+                subSkill.srvMissileA ||
+                (subId === 281
+                  ? 'wake of destruction maker'
+                  : subId === 306
+                    ? 'chargedbolt'
+                    : subId === 311
+                      ? 'inferno1'
+                      : 'sentrylightningbolt')
+
+          const skelMastery = calculateSkeletonMasteryStats(params.owner.statList.getEffectiveSkillLevel(69))
+          const mageBonusDmg = pet.kind === 'skeleton_mage' ? skelMastery.skeletonDamage : 0
+          const minElem = (25 + pet.slvl * 12 + mageBonusDmg) * FIXED_ONE
+          const maxElem = (45 + pet.slvl * 18 + mageBonusDmg) * FIXED_ONE
+
           params.missileEngine.spawnMissile({
             missileNameOrId: mslName,
             sourceSkillId: pet.sourceSkillId,
@@ -362,9 +519,9 @@ export class SummonManager {
             dmgPacket: {
               skillId: pet.sourceSkillId,
               attackKind: 'spell',
-              elemType: subId === 281 || subId === 311 || subId === 337 ? 'fire' : 'ltng',
-              elemMin256: (25 + pet.slvl * 12) * FIXED_ONE,
-              elemMax256: (45 + pet.slvl * 18) * FIXED_ONE,
+              elemType: elem,
+              elemMin256: minElem,
+              elemMax256: maxElem,
               autoHit: true,
             },
           })
@@ -384,7 +541,13 @@ export class SummonManager {
         pet.petType !== 'hydra' &&
         params.currentTick % 10 === 0
       ) {
-        const basePetPhys = (20 + pet.slvl * 10) * (pet.rageBuffActive ? 2 : 1) * FIXED_ONE
+        const skelMastery = calculateSkeletonMasteryStats(params.owner.statList.getEffectiveSkillLevel(69))
+        const flatBonus = pet.kind === 'skeleton' ? skelMastery.skeletonDamage : 0
+        const pctBonus = pet.kind === 'skeleton' ? skelMastery.damagePct : 0
+        const basePetPhys = Math.floor(
+          ((20 + pet.slvl * 10 + flatBonus) * (pet.rageBuffActive ? 2 : 1) * (1 + pctBonus / 100)) * FIXED_ONE,
+        )
+
         const out = executeSUnitDmg(params.owner, primaryTarget, {
           skillId: pet.sourceSkillId,
           attackKind: 'melee',
@@ -395,6 +558,25 @@ export class SummonManager {
         })
         damageDealt += out.totalDamage
         petAttacks += 1
+
+        // Clay Golem Slow-on-hit effect against defender
+        if (pet.kind === 'clay_golem' && pet.slowPct) {
+          primaryTarget.stateBus.applyState({
+            stateNameOrId: 'slowed',
+            slvl: pet.slvl,
+            durationFrames: 150,
+            stats: { item_slow: pet.slowPct },
+          })
+        }
+
+        // Blood Golem Life Link healing to player
+        if (pet.kind === 'blood_golem' && pet.lifeLink && out.totalDamage > 0) {
+          const healAmount256 = Math.floor((out.totalDamage * FIXED_ONE * pet.lifeLink.healCasterPct) / 100)
+          const curHp256 = params.owner.statList.getHp256()
+          const maxHp256 = params.owner.statList.getMaxHp256()
+          const newHp256 = Math.min(maxHp256, curHp256 + healAmount256)
+          params.owner.statList.setHp256(newHp256)
+        }
       }
     }
 
@@ -417,3 +599,4 @@ export class SummonManager {
     return this.pets
   }
 }
+
diff --git a/src/game/skills.ts b/src/game/skills.ts
index 9071e53..a0e7f7d 100644
--- a/src/game/skills.ts
+++ b/src/game/skills.ts
@@ -120,6 +120,25 @@ import {
   calculateLowerResistReduction,
   computeImmunityBreak,
   calculateCurseEffect,
+  calculateSkeletonMaxCount,
+  calculateSkeletalMageMaxCount,
+  calculateReviveMaxCount,
+  calculateSkeletonMasteryStats,
+  calculateGolemMasteryStats,
+  calculateSummonResistPct,
+  calculateClayGolemStats,
+  calculateBloodGolemStats,
+  calculateIronGolemStats,
+  calculateFireGolemStats,
+  calculateReviveStats,
+  type SkeletonMasteryStats,
+  type GolemMasteryStats,
+  type ClayGolemStats,
+  type BloodGolemStats,
+  type IronGolemItemProps,
+  type IronGolemStats,
+  type FireGolemStats,
+  type ReviveStats,
   type CurseOpts,
   type CurseSpec,
   type DamageRange,
@@ -219,6 +238,25 @@ export {
   calculateLowerResistReduction,
   computeImmunityBreak,
   calculateCurseEffect,
+  calculateSkeletonMaxCount,
+  calculateSkeletalMageMaxCount,
+  calculateReviveMaxCount,
+  calculateSkeletonMasteryStats,
+  calculateGolemMasteryStats,
+  calculateSummonResistPct,
+  calculateClayGolemStats,
+  calculateBloodGolemStats,
+  calculateIronGolemStats,
+  calculateFireGolemStats,
+  calculateReviveStats,
+  type SkeletonMasteryStats,
+  type GolemMasteryStats,
+  type ClayGolemStats,
+  type BloodGolemStats,
+  type IronGolemItemProps,
+  type IronGolemStats,
+  type FireGolemStats,
+  type ReviveStats,
   type CurseOpts,
   type CurseSpec,
   type DamageRange,
diff --git a/src/scene/act-scene.ts b/src/scene/act-scene.ts
index 8d96862..054b674 100644
--- a/src/scene/act-scene.ts
+++ b/src/scene/act-scene.ts
@@ -46,7 +46,7 @@ import { buildNpcDef, hasPackedSprite } from '../game/npc.ts'
 import { ADDITIVE_OBJECT_TOKENS } from '../game/objects.ts'
 import { npcDialog } from '../game/quests.ts'
 import type { NpcDef } from '../game/quests.ts'
-import { BATCH1_SKILLS, getBatch1SkillDef, isBatch1Skill, getSkillManaCost, calculateSkillDamage, calculateMeteorResidualFireDamage, getMissileTxtData, ISO_GROUND_ASPECT_RATIO, getSkillCastOverlay, isAuraSkill, calculateStaticFieldRadiusPx, calculateStaticFieldDamage, hasLineOfSight, calculateChainLightningJumps, getSkillCooldownTicks, calculateChargedBoltCount, calculateTelekinesisDamage, isTelekinesisItemAllowed, isTelekinesisObjectAllowed, calculateThunderStormDuration, calculateThunderStormInterval, calculateEnergyShieldDuration, calculateEnergyShieldAbsorbPct, calculateFrozenArmorDuration, calculateShiverArmorDuration, calculateChillingArmorDuration, calculateIceBlastFreezeLength, calculateGlacialSpikeFreezeLength, calculateFireWallDamage, calculateBlazeDamage, calculateInfernoDamage, calculateBlazeDuration, calculateBlazePatchDuration, calculateInfernoRangePx, calculateInfernoContinuousMana256, calculateFireWallPatches, calculateEnchantDamage, calculateEnchantAttackRating, calculateEnchantDuration, calculateFireMasteryBonus, calculateTeethDamage, calculateTeethCount, calculateBoneArmorCapacity, calculatePoisonDaggerDamage, calculatePoisonDaggerAttackRatingBonus, calculateCorpseExplosionDamage, calculateCorpseExplosionRadiusPx, calculateBoneWallStats, calculatePoisonExplosionDamage, calculateBoneSpearDamage, calculateBonePrisonStats, calculatePoisonNovaDamage, calculateBoneSpiritDamage, calculateCurseEffect, calculateCurseRadiusPx, calculateCurseDurationFrames, calculateTerrorDistance, calculateIronMaidenReturnPct } from '../game/skills.ts'
+import { BATCH1_SKILLS, getBatch1SkillDef, isBatch1Skill, getSkillManaCost, calculateSkillDamage, calculateMeteorResidualFireDamage, getMissileTxtData, ISO_GROUND_ASPECT_RATIO, getSkillCastOverlay, isAuraSkill, calculateStaticFieldRadiusPx, calculateStaticFieldDamage, hasLineOfSight, calculateChainLightningJumps, getSkillCooldownTicks, calculateChargedBoltCount, calculateTelekinesisDamage, isTelekinesisItemAllowed, isTelekinesisObjectAllowed, calculateThunderStormDuration, calculateThunderStormInterval, calculateEnergyShieldDuration, calculateEnergyShieldAbsorbPct, calculateFrozenArmorDuration, calculateShiverArmorDuration, calculateChillingArmorDuration, calculateIceBlastFreezeLength, calculateGlacialSpikeFreezeLength, calculateFireWallDamage, calculateBlazeDamage, calculateInfernoDamage, calculateBlazeDuration, calculateBlazePatchDuration, calculateInfernoRangePx, calculateInfernoContinuousMana256, calculateFireWallPatches, calculateEnchantDamage, calculateEnchantAttackRating, calculateEnchantDuration, calculateFireMasteryBonus, calculateTeethDamage, calculateTeethCount, calculateBoneArmorCapacity, calculatePoisonDaggerDamage, calculatePoisonDaggerAttackRatingBonus, calculateCorpseExplosionDamage, calculateCorpseExplosionRadiusPx, calculateBoneWallStats, calculatePoisonExplosionDamage, calculateBoneSpearDamage, calculateBonePrisonStats, calculatePoisonNovaDamage, calculateBoneSpiritDamage, calculateCurseEffect, calculateCurseRadiusPx, calculateCurseDurationFrames, calculateTerrorDistance, calculateIronMaidenReturnPct, calculateSkeletonMaxCount, calculateSkeletalMageMaxCount, calculateReviveMaxCount } from '../game/skills.ts'
 import type { Projectile, ActiveOverlay } from '../game/skills.ts'
 import { findSafeDropPosition, calculateBounceHeight, triggerFlippyBounce, type GroundItemEntity } from '../game/ground-items.ts'
 import {
@@ -1188,7 +1188,7 @@ export function getSkillRange(
 export function getSkillMana(skillId: number, hudManager?: HudManager | null): number {
   if (skillId === 0) return 0
   if (hudManager !== null && hudManager !== undefined) {
-    const entry = hudManager.hotkeys.availableSkills.find(s => s.skillId === skillId)
+    const entry = hudManager.hotkeys?.availableSkills?.find(s => s.skillId === skillId)
     if (entry !== undefined) return entry.manaCost
   }
   if (isBatch1Skill(skillId)) {
@@ -2331,6 +2331,103 @@ export function castSkill(
     return true
   }
 
+  // Necromancer Summoning Spells Tree: 69 (Mastery), 70 (Raise Skeleton), 75 (Clay Golem),
+  // 79 (Golem Mastery), 80 (Raise Skeletal Mage), 85 (Blood Golem), 89 (Summon Resist),
+  // 90 (Iron Golem), 94 (Fire Golem), 95 (Revive)
+  if ([69, 70, 75, 79, 80, 85, 89, 90, 94, 95].includes(skillId)) {
+    const slvl = Math.max(1, (hudManager as any)?.getSkillLevel?.(skillId) ?? 1)
+
+    // Passive skills (69, 79, 89)
+    if (skillId === 69) {
+      status.textContent = `支配骷髅（等级 ${slvl}）：被动提升骷髅与复活怪物的生命与伤害`
+      return true
+    }
+    if (skillId === 79) {
+      status.textContent = `支配石魔（等级 ${slvl}）：被动提升石魔的生命与移动速度`
+      return true
+    }
+    if (skillId === 89) {
+      status.textContent = `召唤物抗性（等级 ${slvl}）：被动提升所有召唤物的元素抗性`
+      return true
+    }
+
+    // Corpse-consuming summons: Raise Skeleton (70), Skeletal Mage (80), Revive (95)
+    if (skillId === 70 || skillId === 80 || skillId === 95) {
+      let targetCorpse: Monster | null = null
+      let bestCorpseDist = 80 // 80px range
+      for (const monster of engine.world.monsters) {
+        if (monster.state !== 'dead' && monster.hp > 0) continue
+        if ((monster as any).corpseConsumed) continue
+        if ((monster.stats as any)?.isBoss || (monster.stats as any)?.type === 'boss') continue
+        const d = Math.hypot(monster.x - targetX, (monster.y - targetY) / ISO_GROUND_ASPECT_RATIO)
+        if (d <= bestCorpseDist) {
+          bestCorpseDist = d
+          targetCorpse = monster
+        }
+      }
+
+      if (!targetCorpse) {
+        status.textContent = '需要未被消耗的怪物尸体（非首领）！'
+        return false
+      }
+
+      ;(targetCorpse as any).corpseConsumed = true
+      targetCorpse.corpseTicks = 0
+
+      // Spawn authentic summon cast overlay
+      engine.spawnOverlay('bonecast', { x: targetCorpse.x, y: targetCorpse.y })
+
+      player.cooldown = 0
+      engine.metrics.casts += 1
+
+      if (skillId === 70) {
+        const maxSkel = calculateSkeletonMaxCount(slvl)
+        status.textContent = `复生骷髅（等级 ${slvl}，上限 ${maxSkel} 只）召唤成功`
+      } else if (skillId === 80) {
+        const maxMage = calculateSkeletalMageMaxCount(slvl)
+        status.textContent = `复生骷髅法师（等级 ${slvl}，上限 ${maxMage} 只）召唤成功`
+      } else {
+        const maxRevive = calculateReviveMaxCount(slvl)
+        status.textContent = `重生（等级 ${slvl}，上限 ${maxRevive} 只，持续 180 秒）召唤成功`
+      }
+      return true
+    }
+
+    // Golems: Clay (75), Blood (85), Iron (90), Fire (94)
+    if (skillId === 90) {
+      // Iron Golem requires metallic item
+      engine.spawnOverlay('bonecast', { x: targetX, y: targetY })
+      player.cooldown = 0
+      engine.metrics.casts += 1
+      status.textContent = `钢铁石魔（等级 ${slvl}，继承装备属性与反伤）召唤成功`
+      return true
+    }
+
+    if (skillId === 75) {
+      engine.spawnOverlay('bonecast', { x: targetX, y: targetY })
+      player.cooldown = 0
+      engine.metrics.casts += 1
+      status.textContent = `粘土石魔（等级 ${slvl}，附带减速攻击与受击减速）召唤成功`
+      return true
+    }
+
+    if (skillId === 85) {
+      engine.spawnOverlay('bonecast', { x: targetX, y: targetY })
+      player.cooldown = 0
+      engine.metrics.casts += 1
+      status.textContent = `鲜血石魔（等级 ${slvl}，附带 70% 生命链接与伤害分担）召唤成功`
+      return true
+    }
+
+    if (skillId === 94) {
+      engine.spawnOverlay('bonecast', { x: targetX, y: targetY })
+      player.cooldown = 0
+      engine.metrics.casts += 1
+      status.textContent = `火焰石魔（等级 ${slvl}，附带圣火脉冲与火焰吸收）召唤成功`
+      return true
+    }
+  }
+
   // Projectile Skills
   let speed = 450
   let range = 450
diff --git a/tests/skills/nec/adv-summoning-stress.test.ts b/tests/skills/nec/adv-summoning-stress.test.ts
new file mode 100644
index 0000000..eb9653e
--- /dev/null
+++ b/tests/skills/nec/adv-summoning-stress.test.ts
@@ -0,0 +1,429 @@
+/**
+ * Adversarial Challenger Stress & Boundary Suite: Necromancer Summoning Spells Tree
+ * Milestone M4: Skills 69, 70, 75, 79, 80, 85, 89, 90, 94, 95 (1.13c Ground Truth)
+ *
+ * Verifies:
+ * 1. Rapid multi-summon stress testing (pet cap enforcement under burst casting).
+ * 2. Golem mutual exclusivity stress (switching between 4 golems across 100 iterations leaves exactly 1 golem active).
+ * 3. Corpse depletion stress (fails cast cleanly when corpses are exhausted or boss corpses are targeted).
+ * 4. Revive expiration stress (exactly 4500 frames ticks down and despawns minion).
+ * 5. Blood Golem life link stress (heals damaged player without exceeding maxHp).
+ * 6. Fire Golem fire absorption stress (healed by large fire attacks instead of taking damage).
+ * 7. 2:1 isometric ground geometry verification for minion following and radial Holy Fire pulses.
+ * 8. ActScene summon casting lifecycle, corpse consumption, and overlay creation.
+ */
+import { describe, expect, it, beforeEach } from 'vitest'
+import {
+  ISO_GROUND_ASPECT_RATIO,
+  calculateSkeletonMaxCount,
+  calculateSkeletalMageMaxCount,
+  calculateReviveMaxCount,
+  calculateSkeletonMasteryStats,
+  calculateGolemMasteryStats,
+  calculateSummonResistPct,
+  calculateClayGolemStats,
+  calculateBloodGolemStats,
+  calculateIronGolemStats,
+  calculateFireGolemStats,
+  calculateReviveStats,
+} from '../../../src/game/skills.ts'
+import {
+  executeSUnitDmg,
+  type CombatUnitContext,
+} from '../../../src/game/engine/combat-pipeline.ts'
+import { FIXED_ONE, UnitStatList } from '../../../src/game/engine/stat-list.ts'
+import { StateBus } from '../../../src/game/engine/state-bus.ts'
+import { getSharedDataRegistry } from '../../../src/game/engine/data-registry.ts'
+import { SummonManager } from '../../../src/game/engine/summon-manager.ts'
+import { MissileEngine } from '../../../src/game/engine/missile-engine.ts'
+import { AuraScanner } from '../../../src/game/engine/aura-scanner.ts'
+import { GameEngine, type GameEngineOptions } from '../../../src/game/engine.ts'
+import { castSkill } from '../../../src/scene/act-scene.ts'
+import type { Monster } from '../../../src/game/combat.ts'
+
+describe('Adversarial Challenger: Necromancer Summoning Stress & Boundary Suite', () => {
+  let engine: GameEngine
+  let statusElem: HTMLElement
+  const dummyTerrain: any = { widthPx: 1000, heightPx: 1000, overlap: () => 0 }
+
+  beforeEach(() => {
+    const dummyOpts: GameEngineOptions = {
+      spawn: { x: 200, y: 200 },
+      stats: [],
+      xpTable: [0, 100],
+      itemBases: [],
+      prefixAffixes: [],
+      suffixAffixes: [],
+      skills: [],
+      npcDefs: [],
+      questDefs: [],
+      monsterCount: 0,
+      combatOptions: {
+        playerSpeed: 100,
+        playerReach: 50,
+        playerCooldownTicks: 0,
+        playerDamage: 25,
+        playerManaPerAttack: 0,
+        respawnTicks: 100,
+      },
+      talkRadius: 80,
+      pickupRadius: 40,
+      inventoryCols: 10,
+      inventoryRows: 4,
+    }
+    engine = new GameEngine(dummyTerrain, dummyOpts)
+    engine.world.player.x = 200
+    engine.world.player.y = 200
+    engine.world.player.cooldown = 0
+    engine.world.player.mana = 5000
+    statusElem = { textContent: '' } as any
+  })
+
+  // =========================================================================
+  // 1. Rapid Multi-Summon Stress (Pet Cap FIFO Enforcement)
+  // =========================================================================
+  describe('1. Rapid Multi-Summon Stress (Pet Cap FIFO Enforcement)', () => {
+    it('strictly maintains exact pet cap under 50 burst summon requests', async () => {
+      const registry = await getSharedDataRegistry()
+      const sm = new SummonManager(registry)
+      const stats = new UnitStatList(registry)
+      const owner: CombatUnitContext = {
+        id: 'player',
+        name: 'Necro',
+        statList: stats,
+        stateBus: new StateBus(stats, registry),
+      }
+
+      // At slvl 20, max skeleton count is 8
+      const maxCount = calculateSkeletonMaxCount(20)
+      expect(maxCount).toBe(8)
+
+      // Provide 50 corpses
+      const corpses = Array.from({ length: 50 }, (_, i) => ({
+        id: `corpse-${i}`,
+        consumed: false,
+        baseMaxHp: 500,
+        isBoss: false,
+      }))
+
+      for (let i = 0; i < 50; i++) {
+        const res = sm.createPet({ owner, skillId: 70, slvl: 20, corpses })
+        expect(res.created).toBe(true)
+        const active = sm.getActivePets().filter(p => p.petType === 'skeleton')
+        expect(active.length).toBeLessThanOrEqual(maxCount)
+      }
+
+      const finalSkeletons = sm.getActivePets().filter(p => p.petType === 'skeleton')
+      expect(finalSkeletons.length).toBe(maxCount)
+      // Exactly 50 corpses should have been consumed
+      expect(corpses.filter(c => c.consumed).length).toBe(50)
+    })
+  })
+
+  // =========================================================================
+  // 2. Golem Mutual Exclusivity Stress
+  // =========================================================================
+  describe('2. Golem Mutual Exclusivity Stress', () => {
+    it('rapidly alternates across Clay, Blood, Iron, Fire Golem for 100 cycles with exactly 1 active golem', async () => {
+      const registry = await getSharedDataRegistry()
+      const sm = new SummonManager(registry)
+      const stats = new UnitStatList(registry)
+      const owner: CombatUnitContext = {
+        id: 'player',
+        name: 'Necro',
+        statList: stats,
+        stateBus: new StateBus(stats, registry),
+      }
+
+      const golemSkillIds = [75, 85, 90, 94]
+      for (let i = 0; i < 100; i++) {
+        const skillId = golemSkillIds[i % 4]!
+        const res = sm.createPet({ owner, skillId, slvl: 10 })
+        expect(res.created).toBe(true)
+
+        const activeGolems = sm.getActivePets().filter(p => p.petGroup === 3)
+        expect(activeGolems.length).toBe(1)
+      }
+
+      expect(sm.getActivePets().length).toBe(1)
+      expect(sm.getActivePets()[0]!.petGroup).toBe(3)
+    })
+  })
+
+  // =========================================================================
+  // 3. Corpse Depletion & Boss Rejection Stress
+  // =========================================================================
+  describe('3. Corpse Depletion & Boss Rejection Stress', () => {
+    it('fails to summon and rejects cast cleanly when corpses run out or are bosses', async () => {
+      const registry = await getSharedDataRegistry()
+      const sm = new SummonManager(registry)
+      const stats = new UnitStatList(registry)
+      const owner: CombatUnitContext = {
+        id: 'player',
+        name: 'Necro',
+        statList: stats,
+        stateBus: new StateBus(stats, registry),
+      }
+
+      const mixedCorpses = [
+        { id: 'corpse-1', consumed: false, baseMaxHp: 500, isBoss: false },
+        { id: 'boss-1', consumed: false, baseMaxHp: 5000, isBoss: true },
+        { id: 'corpse-2', consumed: false, baseMaxHp: 500, isBoss: false },
+      ]
+
+      // Cast 1 -> consumes corpse-1
+      const res1 = sm.createPet({ owner, skillId: 80, slvl: 1, corpses: mixedCorpses })
+      expect(res1.created).toBe(true)
+      expect(mixedCorpses[0]!.consumed).toBe(true)
+
+      // Cast 2 -> skips boss-1, consumes corpse-2
+      const res2 = sm.createPet({ owner, skillId: 80, slvl: 1, corpses: mixedCorpses })
+      expect(res2.created).toBe(true)
+      expect(mixedCorpses[1]!.consumed).toBe(false) // Boss untouched
+      expect(mixedCorpses[2]!.consumed).toBe(true)
+
+      // Cast 3 -> only boss remains -> fails cast
+      const res3 = sm.createPet({ owner, skillId: 80, slvl: 1, corpses: mixedCorpses })
+      expect(res3.created).toBe(false)
+      expect(res3.reason).toBe('missing_corpse')
+      expect(mixedCorpses[1]!.consumed).toBe(false)
+    })
+  })
+
+  // =========================================================================
+  // 4. Revive Lifespan Countdown Stress
+  // =========================================================================
+  describe('4. Revive Lifespan Countdown Stress', () => {
+    it('counts down exactly 4500 frames (180.0s @ 25Hz) and cleanly removes minion', async () => {
+      const registry = await getSharedDataRegistry()
+      const sm = new SummonManager(registry)
+      const stats = new UnitStatList(registry)
+      const owner: CombatUnitContext = {
+        id: 'player',
+        name: 'Necro',
+        statList: stats,
+        stateBus: new StateBus(stats, registry),
+      }
+
+      const corpses = [{ id: 'corpse-revive', consumed: false, baseMaxHp: 1200, isBoss: false }]
+      const res = sm.createPet({ owner, skillId: 95, slvl: 5, corpses })
+      expect(res.created).toBe(true)
+
+      const pet = res.pet!
+      expect(pet.lifespanTicks).toBe(4500)
+
+      const me = new MissileEngine(registry)
+      const auraScanner = new AuraScanner(registry)
+
+      // Fast forward 4499 ticks
+      pet.lifespanTicks = 2
+      sm.tickPets({
+        currentTick: 1,
+        owner,
+        enemies: [],
+        enemyPositions: new Map(),
+        missileEngine: me,
+        auraScanner,
+      })
+      expect(sm.getActivePets().length).toBe(1)
+      expect(pet.lifespanTicks).toBe(1)
+
+      // Next tick reaches 0 -> minion despawns
+      sm.tickPets({
+        currentTick: 2,
+        owner,
+        enemies: [],
+        enemyPositions: new Map(),
+        missileEngine: me,
+        auraScanner,
+      })
+      expect(sm.getActivePets().length).toBe(0)
+    })
+  })
+
+  // =========================================================================
+  // 5. Blood Golem Life Link Healing Stress
+  // =========================================================================
+  describe('5. Blood Golem Life Link Healing Stress', () => {
+    it('heals heavily damaged player on high damage strikes without exceeding maxHp', async () => {
+      const registry = await getSharedDataRegistry()
+      const sm = new SummonManager(registry)
+      const stats = new UnitStatList(registry, { maxhp: 1000 * FIXED_ONE, hitpoints: 100 * FIXED_ONE })
+      const owner: CombatUnitContext = {
+        id: 'player',
+        name: 'Necro',
+        statList: stats,
+        stateBus: new StateBus(stats, registry),
+      }
+
+      sm.createPet({ owner, skillId: 85, slvl: 20 })
+      const dummyStats = new UnitStatList(registry, { maxhp: 20000 * FIXED_ONE, hitpoints: 20000 * FIXED_ONE })
+      const enemy: CombatUnitContext = {
+        id: 'enemy-1',
+        name: 'Boss Dummy',
+        statList: dummyStats,
+        stateBus: new StateBus(dummyStats, registry),
+      }
+      const enemyPositions = new Map([['enemy-1', { x: 20, y: 60 }]])
+
+      const me = new MissileEngine(registry)
+      const auraScanner = new AuraScanner(registry)
+
+      // Perform 5 melee cycles
+      for (let tick = 10; tick <= 50; tick += 10) {
+        sm.tickPets({
+          currentTick: tick,
+          owner,
+          enemies: [enemy],
+          enemyPositions,
+          missileEngine: me,
+          auraScanner,
+        })
+      }
+
+      // Player life should be restored and never exceed maxHp (1000)
+      expect(owner.statList.getHp()).toBeGreaterThan(100)
+      expect(owner.statList.getHp()).toBeLessThanOrEqual(1000)
+    })
+  })
+
+  // =========================================================================
+  // 6. Fire Golem Fire Absorption Stress
+  // =========================================================================
+  describe('6. Fire Golem Fire Absorption Stress', () => {
+    it('converts incoming massive fire damage to 100% healing', async () => {
+      const registry = await getSharedDataRegistry()
+      const sm = new SummonManager(registry)
+      const ownerStats = new UnitStatList(registry)
+      const owner: CombatUnitContext = {
+        id: 'player',
+        name: 'Necro',
+        statList: ownerStats,
+        stateBus: new StateBus(ownerStats, registry),
+      }
+
+      const res = sm.createPet({ owner, skillId: 94, slvl: 10 })
+      const golem = res.pet!
+      // Set golem HP to half
+      const maxHp256 = golem.statList.getMaxHp256()
+      golem.statList.setHp256(Math.trunc(maxHp256 / 2))
+      const halfHp = golem.statList.getHp()
+
+      const attackerStats = new UnitStatList(registry)
+      const attacker: CombatUnitContext = {
+        id: 'fire_mage',
+        name: 'Fire Monster',
+        statList: attackerStats,
+        stateBus: new StateBus(attackerStats, registry),
+      }
+
+      const golemContext: CombatUnitContext = {
+        id: golem.uid,
+        name: 'Fire Golem',
+        statList: golem.statList,
+        stateBus: golem.stateBus,
+        unitType: 'minion',
+      }
+
+      // Hit golem with 200 fire damage
+      const out = executeSUnitDmg(attacker, golemContext, {
+        skillId: 0,
+        attackKind: 'spell',
+        elemType: 'fire',
+        elemMin256: 200 * FIXED_ONE,
+        elemMax256: 200 * FIXED_ONE,
+        autoHit: true,
+      })
+
+      // Damage dealt should be 0 because of absorption, and golem should be healed
+      expect(out.totalDamage).toBe(0)
+      expect(golem.statList.getHp()).toBeGreaterThan(halfHp)
+    })
+  })
+
+  // =========================================================================
+  // 7. 2:1 Isometric Ground Geometry Alignment
+  // =========================================================================
+  describe('7. 2:1 Isometric Ground Geometry Alignment', () => {
+    it('evaluates distance along dx^2 + 4*dy^2 <= r^2 for Holy Fire radial pulse', () => {
+      const radiusPx = 400
+      const pet = { x: 200, y: 200 }
+
+      // Point at (400, 200) -> dx = 200, dy = 0 -> 200^2 + 0 = 40000 <= 160000 (IN)
+      const p1 = { x: 400, y: 200 }
+      const d1 = (p1.x - pet.x) ** 2 + 4 * (p1.y - pet.y) ** 2
+      expect(d1).toBeLessThanOrEqual(radiusPx ** 2)
+
+      // Point at (200, 300) -> dx = 0, dy = 100 -> 0 + 4*100^2 = 40000 <= 160000 (IN)
+      const p2 = { x: 200, y: 300 }
+      const d2 = (p2.x - pet.x) ** 2 + 4 * (p2.y - pet.y) ** 2
+      expect(d2).toBeLessThanOrEqual(radiusPx ** 2)
+
+      // Point at (200, 450) -> dx = 0, dy = 250 -> 4 * 62500 = 250000 > 160000 (OUT)
+      const p3 = { x: 200, y: 450 }
+      const d3 = (p3.x - pet.x) ** 2 + 4 * (p3.y - pet.y) ** 2
+      expect(d3).toBeGreaterThan(radiusPx ** 2)
+    })
+  })
+
+  // =========================================================================
+  // 8. ActScene Summon Casting Lifecycle
+  // =========================================================================
+  describe('8. ActScene Summon Casting Lifecycle', () => {
+    it('executes Raise Skeleton cast with corpse validation and visual overlay in ActScene', () => {
+      // Spawn dead monster corpse in world
+      const deadMonster: Monster = {
+        index: 0,
+        x: 230,
+        y: 215,
+        hp: 0,
+        cooldown: 0,
+        hitFlash: 0,
+        corpseTicks: 0,
+        state: 'dead',
+        facing: 0,
+        stats: { id: 'fallen_0', name: 'Fallen', hp: 500, damage: 10, cooldownTicks: 10, reach: 20, aggroRadius: 100, speed: 2, xp: 5 },
+      }
+      engine.world.monsters = [deadMonster]
+
+      const hudManager = {
+        getSkillLevel: (_id: number) => 10,
+        syncPublishedState: () => {},
+        mana: 1000,
+      }
+
+      const dummyRuntime: any = { map: null }
+      const res = castSkill(70, 230, 215, {
+        engine,
+        runtime: dummyRuntime,
+        hudManager: hudManager as any,
+        status: statusElem,
+      })
+
+      expect(res).toBe(true)
+      expect((deadMonster as any).corpseConsumed).toBe(true)
+      expect(statusElem.textContent).toContain('复生骷髅（等级 10，上限 5 只）召唤成功')
+      expect(engine.overlays.some(o => o.overlayName === 'bonecast')).toBe(true)
+    })
+
+    it('rejects Raise Skeleton in ActScene when no corpse is nearby', () => {
+      engine.world.monsters = []
+      const hudManager = {
+        getSkillLevel: (_id: number) => 1,
+        syncPublishedState: () => {},
+        mana: 1000,
+      }
+      const dummyRuntime: any = { map: null }
+
+      const res = castSkill(70, 200, 200, {
+        engine,
+        runtime: dummyRuntime,
+        hudManager: hudManager as any,
+        status: statusElem,
+      })
+
+      expect(res).toBe(false)
+      expect(statusElem.textContent).toContain('需要未被消耗的怪物尸体')
+    })
+  })
+})
diff --git a/tests/skills/nec/summoning.test.ts b/tests/skills/nec/summoning.test.ts
new file mode 100644
index 0000000..ce47511
--- /dev/null
+++ b/tests/skills/nec/summoning.test.ts
@@ -0,0 +1,492 @@
+/**
+ * Diablo II: Lord of Destruction v1.13c — Necromancer Summoning Spells Tree Verification Suite
+ * Milestone M4: Skills 69, 70, 75, 79, 80, 85, 89, 90, 94, 95
+ *
+ * Verifies:
+ * 1. Architecture invariants:
+ *    - BATCH1_SKILLS length strictly 38.
+ *    - ISO_GROUND_ASPECT_RATIO = 0.5.
+ *    - Decoupled standalone summon formulas.
+ *    - calculateSkillDamage returns { min: 0, max: 0 } for all 10 summoning skills.
+ * 2. Skeleton Mastery (69): flat HP, flat damage, life %, dmg %, defense scaling.
+ * 3. Raise Skeleton (70): max count formula ((slvl < 4) ? slvl : 2 + floor(slvl/3)), corpse requirement.
+ * 4. Clay Golem (75): Golem Group 3 exclusivity, slow-on-hit effect against targets and melee attackers.
+ * 5. Golem Mastery (79): passive HP % (20% + 25%/lvl) and run/walk speed bonuses.
+ * 6. Raise Skeletal Mage (80): max count matching warriors, 4 elemental types, ranged elemental missile firing.
+ * 7. Blood Golem (85): 70% life link healing on damage dealt, damage sharing with player.
+ * 8. Summon Resist (89): diminishing passive elemental & poison resistances (dm56(28, 75)) capped at 75%.
+ * 9. Iron Golem (90): consumes metallic item, inherits properties, innate Thorns reflection (150% + 15%/lvl).
+ * 10. Fire Golem (94): Holy Fire pulse aura every 50 ticks, fire absorption healing, Fire Nova death explosion.
+ * 11. Revive (95): max count = slvl, copies target monster stats with +200% HP and +215% damage, 180s (4500 frames) lifespan timer.
+ */
+import { describe, expect, it } from 'vitest'
+import {
+  BATCH1_SKILLS,
+  calculateSkillDamage,
+  ISO_GROUND_ASPECT_RATIO,
+  calculateSkeletonMaxCount,
+  calculateSkeletalMageMaxCount,
+  calculateReviveMaxCount,
+  calculateSkeletonMasteryStats,
+  calculateGolemMasteryStats,
+  calculateSummonResistPct,
+  calculateClayGolemStats,
+  calculateBloodGolemStats,
+  calculateIronGolemStats,
+  calculateFireGolemStats,
+  calculateReviveStats,
+} from '../../../src/game/skills.ts'
+import {
+  executeSUnitDmg,
+  type CombatUnitContext,
+} from '../../../src/game/engine/combat-pipeline.ts'
+import { FIXED_ONE, UnitStatList } from '../../../src/game/engine/stat-list.ts'
+import { StateBus } from '../../../src/game/engine/state-bus.ts'
+import { getSharedDataRegistry } from '../../../src/game/engine/data-registry.ts'
+import { SummonManager } from '../../../src/game/engine/summon-manager.ts'
+import { MissileEngine } from '../../../src/game/engine/missile-engine.ts'
+import { AuraScanner } from '../../../src/game/engine/aura-scanner.ts'
+
+describe('Milestone M4: Necromancer Summoning Spells Tree (1.13c Ground Truth)', () => {
+  // =========================================================================
+  // 1. Architecture Invariants
+  // =========================================================================
+  describe('1. Architecture Invariants', () => {
+    it('preserves BATCH1_SKILLS length strictly at 38 skills', () => {
+      expect(Object.keys(BATCH1_SKILLS).length).toBe(38)
+    })
+
+    it('enforces ISO_GROUND_ASPECT_RATIO === 0.5', () => {
+      expect(ISO_GROUND_ASPECT_RATIO).toBe(0.5)
+    })
+
+    it('returns { min: 0, max: 0 } from calculateSkillDamage for all 10 summoning skills', () => {
+      const summonSkillIds = [69, 70, 75, 79, 80, 85, 89, 90, 94, 95]
+      for (const id of summonSkillIds) {
+        const dmg = calculateSkillDamage(id, 20)
+        expect(dmg).toEqual({ min: 0, max: 0 })
+      }
+    })
+  })
+
+  // =========================================================================
+  // 2. Skeleton Mastery (Skill 69)
+  // =========================================================================
+  describe('2. Skeleton Mastery (Skill 69)', () => {
+    it('calculates flat HP, flat damage, revive HP %, damage %, and defense at slvl 1, 10, 20', () => {
+      const sm1 = calculateSkeletonMasteryStats(1)
+      expect(sm1.skeletonHp).toBe(8)
+      expect(sm1.skeletonDamage).toBe(2)
+      expect(sm1.reviveHpPct).toBe(5)
+      expect(sm1.damagePct).toBe(10)
+      expect(sm1.defense).toBe(10)
+
+      const sm10 = calculateSkeletonMasteryStats(10)
+      expect(sm10.skeletonHp).toBe(80)
+      expect(sm10.skeletonDamage).toBe(20)
+      expect(sm10.reviveHpPct).toBe(50)
+      expect(sm10.damagePct).toBe(100)
+      expect(sm10.defense).toBe(100)
+
+      const sm20 = calculateSkeletonMasteryStats(20)
+      expect(sm20.skeletonHp).toBe(160)
+      expect(sm20.skeletonDamage).toBe(40)
+      expect(sm20.reviveHpPct).toBe(100)
+      expect(sm20.damagePct).toBe(200)
+      expect(sm20.defense).toBe(200)
+    })
+  })
+
+  // =========================================================================
+  // 3. Raise Skeleton (Skill 70)
+  // =========================================================================
+  describe('3. Raise Skeleton (Skill 70)', () => {
+    it('calculates exact 1.13c max skeleton count formula', () => {
+      expect(calculateSkeletonMaxCount(1)).toBe(1)
+      expect(calculateSkeletonMaxCount(2)).toBe(2)
+      expect(calculateSkeletonMaxCount(3)).toBe(3)
+      expect(calculateSkeletonMaxCount(4)).toBe(3)
+      expect(calculateSkeletonMaxCount(5)).toBe(3)
+      expect(calculateSkeletonMaxCount(6)).toBe(4)
+      expect(calculateSkeletonMaxCount(9)).toBe(5)
+      expect(calculateSkeletonMaxCount(10)).toBe(5)
+      expect(calculateSkeletonMaxCount(20)).toBe(8)
+    })
+
+    it('requires and synchronously consumes an unconsumed non-boss corpse', async () => {
+      const registry = await getSharedDataRegistry()
+      const sm = new SummonManager(registry)
+      const stats = new UnitStatList(registry)
+      const owner: CombatUnitContext = {
+        id: 'player',
+        name: 'Necro',
+        statList: stats,
+        stateBus: new StateBus(stats, registry),
+      }
+
+      // No corpses available -> fails with 'missing_corpse'
+      const failRes = sm.createPet({
+        owner,
+        skillId: 70,
+        slvl: 1,
+        corpses: [],
+      })
+      expect(failRes.created).toBe(false)
+      expect(failRes.reason).toBe('missing_corpse')
+
+      // Boss corpse available -> fails
+      const bossCorpse = [{ id: 'corpse-boss', consumed: false, baseMaxHp: 5000, isBoss: true }]
+      const failBoss = sm.createPet({
+        owner,
+        skillId: 70,
+        slvl: 1,
+        corpses: bossCorpse,
+      })
+      expect(failBoss.created).toBe(false)
+      expect(failBoss.reason).toBe('missing_corpse')
+      expect(bossCorpse[0]!.consumed).toBe(false)
+
+      // Valid corpse available -> succeeds and marks corpse consumed
+      const validCorpse = [{ id: 'corpse-1', consumed: false, baseMaxHp: 500, isBoss: false }]
+      const successRes = sm.createPet({
+        owner,
+        skillId: 70,
+        slvl: 1,
+        corpses: validCorpse,
+      })
+      expect(successRes.created).toBe(true)
+      expect(validCorpse[0]!.consumed).toBe(true)
+      expect(successRes.pet?.kind).toBe('skeleton')
+    })
+  })
+
+  // =========================================================================
+  // 4. Clay Golem (Skill 75)
+  // =========================================================================
+  describe('4. Clay Golem (Skill 75)', () => {
+    it('evaluates slow percentage and base HP with synergies', () => {
+      const c1 = calculateClayGolemStats(1, 0, 0)
+      expect(c1.slowPct).toBe(11)
+      expect(c1.baseHp).toBe(175)
+
+      const c10 = calculateClayGolemStats(10, 0, 0)
+      expect(c10.slowPct).toBe(33) // 11 + floor(40*9/16) = 11 + 22 = 33
+      expect(c10.baseHp).toBe(490)
+
+      const c20 = calculateClayGolemStats(20, 0, 0)
+      expect(c20.slowPct).toBe(40) // 11 + floor(40*19/26) = 11 + 29 = 40
+      expect(c20.baseHp).toBe(840)
+
+      // Synergy: +5% HP per base pt in Blood Golem
+      const c20Syn = calculateClayGolemStats(20, 0, 10)
+      expect(c20Syn.hpBonusPct).toBe(50)
+    })
+
+    it('enforces Golem Group 3 exclusivity (only 1 active golem allowed)', async () => {
+      const registry = await getSharedDataRegistry()
+      const sm = new SummonManager(registry)
+      const stats = new UnitStatList(registry)
+      const owner: CombatUnitContext = {
+        id: 'player',
+        name: 'Necro',
+        statList: stats,
+        stateBus: new StateBus(stats, registry),
+      }
+
+      // Summon Clay Golem
+      const clay = sm.createPet({ owner, skillId: 75, slvl: 1 })
+      expect(clay.created).toBe(true)
+      expect(sm.getActivePets().length).toBe(1)
+      expect(sm.getActivePets()[0]!.kind).toBe('clay_golem')
+
+      // Summon Blood Golem -> evicts Clay Golem!
+      const blood = sm.createPet({ owner, skillId: 85, slvl: 1 })
+      expect(blood.created).toBe(true)
+      expect(blood.evictedPetUids).toContain(clay.pet!.uid)
+      expect(sm.getActivePets().length).toBe(1)
+      expect(sm.getActivePets()[0]!.kind).toBe('blood_golem')
+    })
+  })
+
+  // =========================================================================
+  // 5. Golem Mastery (Skill 79)
+  // =========================================================================
+  describe('5. Golem Mastery (Skill 79)', () => {
+    it('calculates passive HP % (20% + 25%/lvl) and diminishing speed %', () => {
+      const gm1 = calculateGolemMasteryStats(1)
+      expect(gm1.hpBonusPct).toBe(20)
+      expect(gm1.speedBonusPct).toBe(20)
+
+      const gm10 = calculateGolemMasteryStats(10)
+      expect(gm10.hpBonusPct).toBe(245) // 20 + 9*25 = 245
+      expect(gm10.speedBonusPct).toBe(32) // 20 + floor(20*9/15) = 20 + 12 = 32
+
+      const gm20 = calculateGolemMasteryStats(20)
+      expect(gm20.hpBonusPct).toBe(495) // 20 + 19*25 = 495
+      expect(gm20.speedBonusPct).toBe(35) // 20 + floor(20*19/25) = 20 + 15 = 35
+    })
+  })
+
+  // =========================================================================
+  // 6. Raise Skeletal Mage (Skill 80)
+  // =========================================================================
+  describe('6. Raise Skeletal Mage (Skill 80)', () => {
+    it('calculates max count formula matching warriors', () => {
+      expect(calculateSkeletalMageMaxCount(1)).toBe(1)
+      expect(calculateSkeletalMageMaxCount(3)).toBe(3)
+      expect(calculateSkeletalMageMaxCount(4)).toBe(3)
+      expect(calculateSkeletalMageMaxCount(6)).toBe(4)
+      expect(calculateSkeletalMageMaxCount(20)).toBe(8)
+    })
+
+    it('spawns elemental variants that fire ranged missiles', async () => {
+      const registry = await getSharedDataRegistry()
+      const sm = new SummonManager(registry)
+      const stats = new UnitStatList(registry)
+      const owner: CombatUnitContext = {
+        id: 'player',
+        name: 'Necro',
+        statList: stats,
+        stateBus: new StateBus(stats, registry),
+      }
+
+      const corpses = [{ id: 'corpse-1', consumed: false, baseMaxHp: 500, isBoss: false }]
+      const res = sm.createPet({ owner, skillId: 80, slvl: 5, corpses })
+      expect(res.created).toBe(true)
+      expect(res.pet?.kind).toBe('skeleton_mage')
+      expect(['fire', 'cold', 'lightning', 'poison']).toContain(res.pet?.mageElement)
+
+      // Test missile firing in tickPets
+      const me = new MissileEngine(registry)
+      const auraScanner = new AuraScanner(registry)
+      const dummyStats = new UnitStatList(registry, { maxhp: 5000 * FIXED_ONE, hitpoints: 5000 * FIXED_ONE })
+      const enemy: CombatUnitContext = {
+        id: 'enemy-1',
+        name: 'Target Dummy',
+        statList: dummyStats,
+        stateBus: new StateBus(dummyStats, registry),
+      }
+      const enemyPositions = new Map([['enemy-1', { x: 100, y: 100 }]])
+
+      const tickRes = sm.tickPets({
+        currentTick: 1,
+        owner,
+        enemies: [enemy],
+        enemyPositions,
+        missileEngine: me,
+        auraScanner,
+      })
+
+      expect(tickRes.petAttacks).toBeGreaterThanOrEqual(1)
+      expect(me.getActiveMissiles().length).toBeGreaterThanOrEqual(1)
+    })
+  })
+
+  // =========================================================================
+  // 7. Blood Golem (Skill 85)
+  // =========================================================================
+  describe('7. Blood Golem (Skill 85)', () => {
+    it('evaluates life link: 70% damage dealt returned as player healing', () => {
+      const bg = calculateBloodGolemStats(1, 0)
+      expect(bg.lifeLeechPct).toBe(70)
+      expect(bg.damageSharePct).toBe(30)
+      expect(bg.baseHp).toBe(201)
+    })
+
+    it('heals owner when Blood Golem attacks in tickPets', async () => {
+      const registry = await getSharedDataRegistry()
+      const sm = new SummonManager(registry)
+      const stats = new UnitStatList(registry, { maxhp: 1000 * FIXED_ONE, hitpoints: 500 * FIXED_ONE })
+      const owner: CombatUnitContext = {
+        id: 'player',
+        name: 'Necro',
+        statList: stats,
+        stateBus: new StateBus(stats, registry),
+      }
+
+      sm.createPet({ owner, skillId: 85, slvl: 10 })
+      const dummyStats = new UnitStatList(registry, { maxhp: 5000 * FIXED_ONE, hitpoints: 5000 * FIXED_ONE })
+      const enemy: CombatUnitContext = {
+        id: 'enemy-1',
+        name: 'Target Dummy',
+        statList: dummyStats,
+        stateBus: new StateBus(dummyStats, registry),
+      }
+      const enemyPositions = new Map([['enemy-1', { x: 20, y: 60 }]])
+
+      const me = new MissileEngine(registry)
+      const auraScanner = new AuraScanner(registry)
+
+      // Step at tick 10 (combat interval)
+      sm.tickPets({
+        currentTick: 10,
+        owner,
+        enemies: [enemy],
+        enemyPositions,
+        missileEngine: me,
+        auraScanner,
+      })
+
+      // Owner should have received healing from Blood Golem Life Link
+      expect(owner.statList.getHp()).toBeGreaterThan(500)
+    })
+  })
+
+  // =========================================================================
+  // 8. Summon Resist (Skill 89)
+  // =========================================================================
+  describe('8. Summon Resist (Skill 89)', () => {
+    it('calculates exact dm12 diminishing curve with 75% cap', () => {
+      expect(calculateSummonResistPct(1)).toBe(28)
+      expect(calculateSummonResistPct(5)).toBe(47)
+      expect(calculateSummonResistPct(10)).toBe(57)
+      expect(calculateSummonResistPct(20)).toBe(66)
+      expect(calculateSummonResistPct(60)).toBe(75) // Capped at 75%
+    })
+  })
+
+  // =========================================================================
+  // 9. Iron Golem (Skill 90)
+  // =========================================================================
+  describe('9. Iron Golem (Skill 90)', () => {
+    it('calculates innate Thorns reflection (150% + 15%/lvl) and defense bonus', () => {
+      const ig1 = calculateIronGolemStats(1)
+      expect(ig1.thornsReturnPct).toBe(150)
+      expect(ig1.defenseBonus).toBe(0)
+
+      const ig10 = calculateIronGolemStats(10)
+      expect(ig10.thornsReturnPct).toBe(285) // 150 + 9*15 = 285
+      expect(ig10.defenseBonus).toBe(315) // 9*35 = 315
+
+      const ig20 = calculateIronGolemStats(20)
+      expect(ig20.thornsReturnPct).toBe(435) // 150 + 19*15 = 435
+      expect(ig20.defenseBonus).toBe(665) // 19*35 = 665
+    })
+
+    it('inherits item damage, defense, and auras when created from an item', () => {
+      const item = { baseDamage: 45, defense: 350, auras: [98] } // Might aura
+      const ig = calculateIronGolemStats(5, item)
+      expect(ig.inheritedDamage).toBe(45)
+      expect(ig.inheritedDefense).toBe(350)
+      expect(ig.inheritedAuras).toEqual([98])
+    })
+  })
+
+  // =========================================================================
+  // 10. Fire Golem (Skill 94)
+  // =========================================================================
+  describe('10. Fire Golem (Skill 94)', () => {
+    it('calculates Holy Fire aura pulse damage, fire absorption, and death explosion', () => {
+      const fg1 = calculateFireGolemStats(1)
+      expect(fg1.holyFireAuraLevel).toBe(1)
+      expect(fg1.holyFirePulseDmg).toBe(4) // 2 + 1*2
+      expect(fg1.fireAbsorbPct).toBe(100)
+      expect(fg1.deathExplosionDmg).toBe(100)
+
+      const fg10 = calculateFireGolemStats(10)
+      expect(fg10.holyFireAuraLevel).toBe(10)
+      expect(fg10.holyFirePulseDmg).toBe(22) // 2 + 10*2
+      expect(fg10.deathExplosionDmg).toBe(280) // 100 + 9*20 = 280
+
+      const fg20 = calculateFireGolemStats(20)
+      expect(fg20.holyFireAuraLevel).toBe(20)
+      expect(fg20.holyFirePulseDmg).toBe(42) // 2 + 20*2
+      expect(fg20.deathExplosionDmg).toBe(480) // 100 + 19*20 = 480
+    })
+
+    it('emits Holy Fire radial pulse every 50 ticks in tickPets', async () => {
+      const registry = await getSharedDataRegistry()
+      const sm = new SummonManager(registry)
+      const stats = new UnitStatList(registry)
+      const owner: CombatUnitContext = {
+        id: 'player',
+        name: 'Necro',
+        statList: stats,
+        stateBus: new StateBus(stats, registry),
+      }
+
+      sm.createPet({ owner, skillId: 94, slvl: 10 })
+      const dummyStats = new UnitStatList(registry, { maxhp: 5000 * FIXED_ONE, hitpoints: 5000 * FIXED_ONE })
+      const enemy: CombatUnitContext = {
+        id: 'enemy-1',
+        name: 'Target Dummy',
+        statList: dummyStats,
+        stateBus: new StateBus(dummyStats, registry),
+      }
+      const enemyPositions = new Map([['enemy-1', { x: 10, y: 70 }]])
+
+      const me = new MissileEngine(registry)
+      const auraScanner = new AuraScanner(registry)
+
+      // Step at tick 50 (Holy Fire pulse tick)
+      const tickRes = sm.tickPets({
+        currentTick: 50,
+        owner,
+        enemies: [enemy],
+        enemyPositions,
+        missileEngine: me,
+        auraScanner,
+      })
+
+      expect(tickRes.damageDealt).toBeGreaterThan(0)
+    })
+  })
+
+  // =========================================================================
+  // 11. Revive (Skill 95)
+  // =========================================================================
+  describe('11. Revive (Skill 95)', () => {
+    it('calculates max count = slvl, duration = 4500 frames (180s), and multipliers', () => {
+      expect(calculateReviveMaxCount(1)).toBe(1)
+      expect(calculateReviveMaxCount(10)).toBe(10)
+      expect(calculateReviveMaxCount(20)).toBe(20)
+
+      const rev0 = calculateReviveStats(1, 0)
+      expect(rev0.durationFrames).toBe(4500)
+      expect(rev0.hpMultiplier).toBe(3.0) // +200% base
+      expect(rev0.damageMultiplier).toBe(3.15) // +215% base
+
+      // Boosted by Skeleton Mastery: +5%/lvl HP and +10%/lvl damage
+      const rev10 = calculateReviveStats(1, 10)
+      expect(rev10.hpMultiplier).toBe(3.5) // 3.0 + 10 * 0.05
+      expect(rev10.damageMultiplier).toBe(4.15) // 3.15 + 10 * 0.10
+    })
+
+    it('ticks down lifespan and despawns after 4500 frames', async () => {
+      const registry = await getSharedDataRegistry()
+      const sm = new SummonManager(registry)
+      const stats = new UnitStatList(registry)
+      const owner: CombatUnitContext = {
+        id: 'player',
+        name: 'Necro',
+        statList: stats,
+        stateBus: new StateBus(stats, registry),
+      }
+
+      const corpses = [{ id: 'corpse-1', consumed: false, baseMaxHp: 800, isBoss: false }]
+      const res = sm.createPet({ owner, skillId: 95, slvl: 1, corpses })
+      expect(res.created).toBe(true)
+      expect(sm.getActivePets().length).toBe(1)
+
+      const pet = res.pet!
+      expect(pet.lifespanTicks).toBe(4500)
+
+      const me = new MissileEngine(registry)
+      const auraScanner = new AuraScanner(registry)
+
+      // Set lifespan to 1 tick remaining
+      pet.lifespanTicks = 1
+      sm.tickPets({
+        currentTick: 1,
+        owner,
+        enemies: [],
+        enemyPositions: new Map(),
+        missileEngine: me,
+        auraScanner,
+      })
+
+      // Must be expired and removed from active pets
+      expect(sm.getActivePets().length).toBe(0)
+    })
+  })
+})