@gotcos/glasses-server 6.21.6 → 6.21.9

package/.env.example

@@ -153,6 +153,20 @@ BIND_HOST=0.0.0.0
 # keeps working if the default ever flips to Metal-on.
 # COS_BATCH_HQ_FORCE_CPU=1
 
+# Private 6.21.8 canaries can precompute reusable Large-v3 checkpoints for
+# sealed 30-second windows while a meeting is still running. Work is CPU-only,
+# global-single-flight, preemptible, and never canonical until Stop/save accepts
+# it. Balanced is hard-capped at 2 threads for fanless M1/M2 MacBook Airs; Max
+# defaults to 6 and is still capped by available CPUs. Leave OFF for public use
+# until the canary latency/thermal gate passes.
+# COS_MEETING_PROGRESSIVE_HQ=1
+# COS_MEETING_PROGRESSIVE_HQ_THREADS=2   # optional lower override; cannot raise the tier cap
+
+# Early Sync writes stable meeting identity to the Operations pipeline before
+# HQ finishes, then enriches that same artifact in place. It is I/O-only and
+# deliberately independent from the progressive-HQ compute switch.
+# COS_MEETING_EARLY_SYNC=1
+
 # ── UNSAVED-CAPTURE QUARANTINE (6.19.0) ─────────────────────────────────
 # Meeting audio whose save never landed is QUARANTINED, never deleted. It
 # surfaces on /api/health (unsaved_captures) and, with COS Control 0.3.1+,

package/CHANGELOG.md

@@ -1,3 +1,38 @@
+## 6.21.9
+
+- Prevent an unclosed or abandoned recording from monopolizing progressive HQ.
+  Each live session now receives one sealed window per FIFO turn, and sessions
+  idle for 45 seconds yield only disposable checkpoint compute while preserving
+  raw audio, recovery ledgers, completed checkpoints, and save behavior.
+- Resume a yielded session automatically when a new canonical chunk arrives,
+  and expose `paused_idle` in the progressive health snapshot for diagnosis.
+
+## 6.21.8
+
+- Decouple durable G2 sync identity from post-meeting HQ so a saved meeting can
+  enter Operations immediately and be enriched in place when Large-v3 finishes.
+- Add default-off progressive Large-v3 checkpoints for sealed 30-second meeting
+  windows. Stop reuses only cache entries whose audio, context, model, and session
+  identities still match; provisional text never becomes canonical on its own.
+- Make progressive CPU admission tier-aware. Balanced is capped at two background
+  threads for fanless M1/M2-class Macs; Max defaults to six and remains capped by
+  available CPUs. Both stay global-single-flight, preemptible, and separately
+  kill-switched from Early Sync.
+- Publish requested/effective tier, thread policy, sealed-window progress, early
+  sync outcomes, and durable finalization recovery through health for COS Control.
+
+## 6.21.7
+
+- Add a default-off, authenticated meeting-preview endpoint for private canaries.
+  It accepts bounded, server-pinned audio snapshots and returns disposable
+  Large-v3-Turbo text without creating or mutating meeting sessions.
+- Keep canonical Large-v3 transcription, speaker attribution, recovery, save, HQ
+  polish, and indexing unchanged. Preview never falls back to the canonical worker
+  and drops under canonical Metal contention.
+- Reject stale server pins and oversized bodies before inference, recheck
+  maintenance admission after slow uploads, and drop concurrent preview work rather
+  than building a latency queue. `COS_WHISPER_MEETING_PREVIEW=1` is required.
+
 ## 6.21.6
 
 - Make server-owned durable query jobs the default so accepted replies keep

package/README.md

@@ -270,6 +270,15 @@ to Turbo rather than making transcription unavailable. COS Control is the
 supported owner of the machine-wide tier; the per-lane environment variables
 remain advanced overrides.
 
+Server 6.21.8 adds a default-off meeting-completion canary. With
+`COS_MEETING_PROGRESSIVE_HQ=1`, sealed meeting windows can be polished ahead of
+Stop/save on a CPU-only, single-flight lane; finalization reuses only matching
+audio/model/context checkpoints. Balanced is capped at two background threads
+for fanless M1/M2 MacBook Airs, while Max defaults to six and remains capped by
+available CPUs. `COS_MEETING_EARLY_SYNC=1` separately gives the Operations sync
+pipeline a stable meeting identity before HQ completes. Either switch can be
+disabled without changing canonical live transcription or raw meeting audio.
+
 The first server start downloads the real-time turbo model. True HQ additionally
 requires the full `ggml-large-v3.bin` model (about 3.1 GB):
 

package/package.json

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

@@ -19,7 +19,7 @@ import { providerProofRouter } from './routes/provider-proof.js'
 import { transcribeRouter } from './routes/transcribe.js'
 import { displayRouter } from './routes/display.js'
 import { transcribeStreamRouter } from './routes/transcribe-stream.js'
-import { meetingRouter } from './routes/meeting.js'
+import { meetingRouter, resumeMeetingFinalizationJobs } from './routes/meeting.js'
 import { meetingsRouter } from './routes/meetings.js'
 import { openaiCompatRouter } from './routes/openai-compat.js'
 import { openaiKeyRouter } from './routes/openai-key.js'
@@ -439,6 +439,10 @@ listenRequiredServers(listeners).then(() => {
     if (admittedRuntimeStarted) return
     admittedRuntimeStarted = true
 
+    // Resume already-saved meetings whose post-response HQ/operations work
+    // was interrupted by a prior server update or process exit.
+    resumeMeetingFinalizationJobs()
+
     void initQueryJobRuntime().then(health => {
       if (process.env.COS_DURABLE_QUERY_JOBS !== '0') {
         console.log(`[COS API] Durable query jobs: ${health.store.state} · ${health.store.retainedIdentities} retained`)

package/server/lib/batch-transcript-quality.ts

@@ -12,7 +12,7 @@ export interface BatchResult {
   segment: BatchSegment
   text: string
   words: WhisperWord[]
-  speakerWords: Array<{ word: string; start: number; end: number; speaker: string }>
+  speakerWords: Array<{ word: string; start: number; end: number; speaker: string; similarity: number }>
 }
 
 export interface BatchTranscription {

package/server/lib/g2-enrichment-runner.ts

@@ -5,7 +5,7 @@ import { isAbsolute } from 'node:path'
 export const G2_RESULT_PREFIX = 'COS_G2_RESULT='
 
 export interface G2EnrichmentOutcome {
-  status: 'enriched' | 'already-enriched' | 'blended'
+  status: 'claimed' | 'retained' | 'enriched' | 'already-enriched' | 'blended'
   path: string
   title: string
 }
@@ -34,6 +34,8 @@ export interface G2EnrichmentOptions {
   timeoutMs?: number
   killGraceMs?: number
   onAttempt?: (message: string) => void
+  claimOnly?: boolean
+  importLocal?: boolean
 }
 
 export interface G2EnrichmentDependencies {
@@ -57,7 +59,7 @@ export function parseG2EnrichmentOutcome(stdout: string): G2EnrichmentOutcome |
     try {
       const parsed = JSON.parse(line.slice(G2_RESULT_PREFIX.length)) as Partial<G2EnrichmentOutcome>
       if (
-        (parsed.status === 'enriched' || parsed.status === 'already-enriched' || parsed.status === 'blended')
+        (parsed.status === 'claimed' || parsed.status === 'retained' || parsed.status === 'enriched' || parsed.status === 'already-enriched' || parsed.status === 'blended')
         && typeof parsed.path === 'string'
         && parsed.path.length > 0
         && typeof parsed.title === 'string'
@@ -72,8 +74,19 @@ export function parseG2EnrichmentOutcome(stdout: string): G2EnrichmentOutcome |
   return null
 }
 
-export function buildExactG2SyncArgs(syncScript: string, meetingFile: string): string[] {
-  return [syncScript, '--g2-only', '--g2-file', meetingFile, '--quiet']
+export function buildExactG2SyncArgs(
+  syncScript: string,
+  meetingFile: string,
+  claimOnly = false,
+  importLocal = false,
+): string[] {
+  return [
+    syncScript,
+    '--g2-only',
+    importLocal ? '--g2-import-file' : '--g2-file', meetingFile,
+    ...(claimOnly ? ['--g2-claim-only'] : []),
+    '--quiet',
+  ]
 }
 
 function signalChildTree(child: ReturnType<typeof spawn>, signal: NodeJS.Signals): boolean {
@@ -91,7 +104,12 @@ export async function spawnG2SyncAttempt(options: G2EnrichmentOptions): Promise<
   return await new Promise(resolve => {
     const child = spawn(
       options.pythonBin,
-      buildExactG2SyncArgs(options.syncScript, options.meetingFile),
+      buildExactG2SyncArgs(
+        options.syncScript,
+        options.meetingFile,
+        options.claimOnly,
+        options.importLocal,
+      ),
       {
         cwd: options.scriptsDir,
         stdio: ['ignore', 'pipe', 'pipe'],
@@ -176,4 +194,3 @@ export async function runG2EnrichmentWithRetry(
 
   return { ok: false, attempts: retryDelaysMs.length, error: lastError }
 }
-

package/server/lib/g2-ops-handoff.ts

@@ -10,16 +10,74 @@
 //      lets sync_meetings reclassify).
 //   3. Run sync_meetings.py --g2-only --g2-file with the private-app retry helper.
 
-import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { existsSync, mkdirSync, readFileSync } from 'node:fs'
 import { basename, dirname, join } from 'node:path'
+import { durableAtomicWriteFileSync } from './atomic-fs.js'
 import { resolveCosOperationsDir } from './cos-operations-meetings.js'
 import { runG2EnrichmentWithRetry } from './g2-enrichment-runner.js'
 import { COS_SCRIPTS_DIR, PYTHON_BIN } from './python-bridge.js'
+import { getServerInstanceId } from './server-instance-id.js'
 
 const PENDING_SUMMARY = '*G2 recording — summary pending pipeline processing.*'
 const DOMAIN_REVIEW_MARKER = '<!-- g2-needs-domain-review -->'
+const HQ_PENDING_MARKER = '<!-- g2-hq-state: pending -->'
+const OPERATIONS_OWNED_SIDECAR_FIELDS = new Set([
+  'blended_into',
+  'dedupEvidence',
+  'enrichmentState',
+  'finalPath',
+  'operationsPath',
+])
 
-export function patchRecordingForG2Pipeline(markdown: string): string {
+export function earlyMeetingSyncEnabled(): boolean {
+  return process.env.COS_MEETING_EARLY_SYNC === '1'
+}
+
+interface EarlySyncRuntimeState {
+  inFlight: boolean
+  pendingCount: number
+  lastOutcome: 'claimed' | 'finalized' | 'failed' | null
+  lastAt: string | null
+  lastError: string | null
+}
+
+const earlySyncRuntime: EarlySyncRuntimeState = {
+  inFlight: false,
+  pendingCount: 0,
+  lastOutcome: null,
+  lastAt: null,
+  lastError: null,
+}
+
+export function getEarlyMeetingSyncSnapshot(): EarlySyncRuntimeState & {
+  requested: boolean
+  enabled: boolean
+  available: boolean
+  reason: string | null
+} {
+  const requested = earlyMeetingSyncEnabled()
+  const scriptsDir = process.env.COS_SCRIPTS_DIR?.trim() || COS_SCRIPTS_DIR
+  const syncScript = scriptsDir ? join(scriptsDir, 'sync_meetings.py') : ''
+  const python = process.env.COS_PYTHON_BIN?.trim() || PYTHON_BIN
+  let reason: string | null = null
+  if (!scriptsDir) reason = 'operations_not_configured'
+  else if (!python || !existsSync(python)) reason = 'python_unavailable'
+  else if (!syncScript || !existsSync(syncScript)) reason = 'sync_script_missing'
+  else if (!syncScriptSupportsLockedImport(syncScript)) reason = 'sync_script_upgrade_required'
+  const available = reason === null
+  return { requested, enabled: requested && available, available, reason, ...earlySyncRuntime }
+}
+
+export interface G2StageOptions {
+  phase?: 'claim' | 'final'
+  hqState?: 'queued' | 'running' | 'accepted' | 'rejected' | 'failed' | 'unavailable'
+  revision?: number
+}
+
+export function patchRecordingForG2Pipeline(
+  markdown: string,
+  options: G2StageOptions = {},
+): string {
   let text = markdown.replace(/\r\n?/g, '\n')
   if (!/\|\s*\*\*Source\*\*\s*\|\s*G2 Glasses\s*\|/i.test(text) && !text.includes('| G2 Glasses')) {
     text = text.replace(
@@ -45,11 +103,71 @@ export function patchRecordingForG2Pipeline(markdown: string): string {
       text = `${text.trimEnd()}\n\n${DOMAIN_REVIEW_MARKER}\n`
     }
   }
+  text = text.replace(/\n?<!-- g2-hq-state: pending -->\n?/g, '\n')
+  if (options.phase === 'claim') {
+    text = text.includes(DOMAIN_REVIEW_MARKER)
+      ? text.replace(DOMAIN_REVIEW_MARKER, `${HQ_PENDING_MARKER}\n${DOMAIN_REVIEW_MARKER}`)
+      : `${text.trimEnd()}\n\n${HQ_PENDING_MARKER}\n`
+  }
   return text
 }
 
+function parseSidecar(path: string): Record<string, unknown> | null {
+  if (!existsSync(path)) return null
+  try {
+    const parsed = JSON.parse(readFileSync(path, 'utf8')) as unknown
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+      ? parsed as Record<string, unknown>
+      : null
+  } catch {
+    return null
+  }
+}
+
+/** Merge server-owned capture truth while preserving operations-owned match state. */
+export function mergeG2OperationsSidecar(
+  sourcePath: string,
+  destinationPath: string,
+  options: G2StageOptions = {},
+): void {
+  const source = parseSidecar(sourcePath)
+  if (!source) return
+  const existing = parseSidecar(destinationPath) ?? {}
+  const sourceSession = typeof source.sessionId === 'string' ? source.sessionId : ''
+  const existingSession = typeof existing.sessionId === 'string' ? existing.sessionId : ''
+  if (sourceSession && existingSession && sourceSession !== existingSession) {
+    throw new Error(`Refusing G2 sidecar merge across sessions (${existingSession} != ${sourceSession})`)
+  }
+
+  const priorRevision = Number(existing.lifecycleRevision ?? 0)
+  const nextRevision = Math.max(Number(options.revision ?? 0), Number(source.lifecycleRevision ?? 0))
+  if (Number.isFinite(priorRevision) && Number.isFinite(nextRevision) && nextRevision < priorRevision) {
+    throw new Error(`Refusing regressing G2 sidecar revision ${nextRevision} < ${priorRevision}`)
+  }
+
+  const merged: Record<string, unknown> = { ...existing, ...source }
+  for (const field of OPERATIONS_OWNED_SIDECAR_FIELDS) {
+    if (Object.prototype.hasOwnProperty.call(existing, field)) merged[field] = existing[field]
+  }
+  merged.lifecycleRevision = Math.max(priorRevision || 0, nextRevision || 0)
+  const inferredFinalHqState = source.batchApplied === true
+    ? 'accepted'
+    : source.batchQualityReport
+      ? 'rejected'
+      : 'unavailable'
+  merged.hqState = options.hqState
+    ?? (options.phase === 'claim' ? 'queued' : inferredFinalHqState)
+  merged.syncState = options.phase === 'claim' ? 'claimed' : 'finalized'
+  merged.serverInstanceId = getServerInstanceId()
+  merged.lifecycleUpdatedAt = new Date().toISOString()
+  durableAtomicWriteFileSync(destinationPath, JSON.stringify(merged, null, 2), { mode: 0o600 })
+}
+
 /** Stage local recording into operations/personal for exact enrichment. */
-export function stageRecordingIntoOperations(localMeetingPath: string): string | null {
+export function stageRecordingIntoOperations(
+  localMeetingPath: string,
+  options: G2StageOptions = { phase: 'final' },
+): string | null {
   const operationsDir = resolveCosOperationsDir()
   if (!operationsDir) return null
   if (!existsSync(localMeetingPath)) {
@@ -66,71 +184,114 @@ export function stageRecordingIntoOperations(localMeetingPath: string): string |
   const destDir = join(operationsDir, 'personal', 'meetings', month)
   mkdirSync(destDir, { recursive: true })
   const destPath = join(destDir, basename(localMeetingPath))
-  const patched = patchRecordingForG2Pipeline(readFileSync(localMeetingPath, 'utf8'))
-  writeFileSync(destPath, patched, { encoding: 'utf8', mode: 0o600 })
+  const patched = patchRecordingForG2Pipeline(readFileSync(localMeetingPath, 'utf8'), options)
 
   const stem = basename(localMeetingPath, '.md')
   const localDir = dirname(localMeetingPath)
   for (const companionName of [`${stem}.g2-chunks.json`, `${stem}.json`]) {
     const companion = join(localDir, companionName)
     if (existsSync(companion)) {
-      try {
-        copyFileSync(companion, join(destDir, companionName))
-      } catch (error) {
-        console.warn(
-          `[g2-ops-handoff] Sidecar copy failed for ${companionName}: `
-          + `${error instanceof Error ? error.message : String(error)}`,
-        )
-      }
+      mergeG2OperationsSidecar(companion, join(destDir, companionName), options)
     }
   }
+  // Markdown is the visible commit marker. Publish it only after every
+  // identity/revision sidecar has validated and committed.
+  durableAtomicWriteFileSync(destPath, patched, { mode: 0o600 })
   return destPath
 }
 
-export async function handoffMeetingToOperations(localMeetingPath: string): Promise<void> {
-  if (!COS_SCRIPTS_DIR || !PYTHON_BIN) {
+async function runOperationsSync(localMeetingPath: string, claimOnly: boolean): Promise<void> {
+  if (!COS_SCRIPTS_DIR) {
     console.log('[meeting/save] Standalone mode — skipping G2 sync pipeline')
     return
   }
+  if (!PYTHON_BIN) throw new Error('COS operations configured but Python bridge is unavailable')
   if (!existsSync(PYTHON_BIN)) {
-    console.warn(`[meeting/save] COS python missing at ${PYTHON_BIN} — skipping G2 sync`)
-    return
-  }
-
-  const staged = stageRecordingIntoOperations(localMeetingPath)
-  if (!staged) {
-    console.warn('[meeting/save] COS operations dir unset/unavailable — G2 sync skipped')
-    return
+    throw new Error(`COS python missing at ${PYTHON_BIN}`)
   }
 
   const syncScript = join(COS_SCRIPTS_DIR, 'sync_meetings.py')
   if (!existsSync(syncScript)) {
-    console.warn(`[meeting/save] sync_meetings.py missing at ${syncScript}`)
-    return
+    throw new Error(`sync_meetings.py missing at ${syncScript}`)
   }
 
   const spawnPath = process.env.PATH?.includes('/opt/homebrew/bin')
     ? process.env.PATH
     : `/opt/homebrew/bin:${process.env.PATH || ''}`
 
+  const supportsLockedImport = syncScriptSupportsLockedImport(syncScript)
+  if (claimOnly && !supportsLockedImport) {
+    throw new Error('Early meeting sync requires a newer sync_meetings.py with --g2-import-file')
+  }
+  const meetingFile = supportsLockedImport
+    ? localMeetingPath
+    : stageRecordingIntoOperations(localMeetingPath, { phase: 'final' })
+  if (!meetingFile) throw new Error('Unable to stage G2 recording into operations')
+
   const enrichment = await runG2EnrichmentWithRetry({
     pythonBin: PYTHON_BIN,
     syncScript,
     scriptsDir: COS_SCRIPTS_DIR,
-    meetingFile: staged,
-    env: { ...process.env, PYTHONUNBUFFERED: '1', PATH: spawnPath },
-    onAttempt: message => console.log(`[meeting/save] G2 exact sync: ${message}`),
+    meetingFile,
+    env: {
+      ...process.env,
+      PYTHONUNBUFFERED: '1',
+      PATH: spawnPath,
+      COS_G2_IMPORT_ROOT: dirname(dirname(localMeetingPath)),
+      COS_SERVER_INSTANCE_ID: getServerInstanceId() ?? '',
+    },
+    claimOnly,
+    importLocal: supportsLockedImport,
+    retryDelaysMs: claimOnly ? [0] : undefined,
+    timeoutMs: claimOnly ? 30_000 : undefined,
+    onAttempt: message => console.log(`[meeting/save] G2 ${claimOnly ? 'claim' : 'exact sync'}: ${message}`),
   })
 
   if (enrichment.ok && enrichment.outcome) {
     console.log(
-      `[meeting/save] G2 pipeline verified after ${enrichment.attempts} attempt(s): `
+      `[meeting/save] G2 ${claimOnly ? 'claim' : 'pipeline'} verified after ${enrichment.attempts} attempt(s): `
       + `${enrichment.outcome.title} → ${enrichment.outcome.path}`,
     )
   } else {
-    console.error(
-      `[meeting/save] G2 pipeline FAILED after ${enrichment.attempts} attempt(s): `
-      + `${enrichment.error ?? 'unknown exact-file enrichment failure'}`,
+    throw new Error(
+      `G2 ${claimOnly ? 'claim' : 'pipeline'} failed after ${enrichment.attempts} attempt(s): `
+      + `${enrichment.error ?? 'unknown exact-file sync failure'}`
     )
   }
 }
+
+function syncScriptSupportsLockedImport(syncScript: string): boolean {
+  try { return readFileSync(syncScript, 'utf8').includes('--g2-import-file') } catch { return false }
+}
+
+let claimQueueTail: Promise<void> = Promise.resolve()
+
+export async function claimMeetingInOperations(localMeetingPath: string): Promise<void> {
+  if (!earlyMeetingSyncEnabled()) return
+  earlySyncRuntime.pendingCount += 1
+  const claim = claimQueueTail.then(async () => {
+    earlySyncRuntime.inFlight = true
+    try {
+      await runOperationsSync(localMeetingPath, true)
+      earlySyncRuntime.lastOutcome = 'claimed'
+      earlySyncRuntime.lastError = null
+    } catch (error) {
+      earlySyncRuntime.lastOutcome = 'failed'
+      earlySyncRuntime.lastError = error instanceof Error ? error.message : String(error)
+      throw error
+    } finally {
+      earlySyncRuntime.pendingCount -= 1
+      earlySyncRuntime.inFlight = earlySyncRuntime.pendingCount > 0
+      earlySyncRuntime.lastAt = new Date().toISOString()
+    }
+  })
+  claimQueueTail = claim.catch(() => undefined)
+  await claim
+}
+
+export async function handoffMeetingToOperations(localMeetingPath: string): Promise<void> {
+  await runOperationsSync(localMeetingPath, false)
+  earlySyncRuntime.lastOutcome = 'finalized'
+  earlySyncRuntime.lastError = null
+  earlySyncRuntime.lastAt = new Date().toISOString()
+}