Review follow-ups A + B: armed abilities survive the fight, supply pool serialized

A. An armed ability lasted one round of a turn-based fight.

buildZoneCombatants called applyArmedAbility, which applies an ability's mods
*and* clears ArmedAbility and saves the sheet. The turn engine calls that
builder again on every !attack / !cast / !consume, so round 1 fired the ability
and disarmed the character, and every later round rebuilt them with none of its
mods. A Berserker paid stamina for a single round of BerserkerRage /
RageMeleeDmg / PhysicalResistRage / FrenzyDmgBonus. Every entry in
dndActiveAbilities had the same shape. mods.BerserkerRage was not merely unread
at close-out — by then it no longer existed.

Split arming into its two halves:

  consumeArmedAbility(c)          mutates: disarms, saves, returns the id. Once,
                                  at fight start.
  applyAbilityByID(c, id, mods)   pure: no DB write, no disarm. Safe on every
                                  rebuild. (No ability's Apply writes to the
                                  character, so this really is pure.)
  armAbilityForFight(c, mods)     consume + apply, for the auto-resolve callers
                                  that build and fight in one breath.

buildZoneCombatants now takes the already-consumed id and re-applies it. The id
rides on ActorStatuses.ArmedAbility, seeded per seat at fight start, so
partyCombatantsForSession reproduces the ability every rebuild and the close-out
can still see that a rage fired.

The close-out itself: postCombatBookkeeping now carries grantCombatAchievements
+ persistDnDPostCombatSubclass, and all four close-outs route through it —
runDungeonCombat, runZoneCombatRoster, finishCombatSession,
finishPartyCombatSession. It fires on every terminal status, not just a win: a
Berserker who rages and loses is still exhausted, which is what auto-resolve
always did.

Also: buildFightSeats and runZoneCombatRoster consumed the ability before the
checks that could sit a seat out, so a downed member was disarmed for a fight
they never joined. The refusals now run first.

B. Six unlocked read-modify-writes against the shared supply pool.

updateSupplies rewrites supplies_json wholesale, so a caller folding its delta
onto an *Expedition it read earlier discards whatever landed in between.
Handlers run one goroutine per event, so those writers genuinely interleave.

All six now go through withExpeditionSupplies, which takes advExpeditionLock,
re-reads the row, hands the closure the fresh copy and persists what it returns:
nightRolloverBurn (forage + burn in one write), grantTwoWeeksCache,
advanceToNextRegion's transit burn, campPitch, pitchAutopilotCamp, and the
ambient pack-rat drain. expeditionCmdAccept's hand-rolled lock folds onto the
same helper. expedition_sim.go is left alone: single-threaded, takes no locks.

Known consequence, for the balance track: trySimAutoArm used to live inside the
rebuild, so a simulated Fighter (second_wind) or Cleric (healing_word) re-armed
and re-spent a resource every round of every elite/boss fight. expedition-sim
drives those through the turn engine, so every prior expedition-sim corpus
overstates those two classes. Re-baseline after this, not before.

Claude-Session: https://claude.ai/code/session_017mEwUmmS7aQTP2NQXj6rUa

internal/plugin/dnd_expedition_milestone.go

@@ -176,20 +176,30 @@ const twoWeeksCacheSize = 3
 func (p *AdventurePlugin) grantTwoWeeksCache(e *Expedition) string {
 	var lines []string
 
-	if s := e.Supplies; s.DailyBurn > 0 {
-		s.Current += twoWeeksRestockDays * s.DailyBurn
-		if s.Max > 0 && s.Current > s.Max {
-			s.Current = s.Max
-		}
-		if s.Current > e.Supplies.Current {
-			if err := updateSupplies(e.ID, s); err != nil {
-				slog.Error("milestone: two weeks restock failed",
-					"expedition", e.ID, "err", err)
-			} else {
-				lines = append(lines, fmt.Sprintf(
-					"📦 Supplies restocked — %.1f of %.1f.", s.Current, s.Max))
-				e.Supplies = s
+	if e.Supplies.DailyBurn > 0 {
+		var restocked bool
+		pooled, err := p.withExpeditionSupplies(e.ID, func(fresh *Expedition) (ExpeditionSupplies, error) {
+			s := fresh.Supplies
+			if s.DailyBurn <= 0 {
+				return s, nil
 			}
+			s.Current += twoWeeksRestockDays * s.DailyBurn
+			if s.Max > 0 && s.Current > s.Max {
+				s.Current = s.Max
+			}
+			restocked = s.Current > fresh.Supplies.Current
+			return s, nil
+		})
+		switch {
+		case err != nil:
+			slog.Error("milestone: two weeks restock failed",
+				"expedition", e.ID, "err", err)
+		case restocked:
+			lines = append(lines, fmt.Sprintf(
+				"📦 Supplies restocked — %.1f of %.1f.", pooled.Current, pooled.Max))
+			e.Supplies = pooled
+		default:
+			e.Supplies = pooled
 		}
 	}