@gotcos/glasses-server 6.21.27 → 6.21.28

package/CHANGELOG.md

@@ -1,3 +1,26 @@
+## 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotcos/glasses-server",
-  "version": "6.21.27",
+  "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/routes/meeting.ts

@@ -119,8 +119,14 @@ import {
   isUnattributed,
   reviewMeetingSpeakers,
   type SpeakerWordSegment,
-  type ReviewChunk,
 } 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,
@@ -769,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 ?? '')