Combat: wire pet procs into the turn-based engine

Pet attacks were never resolved in turn-based fights. Roll the proc once
at fight start (a per-round roll would make a proc near-certain over a
long manual fight), persist it on the session so suspend/resume and
reaper auto-play honor the same outcome, and land a single pet hit on
the player's first acting turn.

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

internal/plugin/combat_turn_engine.go

@@ -116,6 +116,7 @@ func resumeTurnEngine(sess *CombatSession, player, enemy *Combatant, rng *rand.R
 		armorBroken:    sess.Statuses.ArmorBroken,
 		armorBreakAmt:  sess.Statuses.ArmorBreakAmt,
 		enemySkipFirst: sess.Statuses.EnemySkipNext,
+		petProcReady:   sess.Statuses.PetProcReady,
 		// Fight-scoped depleting resources + once-per-fight one-shots: restored
 		// from the persisted statuses so a charge or "already used" flag can't
 		// reset across a suspend/resume. commit writes the updated values back.
@@ -186,9 +187,61 @@ func (te *turnEngine) stepPlayerTurn(action PlayerAction) {
 		te.finish(CombatStatusWon)
 		return
 	}
+	if te.petStrike() {
+		te.finish(CombatStatusWon)
+		return
+	}
 	te.sess.Phase = CombatPhaseEnemyTurn
 }
 
+// petStrike resolves the player's pet attack for a turn-based fight. Whether
+// the pet lands a hit was decided once at fight start (rollCombatSessionPetProc)
+// and parked on the session; the pet then strikes a single time on the player's
+// first acting turn — this clears the flag so it never repeats. Damage reuses
+// the auto-resolve formula (PetAttackDmg + d5), and PetAttackDmg already carries
+// any mid-fight buff delta via applySessionBuffs. Returns true if the strike
+// dropped the enemy.
+func (te *turnEngine) petStrike() bool {
+	st := te.st
+	if !st.petProcReady {
+		return false
+	}
+	st.petProcReady = false
+	petDmg := te.player.Mods.PetAttackDmg + st.roll(5)
+	st.enemyHP = max(0, st.enemyHP-petDmg)
+	st.events = append(st.events, CombatEvent{
+		Round: st.round, Phase: turnCombatPhase.Name, Actor: "pet", Action: "pet_attack",
+		Damage: petDmg, PlayerHP: st.playerHP, EnemyHP: st.enemyHP,
+	})
+	return st.enemyHP <= 0
+}
+
+// rollCombatSessionPetProc makes the one-and-only per-fight pet-attack roll and
+// parks the result on the session. Called once at fight start. The draw is
+// deterministic — seeded off the session id on a stream distinct from the
+// per-(round,phase) combat streams — so a reaper auto-play of an abandoned
+// fight reproduces the same outcome. Returns true if the pet will attack (so
+// the caller can decide whether the session needs persisting).
+//
+// Note: only the base PetAttackProc (class/race/subclass passives) is rolled
+// here — a pet-proc buff cast mid-fight gets no fresh roll, consistent with the
+// per-fight rule. Such a buff still raises PetAttackDmg if the pet does strike.
+func rollCombatSessionPetProc(sess *CombatSession, playerMods CombatModifiers) bool {
+	if playerMods.PetAttackProc <= 0 {
+		return false
+	}
+	var seed uint64 = 1469598103934665603
+	for _, c := range sess.SessionID {
+		seed = (seed ^ uint64(c)) * 1099511628211
+	}
+	rng := rand.New(rand.NewPCG(seed, 0x9E3779B97F4A7C15))
+	if rngFloat(rng) < playerMods.PetAttackProc {
+		sess.Statuses.PetProcReady = true
+		return true
+	}
+	return false
+}
+
 // stepPlayerActionEffect resolves a !cast / !consume turn: the command handler
 // has already rolled the spell / picked the item and spent the resource, so the
 // engine only applies the HP deltas and emits the event before handing off to
@@ -219,6 +272,10 @@ func (te *turnEngine) stepPlayerActionEffect(eff *turnActionEffect) {
 		te.finish(CombatStatusWon)
 		return
 	}
+	if te.petStrike() {
+		te.finish(CombatStatusWon)
+		return
+	}
 	if eff.EnemySkip {
 		st.enemySkipFirst = true
 	}
@@ -351,6 +408,7 @@ func (te *turnEngine) commit() {
 	s.ArmorBroken = st.armorBroken
 	s.ArmorBreakAmt = st.armorBreakAmt
 	s.EnemySkipNext = st.enemySkipFirst
+	s.PetProcReady = st.petProcReady
 	s.WardCharges = st.wardCharges
 	s.SporeRounds = st.sporeRounds
 	s.ReflectFrac = st.reflectFrac