@gotcos/glasses-server 6.21.14 → 6.21.17

package/server/routes/health.ts

@@ -6,7 +6,9 @@ import { serverMetrics } from '../lib/server-metrics.js'
 import { getServerInstanceId } from '../lib/server-instance-id.js'
 import { localFirstMeetingsCapability } from '../lib/local-first-meetings-contract.js'
 import { isSileroAvailable } from '../lib/vad-silero.js'
-import { speakerModelState, speakerReadiness } from '../lib/speaker-embeddings.js'
+import { profileProvenanceSummary, speakerModelState, speakerReadiness } from '../lib/speaker-embeddings.js'
+import { chunkEmbeddingStoreStats } from '../lib/chunk-embedding-store.js'
+import { correctionStoreStats } from '../lib/meeting-corrections.js'
 import { getAvailableCliSessionId } from '../lib/claude-bridge.js'
 import {
   isWhisperLocalAvailable,
@@ -116,6 +118,16 @@ healthRouter.get('/health', async (_req, res) => {
   const speakerId = speakerModelState()
   checks.speaker_id = speakerId.state
 
+  // Visible so the correction loop can be seen banking evidence rather than
+  // trusted to be. Counts only — no session ids on an unauthenticated surface.
+  const chunkEmbeddings = chunkEmbeddingStoreStats()
+  // `pending` is the number that matters here: an intent that never closed means
+  // some meeting's files may be half-rewritten.
+  const speakerCorrections = correctionStoreStats()
+  // `noHumanSample` is the one to read: a profile with no human-verified sample
+  // is trained entirely on labels the system chose for itself.
+  const voiceProvenance = speakerId.state === 'active' ? profileProvenanceSummary() : null
+
   // Health is unauthenticated. Publish only availability; the actual CLI
   // session id is a resumable runtime handle and belongs on authenticated
   // query/debug surfaces.
@@ -232,6 +244,9 @@ healthRouter.get('/health', async (_req, res) => {
     cursor_models,
     meeting_sync,
     unsaved_captures,
+    chunk_embeddings: chunkEmbeddings,
+    speaker_corrections: speakerCorrections,
+    ...(voiceProvenance ? { voice_provenance: voiceProvenance } : {}),
     capabilities: {
       transcription: {
         ...transcription,

package/server/routes/meeting.ts

@@ -7,6 +7,13 @@ import { resolve } from 'node:path'
 import { Router } from 'express'
 import { emitDisplay } from '../lib/display-bus.js'
 import { cleanTranscriptLines } from '../lib/hallucination-filter.js'
+import { durableAtomicWriteFileSync } from '../lib/atomic-fs.js'
+import { appendCorrection, pendingCorrections } from '../lib/meeting-corrections.js'
+import {
+  invalidLabelReason,
+  relabelMeetingMarkdown,
+  relabelSidecarJson,
+} from '../lib/meeting-relabel.js'
 import {
   getMeetingStore,
   MeetingStore,
@@ -685,6 +692,177 @@ export function createMeetingRouter(deps: MeetingRouteDependencies = {}): Router
     })
   })
 
+
+  // ── Per-meeting speaker relabel (6.21.16) ─────────────────────────────
+  //
+  // Corrects who a voice was in ONE meeting. Deliberately not a global merge:
+  // Miles, on the design — "changing it doesn't mean that all previous chunks
+  // should also be moved. It should be meeting by meeting, with the goal of
+  // hardening or refining the voice profiles." The identifier mishearing a voice
+  // in one room is not evidence that every past attribution was wrong.
+  //
+  // ORDER IS THE WHOLE DESIGN. The ledger intent is written BEFORE any file is
+  // 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.
+  router.post('/meeting/:sessionId/relabel', (req, res) => {
+    res.set('Cache-Control', 'private, no-store')
+    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 from = typeof req.body?.from === 'string' ? req.body.from : ''
+    const to = typeof req.body?.to === 'string' ? req.body.to : ''
+    const chunks = Array.isArray(req.body?.chunks)
+      ? (req.body.chunks as unknown[]).filter((n): n is number => Number.isInteger(n) && (n as number) >= 0)
+      : []
+    if (Array.isArray(req.body?.chunks) && chunks.length !== req.body.chunks.length) {
+      res.status(400).json({ error: 'chunks must be non-negative integers', reason: 'invalid_chunks' })
+      return
+    }
+    for (const [which, label] of [['from', from], ['to', to]] as const) {
+      const bad = invalidLabelReason(label)
+      if (bad) {
+        res.status(400).json({ error: `${which}: ${bad}`, reason: 'invalid_label' })
+        return
+      }
+    }
+    if (from === to) {
+      res.status(400).json({ error: 'from and to are the same label', reason: 'noop_relabel' })
+      return
+    }
+
+    // Same resolution as GET /speakers — operations tree first when configured,
+    // so the panel and the correction act on the same copy of the meeting.
+    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 meetingPath = operations?.meetingPath ?? saved!.filepath
+    const title = operations?.title ?? saved!.title
+
+    let sidecarRaw: string
+    try {
+      sidecarRaw = readFileSync(sidecarPath, 'utf-8')
+    } catch {
+      res.status(422).json({ error: 'Chunk sidecar is missing or unreadable', reason: 'sidecar_unreadable' })
+      return
+    }
+
+    const plan = relabelSidecarJson(sidecarRaw, from, to, chunks)
+    if (!plan.ok) {
+      res.status(422).json({ error: plan.error, reason: 'relabel_rejected' })
+      return
+    }
+
+    // The markdown may only be rewritten when EVERY chunk carrying `from` is
+    // covered. Its turn segmentation does not match the sidecar's, so a partial
+    // relabel has no way to know which turns the selected chunks became.
+    let markdownRaw: string | null = null
+    let markdownPlan: ReturnType<typeof relabelMeetingMarkdown> | null = null
+    if (plan.value.coveredAllWithLabel) {
+      try {
+        markdownRaw = readFileSync(meetingPath, 'utf-8')
+        markdownPlan = relabelMeetingMarkdown(markdownRaw, from, to)
+      } catch {
+        markdownRaw = null   // sidecar-only correction; reported in the response
+      }
+    }
+    const md = markdownPlan?.ok ? markdownPlan.value : null
+
+    const surfaces = {
+      sidecar: plan.value.changed.length,
+      attendees: md?.attendees ?? 0,
+      transcript: md?.transcript ?? 0,
+    }
+    const preview = {
+      sessionId,
+      title,
+      from,
+      to,
+      scope: 'meeting' as const,
+      chunks: plan.value.changed,
+      surfaces,
+      partial: !plan.value.coveredAllWithLabel,
+      remainingWithFrom: plan.value.remainingWithFrom,
+      speakersAfter: plan.value.speakers,
+      proseStale: md?.proseStale ?? false,
+      proseHits: md?.proseHits ?? [],
+      markdownSkipped: !plan.value.coveredAllWithLabel
+        ? 'partial relabel: transcript turns cannot be mapped to chunk indices'
+        : markdownRaw === null ? 'meeting markdown unreadable' : null,
+    }
+
+    if (req.body?.dryRun === true || req.body?.confirm !== true) {
+      res.status(req.body?.dryRun === true ? 200 : 400).json({
+        ...(req.body?.dryRun === true ? {} : { error: 'confirmation required', reason: 'confirmation_required' }),
+        message: `Relabelling ${surfaces.sidecar} chunk(s) from "${from}" to "${to}" in this meeting`
+          + (preview.proseStale
+            ? '. The summary and decisions still name the old speaker and are NOT rewritten — '
+              + `prose refers to people by first name (${preview.proseHits.join(', ')}), `
+              + 'so substituting it could rewrite a sentence about someone else.'
+            : '.'),
+        ...preview,
+      })
+      return
+    }
+
+    // A prior correction that never closed means this meeting's files may already
+    // be half-written. Refuse rather than layering a second rewrite on top.
+    const stalled = pendingCorrections(sessionId)
+    if (stalled.length > 0 && req.body?.force !== true) {
+      res.status(409).json({
+        error: 'a previous correction on this meeting never completed',
+        reason: 'correction_pending',
+        pending: stalled.map(r => ({ id: r.id, at: r.at, from: r.from, to: r.to })),
+        message: 'Its files may be partly rewritten. Re-check the meeting, then pass { force: true } to proceed.',
+      })
+      return
+    }
+
+    const id = `${sessionId}:${from}>${to}:${Date.now().toString(36)}`
+    const at = new Date().toISOString()
+    // Intent first. If this cannot be written, nothing is mutated — an
+    // unrecorded rewrite is the exact failure the ledger exists to prevent.
+    if (!appendCorrection(sessionId, { id, phase: 'intent', at, from, to, chunks: plan.value.changed, scope: 'meeting' })) {
+      res.status(500).json({
+        error: 'could not record the correction, so nothing was changed',
+        reason: 'ledger_unwritable',
+      })
+      return
+    }
+
+    try {
+      durableAtomicWriteFileSync(sidecarPath, plan.value.json, { mode: 0o600 })
+      if (md && (md.attendees > 0 || md.transcript > 0)) {
+        durableAtomicWriteFileSync(meetingPath, md.markdown, { mode: 0o600 })
+      }
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : String(err)
+      appendCorrection(sessionId, {
+        id, phase: 'failed', at: new Date().toISOString(), from, to,
+        chunks: plan.value.changed, scope: 'meeting', error: message,
+      })
+      res.status(500).json({ error: `relabel failed: ${message}`, reason: 'write_failed' })
+      return
+    }
+
+    appendCorrection(sessionId, {
+      id, phase: 'applied', at: new Date().toISOString(), from, to,
+      chunks: plan.value.changed, scope: 'meeting', surfaces,
+      proseStale: preview.proseStale,
+    })
+
+    res.json({ ok: true, correctionId: id, ...preview })
+  })
+
   // ── Unsaved-capture recovery (6.19.0) ─────────────────────────────────
   // Surface-only by decision (Miles, 2026-08-02): the server NEVER drives
   // recovery on its own. It lists what the quarantine holds, and one

package/server/routes/transcribe-stream.ts

@@ -38,6 +38,10 @@ import {
 import { transcribeWhisperMeetingPreview } from '../lib/whisper-preview.js'
 import { dataPath } from '../lib/data-dir.js'
 import { ageHours, partitionExpiredAudio } from '../lib/audio-retention.js'
+import {
+  appendChunkEmbedding,
+  sweepExpiredChunkEmbeddings,
+} from '../lib/chunk-embedding-store.js'
 import {
   countChunkWavs,
   purgeExpiredQuarantine,
@@ -788,6 +792,16 @@ setInterval(() => {
     }
   } catch {}
 
+  // Sweep expired chunk embeddings. Same shape as the audio sweeps, but a
+  // separate window: these are non-invertible timbre vectors, not speech, and
+  // the correction loop needs them to survive a weekend.
+  try {
+    const swept = sweepExpiredChunkEmbeddings(Date.now())
+    if (swept.removed.length > 0) {
+      console.log(`[chunk-embeddings] Purged ${swept.removed.length} expired session file(s), ${swept.retained.length} retained`)
+    }
+  } catch {}
+
   // Purge ext-audio dirs older than 72 hours
   try {
     if (existsSync(EXT_AUDIO_DIR)) {
@@ -1498,6 +1512,20 @@ function identifyChunkSpeaker(audioBuffer: Buffer, sessionId: string, chunkIndex
   console.log(`[perf] identifySpeaker: ${(performance.now() - tEmb).toFixed(1)}ms`)
   if (!embeddingResult) return { speaker: clientSpeaker, similarity: 0 }
 
+  // Bank the embedding before anything else can return. This is the only moment
+  // it exists: identifySpeaker computes it per chunk and nothing else keeps it,
+  // so a correction made later has no acoustic evidence without this write.
+  // Deliberately includes 'Ext' — an unidentified voice is the case with no
+  // other way to be trained.
+  if (embeddingResult.embedding) {
+    appendChunkEmbedding(sessionId, {
+      i: chunkIndex,
+      speaker: embeddingResult.speaker,
+      similarity: embeddingResult.similarity,
+      embedding: embeddingResult.embedding,
+    })
+  }
+
   let speaker = embeddingResult.speaker
   if (speaker !== clientSpeaker) {
     console.log(`[speaker] Embedding: ${speaker} vs Amplitude: ${clientSpeaker} (sim: ${embeddingResult.similarity.toFixed(2)})`)