@gotcos/glasses-server 6.21.26 → 6.21.28

package/CHANGELOG.md

@@ -1,3 +1,53 @@
+## 6.21.28
+
+- `GET /meeting/:sessionId/content` — the readable meeting plus two ready-made
+  clipboard forms. Resolution is operations-first, identical to `/speakers`, so
+  the list row and this view can never describe the same meeting differently.
+
+  The attendee block is REBUILT from the speaker review, not taken from the
+  scribe's own `## Attendees`, which applies no confidence floor: the 2026-08-06
+  IJO scribe lists 15 attendees for a 26-minute call including a name already
+  confirmed absent. Copying that verbatim into Slack, an email or an LLM prompt
+  launders a guess into a fact. Only asserted voices are named; the rest collapse
+  into one line with their combined talk time.
+
+  Two forms because they serve different jobs — measured on a real 26-minute
+  meeting, 3.6 KB summary for pasting into a message versus 28 KB with the
+  transcript for pasting into a model. Formatting lives server-side so it is
+  mutation-testable; Swift has no execution-test harness here.
+
+- `meetingDate()` — `startTime` in the sidecar is epoch MILLISECONDS, not ISO.
+  Slicing the stringified number produced "1786123940", which renders as a
+  plausible-looking date field containing a timestamp. Caught only by running the
+  route against a real meeting; the unit tests would have stayed green.
+
+## 6.21.27
+
+- Per-speaker speaking time on the review. `speakingMs` per voice, plus
+  `voicedMs`, `attributedSpeakingMs`, `unattributedSpeakingMs` and
+  `notCapturedMs` on the meeting.
+
+  It reads the word timings the HQ batch pass ALREADY writes
+  (`batchSegments[].speakerWords`, present on 82 of 92 measured sidecars), so it
+  is real voiced time with silence excluded — no audio, no VAD, no embedding, and
+  it works past the 7-day audio retention. Without them it falls back to chunk
+  deltas capped at the capture ceiling, and `speakingTimeSource` says which ran.
+
+  Three things the arithmetic had to get right, each caught against real data:
+  word intervals OVERLAP, so a naive sum totals 1.2x-1.5x the meeting's own
+  duration — union counts overlap once and lands at 0.75x-0.97x. Speakers also
+  overlap EACH OTHER, so per-speaker figures legitimately exceed wall clock
+  (a real 5.2-minute capture summed to 6.0); the invariant is therefore
+  `voicedMs + notCapturedMs = durationMs`, never attributed + unattributed.
+  And the attributed/unattributed split is by `nameAsserted` PER VOICE, never
+  per segment: a per-segment floor cannot carry the owner or human-confirmed
+  waivers and contradicts the rows above it (measured on 2026-08-02 "G2 App
+  Fixes": the panel names MU for 47.3% of the meeting, a per-segment floor 14.9%).
+
+- Uncapped chunk deltas credit dead air to whoever spoke last. On 2026-08-04
+  "Design Gaps" that turns 8.1 minutes of speech into 50.2, with a 36.6s MEDIAN
+  gap that no outlier rule would catch. Capped at the measured ceiling.
+
 ## 6.21.26
 
 - `assertedSegments` added to the speaker review: how many segments belong to

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotcos/glasses-server",
-  "version": "6.21.26",
+  "version": "6.21.28",
   "description": "COS Glasses — self-hosted AI heads-up-display server for Even G2 smart glasses, powered by Claude Code, Codex, or Cursor Agent CLI",
   "type": "module",
   "bin": {

package/server/lib/meeting-scribe-content.ts

@@ -0,0 +1,192 @@
+// The readable meeting: what the scribe markdown says, and two clipboard forms.
+//
+// WHY THIS IS NOT JUST "SEND THE FILE". The scribe's `## Attendees` list applies
+// NO confidence floor — it is the raw label set from capture. Measured on the
+// 2026-08-06 IJO Post-Mortem: 15 attendees listed for a 26-minute call, one of
+// them a name Miles had already confirmed was never in the room. Copying that
+// verbatim into Slack, an email, or an LLM prompt launders a guess into a fact,
+// which is the exact defect the display floor exists to prevent one layer up.
+//
+// So the attendee list served here is rebuilt from the speaker review: only
+// voices the review ASSERTS get named, and everything else is reported as
+// unidentified with its share of the talking.
+//
+// Formatting lives here rather than in Swift on purpose. Swift has no execution
+// test harness in this project, and these strings are the product — they need to
+// be mutation-testable.
+
+/** One `## Heading` section of a scribe file, in document order. */
+export interface ScribeSection {
+  heading: string
+  /** Body text with the heading line removed and edges trimmed. */
+  body: string
+}
+
+export interface ParsedScribe {
+  /** The `# Title` line, or '' when the file has none. */
+  title: string
+  sections: ScribeSection[]
+  /** Convenience lookups for the sections a UI renders directly. */
+  summary: string
+  topics: string
+  decisions: string
+  actions: string
+  transcript: string
+}
+
+const SECTION = /^##\s+(.+?)\s*$/
+
+/**
+ * Split a scribe file into its `##` sections.
+ *
+ * Deliberately tolerant: a scribe with no headings returns everything as the
+ * summary rather than an empty object, because a partially-written file is more
+ * useful to a reviewer than nothing. `###` subheadings (the Action Items split
+ * into High Confidence / Needs Review) stay INSIDE their parent section — they
+ * are part of that section's body, not sections of their own.
+ */
+export function parseScribe(markdown: string): ParsedScribe {
+  const lines = markdown.split('\n')
+  let title = ''
+  const sections: ScribeSection[] = []
+  let current: ScribeSection | null = null
+  const preamble: string[] = []
+
+  for (const line of lines) {
+    if (!title && /^#\s+/.test(line)) { title = line.replace(/^#\s+/, '').trim(); continue }
+    const m = SECTION.exec(line)
+    if (m) {
+      if (current) sections.push({ ...current, body: current.body.trim() })
+      current = { heading: m[1], body: '' }
+      continue
+    }
+    if (current) current.body += line + '\n'
+    else preamble.push(line)
+  }
+  if (current) sections.push({ ...current, body: current.body.trim() })
+
+  const find = (...names: string[]): string => {
+    for (const n of names) {
+      const s = sections.find(x => x.heading.toLowerCase() === n.toLowerCase())
+      if (s) return s.body
+    }
+    return ''
+  }
+  const summary = find('Summary')
+  return {
+    title,
+    sections,
+    // No headings at all: treat the whole file as the summary rather than
+    // returning a shell that renders as an empty meeting.
+    summary: summary || (sections.length === 0 ? markdown.trim() : ''),
+    topics: find('Topics Discussed', 'Topics'),
+    decisions: find('Decisions Made', 'Decisions'),
+    actions: find('Action Items', 'Actions'),
+    transcript: find('Transcript'),
+  }
+}
+
+/**
+ * The meeting's calendar date, as `YYYY-MM-DD`.
+ *
+ * `startTime` in the sidecar is epoch MILLISECONDS (measured: 1786123940914),
+ * not an ISO string. Slicing the stringified number gives "1786123940", which
+ * renders in the clipboard as a plausible-looking date field containing a
+ * timestamp. LOCAL date on purpose — the scribe filename uses the local day, so
+ * a UTC conversion would disagree with the file for anything late in the evening.
+ */
+export function meetingDate(startTime: unknown): string {
+  let ms: number | null = null
+  if (typeof startTime === 'number' && Number.isFinite(startTime)) {
+    // Tolerate seconds as well as milliseconds: a 10-digit value is seconds.
+    ms = startTime < 1e12 ? startTime * 1000 : startTime
+  } else if (typeof startTime === 'string' && startTime.trim()) {
+    const t = Date.parse(startTime)
+    if (Number.isFinite(t)) ms = t
+  }
+  if (ms === null) return ''
+  const d = new Date(ms)
+  if (Number.isNaN(d.getTime())) return ''
+  const pad = (n: number) => String(n).padStart(2, '0')
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`
+}
+
+/** A voice as the clipboard should describe it. */
+export interface AttendeeLine {
+  label: string
+  /** False when the review refuses to assert this name. */
+  asserted: boolean
+  speakingMs: number
+  /** Share of NAMED speaking time, 0..1, or null when unknown/unnamed. */
+  share: number | null
+}
+
+function mmss(ms: number): string {
+  const total = Math.round(ms / 1000)
+  const m = Math.floor(total / 60)
+  const s = total % 60
+  return m > 0 ? `${m}m ${s}s` : `${s}s`
+}
+
+/**
+ * The attendee block, floor-applied.
+ *
+ * Asserted voices are named with their talk time. Everything else is collapsed
+ * into a single honest line rather than listed as people: a large unmatched
+ * cluster is frequently several different speakers, and naming them
+ * individually would be the 15-attendee defect again in a new place.
+ */
+export function renderAttendees(voices: AttendeeLine[]): string {
+  const named = voices.filter(v => v.asserted).sort((a, b) => b.speakingMs - a.speakingMs)
+  const rest = voices.filter(v => !v.asserted)
+  const out: string[] = []
+  for (const v of named) {
+    const pct = v.share === null ? '' : ` · ${Math.round(v.share * 100)}% of named speech`
+    out.push(`- ${v.label} — ${mmss(v.speakingMs)}${pct}`)
+  }
+  const restMs = rest.reduce((n, v) => n + v.speakingMs, 0)
+  if (rest.length > 0) {
+    out.push(`- Unidentified — ${mmss(restMs)} across ${rest.length} ` +
+             `voice${rest.length === 1 ? '' : 's'} the review could not name`)
+  }
+  return out.length > 0 ? out.join('\n') : '- (no voices identified)'
+}
+
+export interface ClipboardInput {
+  title: string
+  date: string
+  durationMin: number
+  attendees: AttendeeLine[]
+  scribe: ParsedScribe
+}
+
+/** Compact form: for pasting into Slack, email, or a note. No transcript. */
+export function clipboardSummary(i: ClipboardInput): string {
+  const parts = [
+    `# ${i.title || 'Untitled meeting'}`,
+    `${i.date} · ${i.durationMin} minutes`,
+    '',
+    '## Who spoke',
+    renderAttendees(i.attendees),
+  ]
+  for (const [heading, body] of [
+    ['Summary', i.scribe.summary],
+    ['Topics', i.scribe.topics],
+    ['Decisions', i.scribe.decisions],
+    ['Action items', i.scribe.actions],
+  ] as const) {
+    if (body.trim()) parts.push('', `## ${heading}`, body.trim())
+  }
+  return parts.join('\n') + '\n'
+}
+
+/** Full form: everything including the transcript, for pasting into an LLM. */
+export function clipboardFull(i: ClipboardInput): string {
+  const head = clipboardSummary(i).trimEnd()
+  if (!i.scribe.transcript.trim()) {
+    // Say so rather than silently returning the summary — otherwise "Copy full"
+    // and "Copy summary" produce identical text with no explanation.
+    return head + '\n\n## Transcript\n(no transcript in this scribe)\n'
+  }
+  return head + '\n\n## Transcript\n' + i.scribe.transcript.trim() + '\n'
+}

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

@@ -98,6 +98,17 @@ export const ASSERT_MIN_SEGMENTS = 3
 
 export type Reliability = 'confident' | 'weak' | 'unreliable' | 'unattributed'
 
+/**
+ * Which measurement produced `speakingMs`.
+ *
+ * `words` is real voiced time from the HQ batch pass's word timings — silence is
+ * excluded by construction. `chunks` is wall-clock deltas with each chunk capped
+ * at the capture ceiling, which is coarser and still contains the sub-ceiling
+ * pauses. They are not comparable across meetings, so any UI showing a trend
+ * must not mix them silently.
+ */
+export type SpeakingTimeSource = 'words' | 'chunks'
+
 export interface ThrashPair {
   speaker: string
   flipRate: number
@@ -122,6 +133,9 @@ export interface Phrase {
 export interface VoiceReview {
   label: string
   segments: number
+  /** Voiced milliseconds credited to this voice. See `SpeakingTimeSource` for
+   *  how it was measured — the two methods are not comparable. */
+  speakingMs: number
   meanSimilarity: number | null
   /** Mean consecutive-run length across the WHOLE meeting. Not comparable to
    *  the pair-scoped run in `thrashesWith`: in a 13-voice meeting every
@@ -244,6 +258,29 @@ export interface MeetingSpeakerReview {
    * unrelated word-overlap measure and the two must not read as siblings.
    */
   assertedSegments: number
+  /** How `speakingMs` was measured. */
+  speakingTimeSource: SpeakingTimeSource
+  /** Voiced ms belonging to voices shown WITH A NAME. The headline number. */
+  attributedSpeakingMs: number
+  /** Voiced ms belonging to voices the panel refuses to name. */
+  unattributedSpeakingMs: number
+  /**
+   * Voiced ms in the meeting, crosstalk counted ONCE.
+   *
+   * `attributed + unattributed` does NOT equal this, and must not be presented
+   * as though it does: when two people talk over each other both are credited,
+   * so per-speaker figures legitimately exceed wall clock. Measured on a real
+   * 5.2-minute capture the per-speaker times summed to 6.0 minutes.
+   */
+  voicedMs: number
+  /**
+   * Wall clock that produced no voice at all.
+   *
+   * Reported rather than distributed, because it is frequently large and is not
+   * all silence: a measured 2026-08-06 capture lost 93% of its chunks in
+   * transfer. THE invariant is `voicedMs + notCapturedMs = durationMs`.
+   */
+  notCapturedMs: number
   durationMs: number
   voices: VoiceReview[]
   /** Chronological spans, so a ribbon can be a timeline instead of a share bar. */
@@ -401,6 +438,135 @@ export function selectPhrases(
     .map(({ text, atMs, similarity, chunkIndex }) => ({ text, atMs, similarity, chunkIndex }))
 }
 
+/**
+ * The capture ceiling. A chunk is VAD-flushed with a 2.5s floor and a hard
+ * ceiling here, so no single chunk can carry more voice than this no matter how
+ * long the wall-clock gap before it was.
+ *
+ * Measured on 1,000 retained chunk WAVs: median 6,050ms, max 7,100ms (the
+ * ceiling overshoots because RMS is sampled every ~200ms), and ZERO chunks under
+ * 2s. The ceiling is the normal flush, not an edge case.
+ */
+export const CHUNK_CEILING_MS = 7_100
+
+/**
+ * Voiced milliseconds credited to each chunk, index-aligned to `chunks`.
+ *
+ * WHY A CAP. `elapsed` is a wall-clock offset, so the delta between consecutive
+ * chunks is that chunk's audio PLUS all the dead air before it. Uncapped, that
+ * dead air gets credited to whoever happened to speak last: on the 2026-08-04
+ * "Design Gaps" meeting the deltas sum to 50.2 minutes against 8.1 minutes of
+ * actual speech — a 6.2x inflation, with a 36.6s MEDIAN gap that would sail
+ * under any outlier rule. One chunk elsewhere in the corpus credits 77.5
+ * continuous minutes to a single speaker.
+ *
+ * Capping at the ceiling makes each chunk contribute at most the audio it could
+ * physically hold. Everything the cap removes is real elapsed time that was
+ * never captured, and it is reported as `notCapturedMs` rather than distributed.
+ */
+export function creditedChunkMs(chunks: ReviewChunk[]): number[] {
+  let prev = 0
+  return chunks.map(c => {
+    const at = typeof c.elapsed === 'number' && Number.isFinite(c.elapsed) ? c.elapsed : prev
+    // Monotonic: a sidecar with a backwards or missing elapsed contributes 0
+    // rather than a negative that would silently subtract from someone's total.
+    const delta = Math.max(0, at - prev)
+    prev = Math.max(prev, at)
+    return Math.min(delta, CHUNK_CEILING_MS)
+  })
+}
+
+/** One batch segment's word-level speaker timing, as the sidecar stores it. */
+export interface SpeakerWordSegment {
+  /** Absolute ms offset of this segment; word times are RELATIVE to it. */
+  startElapsed?: number
+  speakerWords?: Array<{ start?: number; end?: number; speaker?: string }>
+}
+
+/** Total length of a set of intervals, counting overlap ONCE. */
+export function unionMs(intervals: Array<[number, number]>): number {
+  if (intervals.length === 0) return 0
+  const sorted = [...intervals].sort((a, b) => a[0] - b[0])
+  let total = 0
+  let [start, end] = sorted[0]
+  for (const [a, b] of sorted.slice(1)) {
+    if (a > end) { total += end - start; start = a; end = b }
+    else if (b > end) { end = b }
+  }
+  return total + (end - start)
+}
+
+/**
+ * Voiced milliseconds per speaker, from the word timings the HQ batch pass
+ * already wrote into the sidecar.
+ *
+ * WHY UNION AND NOT A SUM. Word intervals overlap — both within a segment and
+ * across the overlapping batch windows. Measured over six real meetings, naively
+ * summing word durations totals 1.20x to 1.50x the meeting's own duration, which
+ * is impossible for voiced time. Union counts overlap once and lands at 0.75x to
+ * 0.97x, always under wall clock, which is the shape the answer must have.
+ *
+ * This is real voiced time: silence between words is excluded by construction,
+ * so it needs no ceiling, no gap heuristic, and no retained audio.
+ */
+export function speakerWordIntervals(
+  segments: SpeakerWordSegment[],
+): Map<string, Array<[number, number]>> {
+  const byLabel = new Map<string, Array<[number, number]>>()
+  for (const seg of segments) {
+    const offset = typeof seg.startElapsed === 'number' && Number.isFinite(seg.startElapsed)
+      ? seg.startElapsed
+      : 0
+    for (const w of seg.speakerWords ?? []) {
+      const a = w.start
+      const b = w.end
+      if (typeof a !== 'number' || typeof b !== 'number') continue
+      if (!Number.isFinite(a) || !Number.isFinite(b) || b <= a) continue
+      const label = w.speaker ?? ''
+      if (!byLabel.has(label)) byLabel.set(label, [])
+      byLabel.get(label)!.push([offset + a * 1000, offset + b * 1000])
+    }
+  }
+  return byLabel
+}
+
+/** Voiced ms per speaker, overlap within a speaker counted once. */
+export function speakerWordMs(segments: SpeakerWordSegment[]): Map<string, number> {
+  const out = new Map<string, number>()
+  for (const [label, ivs] of speakerWordIntervals(segments)) out.set(label, Math.round(unionMs(ivs)))
+  return out
+}
+
+/**
+ * The meeting-level decomposition.
+ *
+ * `voicedMs + notCapturedMs = durationMs` is the invariant that HOLDS.
+ * attributed + unattributed does NOT sum to voiced, because a named and an
+ * unnamed speaker can talk over each other and both are credited.
+ */
+function speakingBuckets(
+  voices: VoiceReview[],
+  intervalsFor: (label: string) => Array<[number, number]>,
+  durationMs: number,
+): {
+  attributedSpeakingMs: number
+  unattributedSpeakingMs: number
+  voicedMs: number
+  notCapturedMs: number
+} {
+  const gather = (pick: (v: VoiceReview) => boolean) =>
+    Math.round(unionMs(voices.filter(pick).flatMap(v => intervalsFor(v.label))))
+  const voiced = gather(() => true)
+  return {
+    attributedSpeakingMs: gather(v => v.nameAsserted),
+    unattributedSpeakingMs: gather(v => !v.nameAsserted),
+    voicedMs: voiced,
+    // Wall clock that produced no voice at all: silence, dropped chunks, and
+    // time the capture never saw. Reported, never distributed to a speaker.
+    notCapturedMs: Math.max(0, durationMs - voiced),
+  }
+}
+
 /** Build the whole review for one meeting's chunks. */
 export function reviewMeetingSpeakers(
   chunks: ReviewChunk[],
@@ -415,6 +581,12 @@ export function reviewMeetingSpeakers(
      * the sidecar already carries it.
      */
     confirmed?: Set<string>
+    /**
+     * The sidecar's `batchSegments`, when the HQ pass has run. Their word
+     * timings give real voiced time; without them speaking time falls back to
+     * capped chunk deltas.
+     */
+    batchSegments?: SpeakerWordSegment[]
   } = {},
 ): MeetingSpeakerReview {
   const owner = options.owner ?? 'Me'
@@ -433,6 +605,33 @@ export function reviewMeetingSpeakers(
   const labels = [...new Set(sequence)].filter(s => s.length > 0)
   const named = labels.filter(l => !isUnattributed(l))
 
+  // Word timings when the HQ batch pass produced them (82 of 92 sidecars
+  // measured), capped chunk deltas otherwise. The two are NOT interchangeable —
+  // words are voiced time, deltas are wall clock with the silence capped off —
+  // so the answer carries which one produced it.
+  const wordIntervals = speakerWordIntervals(options.batchSegments ?? [])
+  const speakingTimeSource: SpeakingTimeSource = wordIntervals.size > 0 ? 'words' : 'chunks'
+
+  // The fallback expresses chunks as intervals too, so both paths decompose
+  // through the same union arithmetic. `elapsed` is the chunk END, so a chunk
+  // covers [end - credited, end] — non-overlapping by construction, because
+  // `credited` is already the capped gap to the previous chunk.
+  const chunkIntervals = new Map<string, Array<[number, number]>>()
+  if (speakingTimeSource === 'chunks') {
+    const credited = creditedChunkMs(chunks)
+    chunks.forEach((c, i) => {
+      if (credited[i] <= 0) return
+      const end = typeof c.elapsed === 'number' && Number.isFinite(c.elapsed) ? c.elapsed : 0
+      const label = c.speaker ?? ''
+      if (!chunkIntervals.has(label)) chunkIntervals.set(label, [])
+      chunkIntervals.get(label)!.push([end - credited[i], end])
+    })
+  }
+
+  const intervalsFor = (label: string): Array<[number, number]> =>
+    (speakingTimeSource === 'words' ? wordIntervals : chunkIntervals).get(label) ?? []
+  const speakingFor = (label: string): number => Math.round(unionMs(intervalsFor(label)))
+
   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)
@@ -499,6 +698,7 @@ export function reviewMeetingSpeakers(
     return {
       label,
       segments: own.length,
+      speakingMs: speakingFor(label),
       meanSimilarity: meanSim,
       meanRun: Math.round(mean(runs) * 100) / 100,
       longestRun: runs.length ? Math.max(...runs) : 0,
@@ -525,6 +725,18 @@ export function reviewMeetingSpeakers(
     // list of rows reading "Unidentified voice", which is the confusion this
     // number exists to remove.
     assertedSegments: voices.reduce((n, v) => (v.nameAsserted ? n + v.segments : n), 0),
+    speakingTimeSource,
+    // UNION, not sum. Speakers overlap — crosstalk means two people are each
+    // correctly credited for the same wall-clock second, so per-speaker times
+    // legitimately add up to MORE than the meeting. Verified against a real
+    // 5.2-minute capture where the per-speaker figures summed to 6.0 minutes.
+    // Summing here produced a bucket total larger than the meeting itself.
+    //
+    // Split by nameAsserted PER VOICE, never per segment: a per-segment floor
+    // cannot express ASSERT_MIN_SEGMENTS nor carry the owner and confirmed
+    // waivers, so it contradicts the rows above it (measured on 2026-08-02 "G2
+    // App Fixes": panel names MU for 47.3%, per-segment floor 14.9%).
+    ...speakingBuckets(voices, intervalsFor, durationMs),
     durationMs,
     voices,
     timeline: speakerTimeline(chunks, durationMs),

package/server/routes/meeting.ts

@@ -118,8 +118,15 @@ import {
   attachRawChunkIndices,
   isUnattributed,
   reviewMeetingSpeakers,
-  type ReviewChunk,
+  type SpeakerWordSegment,
 } from '../lib/meeting-speaker-review.js'
+import { type ReviewChunk } from '../lib/meeting-speaker-review.js'
+import {
+  parseScribe,
+  clipboardSummary,
+  clipboardFull,
+  meetingDate,
+} from '../lib/meeting-scribe-content.js'
 import {
   acquireMaintenanceWork,
   maintenanceAdmissionsOpen,
@@ -735,6 +742,13 @@ export function createMeetingRouter(deps: MeetingRouteDependencies = {}): Router
       // timeline span end where it began — a 1.5pt sliver labelled "1s" for what
       // may be a long closing monologue.
       durationMs: typeof sidecar.durationMs === 'number' ? sidecar.durationMs : undefined,
+      // Word-level speaker timings from the HQ batch pass, present on 82 of 92
+      // measured sidecars. These give REAL voiced time per speaker; without them
+      // speaking time falls back to capped chunk deltas, which still carry the
+      // sub-ceiling pauses. `speakingTimeSource` on the response says which ran.
+      batchSegments: Array.isArray(sidecar.batchSegments)
+        ? (sidecar.batchSegments as SpeakerWordSegment[])
+        : undefined,
     })
     res.set('Cache-Control', 'private, no-store')
     res.json({
@@ -761,6 +775,98 @@ export function createMeetingRouter(deps: MeetingRouteDependencies = {}): Router
   // touched, and a failed intent write aborts without mutating anything. A
   // process that dies mid-rewrite therefore leaves a visible pending correction
   // rather than a silently half-relabelled meeting.
+  /**
+   * The readable meeting, plus two clipboard forms.
+   *
+   * Resolution is operations-first, identical to GET /speakers — the same session
+   * lives in both trees under different names and the list reads operations, so
+   * anything keyed on a session has to resolve there too or the row and this
+   * view disagree about the same meeting.
+   *
+   * The attendee list is REBUILT from the speaker review rather than taken from
+   * the scribe's own `## Attendees`, which applies no confidence floor: the
+   * 2026-08-06 IJO scribe lists 15 attendees for a 26-minute call including a
+   * name already confirmed absent. Copying that verbatim would launder a guess
+   * into a fact in whatever the reviewer pastes it into.
+   */
+  router.get('/meeting/:sessionId/content', (req, res) => {
+    const sessionId = String(req.params.sessionId ?? '')
+    if (!/^[A-Za-z0-9:_-]{3,96}$/.test(sessionId)) {
+      res.status(400).json({ error: 'Invalid sessionId', reason: 'invalid_session_id' })
+      return
+    }
+    const operations = cosOperationsMeetingsConfigured()
+      ? findCosOperationsMeetingBySessionId(sessionId)
+      : null
+    const saved = operations ? null : store.findBySessionId(sessionId)
+    if (!operations && !saved) {
+      res.status(404).json({ error: 'No saved meeting for this session', reason: 'meeting_not_found' })
+      return
+    }
+    const sidecarPath = operations?.sidecarPath ?? saved!.sidecarPath
+    const title = operations?.title ?? saved!.title
+    const mdPath = operations?.meetingPath ?? sidecarPath.replace(/\.g2-chunks\.json$/, '.md')
+
+    let sidecar: Record<string, unknown>
+    try {
+      sidecar = (JSON.parse(readFileSync(sidecarPath, 'utf-8')) ?? {}) as Record<string, unknown>
+    } catch {
+      res.status(422).json({ error: 'Chunk sidecar is missing or unreadable', reason: 'sidecar_unreadable' })
+      return
+    }
+    const rawChunks = Array.isArray(sidecar) ? sidecar : sidecar.chunks
+    const chunks = (Array.isArray(rawChunks) ? rawChunks : []) as ReviewChunk[]
+
+    const review = reviewMeetingSpeakers(attachRawChunkIndices(chunks, sidecar.chunkEntries), {
+      owner: getOwnerSpeakerLabel(),
+      confirmed: confirmedLabels(sessionId),
+      durationMs: typeof sidecar.durationMs === 'number' ? sidecar.durationMs : undefined,
+      batchSegments: Array.isArray(sidecar.batchSegments)
+        ? (sidecar.batchSegments as SpeakerWordSegment[])
+        : undefined,
+    })
+
+    // Share is over NAMED speech and totals 100%, matching the panel. The union
+    // in attributedSpeakingMs counts crosstalk once, so dividing by it would let
+    // the shares exceed 100%.
+    const namedTotal = review.voices.reduce((n, v) => (v.nameAsserted ? n + v.speakingMs : n), 0)
+    const attendees = review.voices.map(v => ({
+      label: v.label,
+      asserted: v.nameAsserted,
+      speakingMs: v.speakingMs,
+      share: v.nameAsserted && namedTotal > 0 ? v.speakingMs / namedTotal : null,
+    }))
+
+    // A missing .md is not fatal — the review and the sidecar still describe the
+    // meeting, and a reviewer would rather have who-spoke than a 404.
+    let markdown = ''
+    try { markdown = readFileSync(mdPath, 'utf-8') } catch { markdown = '' }
+    const scribe = parseScribe(markdown)
+
+    const date = meetingDate(sidecar.startTime)
+    const durationMin = Math.round((review.durationMs || 0) / 60_000)
+    const clip = { title: scribe.title || title, date, durationMin, attendees, scribe }
+
+    res.set('Cache-Control', 'private, no-store')
+    res.json({
+      sessionId,
+      title: scribe.title || title,
+      date,
+      durationMin,
+      scribeAvailable: markdown.length > 0,
+      attendees,
+      speakingTimeSource: review.speakingTimeSource,
+      voicedMs: review.voicedMs,
+      summary: scribe.summary,
+      topics: scribe.topics,
+      decisions: scribe.decisions,
+      actions: scribe.actions,
+      transcriptChars: scribe.transcript.length,
+      clipboardSummary: clipboardSummary(clip),
+      clipboardFull: clipboardFull(clip),
+    })
+  })
+
   router.post('/meeting/:sessionId/relabel', (req, res) => {
     res.set('Cache-Control', 'private, no-store')
     const sessionId = String(req.params.sessionId ?? '')