fix(speakers): defer short live epoch labels and gate owner evidence

app/changelog/unreleased/live-speaker-epochs.json

@@ -0,0 +1 @@
+{"change":"Short unidentified live turns stay unnamed across reconnects instead of creating a new numbered speaker for each socket."}

app/docs/ux-contract.md

@@ -217,6 +217,7 @@ participant lists, the speaker filter and every copied, shared or exported trans
 - Everyone else is **Speaker N**, N dense per conversation (1, 2, 3… in order of first
   appearance, skipping the owner and Omi). Never a raw id, never a gap. Naming a person does not
   renumber the others. `TranscriptSegment.getDisplaySpeakerId` returns the same N.
+- Live capture passes `deferShortVoices: true`: unnamed voices remain plain **Speaker** until five seconds of non-overlapping placed speech. Unplaced text cannot qualify. Number at qualification time so a short earlier voice cannot renumber an established voice; owner and known-person names still use their existing authority. This display floor does not identify or merge voices.
 - When the server could not resolve speakers across the conversation (`speaker_resolution.status`
   is `unavailable`), raw ids from different recordings are not comparable, so an unnamed voice is
   the plain **Speaker** (`l10n.unnamedSpeakerLabel`), never "Speaker ?" and never a number, and the

app/lib/pages/episodes/live_episode_page.dart

@@ -382,7 +382,8 @@ class LiveEpisodePageState extends State<LiveEpisodePage> with SingleTickerProvi
     final key = Object.hash(capture.segmentsPhotosVersion, identityHashCode(people));
     if (_namesKey != key || _names == null) {
       _namesKey = key;
-      _names = SpeakerNames.forSegments(capture.segments, people: people ?? const <Person>[], l10n: context.l10n);
+      _names = SpeakerNames.forSegments(capture.segments,
+          people: people ?? const <Person>[], l10n: context.l10n, deferShortVoices: true);
     }
     return _names!;
   }

app/lib/pages/episodes/live_transcript_view.dart

@@ -1,4 +1,4 @@
 import 'package:flutter/material.dart';
 
 import 'package:provider/provider.dart';
 
@@ -175,7 +175,8 @@
       // list, while its old delegate still has the previous itemCount. Keep one
       // membership snapshot for that delegate, its names and decorations.
       _timelineSegments = List<TranscriptSegment>.of(provider.segments);
-      _timelineNames = SpeakerNames.forSegments(_timelineSegments!, people: people, l10n: context.l10n);
+      _timelineNames =
+          SpeakerNames.forSegments(_timelineSegments!, people: people, l10n: context.l10n, deferShortVoices: true);
       _timelineDecorations = LiveTranscriptDecorations.of(widget.episode, conversationId, _timelineSegments!);
       _timelinePhotos = List<ConversationPhoto>.from(provider.photos)
         ..sort((a, b) => a.createdAt.compareTo(b.createdAt));

app/lib/ui/format/speaker_names.dart

@@ -26,7 +26,11 @@ import 'package:omi/ui/format/diarization_label.dart';
 /// ```
 class SpeakerNames {
   static const maxUnnamedVoices = 8;
-  SpeakerNames._(this._ordinals, this._peopleById, this._ownerName, this._l10n, this._unresolved, this._collapsed);
+
+  // Display qualification only; voice linking still requires backend acoustic evidence.
+  static const minLiveVoiceSeconds = 5.0;
+  SpeakerNames._(this._ordinals, this._peopleById, this._ownerName, this._l10n, this._unresolved, this._collapsed,
+      this._deferShortVoices);
 
   /// Resolver for [segments] (the whole conversation, so numbering matches every surface).
   ///
@@ -37,15 +41,20 @@ class SpeakerNames {
     List<Person> people = const [],
     String? ownerName,
     bool unresolved = false,
+    bool deferShortVoices = false,
     required AppLocalizations l10n,
   }) {
     return SpeakerNames._(
-      {for (final entry in denseOrdinals(segments).entries) DiarizationLabel.fromRaw(entry.key): entry.value},
+      {
+        for (final entry in (deferShortVoices ? _qualifiedLiveOrdinals(segments) : denseOrdinals(segments)).entries)
+          DiarizationLabel.fromRaw(entry.key): entry.value
+      },
       {for (final person in people) person.id: person},
       ownerName == null || ownerName.trim().isEmpty ? null : ownerName.trim(),
       l10n,
       unresolved,
       _surplusVoices(segments, people),
+      deferShortVoices,
     );
   }
 
@@ -55,6 +64,7 @@ class SpeakerNames {
   final String? _ownerName;
   final AppLocalizations _l10n;
   final bool _unresolved;
+  final bool _deferShortVoices;
 
   /// The name for [segment]'s speaker. [person] overrides the people lookup (callers that already
   /// resolved it).
@@ -91,7 +101,9 @@ class SpeakerNames {
   /// "Speaker N" for a diarized [speakerId], with N from [ordinalFor].
   String anonymousName(int speakerId) {
     if (speakerId == omiSpeakerId) return _l10n.omiAppName;
-    if (_unresolved) return _l10n.unnamedSpeakerLabel;
+    if (_unresolved || (_deferShortVoices && !_ordinals.containsKey(DiarizationLabel.fromRaw(speakerId)))) {
+      return _l10n.unnamedSpeakerLabel;
+    }
     if (_collapsed.contains(DiarizationLabel.fromRaw(speakerId))) return _l10n.othersSpeakerLabel;
     return _l10n.speakerWithId('${ordinalFor(speakerId)}');
   }
@@ -112,6 +124,41 @@ class SpeakerNames {
     return ordinals;
   }
 
+  /// Allocate at the turn that completes five non-overlapping placed seconds.
+  /// A short early voice qualifying later cannot renumber an already qualified voice.
+  static Map<int, int> _qualifiedLiveOrdinals(List<TranscriptSegment> segments) {
+    final ranges = <int, List<(double, double)>>{};
+    for (final segment in segments) {
+      if (segment.isUser || segment.speakerId == omiSpeakerId) continue;
+      final start = segment.start, end = segment.end;
+      if (!start.isFinite || !end.isFinite || start < 0 || end <= start) continue;
+      ranges.putIfAbsent(segment.speakerId, () => []).add((start, end));
+    }
+    final qualifiedAt = <int, double>{};
+    for (final entry in ranges.entries) {
+      final voiceRanges = entry.value..sort((a, b) => a.$1.compareTo(b.$1));
+      var coveredEnd = double.negativeInfinity, seconds = 0.0;
+      for (final range in voiceRanges) {
+        final uncoveredStart = range.$1 > coveredEnd ? range.$1 : coveredEnd;
+        final fresh = range.$2 > uncoveredStart ? range.$2 - uncoveredStart : 0.0;
+        if (seconds + fresh >= minLiveVoiceSeconds) {
+          qualifiedAt[entry.key] = uncoveredStart + minLiveVoiceSeconds - seconds;
+          break;
+        }
+        seconds += fresh;
+        if (range.$2 > coveredEnd) coveredEnd = range.$2;
+      }
+    }
+    final appearance = {for (final entry in ranges.keys.indexed) entry.$2: entry.$1};
+    final qualified = qualifiedAt.keys.toList()
+      ..sort((a, b) {
+        final byTime = qualifiedAt[a]!.compareTo(qualifiedAt[b]!);
+        return byTime != 0 ? byTime : appearance[a]!.compareTo(appearance[b]!);
+      });
+    final ordinals = {for (final entry in qualified.indexed) entry.$2: entry.$1 + 1};
+    return ordinals;
+  }
+
   /// Presentation mitigation only: keep at most seven substantial unknown voices plus Others.
   /// Known people and the owner are never merged. Raw identity remains available for correction.
   static Set<DiarizationLabel> _surplusVoices(List<TranscriptSegment> segments, List<Person> people) {

app/lib/widgets/transcript.dart

@@ -1,4 +1,4 @@
 import 'dart:convert';
 import 'dart:math';
 
 import 'package:omi/utils/platform/platform_manager.dart';
@@ -809,6 +809,7 @@
       people: people,
       l10n: context.l10n,
       unresolved: widget.unresolvedSpeakers,
+      deferShortVoices: widget.followLatest,
     );
     final searchBarHeight = widget.searchQuery.isNotEmpty ? 100.0 : 0.0;
     final transcriptList = NotificationListener<ScrollMetricsNotification>(
@@ -944,7 +945,7 @@
     );
   }
 
   Widget _buildSegmentItem(int segmentIdx, List<Person> people, SpeakerNames names, Set<String> askSegmentIds) {
     if (widget.isConversationDetail) return _buildDetailLine(segmentIdx, people, names, askSegmentIds);
     final data = widget.segments[segmentIdx];
     final Person? person = personById(people, data.personId);

app/test/unit/ui_format/speaker_names_test.dart

@@ -33,7 +33,7 @@
     Person(id: id, name: name, createdAt: DateTime(2026), updatedAt: DateTime(2026));
 
 /// One speaker vocabulary on every surface: "You", people's names, "Omi", and dense "Speaker N".
 void main() {
   final en = lookupAppLocalizations(const Locale('en'));
 
   test('on-device engines carry no speaker label in UI or transcript exports', () {
@@ -59,6 +59,45 @@
     expect(SpeakerNames.forSegments(before, l10n: en).forSegment(before[2]), 'Speaker 3');
   });
 
+  test('live short socket epochs stay unnamed and do not spend ordinals', () {
+    final rows = [for (var id = 4; id <= 8; id++) seg(id)];
+    final names = SpeakerNames.forSegments(rows, deferShortVoices: true, l10n: en);
+    expect(rows.map(names.forSegment).toSet(), {'Speaker'});
+    expect(rows.map((r) => r.speakerId).toSet().length, 5);
+    final qualified = [...rows, seg(20)..end = 5, seg(21)..end = 5];
+    final next = SpeakerNames.forSegments(qualified, deferShortVoices: true, l10n: en);
+    expect(qualified.take(5).map(next.forSegment).toSet(), {'Speaker'});
+    expect(qualified.skip(5).map(next.forSegment), ['Speaker 1', 'Speaker 2']);
+    expect(next.anonymousName(50), 'Speaker', reason: 'new arrivals have no evidence yet');
+  });
+
+  test('live evidence pools short turns once and allocates in qualification order', () {
+    final first = seg(4)..end = 2.5;
+    final second = seg(4)
+      ..start = 3
+      ..end = 5.5;
+    final substantial = seg(8)..end = 5;
+    final rows = [first, substantial, second];
+    final names = SpeakerNames.forSegments(rows, deferShortVoices: true, l10n: en);
+    expect(names.forSegment(substantial), 'Speaker 1');
+    expect(names.forSegment(first), 'Speaker 2');
+    final repeats = [
+      first,
+      seg(4)..end = 4.99,
+      seg(9)
+        ..start = -1
+        ..end = -1
+    ];
+    final pending = SpeakerNames.forSegments(repeats, deferShortVoices: true, l10n: en);
+    expect(repeats.map(pending.forSegment).toSet(), {'Speaker'});
+  });
+
+  test('live deferral preserves owner and manual names without guessing another owner', () {
+    final rows = [seg(4, isUser: true), seg(5, personId: 'ada'), seg(6), seg(7, isUser: true)];
+    final names = SpeakerNames.forSegments(rows, people: [person('ada', 'Ada')], deferShortVoices: true, l10n: en);
+    expect(rows.map(names.forSegment), ['You', 'Ada', 'Speaker', 'You']);
+  });
+
   test('Omi is "Omi", never "Speaker 100", and never takes a number', () {
     final segments = [seg(omiSpeakerId), seg(4)];
     final names = SpeakerNames.forSegments(segments, l10n: en);

app/test/widgets/transcript_test.dart

@@ -1,4 +1,4 @@
 import 'dart:convert';
 
 import 'package:flutter/gestures.dart' show kDoubleTapTimeout;
 import 'package:flutter/material.dart';
@@ -18,7 +18,7 @@
 import 'package:omi/providers/people_provider.dart';
 import 'package:provider/provider.dart';
 
 void main() {
   setUpAll(() async {
     TestWidgetsFlutterBinding.ensureInitialized();
     SharedPreferences.setMockInitialValues({});
@@ -90,6 +90,32 @@
     expect(find.text('Speaker 1'), findsOneWidget);
   });
 
+  testWidgets('live short epochs render unnamed while preserving correction identities', (tester) async {
+    await setupSharedPreferences();
+    await tester.binding.setSurfaceSize(const Size(800, 1000));
+    addTearDown(() => tester.binding.setSurfaceSize(null));
+    final rows = [for (var id = 4; id <= 8; id++) segmentFor('epoch-$id', id)];
+    final edited = <int>[];
+    await tester.pumpWidget(MaterialApp(
+      localizationsDelegates: AppLocalizations.localizationsDelegates,
+      supportedLocales: AppLocalizations.supportedLocales,
+      home: Scaffold(
+          body: TranscriptWidget(
+        segments: rows,
+        followLatest: true,
+        editSegment: (_, id) => edited.add(id),
+      )),
+    ));
+    await tester.pumpAndSettle();
+    expect(find.text('Speaker'), findsNWidgets(5));
+    for (var id = 1; id <= 8; id++) {
+      expect(find.text('Speaker $id'), findsNothing);
+    }
+    await tester.tap(find.text('Speaker').at(1));
+    await tester.pump();
+    expect(edited, [5]);
+  });
+
   group('Speaker label display', () {
     for (final source in ['auto', 'manual']) {
       testWidgets('Omi speaker with $source label stays inert', (tester) async {

backend/docs/listen_pusher_pipeline.mdx

@@ -6800,3 +6800,65 @@ part receipt and advances the owner watermark only with the final assignment
 receipt transaction. Successors can drain while held uploads stay incomplete
 and outside completion retention. See [owner repair](runbooks/batch-projection-repair.md)
 for the dry-run operator tool, 15-minute obligation metric, and lead-only recovery.
+
+
+## Live speaker epochs: bounded safe repair
+
+Soniox idle reopen continues to stamp a new socket epoch. Listen reconnect
+continues to hydrate conversation-local reservations without equating provider
+labels across scopes. Raw and manual correction keys are unchanged.
+
+Live moments and Flutter live transcript naming defer a new unnamed ordinal
+until the voice has at least the shared policy's five seconds of non-overlapping,
+placed speech. Unknown short epochs keep separate identity keys and a plain
+unnamed label; they consume no live moment voice-order ledger slots. Names and
+owner attribution still require their existing authorities. Display duration is
+not acoustic evidence and never links identities. Saved transcript numbering
+retains its existing behavior.
+
+The persisted moment voice-order ledger also carries display qualification:
+later short or unplaced replies with the same conversation and scoped voice
+keep their established ordinal. A new scope or conversation cannot borrow that
+qualification and must satisfy the floor independently.
+
+The live owner's existing cross-epoch acoustic competition grouping now requires
+five seconds of extracted evidence on **both** voices, the shared `CROSS_EPOCH`
+strict cosine-distance boundary and `MATCH_MARGIN`, and complete-link agreement
+with every peer. Same-scope provider voices cannot join. Shortened owner
+continuity proofs keep their separate receipt-fenced policy and cannot supply
+voice-grouping evidence. Until the five-second floor, those provisional voices
+sit out cross-scope owner competition without being grouped; each still needs
+its own valid owner-continuity proof. Same-scope voices, manual reservations and
+retained competition-only evidence continue to constrain owner claims. Once both
+voices qualify, ordinary strict grouping and joint arbitration apply again.
+Ambiguous, invalid or weak vectors abstain.
+
+Acceptance: `tests/unit/test_live_speaker_epochs.py` drives the real Soniox idle
+close/reopen adapter, epoch stamping/allocation, short-turn embedding pooling,
+owner arbitration and a fresh listen matcher. Deterministic embeddings prove
+control-flow policy, not production acoustic accuracy. Flutter naming tests
+verify short Speaker 4–8 epochs spend no ordinals and qualified distinct IDs
+retain distinct labels.
+
+### Remaining live anonymous linking (lead follow-up)
+
+This safe repair does **not** reuse anonymous conversation IDs across epochs or
+replicas. A voice with five seconds in each of several epochs can still acquire
+several anonymous ordinals. Owner matching re-acquires against enrollment after
+reconnect; no owner is inferred from a provider label or from being the only voice.
+
+Full anonymous linking needs a bounded encrypted conversation-voice evidence
+handoff, tied to conversation and manual-receipt generations, model/policy
+version, and audio provenance. Persist a separate reversible presentation alias
+rather than changing manual correction keys. Require five seconds on each side,
+a strict cross-epoch threshold and runner-up margin, complete-link agreement,
+and same-scope/overlap cannot-link constraints. Recheck manual authority before
+publication, retract aliases on contradictory evidence/correction, and fence
+concurrent replicas and finalization. Qualify with real audio across socket and
+replica reconnects before rollout. Do not copy the owner-only continuity capsule
+into a generic voice cache without those fences.
+
+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.

backend/routers/listen/speakers.py

@@ -1,4 +1,4 @@
 """Speaker assignment state and embedding matching for listen sessions."""
 
 from __future__ import annotations
 
@@ -29,11 +29,11 @@
 from utils.speaker_sample import download_sample_audio
 from utils.speaker_sample_migration import maybe_migrate_person_samples
 from utils.manual_speaker_assignments import manual_owner_reserved, manual_rejected_speakers
-from utils.speakers.policy import CROSS_EPOCH
 from utils.stt.owner_profile import load_owner_embedding, validated_embedding
 from utils.stt.speaker_embedding import compare_embeddings, extract_embedding_from_bytes
 from utils.stt.speaker_match import (
     select_speaker_match,
+    group_epoch_voices,
     SPEAKER_MATCH_MAX_CLIPS,
     SPEAKER_MATCH_MIN_EVIDENCE_SECONDS,
     SpeakerMatchDecision,
@@ -199,7 +199,7 @@
         """Manual receipt ids copied by this rollover; automatic ids join after validation."""
         self._pending_rollover_carry = set(carried_speaker_ids)
 
     async def refresh_for_conversation(
         self,
         conversation_id: str,
         *,
@@ -397,6 +397,8 @@
                     {v: d for v, d in self._voice_decisions.items() if v not in rejected},
                     owner_reserved=final_authority.owner_reserved,
                     voice_groups=self._provider_epoch_voice_groups(),
+                    voice_scopes=self._voice_scopes,
+                    evidence_seconds=self._provider_epoch_evidence_seconds(),
                 )
                 # Runner-up evidence constrains the owner but never automatically
                 # carries a non-owner identity across a conversation boundary.
@@ -610,6 +612,8 @@
             automatic,
             owner_reserved=final_authority.owner_reserved,
             voice_groups=self._provider_epoch_voice_groups(),
+            voice_scopes=self._voice_scopes,
+            evidence_seconds=self._provider_epoch_evidence_seconds(),
         )
         self._publish_decisions(decisions)
         await self.continuity.update(receipt, force=True, generation=generation)
@@ -1005,7 +1009,7 @@
             return None
         return decision
 
     async def _match_unmapped(
         self, speaker_id: int, segment: dict[str, Any], generation: int, conversation_id: Optional[str]
     ) -> None:
         short_reconnect = False
@@ -1231,6 +1235,8 @@
                 {v: d for v, d in self._voice_decisions.items() if v not in rejected},
                 owner_reserved=owner_reserved,
                 voice_groups=voice_groups,
+                voice_scopes=self._voice_scopes,
+                evidence_seconds=self._provider_epoch_evidence_seconds(),
             )
             decision = decisions.get(speaker_id)
             self._rejectors.comparison(speaker_id, decision, evidence_seconds)
@@ -1436,26 +1442,20 @@
         """
         reconcile_pinned_suggestion(self, voice, result, pinned, segment_id, assigned)
 
+    def _provider_epoch_evidence_seconds(self) -> Dict[int, float]:
+        return {
+            voice: sum(seconds for _, seconds in evidence)
+            for voice, evidence in self.speaker_evidence.items()
+            if voice not in self._competition_only
+        }
+
     def _provider_epoch_voice_groups(self) -> Dict[int, int]:
-        """Reconcile a voice only across stamped provider epochs with close audio."""
-        groups: Dict[int, int] = {}
-        members: Dict[int, list[int]] = {}
-        for voice, centroid in self._voice_centroids.items():
-            scope = self._voice_scopes.get(voice)
-            group = voice
-            if scope:
-                for representative, peers in members.items():
-                    if all(
-                        self._voice_scopes.get(peer)
-                        and self._voice_scopes[peer] != scope
-                        and compare_embeddings(centroid, self._voice_centroids[peer]) < CROSS_EPOCH.distance
-                        for peer in peers
-                    ):
-                        group = representative
-                        break
-            groups[voice] = group
-            members.setdefault(group, []).append(voice)
-        return groups
+        return group_epoch_voices(
+            self._voice_centroids,
+            self._voice_scopes,
+            self._provider_epoch_evidence_seconds(),
+            distance=compare_embeddings,
+        )
 
     async def drain(self, *, timeout: float, label: str) -> None:
         if self.tasks:

backend/tests/unit/test_episodes_incremental_live.py

@@ -24,7 +24,7 @@ def test_render_moment_joins_voices_and_bounds_long_text():
             {'text': '   '},
         ]
     )
-    assert rendered.text == 'You: hello there still me\nSpeaker A: hi\nMinh: named'
+    assert rendered.text == 'You: hello there still me\nUnknown speaker: hi\nMinh: named'
     assert rendered.words == 6
     long = incremental.render_moment([{'text': 'word ' * 4000, 'is_user': True}])
     assert len(long.text) <= config.MOMENT_TEXT_MAX_CHARS and '[…]' in long.text