feat(voice): ground STT analyzer prompt on the live VC roster + emit addressed_seat_no

The roster grounding fixes two compounding failure modes that surfaced
when sakura said "ラキオが怪しい" in voicetest and the analyzer
returned ``addressed_name=null, stance={}, vote_target_seat=null`` —
i.e. nothing routable to seat 1 — even though the speaker's intent
was unambiguous.

1) Whisper renders less-common Japanese names with phonetic drift
   ("ラキオ" → "ラッキーオ"). The static analyzer prompt only saw the
   mistranscription, had no anchor to the actual participant list,
   and could not resolve the name back to a seat. Now the STT call
   threads a ``roster: Sequence[(seat_no, display_name)]`` derived
   from the *live* VC member list (via ``bot.get_guild().get_member().display_name``,
   cross-referenced with NpcRegistry for NPC-bot user IDs since their
   seats carry ``discord_user_id=NULL``). The analyzer prompt
   instructs the LLM to collapse phonetic / orthographic / honorific
   variants onto a roster entry and to also resolve ``vote_target_seat``
   against the same list. xAI Grok dry-run on the canonical failure
   case confirms the fix:
       INPUT  : "ラッキーオさんが怪しいと思います"
       BEFORE : addressed_name=null, stance={}, vote_target_seat=null
       AFTER  : addressed_name="🦋ラキオ", stance={"1":"negative"},
                summary normalised to canonical name

2) The legacy resolver only matched against ``Seat.display_name``
   (set once at backfill = the persona's canonical handle, e.g.
   "🦋ラキオ"). When an operator renamed an NPC bot in the guild
   ("Lucky"), the live VC nickname diverged from the persona handle
   and downstream ``resolve_seat_by_name("Lucky", seats)`` returned
   None — so even with a roster grounding, the analyzer's literal
   string answer would not survive Master-side resolution. Add an
   ``addressed_seat_no`` field analogous to ``vote_target_seat`` that
   the analyzer pre-resolves from the roster directly. Plumb it
   through ``SttResult`` → ``SpeechEventPayload`` and have
   ``MasterIngestService.ingest_voice`` prefer it when it points at
   an alive seat, falling back to the name path on miss / hallucinated
   value. Verified against Grok with a renamed-bot roster:
       INPUT  : "Luckyさん何か言いたそうですね" (seat 1 = "Lucky")
       OUTPUT : addressed_name="Lucky", addressed_seat_no=1
       INPUT  : "ラッキーオさんに投票します"
       OUTPUT : vote_target_seat=1, addressed_seat_no=1

Voicetest mirrors the production resolver — the roster lookup pulls
from ``vc_channel.members`` so an operator can A/B with the same
nicknames the speaker actually sees on their VC overlay. A startup
log line dumps the resolved roster snapshot so the prompt grounding
is auditable without crawling the JSONL trace.

Author: skr19930617

src/wolfbot/domain/ws_messages.py

@@ -538,6 +538,18 @@ class SpeechEventPayload(BaseEnvelope):
             "the analyzer didn't detect a named address."
         ),
     )
+    addressed_seat_no: int | None = Field(
+        default=None,
+        description=(
+            "Seat number the analyzer pre-resolved ``addressed_name`` to "
+            "when its prompt was grounded with a roster. Master prefers "
+            "this over running ``resolve_seat_by_name(addressed_name, ...)`` "
+            "which only matches against the persona-canonical "
+            "``Seat.display_name`` and fails when the bot's live VC "
+            "nickname diverges from the persona handle. None when the "
+            "analyzer wasn't grounded or couldn't pick a seat."
+        ),
+    )
 
 
 class SttFailed(BaseEnvelope):

src/wolfbot/main.py

@@ -103,9 +103,23 @@ async def post_public(self, game_id: str, text: str, kind: str) -> None:
     # voice-ingest seat/phase caches (populated when integrated ingest is active)
     _vc_seat_map: dict[str, int] = {}
     _vc_phase_cache: list[tuple[str, str] | None] = [None]
+    # Alive seats as ``(seat_no, display_name)`` so the analyzer LLM
+    # can resolve mistranscribed names to a canonical participant.
+    _vc_roster: list[tuple[int, str]] = []
 
     async def _refresh_voice_ingest_cache(game_id: str) -> None:
-        """Update seat map and phase cache for the integrated voice-ingest."""
+        """Update seat map and phase cache for the integrated voice-ingest.
+
+        ``_vc_roster`` holds the alive seats in ``(seat_no, display_name)``
+        form for the analyzer LLM's name-resolution prompt. The
+        ``display_name`` here is the **live VC nickname** as Discord
+        renders it for that participant - i.e. what the human speaker
+        actually sees on their VC overlay - not the stored
+        ``Seat.display_name`` (which for NPC seats is the persona's
+        canonical handle and may differ from the Discord bot's
+        guild-side nickname). Falls back to the stored value when the
+        member is uncached or the bot user_id isn't known yet.
+        """
         game = await repo.load_game(game_id)
         if game is None or game.ended_at is not None:
             _vc_phase_cache[0] = None
@@ -115,11 +129,42 @@ async def _refresh_voice_ingest_cache(game_id: str) -> None:
         _vc_phase_cache[0] = (game.id, phase_id)
         seats = await repo.load_seats(game_id)
         players = await repo.load_players(game_id)
+        alive_seats = {p.seat_no for p in players if p.alive}
         _vc_seat_map.clear()
         for s in seats:
-            if s.discord_user_id and any(p.seat_no == s.seat_no and p.alive for p in players):
+            if s.discord_user_id and s.seat_no in alive_seats:
                 _vc_seat_map[s.discord_user_id] = s.seat_no
 
+        # Resolve each seat's live VC display name. NPC seats have
+        # ``discord_user_id=NULL`` in the seats table, so cross-
+        # reference NpcRegistry to pick up the bot's actual user id
+        # (each NPC bot logs in as its own Discord user).
+        try:
+            guild = bot.get_guild(int(game.guild_id)) if game.guild_id else None
+        except (TypeError, ValueError):
+            guild = None
+        npc_user_by_seat: dict[int, str] = {}
+        if _npc_registry_ref:
+            registry = _npc_registry_ref[0]
+            for entry in registry.assigned_to_game(game.id):
+                if entry.assigned_seat is not None:
+                    npc_user_by_seat[entry.assigned_seat] = entry.discord_bot_user_id
+
+        _vc_roster.clear()
+        for s in sorted(seats, key=lambda x: x.seat_no):
+            if s.seat_no not in alive_seats:
+                continue
+            user_id_str = s.discord_user_id or npc_user_by_seat.get(s.seat_no)
+            live_name: str | None = None
+            if guild is not None and user_id_str:
+                try:
+                    member = guild.get_member(int(user_id_str))
+                except (TypeError, ValueError):
+                    member = None
+                if member is not None:
+                    live_name = member.display_name
+            _vc_roster.append((s.seat_no, live_name or s.display_name))
+
     # ---- Master VC join lifecycle ---------------------------------------
     # Single VC connection; one Master = one guild = at most one active
     # reactive_voice game at a time. Held in a list so closures can rebind.
@@ -1103,6 +1148,15 @@ def _seat_lookup(discord_user_id: str) -> int | None:
             def _phase_lookup() -> tuple[str, str] | None:
                 return _vc_phase_cache[0]
 
+            def _roster_lookup() -> list[tuple[int, str]]:
+                """Snapshot of alive seats for grounding the STT analyzer.
+
+                Read out of the ``_vc_roster`` cache populated by
+                ``_refresh_voice_ingest_cache`` so we don't hit the DB
+                on every speech segment.
+                """
+                return list(_vc_roster)
+
             voice_ingest = VoiceIngestService(
                 registry_view=_RegistryViewAdapter(),
                 master_client=direct_client,
@@ -1113,6 +1167,7 @@ def _phase_lookup() -> tuple[str, str] | None:
                     pre_stt_min_rms=settings.VOICE_PRE_STT_MIN_RMS,
                     pre_stt_min_duration_ms=settings.VOICE_PRE_STT_MIN_DURATION_MS,
                 ),
+                roster_lookup=_roster_lookup,
             )
             if settings.VOICE_STT_PROVIDER == "groq":
                 log.info(

src/wolfbot/master/ingest_service.py

@@ -232,8 +232,23 @@ async def ingest_voice(
             alive_seat_nos=alive_seat_nos,
         )
 
+        # Prefer the analyzer's pre-resolved seat number when its
+        # prompt was grounded with a roster - that path bypasses the
+        # legacy ``resolve_seat_by_name`` string match, which only
+        # compares against ``Seat.display_name`` (=persona handle)
+        # and silently drops the address when the live VC nickname
+        # diverges. Validate the seat is actually alive in this
+        # phase before trusting it; fall back to the name-resolution
+        # path otherwise so a buggy / hallucinated seat number
+        # doesn't poison the routing.
         addressed_seat_no: int | None = None
-        if payload.addressed_name:
+        alive_set = set(alive_seat_nos)
+        if (
+            payload.addressed_seat_no is not None
+            and payload.addressed_seat_no in alive_set
+        ):
+            addressed_seat_no = payload.addressed_seat_no
+        elif payload.addressed_name:
             try:
                 addressed_seat_no = await self.phase_lookup.resolve_addressed_seat(
                     payload.game_id, payload.addressed_name
@@ -245,9 +260,9 @@ async def ingest_voice(
                     payload.addressed_name,
                 )
                 addressed_seat_no = None
-            # Self-address never needs a routed reply.
-            if addressed_seat_no is not None and addressed_seat_no == payload.seat_no:
-                addressed_seat_no = None
+        # Self-address never needs a routed reply.
+        if addressed_seat_no is not None and addressed_seat_no == payload.seat_no:
+            addressed_seat_no = None
 
         event = SpeechEvent(
             event_id=new_event_id(),