@gotcos/glasses-server 6.21.14 → 6.21.18

package/server/lib/meeting-relabel.ts

@@ -0,0 +1,279 @@
+// Rewriting a speaker label inside one meeting's files.
+//
+// Pure over strings: every function takes file content and returns file content,
+// so each rule below is testable by execution rather than by reading it.
+//
+// THE CONSTRAINT THAT SHAPES THIS FILE. The markdown transcript is NOT an
+// index-parallel rendering of the chunk sidecar. Measured on a real meeting
+// (2026-08-06 Health Score V2): 135 sidecar chunks collapse to 46 speaker runs,
+// while the markdown carries 70 turns — and they disagree on who spoke, with the
+// markdown's 4th turn attributed to Joe Karbowski where the sidecar's 4th run
+// says Richard Jenkins. The transcript was rendered from a different
+// segmentation pass. So:
+//
+//   * There is NO mapping from a chunk index to a transcript turn.
+//   * A relabel of EVERY chunk carrying a label can still be applied to the
+//     markdown, because "all X becomes Y" needs no index alignment.
+//   * A relabel of a SUBSET of chunks cannot touch the markdown transcript at
+//     all. Rewriting by label would relabel turns the human never selected.
+//
+// `coveredAllWithLabel` on the sidecar result is how the caller knows which case
+// it is. It is returned as DATA rather than left as a rule to remember.
+//
+// AND WHAT IS NEVER REWRITTEN: the Summary / Topics / Decisions / Action Items
+// prose. It refers to people by bare first name — 6 of 12 speakers did so on the
+// meeting above — and this org has two Kyles, two Jacobuses and two Chrises, so
+// a first-name substitution in narrative text would rewrite sentences about
+// somebody else. Reported as `proseStale` instead.
+
+/** A label that would corrupt the file formats it gets written into. */
+export function invalidLabelReason(label: string): string | null {
+  if (label.trim() === '') return 'label is empty'
+  if (label !== label.trim()) return 'label has leading or trailing whitespace'
+  if (label.length > 120) return 'label is longer than 120 characters'
+  // `[Name]:` delimits transcript turns and `- Name` delimits attendees; a
+  // label containing these would make the file unparseable by its own readers.
+  if (/[\[\]\n\r]/.test(label)) return 'label contains a bracket or newline'
+  return null
+}
+
+function escapeRegExp(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+export interface SidecarRelabelResult {
+  /** Serialized in the same shape the pipeline writes: 2-space indent, trailing newline. */
+  json: string
+  /** Chunk indices whose speaker actually changed. */
+  changed: number[]
+  /**
+   * True when no chunk still carries `from` after this relabel. ONLY then may the
+   * caller rewrite the markdown transcript by label. See the file header.
+   */
+  coveredAllWithLabel: boolean
+  /** The top-level `speakers` array after the relabel. */
+  speakers: string[]
+  /** Chunks still carrying `from` — non-zero for a deliberate partial relabel. */
+  remainingWithFrom: number
+}
+
+export type RelabelOutcome<T> = { ok: true; value: T } | { ok: false; error: string }
+
+/**
+ * Relabel chunks in a `.g2-chunks.json` sidecar.
+ *
+ * `chunks` empty means every chunk carrying `from`. An explicit list restricts
+ * the change to those indices — the partial case, which exists because the
+ * identifier can mishear one stretch of a meeting without being wrong about the
+ * rest.
+ */
+export function relabelSidecarJson(
+  raw: string,
+  from: string,
+  to: string,
+  chunks: number[] = [],
+): RelabelOutcome<SidecarRelabelResult> {
+  if (from === to) return { ok: false, error: 'from and to are the same label' }
+  for (const [which, label] of [['from', from], ['to', to]] as const) {
+    const bad = invalidLabelReason(label)
+    if (bad) return { ok: false, error: `${which}: ${bad}` }
+  }
+
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(raw)
+  } catch {
+    return { ok: false, error: 'sidecar is not valid JSON' }
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    return { ok: false, error: 'sidecar is not an object' }
+  }
+  const doc = parsed as Record<string, unknown>
+  const rows = doc.chunks
+  if (!Array.isArray(rows)) return { ok: false, error: 'sidecar has no chunks array' }
+
+  const restrict = chunks.length > 0 ? new Set(chunks) : null
+  // A caller naming indices that do not carry `from` is confused about what it
+  // is correcting; failing loudly beats silently relabelling nothing.
+  if (restrict) {
+    const mismatched = chunks.filter(i => {
+      const row = rows[i]
+      return !row || typeof row !== 'object' || (row as Record<string, unknown>).speaker !== from
+    })
+    if (mismatched.length > 0) {
+      return { ok: false, error: `chunks do not carry "${from}": ${mismatched.slice(0, 8).join(', ')}` }
+    }
+  }
+
+  const changed: number[] = []
+  let remainingWithFrom = 0
+  rows.forEach((row, i) => {
+    // The `typeof` half guards the cast below rather than any behaviour — a
+    // truthy non-object can never satisfy `.speaker === from`, so it is
+    // deliberately not claimed as tested.
+    if (!row || typeof row !== 'object') return
+    const r = row as Record<string, unknown>
+    if (r.speaker !== from) return
+    if (restrict && !restrict.has(i)) { remainingWithFrom++; return }
+    r.speaker = to
+    changed.push(i)
+  })
+
+  if (changed.length === 0) return { ok: false, error: `no chunk carries "${from}"` }
+
+  // Keep the top-level speaker list truthful: it is what the review panel and
+  // the attendee renderer read, so a stale entry shows a person who is no longer
+  // attributed anything.
+  const existing = Array.isArray(doc.speakers) ? doc.speakers.filter((s): s is string => typeof s === 'string') : []
+  const speakers = [...existing]
+  if (!speakers.includes(to)) {
+    // Replace in place when `from` is being fully retired, so the list keeps its
+    // original ordering rather than moving the person to the end.
+    const at = speakers.indexOf(from)
+    if (at >= 0 && remainingWithFrom === 0) speakers[at] = to
+    else speakers.push(to)
+  } else if (remainingWithFrom === 0) {
+    // `to` already listed and `from` fully retired — merging a split identity.
+    // Drop the old entry rather than leaving a name nothing is attributed to.
+    const at = speakers.indexOf(from)
+    if (at >= 0) speakers.splice(at, 1)
+  }
+  doc.speakers = speakers
+
+  return {
+    ok: true,
+    value: {
+      json: `${JSON.stringify(doc, null, 2)}\n`,
+      changed,
+      coveredAllWithLabel: remainingWithFrom === 0,
+      speakers,
+      remainingWithFrom,
+    },
+  }
+}
+
+export interface MarkdownRelabelResult {
+  markdown: string
+  /** Attendee bullet lines changed or removed. */
+  attendees: number
+  /** `[Name]:` turn labels rewritten. */
+  transcript: number
+  /**
+   * True when the old label still appears in narrative prose, which is left
+   * untouched on purpose. The caller records this so a human can be told the
+   * summary predates their correction.
+   */
+  proseStale: boolean
+  /** The prose forms found, for an honest message rather than a bare boolean. */
+  proseHits: string[]
+}
+
+/** Byte range of a `## Heading` section, or null when absent. */
+function sectionRange(md: string, heading: string): { start: number; end: number } | null {
+  const re = new RegExp(`^##\\s+${escapeRegExp(heading)}\\s*$`, 'm')
+  const m = re.exec(md)
+  if (!m) return null
+  const start = m.index + m[0].length
+  const next = /^##\s+/m.exec(md.slice(start))
+  return { start, end: next ? start + next.index : md.length }
+}
+
+/**
+ * Rewrite the structured label positions in a meeting markdown file.
+ *
+ * ONLY sound when every chunk carrying `from` is being relabelled — this works
+ * by label, not by index, and the markdown's turn segmentation does not match
+ * the sidecar's. See the file header.
+ */
+export function relabelMeetingMarkdown(
+  md: string,
+  from: string,
+  to: string,
+  options: { removeAttendee?: boolean } = {},
+): RelabelOutcome<MarkdownRelabelResult> {
+  if (from === to) return { ok: false, error: 'from and to are the same label' }
+  for (const [which, label] of [['from', from], ['to', to]] as const) {
+    const bad = invalidLabelReason(label)
+    if (bad) return { ok: false, error: `${which}: ${bad}` }
+  }
+
+  let out = md
+  let attendees = 0
+  let transcript = 0
+
+  // --- Attendees: exact bullet lines only, inside the Attendees section only.
+  const att = sectionRange(out, 'Attendees')
+  if (att) {
+    const body = out.slice(att.start, att.end)
+    // Anchored at BOTH ends, and `[ \t]` rather than `\s` so a pattern can never
+    // run past its own line. Without the end anchor, `- Luke H` matches the
+    // PREFIX of `- Luke Henry` and deleting it leaves the fragment `enry`.
+    const line = (label: string) => `^-[ \t]+${escapeRegExp(label)}[ \t]*$`
+    // A de-attribution must DELETE the attendee bullet, never rename it. Renaming
+    // writes `- Unidentified 2` into the attendee list as though it were a
+    // person, and the COS pipeline that BUILDS attendees deliberately excludes
+    // unidentified labels (sync_meetings.py filters them) while every reader —
+    // parseAttendees, extractAttendees, the Python prep generators — takes the
+    // bullet at face value. So a rename here injects a phantom attendee that
+    // downstream treats as real.
+    const alreadyListed = options.removeAttendee || new RegExp(line(to), 'm').test(body)
+    let rewritten: string
+    if (alreadyListed) {
+      // Both names present: drop the old bullet instead of creating a duplicate
+      // attendee. This is the normal case when merging a split identity.
+      rewritten = body.replace(new RegExp(`${line(from)}\\n?`, 'gm'), () => { attendees++; return '' })
+    } else {
+      rewritten = body.replace(new RegExp(line(from), 'gm'), () => { attendees++; return `- ${to}` })
+    }
+    out = out.slice(0, att.start) + rewritten + out.slice(att.end)
+  }
+
+  // --- Transcript: `[Name]:` at line start only. A name appearing inside spoken
+  //     text is a quote, not a label, and must not be touched.
+  const tr = sectionRange(out, 'Transcript')
+  if (tr) {
+    const body = out.slice(tr.start, tr.end)
+    const rewritten = body.replace(
+      new RegExp(`^\\[${escapeRegExp(from)}\\]:`, 'gm'),
+      () => { transcript++; return `[${to}]:` },
+    )
+    out = out.slice(0, tr.start) + rewritten + out.slice(tr.end)
+  }
+
+  // --- Prose: detect, never rewrite.
+  const proseHits = detectProseReferences(out, from)
+
+  return {
+    ok: true,
+    value: { markdown: out, attendees, transcript, proseStale: proseHits.length > 0, proseHits },
+  }
+}
+
+/**
+ * Forms of `label` still present in narrative prose.
+ *
+ * Searches everything except the attendee list and the transcript — the
+ * transcript's body is spoken words, and a name said aloud is a quote rather
+ * than a stale attribution.
+ */
+export function detectProseReferences(md: string, label: string): string[] {
+  const ranges = [sectionRange(md, 'Attendees'), sectionRange(md, 'Transcript')].filter(
+    (r): r is { start: number; end: number } => r !== null,
+  )
+  let prose = ''
+  let cursor = 0
+  for (const r of ranges.sort((a, b) => a.start - b.start)) {
+    prose += md.slice(cursor, r.start)
+    cursor = Math.max(cursor, r.end)
+  }
+  prose += md.slice(cursor)
+
+  const hits: string[] = []
+  const full = new RegExp(`\\b${escapeRegExp(label)}\\b`)
+  if (full.test(prose)) hits.push(label)
+  const first = label.split(/\s+/)[0]
+  // Only a multi-word label has a distinct bare-first-name form. 'MU' or 'Ext'
+  // would otherwise be reported twice for the same match.
+  if (first && first !== label && new RegExp(`\\b${escapeRegExp(first)}\\b`).test(prose)) hits.push(first)
+  return hits
+}

package/server/lib/meeting-speaker-review.ts

@@ -26,6 +26,19 @@
 export interface ReviewChunk {
   text?: string
   speaker?: string
+  /**
+   * RAW capture index — the number in `chunk_NNNN.wav`, NOT this chunk's position
+   * in the array.
+   *
+   * These differ and the gap grows through a meeting. Measured on the 2026-08-06
+   * Ditto sidecar: 885 compacted chunks against raw indices 0..945 with 36 gaps,
+   * so array position 884 is really raw chunk 940 — a 56-chunk error, minutes of
+   * audio. `chunks` is filtered to text-bearing entries (transcribe-stream's
+   * getSessionChunks) while the WAV is written for EVERY received chunk before
+   * ASR, so the position can never address the audio. Populated from the
+   * sidecar's `chunkEntries`, which exists precisely to preserve these.
+   */
+  chunkIndex?: number
   /** MILLISECONDS from meeting start. Confirmed against the writer:
    *  meeting.ts accumulates `elapsed += row.durationMs`. Treating this as
    *  seconds reports a 32-minute meeting as 30,936 minutes. */
@@ -36,6 +49,24 @@ export interface ReviewChunk {
 /** Labels that mean "nobody was identified", not a person. */
 export const UNATTRIBUTED = new Set(['Unknown', 'Ext', '', 'Speaker 1', 'Speaker 2', 'Speaker 3'])
 
+/**
+ * Prefix for a voice a human de-attributed, numbered so distinct people stay
+ * distinct.
+ *
+ * De-attributing to a single shared `Ext` folded every corrected voice into one
+ * row: on the 2026-08-06 Ditto meeting Miles named five wrong attributions, and
+ * collapsing them would have destroyed his ability to tell those five voices
+ * apart afterwards — which is exactly what he then needs playback for. Numbering
+ * keeps them separable while asserting no identity.
+ */
+export const DEATTRIBUTED_PREFIX = 'Unidentified'
+
+/** True when a label asserts no identity — the exact set, or a numbered
+ *  de-attribution. Prefix-aware so `Unidentified 3` is treated as unnamed. */
+export function isUnattributed(label: string): boolean {
+  return UNATTRIBUTED.has(label) || new RegExp(`^${DEATTRIBUTED_PREFIX} \\d+$`).test(label)
+}
+
 /** Calibrated from the control pair above. A pair must be BOTH flip-happy and
  *  short-run to be called unreliable — either alone has honest explanations
  *  (a rapid-fire exchange is flip-happy; a brief interjection is short-run). */
@@ -44,6 +75,27 @@ export const THRASH_MEAN_RUN = 8
 /** Below the search-accept threshold a name was never asserted with confidence. */
 export const CONFIDENT_SIMILARITY = 0.65
 
+/**
+ * FLOOR FOR PRESENTING A NAME AT ALL.
+ *
+ * The identifier accepts a match at SEARCH_THRESHOLD = 0.55, so a single segment
+ * scoring 0.55 currently arrives in the panel wearing somebody's full name. On
+ * Miles's 2026-08-06 Ditto meeting that produced Richard Jenkins (1 segment,
+ * 0.60), Luke Henry (1 segment, 0.55), Dylan Jackson (2 segments, 0.58) and
+ * Navaz Sharif (3 segments, 0.58) — and he confirmed none of them were in the
+ * room. Presenting those as names is the defect; the reviewer then has to undo
+ * an assertion the system should never have made.
+ *
+ * Standing rule this enforces: speaker identity is a SUGGESTION, never an
+ * assertion. Below the floor the row is "unidentified" and the label survives
+ * only as a scored candidate.
+ *
+ * A floor cannot catch everything — a wrong match can still score well — so this
+ * removes obvious noise rather than guaranteeing correctness.
+ */
+export const ASSERT_MIN_SIMILARITY = CONFIDENT_SIMILARITY
+export const ASSERT_MIN_SEGMENTS = 3
+
 export type Reliability = 'confident' | 'weak' | 'unreliable' | 'unattributed'
 
 export interface ThrashPair {
@@ -58,6 +110,13 @@ export interface Phrase {
   /** Milliseconds from meeting start, matching the sidecar. */
   atMs: number
   similarity: number | null
+  /**
+   * Raw capture index for playback, or null when the sidecar cannot supply one
+   * (pre-`chunkEntries` captures). Null means "do not offer playback" — a
+   * guessed index plays somebody else's voice, which is worse than no button
+   * on a screen whose whole purpose is confirming identity.
+   */
+  chunkIndex: number | null
 }
 
 export interface VoiceReview {
@@ -72,22 +131,138 @@ export interface VoiceReview {
   longestRun: number
   isOwner: boolean
   reliability: Reliability
+  /**
+   * Whether `label` may be shown to a human AS A NAME.
+   *
+   * False means the UI must render the row as unidentified and offer `label`
+   * only as a scored candidate. Carried as data rather than left to each client
+   * to re-derive, so the phone, the lens and Control cannot disagree about
+   * whether a name was earned.
+   */
+  nameAsserted: boolean
+  /** Why the name is not asserted — so a UI can explain rather than just hide. */
+  assertionBlockers: string[]
   thrashesWith: ThrashPair[]
   phrases: Phrase[]
 }
 
+/** One stretch of the meeting held by a single label. */
+export interface TimelineSpan {
+  /** The label as stored. Whether it may be SHOWN as a name is still governed by
+   *  the matching voice row's `nameAsserted` — a span is not a second opinion. */
+  speaker: string
+  /** Milliseconds from meeting start. `elapsed` on a chunk is its START offset:
+   *  meeting.ts assigns `elapsed` and only then does `elapsed += durationMs`. */
+  startMs: number
+  endMs: number
+  segments: number
+}
+
+/**
+ * Collapse the chunk sequence into consecutive same-speaker spans.
+ *
+ * This exists because the ribbon needs a TIME axis. The previous ribbon drew one
+ * rectangle per voice sized by share of segments and labelled itself "who spoke,
+ * in order" — there was no ordering in it at all, so hovering could not report
+ * anything true.
+ *
+ * Non-monotonic or missing `elapsed` values are carried forward rather than
+ * trusted: a span with a negative width would render as an invisible or
+ * inverted block, which is worse than a slightly wrong boundary.
+ */
+export function speakerTimeline(chunks: ReviewChunk[], durationMs: number): TimelineSpan[] {
+  const spans: TimelineSpan[] = []
+  let cursor = 0
+  for (const c of chunks) {
+    const label = c.speaker ?? ''
+    const raw = typeof c.elapsed === 'number' && Number.isFinite(c.elapsed) ? c.elapsed : 0
+    // ONE clamp does all three jobs, because `cursor` is monotonic and never
+    // negative: it recovers a missing value, a negative value, and a value that
+    // goes backwards. Mutation showed the extra Math.max(0, raw) and the
+    // `: cursor` fallback were both unreachable behind it.
+    const startMs = Math.max(cursor, raw)
+    cursor = startMs
+    const last = spans[spans.length - 1]
+    if (last && last.speaker === label) {
+      last.segments++
+    } else {
+      spans.push({ speaker: label, startMs, endMs: startMs, segments: 1 })
+    }
+  }
+  // Each span ends where the next begins. The LAST one is the problem: `elapsed`
+  // is a start offset, and on real sidecars `durationMs` frequently equals the
+  // final chunk's start exactly (measured on 2026-08-06 Ditto: both 5,783,732),
+  // so taking the meeting end verbatim leaves the closing turn zero-width — a
+  // 1.5pt sliver for what may be a long monologue.
+  //
+  // The tail gets ONE TYPICAL CHUNK of width, derived from the median gap between
+  // this meeting's own chunk starts. That is measured from the data rather than
+  // invented, and it is the shortest defensible non-zero answer.
+  const gaps: number[] = []
+  for (let i = 1; i < spans.length; i++) {
+    const d = spans[i].startMs - spans[i - 1].startMs
+    if (d > 0) gaps.push(d)
+  }
+  gaps.sort((a, b) => a - b)
+  const typicalGap = gaps.length ? gaps[Math.floor(gaps.length / 2)] : 0
+  for (let i = 0; i < spans.length; i++) {
+    const next = spans[i + 1]
+    if (next) {
+      spans[i].endMs = Math.max(spans[i].startMs, next.startMs)
+    } else if (durationMs > spans[i].startMs) {
+      // A real meeting end, later than this span's start: use it verbatim.
+      spans[i].endMs = durationMs
+    } else {
+      // durationMs is absent, or equals the final chunk's start (the common real
+      // case). Fall back to one typical chunk so the closing turn has width.
+      spans[i].endMs = spans[i].startMs + typicalGap
+    }
+  }
+  return spans
+}
+
 export interface MeetingSpeakerReview {
   segments: number
   /** False when no chunk carries a real speaker — a recovered capture. */
   attributed: boolean
   durationMs: number
   voices: VoiceReview[]
+  /** Chronological spans, so a ribbon can be a timeline instead of a share bar. */
+  timeline: TimelineSpan[]
 }
 
 function mean(xs: number[]): number {
   return xs.length ? xs.reduce((a, b) => a + b, 0) / xs.length : 0
 }
 
+/**
+ * Attach raw capture indices to a compacted chunk array.
+ *
+ * The i-th compacted chunk is the i-th TEXT-BEARING `chunkEntries` row, whose
+ * `chunkIndex` is the raw WAV number. Verified against every 2026-07/08 sidecar
+ * that carries chunkEntries: the text-bearing count always equals the compacted
+ * count and the text lines up positionally.
+ *
+ * Returns the chunks UNCHANGED when the counts disagree or chunkEntries is
+ * absent. A partial or shifted mapping is worse than none: it would silently
+ * point playback at a neighbouring speaker, and this screen exists to confirm
+ * identity.
+ */
+export function attachRawChunkIndices(chunks: ReviewChunk[], chunkEntries: unknown): ReviewChunk[] {
+  if (!Array.isArray(chunkEntries)) return chunks
+  const textBearing = chunkEntries.filter(e => {
+    const chunk = (e as { chunk?: { text?: unknown } } | null)?.chunk
+    return typeof chunk?.text === 'string' && chunk.text.trim() !== ''
+  })
+  if (textBearing.length !== chunks.length) return chunks
+  return chunks.map((c, i) => {
+    const raw = (textBearing[i] as { chunkIndex?: unknown }).chunkIndex
+    return typeof raw === 'number' && Number.isInteger(raw) && raw >= 0
+      ? { ...c, chunkIndex: raw }
+      : c
+  })
+}
+
 /** Consecutive-run lengths for one speaker across the whole meeting. */
 export function speakerRuns(sequence: string[], speaker: string): number[] {
   const runs: number[] = []
@@ -179,6 +354,7 @@ export function selectPhrases(
       text: (c.text ?? '').trim(),
       atMs: typeof c.elapsed === 'number' ? c.elapsed : 0,
       similarity: typeof c.similarity === 'number' ? c.similarity : null,
+      chunkIndex: typeof c.chunkIndex === 'number' ? c.chunkIndex : null,
       score: phraseScore(c.text ?? ''),
     }))
     .filter(p => p.score > 0)
@@ -203,27 +379,34 @@ export function selectPhrases(
   }
   return picked
     .sort((a, b) => a.atMs - b.atMs)
-    .map(({ text, atMs, similarity }) => ({ text, atMs, similarity }))
+    .map(({ text, atMs, similarity, chunkIndex }) => ({ text, atMs, similarity, chunkIndex }))
 }
 
 /** Build the whole review for one meeting's chunks. */
 export function reviewMeetingSpeakers(
   chunks: ReviewChunk[],
-  options: { owner?: string; phrasesPerVoice?: number } = {},
+  options: { owner?: string; phrasesPerVoice?: number; durationMs?: number } = {},
 ): MeetingSpeakerReview {
   const owner = options.owner ?? 'Me'
   const limit = options.phrasesPerVoice ?? 3
   const sequence = chunks.map(c => c.speaker ?? '')
-  const durationMs = chunks.reduce((max, c) => Math.max(max, typeof c.elapsed === 'number' ? c.elapsed : 0), 0)
+  // The caller's durationMs (the sidecar's own) is the meeting's true end.
+  // Falling back to max(elapsed) uses the START of the last chunk, which makes
+  // the final timeline span zero-width — so prefer the real value and only
+  // derive when it is absent.
+  const lastStart = chunks.reduce((max, c) => Math.max(max, typeof c.elapsed === 'number' ? c.elapsed : 0), 0)
+  const durationMs = typeof options.durationMs === 'number' && options.durationMs > lastStart
+    ? options.durationMs
+    : lastStart
 
   const labels = [...new Set(sequence)].filter(s => s.length > 0)
-  const named = labels.filter(l => !UNATTRIBUTED.has(l))
+  const named = labels.filter(l => !isUnattributed(l))
 
   const voices: VoiceReview[] = labels.map(label => {
     const own = chunks.filter(c => (c.speaker ?? '') === label)
     const sims = own.map(c => c.similarity).filter((s): s is number => typeof s === 'number' && s > 0)
     const runs = speakerRuns(sequence, label)
-    const unattributed = UNATTRIBUTED.has(label)
+    const unattributed = isUnattributed(label)
 
     const thrashesWith: ThrashPair[] = []
     if (!unattributed) {
@@ -250,6 +433,32 @@ export function reviewMeetingSpeakers(
         ? 'unreliable'
         : (meanSim ?? 0) >= CONFIDENT_SIMILARITY ? 'confident' : 'weak'
 
+    // What stops this label being presented as a name. Collected as reasons
+    // rather than a bare boolean: "2 segments" and "similarity 0.58" are
+    // different problems and a reviewer deserves to see which one applies.
+    const assertionBlockers: string[] = []
+    if (unattributed) {
+      assertionBlockers.push('no name was ever assigned to this voice')
+    } else if (label === owner) {
+      // The wearer is exempt. Their identity is established by wearing the
+      // device, not by cosine — and the owner is verified at exactly this floor
+      // (VERIFY_THRESHOLD 0.65), so they sit permanently on the boundary and any
+      // thrash pair flips them. Measured across the 2026-08-06 corpus: the owner
+      // row read "Unidentified voice" in 4 of 9 meetings, including one with 285
+      // of their own segments. `thrashesWith` still renders, so a mixed row is
+      // still visible — the name is asserted, the caveat is not hidden.
+    } else {
+      if (own.length < ASSERT_MIN_SEGMENTS) {
+        assertionBlockers.push(`only ${own.length} segment${own.length === 1 ? '' : 's'} (needs ${ASSERT_MIN_SEGMENTS})`)
+      }
+      if ((meanSim ?? 0) < ASSERT_MIN_SIMILARITY) {
+        assertionBlockers.push(`similarity ${(meanSim ?? 0).toFixed(2)} below ${ASSERT_MIN_SIMILARITY}`)
+      }
+      if (thrashesWith.length > 0) {
+        assertionBlockers.push(`swaps with ${thrashesWith[0].speaker} every ${Math.round(thrashesWith[0].meanRun)} segments`)
+      }
+    }
+
     return {
       label,
       segments: own.length,
@@ -258,11 +467,19 @@ export function reviewMeetingSpeakers(
       longestRun: runs.length ? Math.max(...runs) : 0,
       isOwner: label === owner,
       reliability,
+      nameAsserted: assertionBlockers.length === 0,
+      assertionBlockers,
       thrashesWith,
       phrases: selectPhrases(chunks, label, limit, durationMs),
     }
   })
 
   voices.sort((a, b) => b.segments - a.segments)
-  return { segments: chunks.length, attributed: named.length > 0, durationMs, voices }
+  return {
+    segments: chunks.length,
+    attributed: named.length > 0,
+    durationMs,
+    voices,
+    timeline: speakerTimeline(chunks, durationMs),
+  }
 }