@gotcos/glasses-server 6.18.8 → 6.20.0

package/server/lib/meeting-batch-progress.ts

@@ -5,9 +5,11 @@
 import { existsSync, readdirSync, readFileSync, statSync, writeFileSync, unlinkSync } from 'node:fs'
 import { basename, join } from 'node:path'
 import { dataPath } from './data-dir.js'
+import { listActiveRecoveries } from './unsaved-audio-quarantine.js'
 
 export const BATCH_PROGRESS_FILENAME = '_batch_progress.json'
 export const BATCH_PENDING_MARKER = '_batch_pending.marker'
+export const BATCH_TERMINAL_FILENAME = '_batch_terminal.json'
 
 export type MeetingBatchPhase =
   | 'queued'
@@ -44,6 +46,75 @@ export interface MeetingSyncSnapshot {
   label: string
   blocksRestart: boolean
   meetings: MeetingSyncMeeting[]
+  /** Batches that reached a terminal outcome but whose WAVs are deliberately
+   *  retained for retry (rejected quality, failed persist). Additive field —
+   *  older consumers ignore it. Never counts toward active/blocksRestart. */
+  retained: MeetingSyncRetainedMeeting[]
+}
+
+export type MeetingBatchOutcome = 'accepted' | 'rejected' | 'failed'
+
+export interface MeetingBatchTerminal {
+  schemaVersion: 1
+  meetingId: string
+  outcome: MeetingBatchOutcome
+  reason?: string
+  at: string
+}
+
+export interface MeetingSyncRetainedMeeting {
+  meetingId: string
+  outcome: MeetingBatchOutcome
+  reason: string | null
+  chunkFiles: number
+  at: string
+  label: string
+}
+
+/** Record the batch's terminal outcome next to its retained WAVs. Before this
+ *  file existed (≤6.18.8), a rejected batch's dir kept rendering as active
+ *  "HQ polish · N chunks" with blocksRestart:true for the full 12h retention —
+ *  the status conflated "work running" with "evidence retained". */
+export function writeMeetingBatchTerminal(
+  audioDir: string,
+  input: { outcome: MeetingBatchOutcome; reason?: string; meetingId?: string },
+): void {
+  const payload: MeetingBatchTerminal = {
+    schemaVersion: 1,
+    meetingId: input.meetingId ?? basename(audioDir),
+    outcome: input.outcome,
+    ...(input.reason ? { reason: input.reason } : {}),
+    at: new Date().toISOString(),
+  }
+  try {
+    writeFileSync(join(audioDir, BATCH_TERMINAL_FILENAME), `${JSON.stringify(payload)}\n`, {
+      encoding: 'utf8',
+      mode: 0o600,
+    })
+  } catch {
+    // Status only — never fail the pipeline for a status write.
+  }
+}
+
+/** A retry invalidates the previous terminal state. */
+export function clearMeetingBatchTerminal(audioDir: string): void {
+  const path = join(audioDir, BATCH_TERMINAL_FILENAME)
+  try {
+    if (existsSync(path)) unlinkSync(path)
+  } catch { /* ignore */ }
+}
+
+function readTerminalFile(dir: string): MeetingBatchTerminal | null {
+  const path = join(dir, BATCH_TERMINAL_FILENAME)
+  if (!existsSync(path)) return null
+  try {
+    const raw = JSON.parse(readFileSync(path, 'utf8')) as MeetingBatchTerminal
+    if (raw?.schemaVersion !== 1) return null
+    if (raw.outcome !== 'accepted' && raw.outcome !== 'rejected' && raw.outcome !== 'failed') return null
+    return raw
+  } catch {
+    return null
+  }
 }
 
 function pendingBatchRoot(): string {
@@ -111,6 +182,11 @@ export function clearMeetingBatchProgress(audioDir: string): void {
   } catch { /* ignore */ }
 }
 
+/** Public read for surfaces outside this module (orphan recovery progress). */
+export function readMeetingBatchProgress(dir: string): MeetingBatchProgress | null {
+  return readProgressFile(dir)
+}
+
 function readProgressFile(dir: string): MeetingBatchProgress | null {
   const path = join(dir, BATCH_PROGRESS_FILENAME)
   if (!existsSync(path)) return null
@@ -140,8 +216,9 @@ export function getMeetingSyncSnapshot(
   root: string = pendingBatchRoot(),
 ): MeetingSyncSnapshot {
   const meetings: MeetingSyncMeeting[] = []
+  const retained: MeetingSyncRetainedMeeting[] = []
   if (!existsSync(root)) {
-    return { active: false, percent: null, label: 'Idle', blocksRestart: false, meetings }
+    return { active: false, percent: null, label: 'Idle', blocksRestart: false, meetings, retained }
   }
 
   let dirs: string[] = []
@@ -154,7 +231,7 @@ export function getMeetingSyncSnapshot(
       }
     })
   } catch {
-    return { active: false, percent: null, label: 'Idle', blocksRestart: false, meetings }
+    return { active: false, percent: null, label: 'Idle', blocksRestart: false, meetings, retained }
   }
 
   for (const name of dirs) {
@@ -165,6 +242,47 @@ export function getMeetingSyncSnapshot(
       chunkFiles = readdirSync(dir).filter(f => f.endsWith('.wav')).length
     } catch { /* ignore */ }
 
+    // A terminal outcome ends the meeting's ACTIVE life. Its WAVs stay for
+    // retry, reported as retained — never as running work. The gate is
+    // progress==null ONLY: the pending marker is refreshed every segment and
+    // every 60s during the run, so it is always fresh the moment a terminal
+    // is written — gating on marker freshness left the phantom alive for the
+    // first 15 minutes, exactly the post-meeting Update Server window. A
+    // genuine retry clears the terminal first (runMeetingBatchPipeline) and
+    // immediately writes queued progress, so progress presence is the true
+    // live signal.
+    const terminal = readTerminalFile(dir)
+    if (terminal && progress == null) {
+      const reasonSuffix = terminal.reason ? `: ${terminal.reason}` : ''
+      retained.push({
+        meetingId: terminal.meetingId || name,
+        outcome: terminal.outcome,
+        reason: terminal.reason ?? null,
+        chunkFiles,
+        at: terminal.at,
+        label: `Retained (${terminal.outcome}${reasonSuffix}) · ${chunkFiles} chunk${chunkFiles === 1 ? '' : 's'}`,
+      })
+      continue
+    }
+
+    // Backfill: a dir with WAVs, no progress, no fresh marker, and NO terminal
+    // file is a batch that ended before 6.19.0 existed (or whose terminal
+    // write failed). Pre-6.19.0 semantics rendered these as phantom active
+    // work with blocksRestart for the rest of the 12h retention — and the
+    // first boot after an upgrade is exactly when the user watches COS
+    // Control. Classify them as retained with an honest unknown outcome.
+    if (progress == null && !markerFresh(dir) && chunkFiles > 0) {
+      retained.push({
+        meetingId: name,
+        outcome: 'failed',
+        reason: 'pre-terminal batch (ended before 6.19.0 or terminal write lost)',
+        chunkFiles,
+        at: new Date(0).toISOString(),
+        label: `Retained (unknown outcome) · ${chunkFiles} chunk${chunkFiles === 1 ? '' : 's'}`,
+      })
+      continue
+    }
+
     const active = markerFresh(dir) || progress != null
     if (!active && chunkFiles === 0) continue
 
@@ -198,8 +316,36 @@ export function getMeetingSyncSnapshot(
     meetings.push({ ...row, label: labelFor(row) })
   }
 
+  // Active orphan recoveries decode in the quarantine root, which this scan
+  // never visits — surface them as active rows or COS Control shows "Idle"
+  // with blocksRestart:false while a 20-90 minute decode holds the
+  // maintenance lease, and an Update Server drain walks blind into its 90s
+  // timeout and hard-fails to Repair. Same contract as meeting_batch_finalization.
+  for (const recovery of listActiveRecoveries()) {
+    const progress = readProgressFile(recovery.dirPath)
+    const percent = progress && progress.segmentsTotal > 0
+      ? clampPercent(progress.segmentsDone, progress.segmentsTotal)
+      : null
+    const row: Omit<MeetingSyncMeeting, 'label'> = {
+      meetingId: recovery.sessionId,
+      phase: progress?.phase ?? 'queued',
+      percent,
+      segmentsDone: progress && progress.segmentsTotal > 0 ? progress.segmentsDone : null,
+      segmentsTotal: progress && progress.segmentsTotal > 0 ? progress.segmentsTotal : null,
+      chunkFiles: progress?.chunkFiles ?? 0,
+      updatedAt: progress?.updatedAt ?? null,
+    }
+    meetings.push({
+      ...row,
+      label: `Recovering unsaved capture${percent != null ? ` ${percent}%` : ''} · do not update/restart`,
+    })
+  }
+
   if (meetings.length === 0) {
-    return { active: false, percent: null, label: 'Idle', blocksRestart: false, meetings }
+    const label = retained.length > 0
+      ? `Idle · ${retained.length} retained batch${retained.length === 1 ? '' : 'es'}`
+      : 'Idle'
+    return { active: false, percent: null, label, blocksRestart: false, meetings, retained }
   }
 
   const withPercent = meetings.filter(m => m.percent != null)
@@ -217,5 +363,6 @@ export function getMeetingSyncSnapshot(
     label,
     blocksRestart: true,
     meetings,
+    retained,
   }
 }

package/server/lib/meeting-batch-transcribe.ts

@@ -9,7 +9,9 @@ import { transcribeHighQuality, type WhisperWord } from './whisper-local.js'
 import { isMetalBatchPreempted } from './whisper-metal-gate.js'
 import {
   clearMeetingBatchProgress,
+  clearMeetingBatchTerminal,
   writeMeetingBatchProgress,
+  writeMeetingBatchTerminal,
 } from './meeting-batch-progress.js'
 import type { IndexedTranscriptChunk } from '../routes/transcribe-stream.js'
 import {
@@ -165,7 +167,7 @@ function mapWordsToSpeakers(
   })
 }
 
-async function transcribeSegments(
+export async function transcribeSegments(
   audioDir: string,
   segments: BatchSegment[],
   entries: IndexedTranscriptChunk[],
@@ -237,6 +239,16 @@ async function transcribeSegments(
 
 let batchQueueTail: Promise<void> = Promise.resolve()
 
+/** Chain arbitrary HQ-decoder work onto the same serialization tail the batch
+ *  pipeline uses. Orphan recovery MUST go through this: transcribeSegments has
+ *  no internal queue, so calling it directly would run a second (or third)
+ *  16-thread large-v3 decoder in parallel with a live post-meeting batch. */
+export function enqueueSerializedHqWork<T>(work: () => Promise<T>): Promise<T> {
+  const job = batchQueueTail.then(work)
+  batchQueueTail = job.then(() => undefined, () => undefined)
+  return job
+}
+
 /** Serialize 16-thread HQ decoders across meetings on a public user's Mac. */
 export function runMeetingBatchPipeline(
   audioDir: string,
@@ -246,6 +258,8 @@ export function runMeetingBatchPipeline(
   // Lease immediately, including time spent behind another HQ decoder. Without
   // this, the two-hour cleanup could delete a queued meeting before it starts.
   refreshPendingLease(audioDir)
+  // A retry invalidates any prior terminal outcome — live signals must win.
+  clearMeetingBatchTerminal(audioDir)
   writeMeetingBatchProgress(audioDir, {
     phase: 'queued',
     segmentsDone: 0,
@@ -278,7 +292,12 @@ async function runMeetingBatchPipelineNow(
       return { transcriptionQuality: 'streaming' }
     }
     const segments = segmentTranscriptChunks(entries)
-    if (segments.length === 0) return { transcriptionQuality: 'streaming' }
+    if (segments.length === 0) {
+      // Terminal too: WAVs exist but nothing is transcribable. Without this,
+      // the dir re-creates the exact phantom-active state W2 removes.
+      writeMeetingBatchTerminal(audioDir, { outcome: 'failed', reason: 'no_segments' })
+      return { transcriptionQuality: 'streaming' }
+    }
 
     writeMeetingBatchProgress(audioDir, {
       phase: 'hq_polish',
@@ -302,12 +321,20 @@ async function runMeetingBatchPipelineNow(
         + `${qualityReport.streamingWordCount} live words, `
         + `${(qualityReport.duplicateWordRatio * 100).toFixed(1)}% duplicate`,
       )
+      // Terminal: the batch RAN and lost. WAVs stay for retry, but status must
+      // stop reporting active work (pre-6.19.0 this looked like 12h of
+      // "HQ polish · N chunks" with blocksRestart:true after the work ended).
+      writeMeetingBatchTerminal(audioDir, { outcome: 'rejected', reason: qualityReport.reason })
       return { transcriptionQuality: 'streaming', qualityReport }
     }
 
     return { transcriptionQuality: 'batch', batchTranscript, batchSegments, qualityReport }
   } catch (error) {
     console.error(`[meeting-batch] Pipeline failed: ${error instanceof Error ? error.message : String(error)}`)
+    writeMeetingBatchTerminal(audioDir, {
+      outcome: 'failed',
+      reason: error instanceof Error ? error.message.slice(0, 200) : String(error).slice(0, 200),
+    })
     return { transcriptionQuality: 'streaming' }
   }
 }

package/server/lib/profile.ts

@@ -8,6 +8,10 @@ import { atomicWriteFileSync } from './atomic-fs.js'
 
 const APP_ROOT = resolve(import.meta.dirname, '../..')
 
+const PLACEHOLDER_OWNER_NAMES = new Set(['your name', 'user'])
+const PLACEHOLDER_VOCABULARY = new Set(['nameone', 'nametwo', 'yourcompany', 'productname'])
+const PLACEHOLDER_CORRECTIONS = new Set(['soundalike\u0000yourname'])
+
 /** The profile in the data home. Survives updates; the APP_ROOT copy does not. */
 export function homeProfilePath(): string {
   return resolve(homedir(), '.cos-glasses', '.cos-profile.json')
@@ -81,7 +85,8 @@ export function loadProfileField(field: string, fallback: string): string {
 }
 
 export function getOwnerName(): string {
-  return loadProfileField('owner_name', 'User')
+  const value = loadProfileField('owner_name', 'User').trim()
+  return !value || PLACEHOLDER_OWNER_NAMES.has(value.toLowerCase()) ? 'User' : value
 }
 
 /** Short speaker label for the glasses wearer, used by diarization to fast-path
@@ -92,7 +97,81 @@ export function getOwnerSpeakerLabel(): string {
 
 export function getVocabulary(): string[] {
   const profile = loadProfile()
-  return Array.isArray(profile.vocabulary) ? profile.vocabulary as string[] : []
+  if (!Array.isArray(profile.vocabulary)) return []
+  const seen = new Set<string>()
+  return (profile.vocabulary as unknown[]).flatMap(value => {
+    if (typeof value !== 'string') return []
+    const term = value.trim()
+    const key = term.toLowerCase()
+    if (!term || PLACEHOLDER_VOCABULARY.has(key) || seen.has(key)) return []
+    seen.add(key)
+    return [term]
+  })
+}
+
+/** Typed correction map shared by every decoder caller. The legacy profile
+ * stores this field as a JSON string, while hand-authored profiles sometimes
+ * use an object; accept both and ignore the factory example pair. */
+export function getWhisperCorrections(): Record<string, string> {
+  const raw = loadProfile().whisper_corrections
+  let parsed: unknown = raw
+  if (typeof raw === 'string') {
+    try { parsed = JSON.parse(raw) } catch { return {} }
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return {}
+
+  const corrections: Record<string, string> = {}
+  for (const [sourceRaw, targetRaw] of Object.entries(parsed as Record<string, unknown>)) {
+    if (typeof targetRaw !== 'string') continue
+    const source = sourceRaw.trim()
+    const target = targetRaw.trim()
+    if (!source || !target) continue
+    if (PLACEHOLDER_CORRECTIONS.has(`${source.toLowerCase()}\u0000${target.toLowerCase()}`)) continue
+    corrections[source] = target
+  }
+  return corrections
+}
+
+export interface TranscriptionProfileStatus {
+  configured: boolean
+  ownerConfigured: boolean
+  vocabularyTerms: number
+  ignoredPlaceholderTerms: number
+  ignoredPlaceholderCorrection: boolean
+}
+
+/** Path-free setup truth for startup warnings, health, and COS Control. */
+export function getTranscriptionProfileStatus(): TranscriptionProfileStatus {
+  const profile = loadProfile()
+  const rawOwner = typeof profile.owner_name === 'string' ? profile.owner_name.trim() : ''
+  const rawVocabulary = Array.isArray(profile.vocabulary)
+    ? (profile.vocabulary as unknown[]).filter((value): value is string => typeof value === 'string')
+    : []
+  const ignoredPlaceholderTerms = rawVocabulary.filter(term => PLACEHOLDER_VOCABULARY.has(term.trim().toLowerCase())).length
+  const rawCorrections = (() => {
+    const value = profile.whisper_corrections
+    if (typeof value === 'string') {
+      try { return JSON.parse(value) as unknown } catch { return null }
+    }
+    return value
+  })()
+  const ignoredPlaceholderCorrection = Boolean(
+    rawCorrections
+      && typeof rawCorrections === 'object'
+      && !Array.isArray(rawCorrections)
+      && Object.entries(rawCorrections as Record<string, unknown>).some(([source, target]) =>
+        typeof target === 'string'
+        && PLACEHOLDER_CORRECTIONS.has(`${source.trim().toLowerCase()}\u0000${target.trim().toLowerCase()}`)),
+  )
+  const ownerConfigured = Boolean(rawOwner) && !PLACEHOLDER_OWNER_NAMES.has(rawOwner.toLowerCase())
+  const vocabularyTerms = getVocabulary().length
+  return {
+    configured: ownerConfigured || vocabularyTerms > 0 || Object.keys(getWhisperCorrections()).length > 0,
+    ownerConfigured,
+    vocabularyTerms,
+    ignoredPlaceholderTerms,
+    ignoredPlaceholderCorrection,
+  }
 }
 
 export function getSystemContext(): string {