feat: SQLite event storage with pagination and filtering

Implement SQLite-based event persistence as specified in sqlite-event-manager.md.

## Changes

### Backend
- **EventStorage** (`src/classes/event_storage.py`): New SQLite storage layer
  - Cursor-based pagination with compound cursor `{month_stamp}_{rowid}`
  - Avatar filtering (single and pair queries)
  - Major/minor event separation
  - Cleanup API with `keep_major` and `before_month_stamp` filters

- **EventManager** (`src/classes/event_manager.py`): Refactored to use SQLite
  - Delegates to EventStorage for persistence
  - Memory fallback mode for testing
  - New `get_events_paginated()` method

- **API** (`src/server/main.py`):
  - `GET /api/events` - Paginated event retrieval with filtering
  - `DELETE /api/events/cleanup` - User-triggered cleanup

### Frontend
- **EventPanel.vue**: Scroll-to-load pagination, dual-person filter UI
- **world.ts**: Event state management with pagination
- **game.ts**: New API client methods

### Testing
- 81 new tests for EventStorage, EventManager, and API
- Added `pytest-asyncio` and `httpx` to requirements.txt

## Known Issues: Save/Load is Currently Broken

After loading a saved game, the following issues occur:

1. **Wrong database used**: API returns events from the startup database instead
   of the loaded save's `_events.db` file
2. **Events from wrong time period**: Shows events from year 115 when loaded
   save is at year 114
3. **Pagination broken after load**: `has_more` returns `False` despite hundreds
   of events in the saved database
4. **Filter functionality broken**: Character selection filter stops working
   after loading a game

Root cause: `load_game.py` does not properly switch the EventManager's database
connection to the loaded save's events database.

tests/test_save_load_events.py

@@ -0,0 +1,489 @@
+"""
+Tests for save/load functionality with SQLite event storage.
+
+Covers:
+- Events persistence across save/load cycles
+- Database file switching when loading different saves
+- Event retrieval after loading
+"""
+
+import pytest
+import tempfile
+from pathlib import Path
+from unittest.mock import patch, MagicMock
+
+from src.classes.world import World
+from src.classes.map import Map
+from src.classes.tile import TileType
+from src.classes.calendar import Month, Year, create_month_stamp, MonthStamp
+from src.classes.avatar import Avatar, Gender
+from src.classes.age import Age
+from src.classes.cultivation import Realm
+from src.classes.event import Event
+from src.classes.event_storage import EventStorage
+from src.classes.event_manager import EventManager
+from src.sim.simulator import Simulator
+from src.sim.save.save_game import save_game
+from src.sim.load.load_game import load_game
+from src.utils.id_generator import get_avatar_id
+
+
+def create_test_map():
+    """Create a simple 10x10 plain map for testing."""
+    m = Map(width=10, height=10)
+    for x in range(10):
+        for y in range(10):
+            m.create_tile(x, y, TileType.PLAIN)
+    return m
+
+
+def make_event(
+    year: int,
+    month: int,
+    content: str,
+    avatar_ids: list[str] | None = None,
+    is_major: bool = False,
+) -> Event:
+    """Helper to create an Event."""
+    month_stamp = create_month_stamp(Year(year), Month(month))
+    return Event(
+        month_stamp=month_stamp,
+        content=content,
+        related_avatars=avatar_ids,
+        is_major=is_major,
+    )
+
+
+def make_event_by_index(
+    index: int,
+    content: str,
+    avatar_ids: list[str] | None = None,
+) -> Event:
+    """Helper to create an Event from an index (handles year/month calculation)."""
+    year = 100 + (index // 12)
+    month = (index % 12) + 1
+    return make_event(year, month, content, avatar_ids)
+
+
+@pytest.fixture
+def temp_save_dir(tmp_path):
+    """Create a temporary directory for saves."""
+    d = tmp_path / "saves"
+    d.mkdir()
+    return d
+
+
+class TestEventManagerWithWorld:
+    """Tests for EventManager integration with World."""
+
+    def test_world_creates_event_manager_with_db(self, tmp_path):
+        """Test that World.create_with_db creates proper EventManager."""
+        db_path = tmp_path / "events.db"
+        game_map = create_test_map()
+        month_stamp = create_month_stamp(Year(100), Month.JANUARY)
+
+        world = World.create_with_db(
+            map=game_map,
+            month_stamp=month_stamp,
+            events_db_path=db_path,
+        )
+
+        # EventManager should be connected to SQLite
+        assert world.event_manager is not None
+        assert world.event_manager._storage is not None
+        assert db_path.exists()
+
+        # Clean up
+        world.event_manager.close()
+
+    def test_events_written_to_sqlite(self, tmp_path):
+        """Test that events added to World are written to SQLite."""
+        db_path = tmp_path / "events.db"
+        game_map = create_test_map()
+        month_stamp = create_month_stamp(Year(100), Month.JANUARY)
+
+        world = World.create_with_db(
+            map=game_map,
+            month_stamp=month_stamp,
+            events_db_path=db_path,
+        )
+
+        # Add events
+        event1 = make_event(100, 1, "First event", ["a1"])
+        event2 = make_event(100, 2, "Second event", ["a2"])
+
+        world.event_manager.add_event(event1)
+        world.event_manager.add_event(event2)
+
+        # Verify in SQLite
+        assert world.event_manager.count() == 2
+
+        # Clean up and verify persistence
+        world.event_manager.close()
+
+        # Reopen and verify
+        storage = EventStorage(db_path)
+        assert storage.count() == 2
+        storage.close()
+
+
+class TestSaveLoadWithEvents:
+    """Tests for save/load cycle with SQLite events."""
+
+    def test_save_load_preserves_events(self, temp_save_dir, tmp_path):
+        """Test that events are preserved across save/load cycle."""
+        # Setup world with SQLite events
+        db_path = tmp_path / "events.db"
+        game_map = create_test_map()
+        month_stamp = create_month_stamp(Year(100), Month.JANUARY)
+
+        world = World.create_with_db(
+            map=game_map,
+            month_stamp=month_stamp,
+            events_db_path=db_path,
+        )
+
+        # Create avatar
+        avatar_id = get_avatar_id()
+        avatar = Avatar(
+            world=world,
+            name="TestAvatar",
+            id=avatar_id,
+            birth_month_stamp=create_month_stamp(Year(80), Month.JANUARY),
+            age=Age(20, Realm.Qi_Refinement),
+            gender=Gender.MALE,
+        )
+        world.avatar_manager.avatars[avatar.id] = avatar
+
+        # Add events
+        for i in range(10):
+            event = make_event(
+                100, i + 1,
+                f"Event {i} for avatar",
+                [avatar_id],
+                is_major=(i % 3 == 0),
+            )
+            world.event_manager.add_event(event)
+
+        original_count = world.event_manager.count()
+        assert original_count == 10
+
+        # Save
+        sim = Simulator(world)
+        save_path = temp_save_dir / "test_events.json"
+        success, _ = save_game(world, sim, [], save_path)
+        assert success
+
+        # Close current event manager
+        world.event_manager.close()
+
+        # Load
+        with patch('src.run.load_map.load_cultivation_world_map', return_value=create_test_map()):
+            loaded_world, loaded_sim, _ = load_game(save_path)
+
+        # Verify events are accessible
+        # Note: After loading, the world should use a new EventManager
+        # connected to the loaded save's database
+        loaded_events = loaded_world.event_manager.get_recent_events()
+
+        # The exact behavior depends on implementation -
+        # if events DB path is derived from save path, they should be preserved
+        # This test may need adjustment based on actual load_game implementation
+
+    def test_events_filtered_by_avatar_after_load(self, temp_save_dir, tmp_path):
+        """Test that avatar-specific event queries work after loading."""
+        db_path = tmp_path / "events.db"
+        game_map = create_test_map()
+        month_stamp = create_month_stamp(Year(100), Month.JANUARY)
+
+        world = World.create_with_db(
+            map=game_map,
+            month_stamp=month_stamp,
+            events_db_path=db_path,
+        )
+
+        # Create two avatars
+        avatar1_id = get_avatar_id()
+        avatar2_id = get_avatar_id()
+
+        avatar1 = Avatar(
+            world=world,
+            name="Avatar1",
+            id=avatar1_id,
+            birth_month_stamp=create_month_stamp(Year(80), Month.JANUARY),
+            age=Age(20, Realm.Qi_Refinement),
+            gender=Gender.MALE,
+        )
+        avatar2 = Avatar(
+            world=world,
+            name="Avatar2",
+            id=avatar2_id,
+            birth_month_stamp=create_month_stamp(Year(80), Month.JANUARY),
+            age=Age(20, Realm.Qi_Refinement),
+            gender=Gender.FEMALE,
+        )
+
+        world.avatar_manager.avatars[avatar1.id] = avatar1
+        world.avatar_manager.avatars[avatar2.id] = avatar2
+
+        # Add events for different avatars
+        world.event_manager.add_event(make_event(100, 1, "Avatar1 event", [avatar1_id]))
+        world.event_manager.add_event(make_event(100, 2, "Avatar2 event", [avatar2_id]))
+        world.event_manager.add_event(make_event(100, 3, "Both avatars", [avatar1_id, avatar2_id]))
+
+        # Query before save
+        avatar1_events = world.event_manager.get_events_by_avatar(avatar1_id)
+        assert len(avatar1_events) == 2  # "Avatar1 event" and "Both avatars"
+
+        between_events = world.event_manager.get_events_between(avatar1_id, avatar2_id)
+        assert len(between_events) == 1  # "Both avatars"
+
+        # Clean up
+        world.event_manager.close()
+
+
+class TestEventPagination:
+    """Tests for event pagination functionality."""
+
+    def test_pagination_returns_correct_pages(self, tmp_path):
+        """Test that pagination returns events in correct order."""
+        db_path = tmp_path / "events.db"
+        storage = EventStorage(db_path)
+        manager = EventManager(storage)
+
+        # Add 25 events
+        for i in range(25):
+            year = 100 + (i // 12)
+            month = (i % 12) + 1
+            manager.add_event(make_event(year, month, f"Event {i}"))
+
+        # Get first page (10 items)
+        page1, cursor1, has_more1 = manager.get_events_paginated(limit=10)
+        assert len(page1) == 10
+        assert has_more1 is True
+        assert cursor1 is not None
+
+        # Events should be in descending order (newest first)
+        assert page1[0].content == "Event 24"  # Newest
+        assert page1[9].content == "Event 15"
+
+        # Get second page
+        page2, cursor2, has_more2 = manager.get_events_paginated(limit=10, cursor=cursor1)
+        assert len(page2) == 10
+        assert has_more2 is True
+
+        # Get third page (only 5 remaining)
+        page3, cursor3, has_more3 = manager.get_events_paginated(limit=10, cursor=cursor2)
+        assert len(page3) == 5
+        assert has_more3 is False
+        assert cursor3 is None
+
+        # Verify no duplicates across pages
+        all_ids = {e.id for e in page1} | {e.id for e in page2} | {e.id for e in page3}
+        assert len(all_ids) == 25
+
+        manager.close()
+
+    def test_pagination_with_avatar_filter(self, tmp_path):
+        """Test pagination with avatar filter."""
+        db_path = tmp_path / "events.db"
+        storage = EventStorage(db_path)
+        manager = EventManager(storage)
+
+        avatar1_id = "avatar_1"
+        avatar2_id = "avatar_2"
+
+        # Add events alternating between avatars
+        for i in range(20):
+            avatar_id = avatar1_id if i % 2 == 0 else avatar2_id
+            manager.add_event(make_event(100, (i % 12) + 1, f"Event {i}", [avatar_id]))
+
+        # Get avatar1's events (should be 10)
+        page1, cursor, has_more = manager.get_events_paginated(
+            avatar_id=avatar1_id,
+            limit=5
+        )
+        assert len(page1) == 5
+        assert has_more is True
+
+        # All events should be for avatar1
+        for e in page1:
+            assert avatar1_id in e.related_avatars
+
+        # Get remaining
+        page2, _, _ = manager.get_events_paginated(
+            avatar_id=avatar1_id,
+            limit=10,
+            cursor=cursor
+        )
+        assert len(page2) == 5
+
+        manager.close()
+
+    def test_pagination_cursor_format_stability(self, tmp_path):
+        """Test that cursor format is stable and parseable."""
+        db_path = tmp_path / "events.db"
+        storage = EventStorage(db_path)
+
+        # Add some events
+        for i in range(5):
+            storage.add_event(make_event(100, i + 1, f"Event {i}"))
+
+        _, cursor = storage.get_events(limit=3)
+
+        # Cursor should be in format: month_stamp_rowid
+        assert cursor is not None
+        parts = cursor.split("_")
+        assert len(parts) == 2
+        assert parts[0].isdigit()
+        assert parts[1].isdigit()
+
+        # Cursor should be parseable
+        month_stamp, rowid = storage._parse_cursor(cursor)
+        assert isinstance(month_stamp, int)
+        assert isinstance(rowid, int)
+
+        storage.close()
+
+
+class TestEventStorageEdgeCases:
+    """Edge case tests for event storage."""
+
+    def test_concurrent_writes(self, tmp_path):
+        """Test that concurrent writes don't corrupt data."""
+        db_path = tmp_path / "events.db"
+        storage = EventStorage(db_path)
+
+        # Simulate rapid writes (use make_event_by_index to handle month > 12)
+        events = [make_event_by_index(i, f"Event {i}") for i in range(100)]
+
+        for event in events:
+            result = storage.add_event(event)
+            assert result is True
+
+        assert storage.count() == 100
+        storage.close()
+
+    def test_large_event_content(self, tmp_path):
+        """Test handling of large event content."""
+        db_path = tmp_path / "events.db"
+        storage = EventStorage(db_path)
+
+        # Create event with large content (10KB)
+        large_content = "测试内容" * 2500  # ~10KB of Chinese characters
+        event = make_event(100, 1, large_content, ["a1"])
+
+        result = storage.add_event(event)
+        assert result is True
+
+        events, _ = storage.get_events()
+        assert len(events) == 1
+        assert events[0].content == large_content
+
+        storage.close()
+
+    def test_special_characters_in_avatar_id(self, tmp_path):
+        """Test handling of special characters in avatar IDs."""
+        db_path = tmp_path / "events.db"
+        storage = EventStorage(db_path)
+
+        # UUID-style IDs with hyphens
+        avatar_id = "550e8400-e29b-41d4-a716-446655440000"
+        event = make_event(100, 1, "Test event", [avatar_id])
+
+        storage.add_event(event)
+
+        events = storage.get_events_by_avatar(avatar_id)
+        assert len(events) == 1
+        assert avatar_id in events[0].related_avatars
+
+        storage.close()
+
+    def test_empty_database_queries(self, tmp_path):
+        """Test queries on empty database return sensible results."""
+        db_path = tmp_path / "events.db"
+        storage = EventStorage(db_path)
+
+        # All queries should return empty lists, not errors
+        assert storage.get_events() == ([], None)
+        assert storage.get_events_by_avatar("nonexistent") == []
+        assert storage.get_events_between("a1", "a2") == []
+        assert storage.get_major_events_by_avatar("a1") == []
+        assert storage.get_minor_events_by_avatar("a1") == []
+        assert storage.get_recent_events() == []
+        assert storage.count() == 0
+
+        storage.close()
+
+
+class TestEventManagerMemoryFallback:
+    """Tests for EventManager memory fallback mode."""
+
+    def test_memory_mode_basic_operations(self):
+        """Test that memory mode works for basic operations."""
+        manager = EventManager.create_in_memory()
+
+        manager.add_event(make_event(100, 1, "Event 1", ["a1"]))
+        manager.add_event(make_event(100, 2, "Event 2", ["a2"]))
+
+        assert manager.count() == 2
+
+        events = manager.get_recent_events()
+        assert len(events) == 2
+
+        a1_events = manager.get_events_by_avatar("a1")
+        assert len(a1_events) == 1
+
+    def test_memory_mode_cleanup(self):
+        """Test that cleanup works in memory mode."""
+        manager = EventManager.create_in_memory()
+
+        manager.add_event(make_event(100, 1, "Event 1"))
+        manager.add_event(make_event(100, 2, "Event 2"))
+
+        deleted = manager.cleanup()
+
+        assert deleted == 2
+        assert manager.count() == 0
+
+
+class TestEventStorageCleanup:
+    """Tests for event cleanup functionality."""
+
+    def test_cleanup_with_time_filter(self, tmp_path):
+        """Test cleanup with before_month_stamp filter."""
+        db_path = tmp_path / "events.db"
+        storage = EventStorage(db_path)
+
+        # Add events at different times
+        storage.add_event(make_event(50, 1, "Very old", is_major=False))
+        storage.add_event(make_event(100, 1, "Old", is_major=False))
+        storage.add_event(make_event(150, 1, "Recent", is_major=False))
+
+        # Delete events before year 100
+        cutoff = int(create_month_stamp(Year(100), Month.JANUARY))
+        deleted = storage.cleanup(keep_major=False, before_month_stamp=cutoff)
+
+        assert deleted == 1  # Only "Very old" deleted
+        assert storage.count() == 2
+
+        storage.close()
+
+    def test_cleanup_preserves_major_events(self, tmp_path):
+        """Test that cleanup preserves major events by default."""
+        db_path = tmp_path / "events.db"
+        storage = EventStorage(db_path)
+
+        storage.add_event(make_event(100, 1, "Minor 1", is_major=False))
+        storage.add_event(make_event(100, 2, "Major 1", is_major=True))
+        storage.add_event(make_event(100, 3, "Minor 2", is_major=False))
+
+        deleted = storage.cleanup(keep_major=True)
+
+        assert deleted == 2
+        assert storage.count() == 1
+
+        events = storage.get_recent_events()
+        assert events[0].content == "Major 1"
+
+        storage.close()