@@ -6876,3 +6876,15 @@ Unplaced segments still bypass matching. Their capture-placement repair belongs
 to the live timeline lane; this change never invents offsets to obtain evidence.
 No production configuration flip is required or performed. Backend/listen images
 and a Flutter build are required to deliver the corresponding safe changes.
+
+Per-session ordinal churn is exported where the deferral is enforced:
+`omi_live_speaker_ordinals_per_session` (histogram, observed once per listen
+session at teardown by `utils/observability/live_speaker_ordinals.py`) counts the
+distinct unnamed scoped voices that cleared the five-second placed-speech floor,
+with voices the session named excluded; `omi_live_speaker_scope_rotations_total`
+counts scope/epoch rotations over the same sessions. **Watch after listen rolls**:
+`histogram_quantile(0.95, rate(omi_live_speaker_ordinals_per_session_bucket[1h]))`
+and its mean (`_sum/_count`) should fall while rotations per session
+(`rate(omi_live_speaker_scope_rotations_total[1h]) / rate(omi_listen_ws_close_total[1h])`)
+holds — ordinals falling with rotations flat means the deferral is working, not
+that conversations gained fewer speakers.
@@ -64,6 +64,7 @@
 from utils.observability.journeys import ClientJourneyAttempt
 from utils.observability.listen_close import CLOSE_FRAME_DRAIN_SECONDS, note_ws_close, record_listen_ws_close
 from utils.observability.listen_loop import ensure_loop_lag_probe
+from utils.observability.live_speaker_ordinals import LiveSpeakerOrdinalTracker, record_live_speaker_ordinals
 from utils.observability.routing_cohort import RoutingCohort, current_routing_cohort
 from utils.observability.transcription import (
     LiveSTTAttempt,
@@ -223,6 +224,7 @@ def __init__(self, request: ListenRequest):
         self.transcripts: Any = None
         self.conversations: Any = None
         self.parity_capture = ListenParityCapture(None)
+        self.speaker_ordinal_tracker = LiveSpeakerOrdinalTracker()
 
     def _build_components(self) -> None:
         channels = build_channel_config(self.request.source or 'phone_call') if self.is_multi_channel else []
@@ -1447,6 +1449,9 @@ async def _teardown_components(self) -> None:
             await self.language_observations.summarize(None if owner_persistence_blocked else self.request.uid)
         if not owner_persistence_blocked:
             await self.task_supervisor.drain_all(timeout=5.0, cancel=True)
+        # After the transcript loop drained and before the matcher's maps clear:
+        # the ordinal ledger needs both the final segments and final naming.
+        record_live_speaker_ordinals(getattr(self, 'speaker_ordinal_tracker', None), self.speakers)
         self.receiver.clear()
         self.transcripts.clear()
         self.speakers.clear()
 
@@ -1486,11 +1486,14 @@ async def _speaker_detection(
         """
         speaker = self.host.speakers
         observer = getattr(speaker, 'observe_segment', None)
+        ordinal_tracker = getattr(self.host, 'speaker_ordinal_tracker', None)
         if observer is not None:
             observed = queue_from_raw if queue_from_raw is not None else [s.model_dump() for s in segments]
             for raw in observed:
                 if raw.get('speaker_id') is not None:
                     observer(raw['speaker_id'], raw.get('speaker_id_scope') or '', raw.get('id') or '')
+                    if ordinal_tracker is not None:
+                        ordinal_tracker.observe(raw)
         for segment in segments:
             segment_id = cast(str, segment.id)
             if queue_from_raw is None:
 
@@ -0,0 +1,169 @@
+"""Live speaker ordinal churn telemetry mirrors the display deferral, once per session.
+
+The tracker must reproduce #23533's qualification exactly enough to be a churn
+signal: five seconds of non-overlapping placed speech on an unnamed scoped voice
+mint one ordinal, named voices mint none, and scope rotations are counted
+separately so churn is readable against provider-epoch and reconnect rotations.
+"""
+
+from types import SimpleNamespace
+
+from models.transcript_segment import TranscriptSegment
+from routers.listen.transcripts import TranscriptProcessor
+from utils.observability.live_speaker_ordinals import (
+    MAX_TRACKED_VOICES,
+    OMI_LIVE_SPEAKER_ORDINALS_PER_SESSION,
+    OMI_LIVE_SPEAKER_SCOPE_ROTATIONS_TOTAL,
+    LiveSpeakerOrdinalTracker,
+    record_live_speaker_ordinals,
+)
+
+
+def voice(sid, speaker, scope, start, end, *, is_user=False, person_id=None):
+    return dict(
+        id=sid,
+        text='Testing one two',
+        speaker_id=speaker,
+        speaker_id_scope=scope,
+        start=start,
+        end=end,
+        is_user=is_user,
+        person_id=person_id,
+    )
+
+
+def test_deferral_floor_mints_no_ordinal_below_five_placed_seconds():
+    tracker = LiveSpeakerOrdinalTracker()
+    tracker.observe(voice('s1', 0, 'scope:0', 0.0, 4.9))
+    assert tracker.close() == (0, 0)
+
+
+def test_five_seconds_of_one_voice_mints_exactly_one_ordinal():
+    tracker = LiveSpeakerOrdinalTracker()
+    tracker.observe(voice('s1', 0, 'scope:0', 0.0, 2.0))
+    tracker.observe(voice('s2', 0, 'scope:0', 3.0, 6.0))
+    assert tracker.close() == (1, 0)
+
+
+def test_overlapping_and_replayed_spans_union_instead_of_double_counting():
+    tracker = LiveSpeakerOrdinalTracker()
+    # 4s + 4s overlapping in a 1s window is a 7s union: one qualified voice,
+    # and a replay of the first span adds nothing.
+    tracker.observe(voice('s1', 0, 'scope:0', 0.0, 4.0))
+    tracker.observe(voice('s1', 0, 'scope:0', 3.0, 7.0))
+    tracker.observe(voice('s1', 0, 'scope:0', 0.0, 4.0))
+    assert tracker.close() == (1, 0)
+
+    # Adjacent bursts that never reach the floor across two voices mint nothing.
+    adjacent = LiveSpeakerOrdinalTracker()
+    adjacent.observe(voice('a1', 0, 'scope:0', 0.0, 2.5))
+    adjacent.observe(voice('a2', 1, 'scope:0', 2.5, 5.0))
+    assert adjacent.close() == (0, 0)
+
+
+def test_same_speaker_in_new_scope_is_a_new_ordinal_and_one_rotation():
+    tracker = LiveSpeakerOrdinalTracker()
+    tracker.observe(voice('s1', 0, 'scope:0', 0.0, 6.0))
+    tracker.observe(voice('s2', 1, 'scope:1', 10.0, 16.0))
+    tracker.observe(voice('s3', 2, 'scope:2', 20.0, 26.0))
+    assert tracker.close() == (3, 2)
+
+
+def test_named_voices_never_mint_ordinals():
+    tracker = LiveSpeakerOrdinalTracker()
+    tracker.observe(voice('s1', 0, 'scope:0', 0.0, 6.0, is_user=True))
+    tracker.observe(voice('s2', 1, 'scope:0', 0.0, 6.0, person_id='person'))
+    # A voice named only at close, through the matcher's final map.
+    tracker.observe(voice('s3', 2, 'scope:0', 0.0, 6.0))
+    tracker.note_named_voices(SimpleNamespace(speaker_to_person={2: ('person', 'Ada')}, _voice_scopes={2: 'scope:0'}))
+    assert tracker.close() == (0, 0)
+
+
+def test_unplaced_or_malformed_spans_add_no_seconds():
+    tracker = LiveSpeakerOrdinalTracker()
+    tracker.observe(voice('s1', 0, 'scope:0', -1.0, -1.0))
+    tracker.observe(voice('s2', 0, 'scope:0', 4.0, 4.0))
+    tracker.observe(voice('s3', 0, 'scope:0', float('nan'), 6.0))
+    tracker.observe(voice('s4', 0, 'scope:0', None, '6.0'))
+    assert tracker.close() == (0, 0)
+
+
+def test_segments_without_usable_speaker_id_are_ignored():
+    tracker = LiveSpeakerOrdinalTracker()
+    tracker.observe({'id': 's1', 'start': 0.0, 'end': 9.0})
+    tracker.observe(voice('s2', 'zero', 'scope:0', 0.0, 9.0))
+    tracker.observe(voice('s3', True, 'scope:0', 0.0, 9.0))
+    assert tracker.close() == (0, 0)
+
+
+def test_voice_inventory_is_bounded():
+    beyond = LiveSpeakerOrdinalTracker()
+    for index in range(MAX_TRACKED_VOICES):
+        beyond.observe(voice(f's{index}', index, 'scope:0', 0.0, 1.0))
+    # The (MAX_TRACKED_VOICES + 1)-th distinct voice is dropped, never a crash.
+    beyond.observe(voice('late', MAX_TRACKED_VOICES, 'scope:0', 0.0, 60.0))
+    assert beyond.close() == (0, 0)
+
+
+def test_record_observes_histogram_and_rotation_counter():
+    before_observations = OMI_LIVE_SPEAKER_ORDINALS_PER_SESSION._sum.get()
+    before_rotations = OMI_LIVE_SPEAKER_SCOPE_ROTATIONS_TOTAL._value.get()
+    tracker = LiveSpeakerOrdinalTracker()
+    tracker.observe(voice('s1', 0, 'scope:0', 0.0, 6.0))
+    tracker.observe(voice('s2', 1, 'scope:1', 8.0, 14.0))
+    tracker.observe(voice('s3', 2, 'scope:2', 20.0, 26.0))
+    record_live_speaker_ordinals(tracker, SimpleNamespace(speaker_to_person={}, _voice_scopes={}))
+    assert OMI_LIVE_SPEAKER_ORDINALS_PER_SESSION._sum.get() == before_observations + 3
+    assert OMI_LIVE_SPEAKER_SCOPE_ROTATIONS_TOTAL._value.get() == before_rotations + 2
+
+
+def test_record_never_raises_and_close_resets_state():
+    record_live_speaker_ordinals(None, None)
+    record_live_speaker_ordinals(LiveSpeakerOrdinalTracker(), object())
+    tracker = LiveSpeakerOrdinalTracker()
+    tracker.observe(voice('s1', 0, 'scope:0', 0.0, 6.0))
+    assert tracker.close() == (1, 0)
+    assert tracker.close() == (0, 0)
+
+
+async def test_speaker_detection_feeds_the_session_tracker():
+    observed = []
+    host = SimpleNamespace(
+        limits=SimpleNamespace(max_segment_buffer_size=10, max_photo_buffer_size=10),
+        translation_language=None,
+        language='en',
+        speakers=SimpleNamespace(
+            observe_segment=lambda speaker_id, scope, segment_id: observed.append((speaker_id, scope, segment_id)),
+            person_embeddings={},
+            speaker_to_person={},
+        ),
+        state=SimpleNamespace(speaker_id_enabled=False, current_conversation_id='c1'),
+        speaker_ordinal_tracker=LiveSpeakerOrdinalTracker(),
+    )
+    processor = TranscriptProcessor(host)
+    segments = [
+        TranscriptSegment(
+            id='s1',
+            text='Testing one two',
+            speaker_id=0,
+            speaker_id_scope='scope:0',
+            start=0.0,
+            end=6.0,
+            is_user=False,
+            speech_profile_processed=True,
+        ),
+        TranscriptSegment(
+            id='s2',
+            text='Testing three four',
+            speaker_id=1,
+            speaker_id_scope='scope:0',
+            start=6.0,
+            end=8.0,
+            is_user=False,
+            speech_profile_processed=True,
+        ),
+    ]
+    await processor._speaker_detection(segments, 0.0)
+    assert observed == [(0, 'scope:0', 's1'), (1, 'scope:0', 's2')]
+    # One qualified voice plus one still below the deferral floor, one scope.
+    assert host.speaker_ordinal_tracker.close() == (1, 0)
@@ -0,0 +1,161 @@
+"""Live per-session unnamed-speaker ordinal churn, observed once when a listen session closes.
+
+#23533 defers a live ordinal until an unnamed voice holds MIN_EVIDENCE_SECONDS of
+non-overlapping placed speech; before that floor the voice renders "Unknown
+speaker" and mints no ordinal. This metric answers whether that deferral actually
+reduced the consecutive "Speaker 4, 5, 6, 7, 8" lines seen live: how many distinct
+visible unnamed ordinals one session still mints, and how many speaker scope/epoch
+rotations (provider transitions, reconnect epochs) the session spent. Rotations
+re-key the same humans and re-mint their ordinals, so the pair separates label
+churn from real multi-speaker conversations.
+
+Qualification mirrors ``utils.speakers.display.display_participants`` with
+``defer_short_voices=True``: the same voice key ``(speaker_id_scope, speaker_id)``,
+the same five-second union of placed speech, and a voice the session named (owner
+or person identity) never mints an ordinal. This is display bookkeeping only; it
+never feeds speaker decisions.
+
+Labels: none. Never uid, session or conversation identifiers.
+"""
+
+from __future__ import annotations
+
+import logging
+from math import isfinite
+from typing import Any, Mapping, Optional
+
+from prometheus_client import Counter, Histogram
+
+from utils.speakers.policy import MIN_EVIDENCE_SECONDS
+
+logger = logging.getLogger(__name__)
+
+# Voice inventory ceiling, matching routers.listen.speakers.MAX_SPEAKER_VOICES;
+# a session minting more unnamed voices than this is already collapsed to "Others"
+# by the display layer's MAX_UNNAMED_VOICES guard.
+MAX_TRACKED_VOICES = 128
+# Per-voice merged placed-speech intervals while a voice is still below the
+# evidence floor. Past this many disjoint bursts the tracker stops extending the
+# union (under-counting errs toward "Unknown speaker", the same side as deferral).
+MAX_VOICE_INTERVALS = 512
+
+OMI_LIVE_SPEAKER_ORDINALS_PER_SESSION = Histogram(
+    'omi_live_speaker_ordinals_per_session',
+    'Distinct visible unnamed speaker ordinals one live listen session minted, '
+    'after the #23533 short-voice deferral floor',
+    buckets=(0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 13, 16, 24, 32),
+)
+OMI_LIVE_SPEAKER_SCOPE_ROTATIONS_TOTAL = Counter(
+    'omi_live_speaker_scope_rotations_total',
+    'Speaker scope/epoch rotations inside live listen sessions (provider transitions and '
+    'reconnects), summed per session at close',
+)
+
+
+def _merge_interval(intervals: list[tuple[float, float]], span: tuple[float, float]) -> None:
+    """Insert one span into a sorted, disjoint interval list, merging overlaps in place."""
+    if len(intervals) >= MAX_VOICE_INTERVALS:
+        return
+    start, end = span
+    merged: list[tuple[float, float]] = []
+    placed = False
+    for low, high in intervals:
+        if high < start:
+            merged.append((low, high))
+        elif end < low:
+            if not placed:
+                merged.append((start, end))
+                placed = True
+            merged.append((low, high))
+        else:
+            start = min(start, low)
+            end = max(end, high)
+    if not placed:
+        merged.append((start, end))
+    intervals[:] = merged
+
+
+class LiveSpeakerOrdinalTracker:
+    """Per-session ordinal ledger. Event-loop confined, like the collapse monitor.
+
+    Observe every final live segment (post scope-stamp and speaker-id assignment);
+    close once at session teardown. Unplaced or malformed spans add no speech
+    seconds, exactly like the display deferral's placement gate.
+    """
+
+    def __init__(self, min_evidence_seconds: float = MIN_EVIDENCE_SECONDS) -> None:
+        self._min_evidence_seconds = min_evidence_seconds
+        self._intervals: dict[tuple[str, int], list[tuple[float, float]]] = {}
+        self._qualified: set[tuple[str, int]] = set()
+        self._named: set[tuple[str, int]] = set()
+        self._scopes: set[str] = set()
+
+    def observe(self, segment: Mapping[str, Any]) -> None:
+        speaker_id = segment.get('speaker_id')
+        if isinstance(speaker_id, bool) or not isinstance(speaker_id, int):
+            return
+        scope = segment.get('speaker_id_scope')
+        scope = scope if isinstance(scope, str) else ''
+        if scope:
+            self._scopes.add(scope)
+        key = (scope, speaker_id)
+        if segment.get('is_user') or segment.get('person_id'):
+            self._named.add(key)
+        if key in self._qualified:
+            return
+        start, end = segment.get('start'), segment.get('end')
+        if (
+            isinstance(start, bool)
+            or isinstance(end, bool)
+            or not isinstance(start, (int, float))
+            or not isinstance(end, (int, float))
+        ):
+            return
+        start, end = float(start), float(end)
+        if not (isfinite(start) and isfinite(end) and 0 <= start < end):
+            return
+        intervals = self._intervals.get(key)
+        if intervals is None:
+            if len(self._intervals) >= MAX_TRACKED_VOICES:
+                return
+            intervals = self._intervals[key] = []
+        _merge_interval(intervals, (start, end))
+        if sum(high - low for low, high in intervals) >= self._min_evidence_seconds:
+            # Qualified: the ordinal is minted unless the voice is named by close.
+            self._qualified.add(key)
+            del self._intervals[key]
+
+    def note_named_voices(self, matcher: Any) -> None:
+        """Fold the matcher's final voice-to-person map into the named set."""
+        mappings = getattr(matcher, 'speaker_to_person', None)
+        if not isinstance(mappings, Mapping):
+            return
+        scopes = getattr(matcher, '_voice_scopes', None)
+        scopes = scopes if isinstance(scopes, Mapping) else {}
+        for voice in mappings:
+            if isinstance(voice, int) and not isinstance(voice, bool):
+                self._named.add((scopes.get(voice) or '', voice))
+
+    def close(self) -> tuple[int, int]:
+        """(minted unnamed ordinals, scope rotations) for the session; resets state."""
+        ordinals = len(self._qualified - self._named)
+        rotations = max(0, len(self._scopes) - 1)
+        self._intervals.clear()
+        self._qualified.clear()
+        self._named.clear()
+        self._scopes.clear()
+        return ordinals, rotations
+
+
+def record_live_speaker_ordinals(tracker: Optional[LiveSpeakerOrdinalTracker], matcher: Any) -> None:
+    """Observe one ended listen session. Never raises: telemetry must not fail teardown."""
+    try:
+        if tracker is None:
+            return
+        tracker.note_named_voices(matcher)
+        ordinals, rotations = tracker.close()
+        OMI_LIVE_SPEAKER_ORDINALS_PER_SESSION.observe(ordinals)
+        if rotations:
+            OMI_LIVE_SPEAKER_SCOPE_ROTATIONS_TOTAL.inc(rotations)
+    except Exception as error:
+        logger.warning('Live speaker ordinal metric failed type=%s', type(error).__name__)