@gotcos/glasses-server 6.84.0 → 6.86.0

package/server/routes/prompt-drafts.ts

@@ -52,6 +52,7 @@ import {
 import { getVocabulary, getWhisperCorrections } from '../lib/profile.js'
 import { correctionOnlyForms } from '../lib/glossary-learn.js'
 import { polishLinkProblem, renderSpokenPaths, spokenPathsEnabled } from '../lib/dictation-format.js'
+import { customInstructionsHash, readCustomInstructions } from '../lib/dictation-polish-instructions.js'
 import { createBreaker } from '../lib/claude-circuit.js'
 import { logTokenAudit } from '../lib/token-audit.js'
 import { emitDisplay } from '../lib/display-bus.js'
@@ -109,7 +110,7 @@ function routeAutoClean(req: { body?: any; query?: any }): AutoCleanRequest {
 async function cleanOutboundDictation(
   text: string,
   opts: AutoCleanRequest & { bucket: PolishBucket; signal?: AbortSignal; prewarmToken?: string },
-): Promise<{ text: string; polishSkipped?: PolishSkipped; prewarm?: PrewarmOutcome }> {
+): Promise<PolishResult> {
   const result = await polishOutboundDictation(text, opts)
   // A warm process the model call did not take must not sit until its TTL.
   if (opts.prewarmToken && !result.prewarm) {
@@ -118,10 +119,23 @@ async function cleanOutboundDictation(
   return result
 }
 
+/** 6.85.0, additive and present only when the model was given the user's polish instructions. */
+interface PolishInstructionsUse { customInstructions?: true; instructionsHash?: string }
+type PolishResult = { text: string; polishSkipped?: PolishSkipped; prewarm?: PrewarmOutcome } & PolishInstructionsUse
+
+/**
+ * 6.85.0: the user's polish instructions apply to dictation (Mac dictation and G2 messages, which
+ * are surface "message", and prompt drafts). Meeting lines are a faithful record, so they stay on
+ * the built-in rules alone, the same way they skip the filler pass and spoken paths.
+ */
+export function polishInstructionsFor(bucket: PolishBucket): string {
+  return bucket === 'meeting' ? '' : readCustomInstructions().customInstructions
+}
+
 async function polishOutboundDictation(
   text: string,
   opts: AutoCleanRequest & { bucket: PolishBucket; signal?: AbortSignal; prewarmToken?: string },
-): Promise<{ text: string; polishSkipped?: PolishSkipped; prewarm?: PrewarmOutcome }> {
+): Promise<PolishResult> {
   let cleaned = applyNegativeRules(applyCorrections(text)).replace(/\s+/g, ' ').trim() || text
   // applyCorrections above is an EXACT string map, so it only fixes misspellings someone
   // already hand-authored. A novel miss ("Rileyy" for Riley, "Exampel" for Example) sails
@@ -159,6 +173,10 @@ async function polishOutboundDictation(
   if (polishBudgetExhausted(opts.bucket)) return { text: cleaned, polishSkipped: 'daily_cap' }
   const startedAt = Date.now()
   recordPolishCall(opts.bucket)
+  // Read once per polish: the warm and cold paths see the same instructions.
+  const customInstructions = polishInstructionsFor(opts.bucket)
+  const instructionsHash = customInstructionsHash(customInstructions)
+  const used: PolishInstructionsUse = customInstructions ? { customInstructions: true, instructionsHash } : {}
   // 6.79.2: a warm process started at key press answers without the CLI's start-up cost.
   const warmEntry = opts.prewarmToken ? takePolishPrewarm(opts.prewarmToken, model) : null
   let prewarm: PrewarmOutcome | undefined = opts.prewarmToken ? 'missed' : undefined
@@ -166,18 +184,19 @@ async function polishOutboundDictation(
     let polished: string | null = null
     if (warmEntry) {
       try {
-        polished = (await runWarmPolish(warmEntry, cleaned, getVocabulary(), { signal: opts.signal })).trim()
+        polished = (await runWarmPolish(warmEntry, cleaned, getVocabulary(), { signal: opts.signal, customInstructions })).trim()
         prewarm = 'used'
       } catch (err) {
         // Nothing was sent: the cold path below is the same call, not a second one.
         if (!(err instanceof PrewarmUnavailableError)) throw err
       }
     }
-    if (polished === null) polished = (await autoCleanDictation(cleaned, getVocabulary(), { model, signal: opts.signal })).trim()
+    if (polished === null) polished = (await autoCleanDictation(cleaned, getVocabulary(), { model, signal: opts.signal, customInstructions })).trim()
     autoCleanBreaker.recordSuccess()
     logTokenAudit({
       source: 'g2-dictation-autoclean', model, inputChars: cleaned.length, outputChars: polished.length,
       durationMs: Date.now() - startedAt, caller: `dictation_autoclean_${opts.bucket}`,
+      polishInstructions: { on: Boolean(customInstructions), hash: instructionsHash },
     })
     // 6.83.1: the model never invents a link and never drops one the dictionary wrote. Its
     // answer is refused (the pre-polish text goes out, polishSkipped "link_guard") rather than
@@ -185,13 +204,13 @@ async function polishOutboundDictation(
     const linkProblem = polished ? polishLinkProblem(cleaned, polished, correctionOnlyForms(getWhisperCorrections()), getVocabulary()) : null
     if (linkProblem) {
       console.warn(`[prompt-draft] auto-clean answer refused: ${linkProblem}`)
-      return { text: cleaned, ...(prewarm ? { prewarm } : {}), polishSkipped: 'link_guard' }
+      return { text: cleaned, ...(prewarm ? { prewarm } : {}), polishSkipped: 'link_guard', ...used }
     }
-    return { text: polished || cleaned, ...(prewarm ? { prewarm } : {}) }
+    return { text: polished || cleaned, ...(prewarm ? { prewarm } : {}), ...used }
   } catch (err: any) {
     autoCleanBreaker.recordFailure()
     console.warn(`[prompt-draft] auto-clean failed (glossary-only): ${err?.message ?? err}`)
-    return { text: cleaned, polishSkipped: 'failed', ...(prewarm ? { prewarm } : {}) }
+    return { text: cleaned, polishSkipped: 'failed', ...(prewarm ? { prewarm } : {}), ...used }
   }
 }
 
@@ -219,7 +238,7 @@ promptDraftsRouter.post('/dictation/finalize', async (req, res) => {
 
   const abort = new AbortController()
   res.on('close', () => { if (!res.writableEnded) abort.abort() })
-  const { text: finalText, polishSkipped, prewarm } = await cleanOutboundDictation(text, {
+  const { text: finalText, polishSkipped, prewarm, customInstructions, instructionsHash } = await cleanOutboundDictation(text, {
     enabled: true,
     model,
     bucket: surface,
@@ -231,6 +250,8 @@ promptDraftsRouter.post('/dictation/finalize', async (req, res) => {
   res.json({
     text: finalText, surface, polished: finalText !== text,
     ...(polishSkipped ? { polishSkipped } : {}), ...(prewarm ? { prewarm } : {}),
+    // 6.85.0: only when the model was given the user's polish instructions (a hash, never the text).
+    ...(customInstructions ? { customInstructions, instructionsHash } : {}),
   })
 })
 
@@ -393,7 +414,7 @@ async function transcribeChunk(draftId: string, chunkIndex: number, audio: Buffe
       // plus the decoder's own low confidence (prompt-tail-guard.ts).
       const guarded = guardPromptTail({ text: result.text, words: result.words, speech: speechWindowsFromWav(audio) })
       for (const drop of guarded.dropped) {
-        console.warn(`[prompt-draft] tail_drop ${draftId}/${chunkIndex} ${purpose}/${mode} (${drop.reason}, start=${drop.startSec ?? '?'}s, lastSpeech=${guarded.lastSpeechEndSec ?? '?'}s, p=${drop.meanProbability?.toFixed(2) ?? '?'}): "${drop.text.slice(0, 100)}"`)
+        console.warn(`[prompt-draft] tail_drop ${draftId}/${chunkIndex} ${purpose}/${mode} (${drop.reason}, start=${drop.startSec ?? '?'}s, lastSpeech=${guarded.lastSpeechEndSec ?? '?'}s, p=${drop.meanProbability?.toFixed(2) ?? '?'}): chars=${drop.text.length}`)
       }
       if (guarded.dropped.length > 0 && !guarded.text.trim()) throw new NoSpeechDetectedError(result.text)
       const text = sanitizeTranscript(draftId, guarded.text)
@@ -518,7 +539,7 @@ async function finalizeDraft(draftId: string, mode: 'hq' | 'fast', autoClean: Au
     await markPromptDraftError(draftId, 'No speech detected')
     throw new NoSpeechDetectedError()
   }
-  const { text: finalText, polishSkipped } = await cleanOutboundDictation(text, { ...autoClean, bucket: 'prompt_draft', signal })
+  const { text: finalText, polishSkipped, customInstructions, instructionsHash } = await cleanOutboundDictation(text, { ...autoClean, bucket: 'prompt_draft', signal })
   const finalized = await markPromptDraftFinalized(draftId, finalText)
   const qualities = transcriptRecords.map(record => record.actualQuality)
   const actualQuality: 'hq' | 'fast' | 'cloud' = qualities.includes('cloud')
@@ -548,6 +569,8 @@ async function finalizeDraft(draftId: string, mode: 'hq' | 'fast', autoClean: Au
     ...(engineReason ? { engineReason } : {}),
     // 6.79.1, additive.
     ...(polishSkipped ? { polishSkipped } : {}),
+    // 6.85.0, additive.
+    ...(customInstructions ? { customInstructions, instructionsHash } : {}),
   }
 }
 

package/server/routes/query-jobs.ts

@@ -1,5 +1,6 @@
 import { Router, type Request, type Response } from 'express'
 import { durableQueryJobsEnabled, messagesSteerEnabled } from '../lib/query-job-feature.js'
+import { ACTIVE_QUERY_JOBS_LIST_MAX, ACTIVE_QUERY_JOBS_PROTOCOL } from '../lib/query-job-active.js'
 import {
   QueryJobCoordinator,
   QueryJobCoordinatorError,
@@ -197,6 +198,27 @@ export function createQueryJobsRouter(
     }
   })
 
+  // 6.84.1: the in-flight jobs for COS Control's Running panel (docs/active-query-jobs.md).
+  // Read-only and in memory; registered ahead of `/query-jobs/:jobId`, which would answer
+  // 400 invalid_job_id for "active". A title is the prompt's first line, cut to 80
+  // characters; no prompt body, answer, activity or trail is ever in this answer.
+  router.get('/query-jobs/active', (_req, res) => {
+    try {
+      const now = Date.now()
+      const { items, count } = coordinator.activeJobs(now)
+      return res.json({
+        protocolVersion: ACTIVE_QUERY_JOBS_PROTOCOL,
+        enabled: enabled(),
+        now: new Date(now).toISOString(),
+        count,
+        items: items.slice(0, ACTIVE_QUERY_JOBS_LIST_MAX),
+      })
+    } catch (error) {
+      const wire = wireError(error)
+      return res.status(wire.status).json(wire.body)
+    }
+  })
+
   // Lost-202 recovery is keyed by the immutable client identity. Keep this
   // route explicit and ahead of the dynamic job lookup for future router
   // changes that may broaden the latter's matcher.

package/server/routes/transcribe-stream.ts

@@ -115,6 +115,8 @@ import {
   type MaintenanceWorkLease,
 } from '../lib/maintenance-lifecycle.js'
 import { feedLiveCueTranscript } from '../lib/live-cues-engine.js'
+import { armMacLiveCues, type MacLiveCuesAnswer } from '../lib/live-cues-v2.js'
+import { liveProvisional } from '../lib/live-provisional.js'
 import { preemptMetalBatchForLive, registerLiveActivityProbe } from '../lib/whisper-metal-gate.js'
 import {
   scheduleProgressiveHqCheckpoint,
@@ -1409,10 +1411,23 @@ function recordReceivedChunk(session: TranscriptSession, chunkIndex: number): vo
   }
 }
 
-function recordAsrCompleted(session: TranscriptSession, chunkIndex: number): void {
+function recordAsrCompleted(session: TranscriptSession, chunkIndex: number, sessionId: string): void {
   if (!Number.isInteger(chunkIndex) || chunkIndex < 0) return
   if (!session.asrCompletedIndices) session.asrCompletedIndices = []
   insertSortedUnique(session.asrCompletedIndices, chunkIndex)
+  // 6.86.0: the canonical answer replaces the grey provisional line for this chunk (live-provisional.ts).
+  liveProvisional().settle(sessionId, chunkIndex)
+}
+
+/** 6.86.0: keep the newest preview of a LIVE meeting for COS Control's grey line. Only a session this server holds (a
+ *  close removes it from `sessions`), and only while that chunk is still open: a preview that lands after its chunk (or a
+ *  later one) settled is stale. Memory only; never logged. */
+function noteLiveProvisional(sessionId: string, chunkIndex: number, previewGen: number, text: string, model: string): void {
+  const session = sessions.get(sessionId)
+  if (!session) return
+  const completed = session.asrCompletedIndices ?? []
+  if (completed.length && chunkIndex <= completed[completed.length - 1]) return
+  liveProvisional().record(sessionId, { chunkIndex, previewGen, text, model })
 }
 
 function canonicalIndices(session: TranscriptSession): number[] {
@@ -1773,6 +1788,7 @@ function finishClosingTranscriptSession(
   sessions.delete(sessionId)
   sessionAudioBytes.delete(sessionId)
   sessionAudioWrites.delete(sessionId)
+  liveProvisional().clear(sessionId)
   // Clean up inline hallucination tracking (was leaking until 4-hour interval fired)
   clearSessionHallucinationState(sessionId)
   // Track as deleted so orphan heartbeats get 410 Gone (prevents zombie client spam)
@@ -2088,7 +2104,7 @@ function sanitizeStreamTranscript(sessionId: string, session: TranscriptSession,
     const dropReason = streamSilenceDropReason(trimmedText, isQuiet)
     const flagAllows = dropReason === 'thankyou_silence' ? THANKYOU_FILTER : STRIP_BRAND_URLS
     if (dropReason && flagAllows) {
-      console.log(`[hallucination] Dropped (${dropReason}, q=${isQuiet ? 1 : 0}): "${trimmedText.slice(0, 60)}"`)
+      console.log(`[hallucination] Dropped (${dropReason}, q=${isQuiet ? 1 : 0}): chars=${trimmedText.length}`)
       return { text: '', fallbackReason: dropReason }
     }
   }
@@ -2106,7 +2122,7 @@ function sanitizeStreamTranscript(sessionId: string, session: TranscriptSession,
     const streak = (session.vocabEchoStreak ?? 0) + 1
     session.vocabEchoStreak = streak
     if (isQuiet || streak >= 2 || isCrossChunkRepeat(session, trimmedText)) {
-      console.log(`[hallucination] Dropped (vocab_echo, q=${isQuiet ? 1 : 0}, streak=${streak}): "${trimmedText.slice(0, 60)}"`)
+      console.log(`[hallucination] Dropped (vocab_echo, q=${isQuiet ? 1 : 0}, streak=${streak}): chars=${trimmedText.length}`)
       return { text: '', fallbackReason: 'vocab_echo' }
     }
   } else if (trimmedText) {
@@ -2377,7 +2393,7 @@ async function processStreamChunk(opts: {
   if (alreadyCanonical?.text) {
     session.lastActivityAt = Date.now()
     recordReceivedChunk(session, chunkIndex)
-    recordAsrCompleted(session, chunkIndex)
+    recordAsrCompleted(session, chunkIndex, sessionId)
     if (candidate && candidateRecordKey) {
       session.providerCandidates![candidateRecordKey].accepted =
         alreadyCanonical.asrProvider === 'iphone-whisperkit-beta' && alreadyCanonical.audioSha256 === audioSha256
@@ -2390,7 +2406,7 @@ async function processStreamChunk(opts: {
   if (alreadyEmpty) {
     session.lastActivityAt = Date.now()
     recordReceivedChunk(session, chunkIndex)
-    recordAsrCompleted(session, chunkIndex)
+    recordAsrCompleted(session, chunkIndex, sessionId)
     persistSessionRequired(sessionId)
     return emptyChunkResponse(alreadyEmpty, sessionId, chunkIndex)
   }
@@ -2524,7 +2540,7 @@ async function processStreamChunk(opts: {
   if (labels.segments) labels.segments = labels.segments.map(segment => policyLabel(segment, capturePolicy))
 
   if (!trimmedText) {
-    console.log(`[hallucination] Filtered (${sanitized.fallbackReason || fallbackReason || 'empty'}): "${rawText.slice(0, 60)}"`)
+    console.log(`[hallucination] Filtered (${sanitized.fallbackReason || fallbackReason || 'empty'}): chars=${rawText.length}`)
     if (candidate && candidateRecordKey && session.providerCandidates?.[candidateRecordKey]) {
       session.providerCandidates[candidateRecordKey].accepted = false
       session.providerCandidates[candidateRecordKey].fallbackReason = sanitized.fallbackReason || fallbackReason || 'empty'
@@ -2543,7 +2559,7 @@ async function processStreamChunk(opts: {
     }
     session.emptyCompletions ??= {}
     session.emptyCompletions[String(chunkIndex)] = emptyCompletion
-    recordAsrCompleted(session, chunkIndex)
+    recordAsrCompleted(session, chunkIndex, sessionId)
     persistSessionRequired(sessionId)
     scheduleSessionProgressiveHq(sessionId)
     return emptyChunkResponse(emptyCompletion, sessionId, chunkIndex)
@@ -2578,12 +2594,12 @@ async function processStreamChunk(opts: {
         session.providerCandidates[candidateRecordKey].accepted ? undefined : 'canonical_exists'
     }
     session.lastActivityAt = Date.now()
-    recordAsrCompleted(session, chunkIndex)
+    recordAsrCompleted(session, chunkIndex, sessionId)
     persistSessionRequired(sessionId)
     return canonicalChunkResponse(finalExisting, sessionId, chunkIndex)
   }
   session.chunks[chunkIndex] = chunk
-  recordAsrCompleted(session, chunkIndex)
+  recordAsrCompleted(session, chunkIndex, sessionId)
   if (candidate && candidateRecordKey) {
     if (session.providerCandidates?.[candidateRecordKey]) {
       session.providerCandidates[candidateRecordKey].accepted = asrProvider === 'iphone-whisperkit-beta'
@@ -2608,7 +2624,9 @@ async function processStreamChunk(opts: {
   // 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)}"`)
+  // 6.85.0: timing and the character count only. This line runs for every chunk, so the meeting
+  // text itself never goes to the server log (transcribe-stream-log-privacy.test.ts).
+  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} | chars=${trimmedText.length}`)
   return canonicalChunkResponse(chunk, sessionId, chunkIndex)
 }
 
@@ -2688,6 +2706,7 @@ transcribeStreamRouter.post('/transcribe-stream/preview', async (req, res) => {
       if (!cleaned || sharedIsFullHallucination(cleaned)) {
         return void res.status(204).send()
       }
+      noteLiveProvisional(sessionId, chunkIndex, previewGen, cleaned, result.model)
       return void res.json({
         sessionId,
         chunkIndex,
@@ -2706,6 +2725,20 @@ transcribeStreamRouter.post('/transcribe-stream/preview', async (req, res) => {
   }
 })
 
+/**
+ * 6.86.0: GET /transcribe-stream/provisional?sessionId=<id>. The newest provisional text of a live meeting, for COS
+ * Control's grey line (live-provisional.ts). Token-authenticated like every /api route; private, no-store. Memory only:
+ * a restart, a save or a settled chunk empties it. `live` is false when this server holds no open session by that id.
+ */
+transcribeStreamRouter.get('/transcribe-stream/provisional', (req, res) => {
+  res.set('Cache-Control', 'private, no-store')
+  const sessionId = typeof req.query.sessionId === 'string' ? req.query.sessionId : ''
+  if (!/^[A-Za-z0-9:_-]{3,96}$/.test(sessionId)) return void res.status(400).json({ error: 'invalid sessionId', reason: 'invalid_session_id' })
+  const live = sessions.has(sessionId)
+  const held = live ? liveProvisional().read(sessionId) : null
+  res.json({ v: 1, sessionId, live, provisional: held, serverInstanceId: getServerInstanceId() })
+})
+
 /** Unlike the received ledger, only these canonical completions acknowledge ASR.
  * A native stop supplies the total captured chunks, including its last tail. */
 export function assertMacCaptureComplete(sessionId: string, expectedChunkCount: unknown): void {
@@ -2739,6 +2772,9 @@ transcribeStreamRouter.post('/mac-recording/start', (req, res) => {
   try {
     const serverInstanceId = requireMacPin(req)
     if (typeof req.body?.captureId !== 'string' || !MAC_CAPTURE_ID.test(req.body.captureId)) throw macError(400, 'invalid_capture_id', 'Invalid Mac capture ID')
+    // 6.86.0: `liveCues: true` asks for live cues on this recording (COS Control's live meeting view). Checked before
+    // anything is written, so a bad body admits nothing.
+    if (req.body.liveCues !== undefined && typeof req.body.liveCues !== 'boolean') throw macError(400, 'invalid_live_cues', 'liveCues must be true or false')
     if (isSessionDeleted(req.body.captureId) || getMeetingStore().findBySessionId(req.body.captureId)) throw macError(410, 'session_closed', 'Capture is closed')
     // An existing non-Mac session may not acquire new source metadata.
     if (sessions.has(req.body.captureId) && !readMacRecording(req.body.captureId)) throw macError(409, 'mac_capture_conflict', 'Capture ID already exists')
@@ -2747,7 +2783,13 @@ transcribeStreamRouter.post('/mac-recording/start', (req, res) => {
     const session = getSession(recording.sessionId)
     if (!session.chunks.some(Boolean)) session.startTime = recording.startTime
     persistSessionRequired(recording.sessionId)
-    res.json({ ...MAC_AUDIO, ...recording, replayed, serverInstanceId })
+    // Arming happens only after the recording is admitted, and its answer never fails the start (armMacLiveCues returns a
+    // reason code instead of throwing). Without `liveCues: true` the answer is byte for byte what 6.85.0 sent.
+    let liveCues: MacLiveCuesAnswer | undefined
+    if (req.body.liveCues === true) {
+      try { liveCues = armMacLiveCues(recording.sessionId) } catch { liveCues = { armed: false, reason: 'unavailable' } }
+    }
+    res.json({ ...MAC_AUDIO, ...recording, replayed, serverInstanceId, ...(liveCues ? { liveCues } : {}) })
   } catch (error) { sendStreamError(res, error) } finally { lease?.release() }
 })
 const macChunkLocks = new Set<string>()

package/server/routes/voice.ts

@@ -341,7 +341,7 @@ voiceRouter.get('/voice/ext-audio', (_req, res) => {
         ageHours: parseFloat(ageHours),
         expiresIn: `${Math.max(0, 72 - parseFloat(ageHours)).toFixed(1)}h`,
         // 6.45.3 — the chunk indices a reviewer can ask to hear (`?chunk=` on
-        // the sample route). Queen, 2026-09-12: the Add-a-voice panel let her
+        // the sample route). Grace, 2026-09-12: the Add-a-voice panel let her
         // name a session but not listen to it; naming is a guess without this.
         chunkIndices: listExtAudioChunks(d.name),
       }

package/server/routes/welcome-context.ts

@@ -3,7 +3,7 @@
 // only proxies Open-Meteo / reverse-geocode — it is not "server location".
 
 import { Router } from 'express'
-import { callPython } from '../lib/python-bridge.js'
+import { callPython, pythonBridgeAvailable } from '../lib/python-bridge.js'
 
 export const welcomeContextRouter = Router()
 
@@ -24,6 +24,8 @@ let lastKnownCity = ''
 
 let cachedNextEvent: NextEventPayload | null = null
 let calendarFetchedAt = 0
+/** 6.84.1: whether the read that filled `cachedNextEvent` really reached the calendar. */
+let cachedCalendarRead = false
 
 // 6.63.1: after a server restart the first forecast lookup can fail and, with nothing cached, the
 // glasses Home got no weather until the app was relaunched. The last good weather and
@@ -282,9 +284,21 @@ function isGenericNoiseEvent(title: string): boolean {
   return /\booo\b|out of office|vacation|\bpto\b/i.test(t)
 }
 
-async function fetchNextEvent(): Promise<NextEventPayload | null> {
+/**
+ * 6.84.1: did the bridge answer with a calendar? False for no bridge (COS_SCRIPTS_DIR unset, or
+ * set without the venv and bridge script: callPython then answers an empty no-op), for a
+ * missing answer, and for the bridge's own error answer (`calendar_unavailable` on its
+ * deadline, or not configured). An empty calendar is a real read.
+ */
+export function calendarAnswerWasRead(bridgeReady: boolean, answer: unknown): boolean {
+  if (!bridgeReady) return false
+  if (!answer || typeof answer !== 'object' || Array.isArray(answer)) return false
+  return !('error' in answer)
+}
+
+async function fetchNextEvent(): Promise<{ event: NextEventPayload | null; read: boolean }> {
   if (cachedNextEvent && Date.now() - calendarFetchedAt < CALENDAR_TTL_MS) {
-    return cachedNextEvent
+    return { event: cachedNextEvent, read: cachedCalendarRead }
   }
 
   try {
@@ -299,6 +313,7 @@ async function fetchNextEvent(): Promise<NextEventPayload | null> {
       minutes_until_next?: number
     } | null
 
+    const read = calendarAnswerWasRead(pythonBridgeAvailable(), cal)
     const remaining = cal?.today_remaining ?? []
     const meaningful = remaining.find((evt) => {
       if (evt.is_all_day) return false
@@ -327,9 +342,11 @@ async function fetchNextEvent(): Promise<NextEventPayload | null> {
     }
 
     calendarFetchedAt = Date.now()
-    return cachedNextEvent
+    cachedCalendarRead = read
+    return { event: cachedNextEvent, read }
   } catch {
-    return cachedNextEvent
+    // Threw or timed out: whatever is cached was not read just now.
+    return { event: cachedNextEvent, read: false }
   }
 }
 
@@ -342,6 +359,7 @@ export function _resetWelcomeContextCachesForTests(): void {
   lastKnownCity = ''
   cachedNextEvent = null
   calendarFetchedAt = 0
+  cachedCalendarRead = false
   weatherPersistence = null
   weatherRestored = false
   lastFailureLogAt.clear()
@@ -354,13 +372,18 @@ welcomeContextRouter.get('/welcome-context', async (req, res) => {
   const pairLat = lat != null && lon != null ? lat : undefined
   const pairLon = lat != null && lon != null ? lon : undefined
 
-  const [weather, nextEvent] = await Promise.all([
+  const [weather, calendar] = await Promise.all([
     fetchWeather(pairLat, pairLon),
     fetchNextEvent(),
   ])
+  const nextEvent = calendar.event
 
   res.json({
     ...(weather ? { weather } : {}),
     ...(nextEvent ? { nextEvent } : {}),
+    // 6.84.1: true only when this answer's calendar came from a successful read (an empty
+    // calendar included); false when the read threw, timed out or there is no COS pipeline.
+    // Lets a client tell "no more events today" from "could not read the calendar".
+    calendarRead: calendar.read,
   })
 })

package/shared/live-cues-v2.ts

@@ -2,13 +2,29 @@
  * Live cues v2 wire contract (server 6.75 candidate, companion 6.10.641 candidate; optional capability fields since 6.76.2).
  * 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.
+ * 6.86.0 widens CueKind (additive for every meeting that did not opt in; see CueKind). A companion that has not taken this
+ * copy keeps validating the two legacy kinds, which is safe because it is never sent anything else.
  */
 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'
+/** 6.86.0: three more kinds for COS Control's live meeting view. A meeting gets them only when its armer opts in (a Mac
+ *  recording, or POST /live-cues/start with `kinds: 'extended'`). Every other meeting keeps the two legacy kinds, so a
+ *  companion that validates `kind` against reinforce | challenge never sees a cue it would drop. Readers must treat any
+ *  kind they do not know as a plain cue, never as an error. */
+export type CueKind = 'reinforce' | 'challenge' | 'decision' | 'promise' | 'followUp'
+export const LEGACY_CUE_KINDS = ['reinforce', 'challenge'] as const
+export const CUE_KINDS = ['reinforce', 'challenge', 'decision', 'promise', 'followUp'] as const
+export type CueKindSet = 'legacy' | 'extended'
+export function isCueKind(value: unknown): value is CueKind {
+  return typeof value === 'string' && (CUE_KINDS as readonly string[]).includes(value)
+}
+/** The legacy kind a v1 reader is shown for any kind (the `coaching_nudge` twin and the stop answer's `nudges`). */
+export function legacyCueKind(kind: CueKind): 'reinforce' | 'challenge' {
+  return kind === 'reinforce' || kind === 'decision' || kind === 'promise' ? 'reinforce' : 'challenge'
+}
 
 /** A past meeting the cue drew on (0 to 2 per cue). */
 export interface CueSourceRef { id: string; date: string; title: string }
@@ -31,7 +47,7 @@ export interface LiveCueV2 {
 }
 
 /** 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 }
+export interface LiveCueV1Compat { nudge: string; type: 'reinforce' | 'challenge'; priority: 2; cueId: string; sessionId: string; protocol: 2 }
 
 /** `reason` when unavailable: master_flag_off, api_key_in_env, decision_invalid_provider, decision_not_configured (no key
  *  for the selected decision provider; jev_not_configured when Jev was chosen and only a SubQ key exists), claude_not_found,
@@ -75,7 +91,7 @@ export function isLiveCueV2(value: unknown): value is LiveCueV2 {
   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')
+    && isCueKind(v.kind)
     && 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'