@gotcos/glasses-server 6.74.0 → 6.76.1

package/server/routes/meeting.ts

@@ -10,6 +10,7 @@ import { resolve } from 'node:path'
 import { createHash } from 'node:crypto'
 import { Router } from 'express'
 import { emitDisplay } from '../lib/display-bus.js'
+import { createStopRequestStore, isStopRequestRefusal, STOP_REQUEST_CLAIM_WINDOW_MS, type StopRequest, type StopRequestStore } from '../lib/meeting-stop-requests.js'
 import { cleanTranscriptLines } from '../lib/hallucination-filter.js'
 import { durableAtomicWriteFileSync } from '../lib/atomic-fs.js'
 import { appendCorrection, appliedCorrections, pendingCorrections } from '../lib/meeting-corrections.js'
@@ -240,6 +241,8 @@ export interface MeetingRouteDependencies {
   emit?: typeof emitDisplay
   finalizationJobs?: MeetingFinalizationJobStore
   finalDiarize?: FinalDiarize
+  /** Control's stop requests for live G2 meetings (lib/meeting-stop-requests.ts). */
+  stopRequests?: StopRequestStore
 }
 
 const activeFinalizationJobs = new Set<string>()
@@ -557,6 +560,7 @@ export function createMeetingRouter(deps: MeetingRouteDependencies = {}): Router
   const finalDiarize = deps.finalDiarize ?? runNemotronFinalPass
   const router = Router()
   const savingSessions = new Set<string>()
+  const stopRequests = deps.stopRequests ?? createStopRequestStore()
   setNamingSessionLiveness(id => sessions.getStartTime(id) !== null || savingSessions.has(id) || activeFinalizationJobs.has(id))
 
   let recoveryPendingLogged = false
@@ -624,6 +628,114 @@ export function createMeetingRouter(deps: MeetingRouteDependencies = {}): Router
     })
   })
 
+  // ── Stop a live G2 meeting from the Mac (COS Control) ────────────────────────────
+  // The Mac never saves a live G2 session itself (lib/meeting-stop-requests.ts says why).
+  // It asks the glasses: POST records the request and puts `meeting_stop_requested` on the
+  // display bus; the companion claims it within the claim window and runs its own Stop;
+  // Control polls GET until the meeting is saved, or says no glasses answered.
+  const stopRequestBody = (request: StopRequest, extra: Record<string, unknown> = {}) => ({
+    sessionId: request.sessionId,
+    requestId: request.requestId,
+    state: request.state,
+    requestedAt: request.requestedAt,
+    claimedAt: request.claimedAt,
+    refusal: request.refusal,
+    claimWindowMs: STOP_REQUEST_CLAIM_WINDOW_MS,
+    ...extra,
+  })
+  const stopRequestSessionId = (req: { params: Record<string, unknown> }, res: { status(code: number): { json(body: unknown): void } }): string | null => {
+    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 null
+    }
+    if (MAC_CAPTURE_ID.test(sessionId)) {
+      // A Mac recording stops from Control itself; it has no glasses to ask.
+      res.status(400).json({ error: 'A Mac recording stops from Record on Mac', reason: 'mac_capture' })
+      return null
+    }
+    return sessionId
+  }
+
+  router.post('/meeting/sessions/:sessionId/stop-request', (req, res) => {
+    const sessionId = stopRequestSessionId(req, res)
+    if (!sessionId) return
+    res.set('Cache-Control', 'private, no-store')
+    const saved = store.findBySessionId(sessionId)
+    if (saved) {
+      res.json({ sessionId, state: 'saved', saveReceipt: publicSaveResponse(saved, true) })
+      return
+    }
+    if (savingSessions.has(sessionId)) {
+      res.json({ sessionId, state: 'finalizing' })
+      return
+    }
+    const live = (sessions.getState ?? defaultSessionState)(sessionId)
+    if (live !== 'active') {
+      res.status(409).json({ error: 'This meeting is not recording', reason: 'not_live', state: live })
+      return
+    }
+    const body = req.body as Record<string, unknown> | undefined
+    const source = typeof body?.source === 'string' && /^[a-z][a-z0-9_-]{0,31}$/.test(body.source) ? body.source : 'control'
+    const request = stopRequests.request(sessionId, source)
+    try {
+      emit({
+        type: 'meeting_stop_requested',
+        data: { sessionId, requestId: request.requestId, source, claimWindowMs: STOP_REQUEST_CLAIM_WINDOW_MS },
+      })
+    } catch (error) {
+      console.warn('[meeting/stop-request] Display notification failed:', error)
+    }
+    console.log(`[meeting/stop-request] ${source} asked the glasses to stop ${sessionId} (${request.requestId})`)
+    res.status(202).json(stopRequestBody(request))
+  })
+
+  // The companion's answer: `accept` claims the request (then it stops), `refuse` says why not.
+  router.post('/meeting/sessions/:sessionId/stop-request/:requestId/claim', (req, res) => {
+    const sessionId = stopRequestSessionId(req, res)
+    if (!sessionId) return
+    res.set('Cache-Control', 'private, no-store')
+    const requestId = String(req.params.requestId ?? '')
+    const body = req.body as Record<string, unknown> | undefined
+    const decision = body?.decision
+    if (decision !== 'accept' && decision !== 'refuse') {
+      res.status(400).json({ error: 'decision must be accept or refuse', reason: 'invalid_decision' })
+      return
+    }
+    if (decision === 'refuse' && !isStopRequestRefusal(body?.reason)) {
+      res.status(400).json({ error: 'Unknown refusal reason', reason: 'invalid_refusal' })
+      return
+    }
+    const result = decision === 'accept'
+      ? stopRequests.claim(sessionId, requestId)
+      : stopRequests.refuse(sessionId, requestId, body!.reason as Parameters<StopRequestStore['refuse']>[2])
+    if (!result.ok) {
+      const status = result.reason === 'unknown_request' ? 404 : 409
+      res.status(status).json({ error: 'Stop request is not open', reason: result.reason })
+      return
+    }
+    console.log(`[meeting/stop-request] glasses ${decision === 'accept' ? 'claimed' : 'refused'} ${result.request.requestId}${result.request.refusal ? ` (${result.request.refusal})` : ''}`)
+    res.json(stopRequestBody(result.request))
+  })
+
+  // Control's poll. A saved meeting answers `saved` with its receipt, whatever the request says.
+  router.get('/meeting/sessions/:sessionId/stop-request/:requestId', (req, res) => {
+    const sessionId = stopRequestSessionId(req, res)
+    if (!sessionId) return
+    res.set('Cache-Control', 'private, no-store')
+    const request = stopRequests.get(sessionId, String(req.params.requestId ?? ''))
+    if (!request) {
+      res.status(404).json({ error: 'Unknown stop request', reason: 'unknown_request' })
+      return
+    }
+    const saved = store.findBySessionId(sessionId)
+    if (saved) {
+      res.json(stopRequestBody(request, { state: 'saved', saveReceipt: publicSaveResponse(saved, true) }))
+      return
+    }
+    res.json(stopRequestBody(request, savingSessions.has(sessionId) ? { finalizing: true } : {}))
+  })
+
   router.post('/meeting/save', async (req, res) => {
     let lockedSessionId: string | null = null
     let maintenanceLease: MaintenanceWorkLease | undefined

package/server/routes/transcribe-stream.ts

@@ -2443,7 +2443,8 @@ async function processStreamChunk(opts: {
   // block on a cue, and no LLM runs on this path. .catch() is required — a
   // bare `void` on a rejecting promise is an unhandled rejection, which Node
   // throws on by default. All gates live inside the feed.
-  void feedLiveCueTranscript(sessionId, trimmedText, Boolean(fallbackReason)).catch(() => {})
+  // The ASR await above lets a late chunk land after Stop or save; a closed session never feeds cues.
+  if (!isSessionDeleted(sessionId)) void feedLiveCueTranscript(sessionId, trimmedText, Boolean(fallbackReason)).catch(() => {})
 
   console.log(`[perf] TOTAL request: ${(performance.now() - tReq).toFixed(1)}ms | chunk #${chunkIndex} | ${audioBuffer.length}b | rms=${Math.round(rms)} q=${isQuiet ? 1 : 0} gate=${quiet.gate}${quiet.speechSec === null ? '' : ` speech=${quiet.speechSec.toFixed(2)}s`} fe=${stt.frontEnd} | ${asrProvider} | "${trimmedText.slice(0, 50)}"`)
   return canonicalChunkResponse(chunk, sessionId, chunkIndex)

package/shared/live-cues-v2.ts

@@ -0,0 +1,77 @@
+/**
+ * Live cues v2 wire contract (server 6.75 candidate, companion 6.10.641 candidate).
+ * Additive to v1: old clients keep receiving `coaching_nudge` and ignore the new named event.
+ * The companion keeps a byte-identical copy at src/lib/live-cues-v2-contract.ts.
+ */
+export const LIVE_CUES_V2_PROTOCOL = 2 as const
+export const CUE_HEADLINE_MAX = 64
+export const CUE_DETAIL_MAX = 220
+export const CUE_FEEDBACK_REASON_MAX = 200
+
+export type CueKind = 'reinforce' | 'challenge'
+
+/** A past meeting the cue drew on (0 to 2 per cue). */
+export interface CueSourceRef { id: string; date: string; title: string }
+
+/** SSE named event `coaching_nudge_v2` (emitted BEFORE its v1 `coaching_nudge` twin), and the rows of GET /api/live-cues/status?sessionId=. */
+export interface LiveCueV2 {
+  protocol: 2
+  cueId: string
+  sessionId: string
+  /** <= 64 chars: the lens footer line. */
+  headline: string
+  /** <= 220 chars: the full cue, shown on tap and in the phone Cues sheet. */
+  detail: string
+  kind: CueKind
+  sources: CueSourceRef[]
+  /** Admission probability from the gate, 0 to 1. */
+  gate: number
+  createdAt: number
+  model: string
+}
+
+/** v1 `coaching_nudge` as the v2 engine emits it for old clients (headline only). */
+export interface LiveCueV1Compat { nudge: string; type: CueKind; priority: 2; cueId: string; sessionId: string; protocol: 2 }
+
+/** `reason` when unavailable: master_flag_off, api_key_in_env, jev_not_configured, claude_not_found, budget_exhausted,
+ *  jev_cap_reached, jev_breaker_open. */
+export interface LiveCuesV2Capability { available: boolean; reason?: string; protocol: 2; model: string }
+
+/** Why cues are not coming for this meeting. `active` means evaluations are running normally (silence is a choice). */
+export type LiveCuesV2SessionState = 'active' | 'paused' | 'ended' | 'stopped'
+export type LiveCuesV2StopReason = 'breaker_open' | 'meeting_cap' | 'budget_exhausted' | 'jev_cap_reached' | 'jev_breaker_open' | 'jev_not_configured'
+
+export interface LiveCuesV2SessionStatus {
+  sessionId: string
+  state: LiveCuesV2SessionState
+  /** Present when state is `stopped`. */
+  reason?: LiveCuesV2StopReason
+  paused: boolean
+  ended: boolean
+  /** The pause request sequence the server last applied (0 when none). */
+  pauseSeq: number
+  cues: LiveCueV2[]
+  evaluations: number
+  writerCalls: number
+}
+
+/** GET /api/live-cues/status?sessionId=X (v2 server). Without sessionId the v1 array shape is unchanged. */
+export interface LiveCuesV2StatusResponse { protocol: 2; enabled: boolean; session: LiveCuesV2SessionStatus | null }
+
+/** POST /api/live-cues/pause -> { ok, paused, applied, pauseSeq }. `seq` is a per-meeting counter from the phone; the server
+ *  ignores a request whose seq is not newer than the last applied one (applied: false) so out-of-order posts cannot win. */
+export interface LiveCuesPauseRequest { sessionId: string; paused: boolean; seq?: number }
+/** POST /api/live-cues/feedback */
+export interface LiveCuesFeedbackRequest { sessionId: string; cueId: string; vote: 'up' | 'down'; reason?: string }
+
+export function isLiveCueV2(value: unknown): value is LiveCueV2 {
+  if (!value || typeof value !== 'object') return false
+  const v = value as Record<string, unknown>
+  return v.protocol === 2 && typeof v.cueId === 'string' && v.cueId.length > 0 && typeof v.sessionId === 'string'
+    && typeof v.headline === 'string' && v.headline.length > 0 && v.headline.length <= CUE_HEADLINE_MAX
+    && typeof v.detail === 'string' && v.detail.length > 0 && v.detail.length <= CUE_DETAIL_MAX
+    && (v.kind === 'reinforce' || v.kind === 'challenge')
+    && Array.isArray(v.sources) && v.sources.length <= 2
+    && v.sources.every(s => !!s && typeof (s as CueSourceRef).id === 'string' && typeof (s as CueSourceRef).date === 'string' && typeof (s as CueSourceRef).title === 'string')
+    && typeof v.gate === 'number' && typeof v.createdAt === 'number' && typeof v.model === 'string'
+}

package/shared/meeting-ask.ts

@@ -40,7 +40,8 @@ export interface MeetingAskSource {
   /** Server-owned accepted post-stop quotation; no live turn target or precise word clock. */
   finalizedTranscript?: boolean
     id: string;
-    kind: 'transcript' | 'memory' | 'meeting' | 'file' | 'web';
+    /** 'profile' (server 6.76.0): the COS owner card from the profile; cited with an H id like other COS history. */
+    kind: 'transcript' | 'memory' | 'meeting' | 'file' | 'web' | 'profile';
     title: string;
     text: string;
     turnId?: number;
@@ -115,6 +116,8 @@ export function meetingAskFromLine(sections: readonly MeetingAskSection[] | unde
         } }));
         parts.push(hosts.length ? `the web, ${hosts.slice(0, 2).join(', ')}` : 'the web');
     }
+    if (used.some(s => s.kind === 'profile'))
+        parts.push('COS profile');
     if (used.some(s => s.kind === 'memory'))
         parts.push('COS memory');
     const meetings = unique(used.filter(s => s.kind === 'meeting').map(s => {
@@ -170,6 +173,8 @@ export interface MeetingAskExchange {
     files: MeetingAskFile[];
     error?: string;
     retryOf?: string;
+    /** Server 6.76.0: how long the answer took on the server and in which phase. Not the meeting position; that is throughMs. */
+    timings?: MeetingAskTimings;
     /** Server 6.71.13 (capabilities.factCheckScope): what a completed Fact check covered. Named-claim checks and follow-ups carry none. */
     factCheckRange?: MeetingAskFactCheckRange;
 }
@@ -178,6 +183,23 @@ export interface MeetingAskExchange {
  * check covers the whole meeting (full); each later one covers only what is new since the last completed
  * check's throughMs. A check that found nothing new still completes with claims 0, so the next one moves on.
  */
+/**
+ * One phase of one answer, in wall-clock ms on the server (6.76.0). plan is a model call that asked for a lookup,
+ * answer the one that wrote the draft, review the grounding check, public_topic the fact-check topic selection,
+ * fact_check the whole fact-check route. forced marks the COS lookup a person question always gets.
+ */
+export interface MeetingAskPhaseTiming {
+    phase: 'plan' | 'answer' | 'review' | 'cos_search' | 'web_search' | 'public_topic' | 'fact_check';
+    ms: number;
+    forced?: true;
+    failed?: true;
+    results?: number;
+}
+export interface MeetingAskTimings {
+    /** From the server starting the request to its final state. */
+    totalMs: number;
+    phases: MeetingAskPhaseTiming[];
+}
 export interface MeetingAskFactCheckRange {
     fromMs: number;
     throughMs: number;