feat: implement spire descent system with room-aware navigation

Implements the spec-driven spire multi-room climbing and descent system:
- Room navigation: currentRoomIndex, roomsPerFloor, startFloor, exitFloor
- Descent tracking: descentPeak, roomResetState, clearedRooms, isDescentComplete
- enterDescentMode: snapshots peak, sets climbDirection='down'
- advanceRoomOrFloor: room-by-room ascending/descending with floor transitions
- onEnterRoomDescend: per-room 50% reset check with auto-skip
- onEnterLibraryRoom: discipline XP scaled by floor
- Seeded PRNG for deterministic room counts and types
- UI: Descend button during ascent, Exit Spire only when isDescentComplete
- UI: Room X/Y display, room type badge, in-game time in RoomDisplay
- Extracted descent actions to combat-descent-actions.ts (file size limit)
- Updated tests for room-aware combat behavior

Spec: docs/specs/spire-climbing-spec.md §4.1-§4.9, §6

src/lib/game/stores/combat-descent-actions.ts

@@ -0,0 +1,248 @@
+// ─── Combat Descent Actions ────────────────────────────────────────────────────
+// Extracted from combatStore.ts to keep the store under the 400-line limit.
+// Implements the spec-driven descent system (climbing spec §4.4–§4.9).
+
+import type { CombatState, CombatStore } from './combat-state.types';
+import { generateSpireFloorState, getRoomsForFloor } from '../utils/spire-utils';
+import { getGuardianForFloor } from '../data/guardian-encounters';
+import { usePrestigeStore } from './prestigeStore';
+import { useDisciplineStore } from './discipline-slice';
+import type { FloorState } from '../types';
+
+type GetFn = () => CombatStore;
+type SetFn = (state: Partial<CombatState>) => void;
+
+/** Helper: compute total enemy HP from a room */
+function calcRoomHP(room: { enemies?: Array<{ hp: number }> }): number {
+  if (!room.enemies || room.enemies.length === 0) return 0;
+  return room.enemies.reduce((sum, e) => sum + e.hp, 0);
+}
+
+// ─── enterDescentMode (climbing spec §4.5) ────────────────────────────────────
+
+export function enterDescentMode(get: GetFn, set: SetFn): void {
+  const s = get();
+  set({
+    climbDirection: 'down',
+    descentPeak: { floor: s.currentFloor, roomIndex: s.currentRoomIndex },
+    isDescentComplete: false,
+  });
+  get().addActivityLog('floor_transition',
+    `Beginning descent from Floor ${s.currentFloor}, Room ${s.currentRoomIndex + 1}`);
+  // Start descending from the current room
+  onEnterRoomDescend(get, set);
+}
+
+// ─── advanceRoomOrFloor (climbing spec §4.4, §4.6) ────────────────────────────
+
+export function advanceRoomOrFloor(get: GetFn, set: SetFn): void {
+  const s = get();
+
+  if (s.climbDirection === 'down') {
+    // ── Descending (spec §4.6) ────────────────────────────────────────────
+    get().addActivityLog('floor_transition', `Room ${s.currentRoomIndex + 1} passed`);
+
+    if (s.currentFloor <= s.exitFloor && s.currentRoomIndex <= 0) {
+      set({ isDescentComplete: true });
+      get().addActivityLog('floor_transition',
+        'Descent complete — Exit Spire is now available');
+      return;
+    }
+
+    if (s.currentRoomIndex <= 0) {
+      const newFloor = s.currentFloor - 1;
+      const newRoomsPerFloor = getRoomsForFloor(newFloor, newFloor * 12345);
+      const newRoomIndex = newRoomsPerFloor - 1;
+      const newRoom = generateSpireFloorState(newFloor, newRoomIndex, newRoomsPerFloor);
+      const newFloorHP = calcRoomHP(newRoom);
+      set({
+        currentFloor: newFloor,
+        currentRoomIndex: newRoomIndex,
+        roomsPerFloor: newRoomsPerFloor,
+        currentRoom: newRoom,
+        floorHP: newFloorHP,
+        floorMaxHP: newFloorHP,
+        castProgress: 0,
+      });
+      get().addActivityLog('floor_transition', `Descended to Floor ${newFloor}`);
+    } else {
+      const newRoomIndex = s.currentRoomIndex - 1;
+      const newRoom = generateSpireFloorState(s.currentFloor, newRoomIndex, s.roomsPerFloor);
+      const newFloorHP = calcRoomHP(newRoom);
+      set({
+        currentRoomIndex: newRoomIndex,
+        currentRoom: newRoom,
+        floorHP: newFloorHP,
+        floorMaxHP: newFloorHP,
+        castProgress: 0,
+      });
+    }
+
+    onEnterRoomDescend(get, set);
+  } else {
+    // ── Ascending (spec §4.4) ─────────────────────────────────────────────
+    const roomKey = `${s.currentFloor}:${s.currentRoomIndex}`;
+    set((prev) => ({
+      clearedRooms: { ...prev.clearedRooms, [roomKey]: true },
+    }));
+    get().addActivityLog('floor_transition',
+      `Floor ${s.currentFloor} Room ${s.currentRoomIndex + 1}/${s.roomsPerFloor} cleared`);
+
+    if (s.currentRoomIndex + 1 >= s.roomsPerFloor) {
+      const newFloor = Math.min(s.currentFloor + 1, 100);
+      const newRoomsPerFloor = getRoomsForFloor(newFloor, newFloor * 12345);
+      const newRoom = generateSpireFloorState(newFloor, 0, newRoomsPerFloor);
+      const newFloorHP = calcRoomHP(newRoom);
+      set({
+        currentFloor: newFloor,
+        currentRoomIndex: 0,
+        roomsPerFloor: newRoomsPerFloor,
+        currentRoom: newRoom,
+        floorHP: newFloorHP,
+        floorMaxHP: newFloorHP,
+        castProgress: 0,
+      });
+      get().addActivityLog('floor_transition', `Ascending to Floor ${newFloor}`);
+    } else {
+      const newRoomIndex = s.currentRoomIndex + 1;
+      const newRoom = generateSpireFloorState(s.currentFloor, newRoomIndex, s.roomsPerFloor);
+      const newFloorHP = calcRoomHP(newRoom);
+      set({
+        currentRoomIndex: newRoomIndex,
+        currentRoom: newRoom,
+        floorHP: newFloorHP,
+        floorMaxHP: newFloorHP,
+        castProgress: 0,
+      });
+    }
+
+    // Handle non-combat rooms on ascent
+    const room = get().currentRoom;
+    if (room.roomType === 'library') {
+      onEnterLibraryRoom(get, set);
+    } else if (room.roomType === 'recovery' || room.roomType === 'treasure' || room.roomType === 'puzzle') {
+      advanceRoomOrFloor(get, set);
+    }
+  }
+}
+
+// ─── onEnterRoomDescend (climbing spec §4.7) ──────────────────────────────────
+
+export function onEnterRoomDescend(get: GetFn, set: SetFn): void {
+  const s = get();
+  const key = `${s.currentFloor}:${s.currentRoomIndex}`;
+
+  if (s.roomResetState[key] === undefined) {
+    set((prev) => ({
+      roomResetState: { ...prev.roomResetState, [key]: Math.random() < 0.5 },
+    }));
+  }
+
+  const wasCleared = s.clearedRooms[key] === true;
+
+  if (!wasCleared) {
+    get().addActivityLog('floor_transition',
+      `Floor ${s.currentFloor} Room ${s.currentRoomIndex + 1} was not cleared — enemies present`);
+    return;
+  }
+
+  const didReset = get().roomResetState[key];
+
+  if (didReset) {
+    const newRoom = generateSpireFloorState(s.currentFloor, s.currentRoomIndex, s.roomsPerFloor);
+    set({ currentRoom: newRoom, castProgress: 0 });
+    get().addActivityLog('floor_transition',
+      `Floor ${s.currentFloor} Room ${s.currentRoomIndex + 1} has reset — enemies respawned`);
+
+    if (newRoom.roomType === 'guardian') {
+      const guardian = getGuardianForFloor(s.currentFloor);
+      if (guardian) {
+        set({
+          guardianShield: guardian.shield ?? 0,
+          guardianShieldMax: guardian.shield ?? 0,
+          guardianBarrier: guardian.barrier ?? 0,
+          guardianBarrierMax: guardian.barrier ?? 0,
+        });
+      }
+    }
+  } else {
+    get().addActivityLog('floor_transition',
+      `Floor ${s.currentFloor} Room ${s.currentRoomIndex + 1} is clear — moving on`);
+    advanceRoomOrFloor(get, set);
+  }
+}
+
+// ─── onEnterLibraryRoom (climbing spec §4.8) ──────────────────────────────────
+
+export function onEnterLibraryRoom(get: GetFn, set: SetFn): void {
+  const s = get();
+  const BASE_LIBRARY_XP = 50;
+  const xpGrant = Math.floor(BASE_LIBRARY_XP * (1 + s.currentFloor / 10));
+
+  const disciplineStore = useDisciplineStore.getState();
+  const activeIds = disciplineStore.activeIds || [];
+  const allDisciplines = disciplineStore.disciplines;
+
+  const activeEntries = activeIds
+    .map((id: string) => [id, allDisciplines[id]] as const)
+    .filter(([, ds]) => ds != null);
+
+  const targetPool = activeEntries.length > 0
+    ? activeEntries
+    : Object.entries(allDisciplines);
+
+  if (targetPool.length > 0) {
+    const [targetId, targetDs] = targetPool[Math.floor(Math.random() * targetPool.length)];
+    useDisciplineStore.setState((prev) => ({
+      disciplines: {
+        ...prev.disciplines,
+        [targetId]: { ...targetDs, xp: (targetDs?.xp || 0) + xpGrant },
+      },
+      totalXP: prev.totalXP + xpGrant,
+    }));
+    const discName = targetDs?.id || targetId;
+    get().addActivityLog('special_effect',
+      `${discName} gained ${xpGrant} XP from ancient tome`);
+  }
+
+  get().addActivityLog('floor_transition',
+    `Entered library room on Floor ${s.currentFloor}`);
+  advanceRoomOrFloor(get, set);
+}
+
+// ─── enterSpireMode (climbing spec §4.1) ──────────────────────────────────────
+
+export function createEnterSpireMode(get: GetFn, set: SetFn, generateFloorState: (floor: number) => FloorState) {
+  return () => {
+    const prestigeStore = usePrestigeStore.getState();
+    const spireKey = prestigeStore.prestigeUpgrades.spireKey || 0;
+    const startFloor = 1 + (spireKey * 2);
+    const seed = startFloor * 12345;
+    const rooms = getRoomsForFloor(startFloor, seed);
+    const freshRoom = generateSpireFloorState(startFloor, 0, rooms);
+
+    set({
+      spireMode: true,
+      currentAction: 'climb',
+      currentFloor: startFloor,
+      startFloor,
+      exitFloor: startFloor,
+      currentRoomIndex: 0,
+      roomsPerFloor: rooms,
+      floorHP: calcRoomHP(freshRoom),
+      floorMaxHP: calcRoomHP(freshRoom),
+      currentRoom: freshRoom,
+      castProgress: 0,
+      climbDirection: 'up',
+      isDescending: false,
+      clearedFloors: {},
+      clearedRooms: {},
+      roomResetState: {},
+      descentPeak: null,
+      isDescentComplete: false,
+    });
+
+    get().addActivityLog('floor_transition',
+      `Entered the Spire at Floor ${startFloor}`);
+  };
+}