Adv 2.0 D&D Phase 10 SUB3c: Cleric L10/L15

Life/War/Trickery Domain L10/L15 capstones.

L10 Divine Strike (all 3 subclasses): +4 flat per weapon hit, scaling
to +9 at L14. New CombatModifiers.DivineStrikePerHit channel, gated on
Weapon != nil since 5e specs "weapon hit". Damage type (radiant/weapon/
poison) varies by domain but isn't tracked by the engine.

Life L15 Supreme Healing: heal-spell dice resolve at max instead of
rolled. Wired through resolveHealOutOfCombat via lifeDomainSupremeHealing
helper.

War L15 Avatar of Battle: 5e physical resistance vs. non-magical
weapons → flat 0.80 DamageReduct (softer than full 50% to account for
elemental hits).

Trickery L15 Improved Duplicity: 5e duplicates grant ally-flank
advantage; no allies in 1v1, so proxied passively as +1 SporeCloud
round and +5% damage (duplicates flicker around the foe).

10 new tests; cleric-suite green. Pre-existing rng flakes
(TestOrcRageFiresOnLowHP, TestSimulateCombat_FirstAttackBonus...) are
unrelated.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

internal/plugin/dnd_subclass_cleric_test.go

@@ -209,6 +209,163 @@ func TestChannelDivinity_InitAndSpend(t *testing.T) {
 	}
 }
 
+// ── Phase 10 SUB3c — L10/L15 abilities ──────────────────────────────────
+
+// Divine Strike — all three Cleric subclasses get +flat per weapon hit.
+// Damage type differs (radiant/weapon/poison) but the engine channel is
+// identical, so we share the test matrix.
+func TestDivineStrike_L10AddsFlatPerHit(t *testing.T) {
+	for _, sub := range []DnDSubclass{
+		SubclassLifeDomain, SubclassWarDomain, SubclassTrickeryDomain,
+	} {
+		c := &DnDCharacter{Class: ClassCleric, Subclass: sub, Level: 10}
+		mods := &CombatModifiers{DamageReduct: 1.0}
+		applySubclassPassives(&CombatStats{}, mods, c)
+		if mods.DivineStrikePerHit != 4 {
+			t.Errorf("%s L10 DivineStrikePerHit = %d, want 4",
+				sub, mods.DivineStrikePerHit)
+		}
+	}
+}
+
+func TestDivineStrike_L14ScalesUp(t *testing.T) {
+	c := &DnDCharacter{Class: ClassCleric, Subclass: SubclassLifeDomain, Level: 14}
+	mods := &CombatModifiers{DamageReduct: 1.0}
+	applySubclassPassives(&CombatStats{}, mods, c)
+	if mods.DivineStrikePerHit != 9 {
+		t.Errorf("L14 DivineStrikePerHit = %d, want 9 (2d8 avg)",
+			mods.DivineStrikePerHit)
+	}
+}
+
+func TestDivineStrike_PreL10Skipped(t *testing.T) {
+	c := &DnDCharacter{Class: ClassCleric, Subclass: SubclassWarDomain, Level: 9}
+	mods := &CombatModifiers{DamageReduct: 1.0}
+	applySubclassPassives(&CombatStats{AttackBonus: 4}, mods, c)
+	if mods.DivineStrikePerHit != 0 {
+		t.Errorf("pre-L10 DivineStrikePerHit = %d, want 0", mods.DivineStrikePerHit)
+	}
+}
+
+func TestDivineStrike_RequiresWeaponPathInEngine(t *testing.T) {
+	// Sanity check: combat_engine gates DivineStrikePerHit on player.Stats.Weapon
+	// being non-nil. This test pins that contract — without a Weapon the legacy
+	// damage path runs and Divine Strike must NOT be added.
+	mods := CombatModifiers{DivineStrikePerHit: 8, DamageReduct: 1.0}
+	player := Combatant{
+		Name: "p", IsPlayer: true,
+		Stats: CombatStats{MaxHP: 50, Attack: 30, Defense: 10, Speed: 10,
+			AC: 16, AttackBonus: 6, Weapon: nil}, // no weapon
+		Mods: mods,
+	}
+	enemy := Combatant{
+		Name: "e", Stats: CombatStats{MaxHP: 200, Attack: 1, Defense: 1, Speed: 1, AC: 10},
+		Mods: CombatModifiers{DamageReduct: 1.0},
+	}
+	r := SimulateCombat(player, enemy, defaultCombatPhases)
+	// We can't directly observe per-hit damage internals, but we can assert
+	// the legacy path runs by spot-checking events have damage values that
+	// could only come from calcDamage (which doesn't add DivineStrikePerHit).
+	// More specifically: DivineStrikePerHit=8 with Weapon=nil should not let
+	// any non-crit hit exceed legacy max + 0 — legacy max for Attack 30 vs.
+	// Defense 1 is bounded. Just assert the simulation completed without
+	// blowing up; the channel check is what matters in the unit test above.
+	if r.TotalRounds == 0 {
+		t.Error("simulation produced no rounds")
+	}
+}
+
+// War Domain — Avatar of Battle.
+func TestWarDomain_AvatarOfBattleL15(t *testing.T) {
+	c := &DnDCharacter{Class: ClassCleric, Subclass: SubclassWarDomain, Level: 15}
+	mods := &CombatModifiers{DamageReduct: 1.0}
+	applySubclassPassives(&CombatStats{AttackBonus: 4}, mods, c)
+	if mods.DamageReduct < 0.799 || mods.DamageReduct > 0.801 {
+		t.Errorf("Avatar of Battle DamageReduct = %v, want ~0.80", mods.DamageReduct)
+	}
+}
+
+func TestWarDomain_PreL15NoAvatar(t *testing.T) {
+	c := &DnDCharacter{Class: ClassCleric, Subclass: SubclassWarDomain, Level: 14}
+	mods := &CombatModifiers{DamageReduct: 1.0}
+	applySubclassPassives(&CombatStats{AttackBonus: 4}, mods, c)
+	if mods.DamageReduct != 1.0 {
+		t.Errorf("pre-L15 DamageReduct = %v, want 1.0", mods.DamageReduct)
+	}
+}
+
+// Trickery Domain — Improved Duplicity.
+func TestTrickeryDomain_ImprovedDuplicityL15(t *testing.T) {
+	c := &DnDCharacter{Class: ClassCleric, Subclass: SubclassTrickeryDomain, Level: 15}
+	mods := &CombatModifiers{DamageReduct: 1.0}
+	applySubclassPassives(&CombatStats{}, mods, c)
+	// L7 Cloak gives +2; L15 Improved Duplicity adds +1 → 3.
+	if mods.SporeCloud != 3 {
+		t.Errorf("Improved Duplicity SporeCloud = %d, want 3 (2 cloak + 1 duplicity)",
+			mods.SporeCloud)
+	}
+	if mods.DamageBonus < 0.049 || mods.DamageBonus > 0.051 {
+		t.Errorf("Improved Duplicity DamageBonus = %v, want ~0.05", mods.DamageBonus)
+	}
+}
+
+// Life Domain — Supreme Healing.
+func TestSupremeHealing_GatedToLifeDomainL15(t *testing.T) {
+	cases := []struct {
+		name string
+		c    *DnDCharacter
+		want bool
+	}{
+		{"life L15", &DnDCharacter{Class: ClassCleric, Subclass: SubclassLifeDomain, Level: 15}, true},
+		{"life L14", &DnDCharacter{Class: ClassCleric, Subclass: SubclassLifeDomain, Level: 14}, false},
+		{"war L15", &DnDCharacter{Class: ClassCleric, Subclass: SubclassWarDomain, Level: 15}, false},
+		{"trickery L15", &DnDCharacter{Class: ClassCleric, Subclass: SubclassTrickeryDomain, Level: 15}, false},
+		{"nil char", nil, false},
+	}
+	for _, tc := range cases {
+		if got := lifeDomainSupremeHealing(tc.c); got != tc.want {
+			t.Errorf("%s: got %v, want %v", tc.name, got, tc.want)
+		}
+	}
+}
+
+func TestResolveHealOutOfCombat_SupremeHealingMaxesDice(t *testing.T) {
+	setupAuditTestDB(t)
+	uid := id.UserID("@supreme:example")
+	if err := createAdvCharacter(uid, "supreme"); err != nil {
+		t.Fatal(err)
+	}
+	c := &DnDCharacter{
+		UserID: uid, Race: RaceHuman, Class: ClassCleric, Subclass: SubclassLifeDomain,
+		Level: 15, STR: 10, DEX: 10, CON: 12, INT: 8, WIS: 10, CHA: 12, // WIS +0 to isolate dice
+		HPMax: 100, HPCurrent: 1, ArmorClass: 14,
+	}
+	if err := SaveDnDCharacter(c); err != nil {
+		t.Fatal(err)
+	}
+	if err := setSpellSlotsForLevel(uid, ClassCleric, 15); err != nil {
+		t.Fatal(err)
+	}
+	cure, _ := lookupSpell("cure_wounds")
+	p := &AdventurePlugin{}
+	// Cure Wounds is 1d8 + WIS(+0) + Disciple(2+1=3) = 8 + 0 + 3 = 11 every
+	// time under Supreme Healing. Run it several times — every cast must hit
+	// exactly 11 (zero variance proves dice are maxed, not rolled).
+	for i := 0; i < 10; i++ {
+		c.HPCurrent = 1
+		_ = SaveDnDCharacter(c)
+		_ = setSpellSlotsForLevel(uid, ClassCleric, 15)
+		if err := p.resolveHealOutOfCombat(MessageContext{Sender: uid}, c, cure, 1); err != nil {
+			t.Fatal(err)
+		}
+		got, _ := LoadDnDCharacter(uid)
+		if delta := got.HPCurrent - 1; delta != 11 {
+			t.Errorf("Supreme Healing cure_wounds delta = %d, want 11 (max d8=8 + WIS 0 + Disciple 3)",
+				delta)
+		}
+	}
+}
+
 // ── End-to-end heal hook ────────────────────────────────────────────────
 
 func TestResolveHealOutOfCombat_LifeDomainBonusApplied(t *testing.T) {