@gotcos/glasses-server 6.84.0 → 6.86.0

package/server/lib/live-provisional.ts

@@ -0,0 +1,86 @@
+// 6.86.0: the newest provisional (grey) line of a live meeting, for COS Control's live meeting view.
+//
+// The preview route (POST /transcribe-stream/preview) already turns the still-open phrase into fast provisional text and
+// hands it to the client that posted the audio. Control reads the meeting from the active-session file and does not post
+// the glasses audio, so it never saw that text. This keeps ONE entry per live meeting, the newest preview, in memory only,
+// and GET /transcribe-stream/provisional serves it. The canonical chunk that settles the same index removes it.
+//
+// Why memory and a route, not a field in active-sessions/<id>.json:
+//   - that file is the 4-hour crash-recovery record. Anything written there outlives a crash; this text must not outlive
+//     the live session, so it never touches disk;
+//   - the file is written with fsync before each chunk is acknowledged. Writing it again per preview would add a durable
+//     write on the recording path, and churn the stamp Control uses to skip unchanged reads.
+//
+// Never logged: this module has no console call, and the route answers only to an authenticated client. Bounded: at most
+// LIVE_PROVISIONAL_LIMITS.maxSessions meetings, the last maxChars characters, and an entry older than ttlMs reads as none.
+
+export const LIVE_PROVISIONAL_LIMITS = {
+  /** The last characters (code points) of the preview are kept: the newest words are the ones still changing. */
+  maxChars: 600,
+  maxSessions: 8,
+  /** A preview not replaced or settled within this long reads as none (the phone stopped posting, a stuck chunk). */
+  ttlMs: 30_000,
+} as const
+
+export interface LiveProvisional {
+  chunkIndex: number
+  previewGen: number
+  text: string
+  model: string
+  /** Epoch ms when the server stored it. */
+  at: number
+}
+
+export class LiveProvisionalStore {
+  private readonly entries = new Map<string, LiveProvisional>()
+  constructor(private readonly now: () => number = Date.now) {}
+
+  /** Keeps `entry` when it is newer than the one held: a later chunk, or the same chunk with a later previewGen. A
+   *  preview that arrives after its chunk settled is refused by the caller (settledThrough), never stored here. */
+  record(sessionId: string, entry: Omit<LiveProvisional, 'at'>): boolean {
+    const text = Array.from(entry.text.replace(/\s+/g, ' ').trim()).slice(-LIVE_PROVISIONAL_LIMITS.maxChars).join('')
+    if (!text) return false
+    const held = this.entries.get(sessionId)
+    if (held && !this.expired(held) && (entry.chunkIndex < held.chunkIndex || (entry.chunkIndex === held.chunkIndex && entry.previewGen <= held.previewGen))) return false
+    this.entries.delete(sessionId)                      // re-insert, so Map order is oldest first for eviction
+    this.entries.set(sessionId, { chunkIndex: entry.chunkIndex, previewGen: entry.previewGen, text, model: entry.model, at: this.now() })
+    for (const [id, e] of this.entries) if (this.expired(e)) this.entries.delete(id)
+    while (this.entries.size > LIVE_PROVISIONAL_LIMITS.maxSessions) {
+      const oldest = this.entries.keys().next().value
+      if (oldest === undefined) break
+      this.entries.delete(oldest)
+    }
+    return true
+  }
+
+  /** The canonical answer for `chunkIndex` landed (text, silence or a drop): a preview for it or an earlier chunk goes. */
+  settle(sessionId: string, chunkIndex: number): void {
+    const held = this.entries.get(sessionId)
+    if (held && held.chunkIndex <= chunkIndex) this.entries.delete(sessionId)
+  }
+
+  /** The meeting closed (saved, discarded, expired, quarantined). */
+  clear(sessionId: string): void { this.entries.delete(sessionId) }
+
+  read(sessionId: string): LiveProvisional | null {
+    const held = this.entries.get(sessionId)
+    if (!held) return null
+    if (this.expired(held)) { this.entries.delete(sessionId); return null }
+    return { ...held }
+  }
+
+  size(): number { return this.entries.size }
+
+  private expired(e: LiveProvisional): boolean { return this.now() - e.at > LIVE_PROVISIONAL_LIMITS.ttlMs }
+}
+
+let store: LiveProvisionalStore | null = null
+export function liveProvisional(): LiveProvisionalStore { return (store ??= new LiveProvisionalStore()) }
+
+/** 6.86.0: what /api/health and /api/models publish as `capabilities.liveMeeting`, so COS Control gates the live meeting
+ *  view by capability, never by a status code. Constants only (health is public). An older server omits the key.
+ *  - macLiveCues: POST /api/mac-recording/start takes `liveCues: true` and answers `liveCues: {armed, ...}`.
+ *  - provisional: GET <route>?sessionId= serves the newest preview of a live meeting. */
+export function liveMeetingCapability(): { protocol: 1; macLiveCues: true; provisional: { route: string; maxChars: number; ttlMs: number } } {
+  return { protocol: 1, macLiveCues: true, provisional: { route: '/api/transcribe-stream/provisional', maxChars: LIVE_PROVISIONAL_LIMITS.maxChars, ttlMs: LIVE_PROVISIONAL_LIMITS.ttlMs } }
+}

package/server/lib/meeting-ask-owner.ts

@@ -83,7 +83,7 @@ export interface OwnerMatch { heard: string; owner: string }
 /**
  * Whether the question names the owner, allowing ASR spellings. Full name: first and last words, in
  * order and adjacent. Surname alone: only after a lead-in word ("who is Ukoma"), never after another
- * first name ("Isaiah Ukaoma" is someone else). First name alone: only when it is the whole subject of
+ * first name ("Rafael Ukaoma" is someone else). First name alone: only when it is the whole subject of
  * a who question, compared exactly.
  */
 export function matchOwnerName(question: string, ownerName: string | null | undefined): OwnerMatch | null {

package/server/lib/meeting-fact-check.ts

@@ -151,7 +151,7 @@ const LEAD_WORDS = new Set('i im am we were are it its is starting leaving going
 export const US_STATE_CODES = new Set('AL AK AZ AR CA CO CT DE FL GA HI ID IL IN IA KS KY LA ME MD MA MI MN MS MO MT NE NV NH NJ NM NY NC ND OH OK OR PA RI SC SD TN TX UT VT VA WA WV WI WY DC PR GU VI AS MP'.split(' '))
 /**
  * Larger US cities and the owner's Austin metro: a typed "City, ST" origin must name one of these (static, no
- * private data), so "Amira TX" or "Silas PM" are never places.
+ * private data), so "Talia TX" or "Silas PM" are never places.
  */
 const US_CITIES = new Set(`new york|los angeles|chicago|houston|phoenix|philadelphia|san antonio|san diego|dallas|san jose|austin|jacksonville|fort worth|columbus|charlotte|san francisco|indianapolis|seattle|denver|washington|boston|el paso|nashville|detroit|oklahoma city|portland|las vegas|memphis|louisville|baltimore|milwaukee|albuquerque|tucson|fresno|mesa|sacramento|atlanta|kansas city|colorado springs|omaha|raleigh|miami|long beach|virginia beach|oakland|minneapolis|tulsa|tampa|arlington|new orleans|wichita|cleveland|bakersfield|aurora|anaheim|honolulu|santa ana|riverside|corpus christi|lexington|henderson|stockton|saint paul|st paul|st louis|saint louis|cincinnati|pittsburgh|greensboro|anchorage|plano|lincoln|orlando|irvine|newark|durham|chula vista|toledo|fort wayne|st petersburg|laredo|jersey city|chandler|madison|lubbock|scottsdale|reno|buffalo|gilbert|glendale|north las vegas|winston salem|chesapeake|norfolk|fremont|garland|irving|hialeah|richmond|boise|spokane|baton rouge|tacoma|san bernardino|modesto|fontana|des moines|santa clarita|fayetteville|birmingham|oxnard|rochester|grand rapids|huntsville|salt lake city|frisco|yonkers|amarillo|huntington beach|mckinney|montgomery|augusta|akron|little rock|tempe|overland park|grand prairie|tallahassee|cape coral|mobile|knoxville|shreveport|worcester|sioux falls|chattanooga|brownsville|fort lauderdale|providence|santa rosa|peoria|salem|eugene|cary|fort collins|springfield|jackson|alexandria|lancaster|pasadena|naperville|bellevue|killeen|midland|odessa|savannah|syracuse|denton|waco|charleston|hartford|new haven|stamford|columbia|santa clara|ann arbor|cambridge|lansing|evansville|college station|beaumont|provo|boulder|tyler|las cruces|green bay|san mateo|burbank|south bend|davenport|tuscaloosa|san angelo|round rock|cedar park|georgetown|leander|pflugerville|san marcos|new braunfels|liberty hill|hutto|kyle|buda|lakeway|bee cave|temple|bryan|abilene|wichita falls|galveston|mcallen|edinburg|pearland|sugar land|the woodlands|conroe|katy|allen|richardson|carrollton|lewisville|flower mound|mesquite|harlingen|key west|palm springs|santa fe|flagstaff|billings|fargo|bismarck|cheyenne|casper|missoula|juneau|burlington|portsmouth|manchester|wilmington|dover|annapolis|trenton|albany|montpelier|concord|augusta|bangor|duluth|des plaines|evanston|topeka|lawrence|olathe|independence|st joseph|joplin|branson|springdale|bentonville|rogers|fayetteville|hot springs|jonesboro|norman|edmond|lafayette|lake charles|monroe|gulfport|biloxi|hattiesburg|pensacola|gainesville|daytona beach|sarasota|naples|fort myers|clearwater|lakeland|ocala|asheville|greenville|myrtle beach|columbia|athens|macon|dothan|chattanooga|knoxville|murfreesboro|clarksville|bowling green|owensboro|dayton|youngstown|canton|erie|scranton|allentown|reading|harrisburg|lancaster|altoona|morgantown|roanoke|lynchburg|charlottesville|norfolk|hampton|newport news`.split('|'))
 /** A full city label the user typed: a listed US city, then a real state code ("Dallas, TX", "San Antonio TX"). */

package/server/lib/query-job-active.ts

@@ -0,0 +1,140 @@
+/**
+ * 6.84.1: the in-flight query jobs, as COS Control's Activity home lists them in its Running
+ * panel (GET /api/query-jobs/active, docs/active-query-jobs.md).
+ *
+ * Read-only and in memory. The store hands each non-terminal hydrated job to
+ * `projectActiveQueryJob` and nothing else leaves it: never the prompt body, the reference
+ * turn, the partial answer, tool activity or the trail. The title is the prompt's first
+ * non-blank line, redacted with the store's own credential and path patterns, flattened to
+ * one line and cut to ACTIVE_QUERY_JOB_TITLE_MAX characters.
+ */
+import {
+  flattenDisplayText,
+  redactQueryJobText,
+  type QueryJobProviderLinkage,
+  type QueryJobRequest,
+  type QueryJobSnapshot,
+  type QueryJobStatus,
+} from './query-job-types.js'
+
+export const ACTIVE_QUERY_JOBS_PROTOCOL = 1 as const
+/** Longest title, in characters (grapheme clusters where the runtime can count them), ellipsis included. */
+export const ACTIVE_QUERY_JOB_TITLE_MAX = 80
+/** Most items one answer carries. `count` is always the full number. */
+export const ACTIVE_QUERY_JOBS_LIST_MAX = 50
+/** Only this much of a prompt (up to 48,000 characters) is ever read to find its first line. */
+const TITLE_SCAN_CHARS = 1_000
+const ELLIPSIS = '…'
+
+/**
+ * Who asked, as far as the job record can tell:
+ * - `person`: typed on the phone or spoken on the glasses. The phone app sends both the same
+ *   way (no `origin`, with a message number), so the server cannot tell the two apart.
+ * - `routine`: a scheduled routine (the morning brief and the routines scheduler).
+ * - `task`: a dispatch of a captured task.
+ * - `other`: anything else with no message number (COS Control Work sessions, meeting reviews).
+ */
+export type ActiveQueryJobOrigin = 'person' | 'routine' | 'task' | 'other'
+
+/** Coarse state for a list row. `status` carries the job model's own value. */
+export type ActiveQueryJobState = 'queued' | 'running' | 'finishing'
+
+export type ActiveQueryJobStatus = Exclude<QueryJobStatus, 'completed' | 'failed' | 'canceled' | 'interrupted'>
+
+export interface ActiveQueryJob {
+  jobId: string
+  generation: number
+  origin: ActiveQueryJobOrigin
+  /** The routine slug or task id, only for `routine` and `task`. */
+  originId?: string
+  state: ActiveQueryJobState
+  status: ActiveQueryJobStatus
+  acceptedAt: string
+  startedAt?: string
+  /** Milliseconds since the job was accepted (the person's wait), never negative. */
+  elapsedMs: number
+  provider?: QueryJobProviderLinkage['provider']
+  /** The model asked for (a slot such as `opus`, or `profile:<id>`). */
+  model?: string
+  /** The model the provider reported, once it started. */
+  resolvedModel?: string
+  /** The message number the phone minted for this question. */
+  messageNo?: number
+  title: string
+}
+
+export interface ActiveQueryJobsList {
+  items: ActiveQueryJob[]
+  /** Non-terminal jobs whose record is not held in memory (listed only in `count`). */
+  unlisted: number
+}
+
+export function activeQueryJobState(status: ActiveQueryJobStatus): ActiveQueryJobState {
+  if (status === 'accepted') return 'queued'
+  if (status === 'answer_ready') return 'finishing'
+  return 'running'
+}
+
+export function activeQueryJobOrigin(request: Readonly<Pick<QueryJobRequest, 'origin' | 'globalMsgNum'>>): { origin: ActiveQueryJobOrigin; originId?: string } {
+  if (request.origin?.kind === 'routine') return { origin: 'routine', originId: request.origin.id }
+  if (request.origin?.kind === 'task') return { origin: 'task', originId: request.origin.id }
+  if (typeof request.globalMsgNum === 'number' && request.globalMsgNum > 0) return { origin: 'person' }
+  return { origin: 'other' }
+}
+
+const graphemeSegmenter = typeof Intl !== 'undefined' && typeof Intl.Segmenter === 'function'
+  ? new Intl.Segmenter(undefined, { granularity: 'grapheme' })
+  : null
+
+function characters(text: string): string[] {
+  return graphemeSegmenter ? Array.from(graphemeSegmenter.segment(text), part => part.segment) : Array.from(text)
+}
+
+/** At most `max` characters, the last one an ellipsis when cut, back to a word break in the second half. */
+export function truncateActiveTitle(text: string, max = ACTIVE_QUERY_JOB_TITLE_MAX): string {
+  const chars = characters(text)
+  if (chars.length <= max) return text
+  const cut = chars.slice(0, max - 1)
+  const space = cut.lastIndexOf(' ')
+  const kept = (space >= (max - 1) / 2 ? cut.slice(0, space) : cut).join('').trimEnd()
+  return `${kept}${ELLIPSIS}`
+}
+
+/** The prompt's first non-blank line as plain text: redacted, one line, at most 80 characters. */
+export function activeQueryJobTitle(query: string): string {
+  if (typeof query !== 'string' || !query) return ''
+  const head = query.slice(0, TITLE_SCAN_CHARS)
+  const line = head.split(/\r\n|[\n\r\u2028\u2029]/).find(candidate => candidate.trim().length > 0) ?? ''
+  if (!line) return ''
+  return truncateActiveTitle(flattenDisplayText(redactQueryJobText(line)))
+}
+
+/** One row. The caller passes only non-terminal jobs (QueryJobStore.listInFlight checks the status). */
+export function projectActiveQueryJob(request: Readonly<QueryJobRequest>, snapshot: Readonly<QueryJobSnapshot>, nowMs: number): ActiveQueryJob {
+  const status = snapshot.status as ActiveQueryJobStatus
+  const acceptedMs = Date.parse(snapshot.acceptedAt)
+  const elapsedMs = Number.isFinite(acceptedMs) ? Math.max(0, Math.round(nowMs - acceptedMs)) : 0
+  const model = snapshot.requestedModel ?? request.model
+  // A COS Control Work session carries the task's display name; it reads better than a prompt line.
+  const named = request.sessionName ? truncateActiveTitle(flattenDisplayText(redactQueryJobText(request.sessionName))) : ''
+  return {
+    jobId: snapshot.jobId,
+    generation: snapshot.generation,
+    ...activeQueryJobOrigin(request),
+    state: activeQueryJobState(status),
+    status,
+    acceptedAt: snapshot.acceptedAt,
+    ...(snapshot.startedAt ? { startedAt: snapshot.startedAt } : {}),
+    elapsedMs,
+    ...(snapshot.provider ? { provider: snapshot.provider } : {}),
+    ...(model ? { model } : {}),
+    ...(snapshot.resolvedModel ? { resolvedModel: snapshot.resolvedModel } : {}),
+    ...(typeof snapshot.globalMsgNum === 'number' ? { messageNo: snapshot.globalMsgNum } : {}),
+    title: named || activeQueryJobTitle(request.query),
+  }
+}
+
+/** Oldest first; a stable order for a list that refreshes every minute. */
+export function compareActiveQueryJobs(a: ActiveQueryJob, b: ActiveQueryJob): number {
+  return a.acceptedAt.localeCompare(b.acceptedAt) || a.jobId.localeCompare(b.jobId)
+}

package/server/lib/query-job-coordinator.ts

@@ -32,6 +32,7 @@ import {
   type QueryJobStoreHealth,
 } from './query-job-types.js'
 import type { QueryJobKeyAnswerFields } from './key-answer-fields.js'
+import { compareActiveQueryJobs, projectActiveQueryJob, type ActiveQueryJob } from './query-job-active.js'
 import { SteerPort, steerClock, steerCutoffMs, type PendingSteer, type QueryProvider } from './claude-steer.js'
 import type { MaintenanceWorkLease } from './maintenance-lifecycle.js'
 import { applyTrailToolMode, type JobTrailDraft } from './job-trail.js'
@@ -1111,6 +1112,13 @@ export class QueryJobCoordinator {
     return this.store.listLiveMessageReservations()
   }
 
+  /** 6.84.1: the in-flight jobs for GET /api/query-jobs/active. In memory and synchronous. */
+  activeJobs(nowMs: number = Date.now()): { items: ActiveQueryJob[]; count: number } {
+    const { items, unlisted } = this.store.listInFlight((request, snapshot) => projectActiveQueryJob(request, snapshot, nowMs))
+    items.sort(compareActiveQueryJobs)
+    return { items, count: items.length + unlisted }
+  }
+
   getHealth(): QueryJobCoordinatorHealth {
     return {
       activeRuns: this.active.size,

package/server/lib/query-job-store.ts

@@ -1829,6 +1829,31 @@ export class QueryJobStore {
     return out
   }
 
+  /**
+   * 6.84.1: the jobs admitted and not yet terminal, each passed to `project` with its live
+   * request and snapshot (READ ONLY: nothing is cloned, so a projection must copy what it
+   * keeps and never write). Synchronous and in memory, like listLiveMessageReservations: no
+   * hydration, no journal read, no await. A non-terminal identity whose body is not hydrated
+   * (the LRU evicts terminal jobs first, so only past QUERY_JOB_LIMITS.hydratedJobs live
+   * ones) is counted in `unlisted` instead of read from disk.
+   */
+  listInFlight<T>(project: (request: Readonly<QueryJobRequest>, snapshot: Readonly<QueryJobSnapshot>) => T | null): { items: T[]; unlisted: number } {
+    const items: T[] = []
+    let unlisted = 0
+    for (const identity of this.identitiesByJobId.values()) {
+      if (isTerminalQueryJobStatus(identity.status)) continue
+      const hydrated = this.jobs.get(identity.jobId)
+      if (!hydrated) {
+        unlisted++
+        continue
+      }
+      // The identity's status is rebuilt with the snapshot on every record, so one check covers both.
+      const item = project(hydrated.request, hydrated.snapshot)
+      if (item != null) items.push(item)
+    }
+    return { items, unlisted }
+  }
+
   async findByClientGeneration(clientJobId: string, generation: number): Promise<QueryJobSnapshot | undefined> {
     await this.ensureInitialized()
     const identity = this.identitiesByKey.get(identityKey(clientJobId.toLowerCase(), generation))

package/server/lib/token-audit.ts

@@ -34,6 +34,8 @@ export interface TokenAuditEntry extends TokenAuditKeyFields {
   sessionId?: string
   clientJobId?: string
   usageKind?: 'provider_final' | 'estimated'
+  /** 6.85.0, dictation polish only: whether the user's polish instructions were in the prompt, and their hash. */
+  polishInstructions?: { on: boolean; hash: string }
 }
 
 /**
@@ -61,6 +63,11 @@ export function buildTokenAuditRecord(entry: TokenAuditEntry, now: Date = new Da
     ...(entry.lane ? { lane: entry.lane } : {}),
     ...(entry.credentialKind ? { credentialKind: entry.credentialKind } : {}),
     ...(typeof entry.usd === 'number' && Number.isFinite(entry.usd) ? { usd: entry.usd } : {}),
+    // 6.85.0: set only by the dictation polish caller, so every other row is unchanged. Never the text.
+    ...(entry.polishInstructions ? {
+      custom_instructions: entry.polishInstructions.on,
+      ...(entry.polishInstructions.hash ? { instructions_hash: entry.polishInstructions.hash } : {}),
+    } : {}),
   }
 }
 

package/server/lib/transcript-cleanup-context.ts

@@ -10,7 +10,7 @@
 // SCREEN AWARENESS. On-screen text lines COS Control recorded during the meeting
 // (transcript-cleanup-screen.ts), shown beside each passage by time.
 //
-// TERMS. Every source contributes terms: capitalised words and runs of them ("Queen
+// TERMS. Every source contributes terms: capitalised words and runs of them ("Grace
 // Ukaoma", "Jewel360"). Terms are the per-meeting vocabulary: deterministic correction
 // may write a term from this meeting's screen or files, the model may write any term,
 // and a term the model writes that came from the meeting (not the dictionary) becomes a
@@ -86,7 +86,7 @@ export function extractTerms(text: string, max: number = CONTEXT_LIMITS.termsPer
     const w = words[i].w
     const capital = /^\p{Lu}/u.test(w)
     if (looksLikeName(w)) out.add(w)
-    // "Queen Ukaoma": a capitalised word directly before a name-like word, with nothing but a space between.
+    // "Grace Ukaoma": a capitalised word directly before a name-like word, with nothing but a space between.
     if (capital && i + 1 < words.length && text.slice(words[i].end, words[i + 1].at) === ' ' && looksLikeName(words[i + 1].w)) {
       out.add(`${w} ${words[i + 1].w}`)
     }

package/server/lib/transcript-cleanup-model.ts

@@ -5,7 +5,7 @@
 // servers, no hooks, an empty scratch workspace, a pinned model id, low effort, a
 // bounded output budget. Never a direct SDK. The doubtful spans of a meeting go in ONE
 // batched prompt; the answer is strict JSON, one entry per span id:
-//   {"edits":[{"id":"S1","action":"keep"},{"id":"S2","action":"replace","text":"Queen Ukaoma"}]}
+//   {"edits":[{"id":"S1","action":"keep"},{"id":"S2","action":"replace","text":"Grace Ukaoma"}]}
 //
 // THE GUARDS. Every replacement is checked before anything is applied. It is rejected if
 //   unknown_span      its id was not sent

package/server/lib/transcript-cleanup-spans.ts

@@ -19,7 +19,7 @@
 //                     adjacent pieces joined ("U coma"), none a function word; or the
 //                     leading-y rule at any confidence ("Yukoma" for Ukaoma)
 //    oov_capitalized  a capitalised word mid-sentence that is no known name and no common
-//                     word, within two words of a known name ("Queen Eucoma")
+//                     word, within two words of a known name ("Grace Eucoma")
 //    repeat           a phrase of 2 to 4 words (or one long word) said three or more
 //                     times in a row: the classic decoder loop
 //    Flagged words one word apart merge; a span holds at most 6 words (12 for a repeat)

package/server/lib/transcript-cleanup.ts

@@ -405,7 +405,7 @@ export function recordSuggestions(applied: readonly AppliedEdit[], pack: Context
   for (const edit of applied) {
     const heardKeys = new Set([...edit.original.matchAll(WORDS)].map(m => fold(m[0])))
     const ws = [...edit.replacement.matchAll(WORDS)].map(m => m[0])
-    // Longest first: "Queen Ukaoma" is one suggestion, not that plus "Ukaoma".
+    // Longest first: "Grace Ukaoma" is one suggestion, not that plus "Ukaoma".
     const candidates = [...new Set<string>([edit.replacement, ...ws.slice(0, -1).map((w, i) => `${w} ${ws[i + 1]}`), ...ws])]
       .sort((a, b) => b.split(' ').length - a.split(' ').length)
     const covered = new Set<string>()

package/server/lib/whisper-local.ts

@@ -1500,7 +1500,8 @@ export async function transcribeLocal(
         console.log(`[whisper-local] Server recovered after ${serverConsecutiveFailures} consecutive failure(s)`)
         serverConsecutiveFailures = 0
       }
-      console.log(`[whisper-local] Server transcribed in ${elapsed}ms (${words?.length ?? 0} words): "${text.slice(0, 80)}${text.length > 80 ? '...' : ''}"`)
+      // 6.85.0: counts only. Every meeting chunk, dictation and draft passes here, so the text stays out of the log.
+      console.log(`[whisper-local] Server transcribed in ${elapsed}ms (${words?.length ?? 0} words, ${text.length} chars)`)
       return { text, backend: 'server', words }
     } catch (err: any) {
       if (previewLease?.signal.aborted) throw new MetalPreviewContendedError()

package/server/routes/dictation-polish-settings.ts

@@ -0,0 +1,91 @@
+// 6.85.0 "Your polish instructions". Token-protected by the /api middleware.
+//
+//   GET    /api/dictation/polish/instructions   the saved instructions (or ""), the cap, a hash
+//   PUT    /api/dictation/polish/instructions   {"customInstructions": "..."}; "" turns it off
+//   DELETE /api/dictation/polish/instructions   Clear (the same as PUT "")
+//   GET    /api/dictation/polish/rules          the built-in rules in use (v3, or v2 when rolled
+//                                               back) and the block the instructions go into
+//
+// Clients find it through capabilities.dictationCleanup.customInstructions on /api/health and
+// /api/models; an older server omits it (and answers 404 here), so the clients hide the box.
+// The text is never logged and never returned anywhere but GET/PUT here.
+
+import { Router } from 'express'
+import {
+  DEFAULT_DICTATION_POLISH_PROMPT, DICTATION_POLISH_SYSTEM_PROMPTS, dictationPolishPromptVersion, dictationPolishRules,
+  USER_PREFERENCES_INTRO, USER_PREFERENCES_PRECEDENCE,
+} from '../lib/dictation-clean.js'
+import {
+  CUSTOM_INSTRUCTIONS_MAX_CHARS, CUSTOM_INSTRUCTIONS_PROTOCOL, customInstructionsHash, readCustomInstructions,
+  sanitizeCustomInstructions, writeCustomInstructions, type StoredInstructions,
+} from '../lib/dictation-polish-instructions.js'
+
+/** Where the instructions apply (prompt-drafts.ts polishInstructionsFor): never meeting lines. */
+export const CUSTOM_INSTRUCTIONS_APPLY_TO = ['message', 'prompt_draft'] as const
+
+/** What capabilities.dictationCleanup carries on both health surfaces. Codes and numbers only. */
+export function customInstructionsCapability() {
+  return { protocol: CUSTOM_INSTRUCTIONS_PROTOCOL, maxChars: CUSTOM_INSTRUCTIONS_MAX_CHARS }
+}
+
+function view(stored: StoredInstructions) {
+  return {
+    customInstructions: stored.customInstructions,
+    enabled: stored.customInstructions.length > 0,
+    updatedAt: stored.updatedAt,
+    instructionsHash: customInstructionsHash(stored.customInstructions),
+    maxChars: CUSTOM_INSTRUCTIONS_MAX_CHARS,
+    appliesTo: CUSTOM_INSTRUCTIONS_APPLY_TO,
+  }
+}
+
+/** The placeholder the rules view shows where the user's own words go. */
+export const INSTRUCTIONS_PLACEHOLDER = '(your polish instructions)'
+
+export const dictationPolishSettingsRouter = Router()
+
+dictationPolishSettingsRouter.get('/dictation/polish/instructions', (_req, res) => {
+  res.json(view(readCustomInstructions()))
+})
+
+dictationPolishSettingsRouter.put('/dictation/polish/instructions', (req, res) => {
+  const body = req.body
+  if (!body || typeof body !== 'object' || Array.isArray(body) || !Object.keys(body).every(key => key === 'customInstructions')) {
+    return res.status(400).json({ error: 'invalid_body', expected: { customInstructions: 'string' } })
+  }
+  const clean = sanitizeCustomInstructions(body.customInstructions)
+  if (!clean.ok) {
+    return res.status(clean.error === 'too_long' ? 413 : 400).json({
+      error: clean.error === 'too_long' ? 'instructions_too_long' : 'instructions_not_a_string',
+      maxChars: clean.maxChars, ...(clean.length !== undefined ? { length: clean.length } : {}),
+    })
+  }
+  try {
+    res.json(view(writeCustomInstructions(clean.value)))
+  } catch {
+    // The reason stays generic: an fs error can carry the path, never the text, but say less.
+    res.status(500).json({ error: 'instructions_not_saved' })
+  }
+})
+
+dictationPolishSettingsRouter.delete('/dictation/polish/instructions', (_req, res) => {
+  try {
+    res.json(view(writeCustomInstructions('')))
+  } catch {
+    res.status(500).json({ error: 'instructions_not_saved' })
+  }
+})
+
+dictationPolishSettingsRouter.get('/dictation/polish/rules', (_req, res) => {
+  const version = dictationPolishPromptVersion()
+  res.json({
+    version,
+    defaultVersion: DEFAULT_DICTATION_POLISH_PROMPT,
+    rolledBack: version !== DEFAULT_DICTATION_POLISH_PROMPT,
+    systemPrompt: DICTATION_POLISH_SYSTEM_PROMPTS[version],
+    rules: dictationPolishRules(version).join('\n'),
+    // The block exactly as the model sees it, with a placeholder for the user's words.
+    userBlock: [...USER_PREFERENCES_INTRO, '<user-style-preferences>', INSTRUCTIONS_PLACEHOLDER, '</user-style-preferences>', USER_PREFERENCES_PRECEDENCE].join('\n'),
+    maxChars: CUSTOM_INSTRUCTIONS_MAX_CHARS,
+  })
+})

package/server/routes/health.ts

@@ -1,4 +1,5 @@
 import { DICTATION_CLEAN_MODELS } from '../lib/dictation-clean-models.js'
+import { customInstructionsCapability } from './dictation-polish-settings.js'
 import { PAIRING_PROTOCOL_VERSION } from '../lib/glasses-pairing.js'
 import { taskBridgeAvailable } from '../lib/task-bridge.js'
 import { Router } from 'express'
@@ -59,6 +60,7 @@ import { G2_LENS_VARIANT_CAPABILITY } from '../lib/media-store.js'
 // whether they are actually registered.
 import { MEDIA_CHUNKED_UPLOAD_ENABLED } from './media.js'
 import { durableQueryJobsCapability, messagesSteerCapability, messagesTrailEnabled } from '../lib/query-job-feature.js'
+import { ACTIVE_QUERY_JOBS_PROTOCOL } from '../lib/query-job-active.js'
 import { claudeSteerSupportKnown } from '../lib/claude-cli-support.js'
 import { jobTrailStats } from '../lib/job-trail.js'
 import { getQueryJobRuntimeHealth } from '../lib/query-job-runtime.js'
@@ -71,6 +73,14 @@ import { maintenanceLifecycle } from '../lib/maintenance-lifecycle.js'
 import { getLocalTtsHealth, refreshLocalTtsHealth } from '../lib/tts-local.js'
 import { liveCuesCapability } from '../lib/live-cues-capability.js'
 import { liveCuesV2Advertised } from '../lib/live-cues-v2.js'
+import { liveMeetingCapability } from '../lib/live-provisional.js'
+import { CUE_KINDS } from '../../shared/live-cues-v2.js'
+
+/** 6.86.0: `capabilities.liveCues.kinds`, the cue kinds this server can write (additive; an older server omits it, which
+ *  is how a client knows to expect only reinforce and challenge). Which kinds a given meeting gets is in its arm answer. */
+function withCueKinds<T extends object>(capability: T): T & { kinds: string[] } {
+  return { ...capability, kinds: [...CUE_KINDS] }
+}
 import { transcriptCleanupAdvertised } from './transcript-cleanup.js'
 import { getMeetingSyncSnapshot } from '../lib/meeting-batch-progress.js'
 import { listUnsavedCaptures } from '../lib/unsaved-audio-quarantine.js'
@@ -296,6 +306,11 @@ healthRouter.get('/health', async (_req, res) => {
     g2LensVariant: G2_LENS_VARIANT_CAPABILITY,
     durableQueryJobs: durableJobs.enabled,
     durableQueryJobsProtocol: durableJobs.protocolVersion,
+    // 6.84.1: GET /api/query-jobs/active (docs/active-query-jobs.md), the in-flight jobs for
+    // COS Control's Running panel. Static: this build has the route; it lists nothing while
+    // durableQueryJobs is false. Absent on older servers, which answer that path 400.
+    activeQueryJobs: true,
+    activeQueryJobsProtocol: ACTIVE_QUERY_JOBS_PROTOCOL,
     // Static: this build carries the scheduler. The live schedule is under
     // capabilities.morningBrief and may be absent while the runtime boots.
     morningBrief: true,
@@ -473,7 +488,7 @@ healthRouter.get('/health', async (_req, res) => {
     ...(voiceProvenance ? { voice_provenance: voiceProvenance } : {}),
     capabilities: {
       meetingAsk: { ...meetingAskCapabilities(), webRetrieval: meetingWebCapability().available },
-      dictationCleanup: { models: DICTATION_CLEAN_MODELS },
+      dictationCleanup: { models: DICTATION_CLEAN_MODELS, customInstructions: customInstructionsCapability() },
       // 6.67.0: glasses pairing (docs/pairing-contract.md). Public on purpose: the phone
       // reads it before it holds a token, and an older server omits it, which is how
       // the phone knows to say "Update COS on your Mac (server 6.67 or newer)".
@@ -499,8 +514,9 @@ healthRouter.get('/health', async (_req, res) => {
         carriedAcrossBoot: maintenance.operation?.carriedAcrossBoot ?? false,
       },
       cliDebug: CLI_DEBUG_CAPABILITY,
-      liveCues,
+      liveCues: withCueKinds(liveCues),
       ...(liveCuesV2Advertised() ? { liveCuesV2: liveCuesV2Advertised() } : {}),
+      liveMeeting: liveMeetingCapability(),
       // 6.77.0: codes only (this route is public): the protocol and whether the switch is on.
       transcriptCleanup: transcriptCleanupAdvertised(),
       richMedia: {
@@ -660,7 +676,7 @@ healthRouter.get('/models', async (req, res) => {
     ...(apiToken ? { displayStreamTicket: mintDisplayTicket(apiToken) } : {}),
     capabilities: {
       meetingAsk: { ...meetingAskCapabilities(), webRetrieval: meetingWebCapability().available },
-      dictationCleanup: { models: DICTATION_CLEAN_MODELS },
+      dictationCleanup: { models: DICTATION_CLEAN_MODELS, customInstructions: customInstructionsCapability() },
       durableQueryJobs: {
         enabled: durableJobs.enabled,
         protocolVersion: durableJobs.protocolVersion,
@@ -696,8 +712,9 @@ healthRouter.get('/models', async (req, res) => {
       // Same helper as /api/health — the companion's 15s liveness poll reads
       // THIS surface, so a value present only on /api/health leaves the
       // live-cues indicator blind.
-      liveCues: liveCuesCapability(),
+      liveCues: withCueKinds(liveCuesCapability()),
       ...(liveCuesV2Advertised() ? { liveCuesV2: liveCuesV2Advertised() } : {}),
+      liveMeeting: liveMeetingCapability(),
       richMedia: {
         video: richMedia.video,
         maxPromptVisuals: MAX_MODEL_IMAGE_INPUTS,

package/server/routes/live-cues.ts

@@ -1,7 +1,9 @@
 // Live Cues routes. Authenticated by the global /api X-Cos-Token middleware
 // (index.ts:148) like every other /api route — no route-local auth needed.
 //
-// POST /live-cues/start { sessionId }  -> { armed, sessionId, pipelinesUsed }
+// POST /live-cues/start { sessionId, kinds? }  -> { armed, sessionId, pipelinesUsed } (v1) or the v2 arm answer
+//   kinds (6.86.0, v2 only): 'legacy' (reinforce, challenge) or 'extended' (plus decision, promise, followUp). Absent: a
+//   Mac recording (mac_ id) gets extended, every other meeting legacy, so an older companion never sees a kind it drops.
 // POST /live-cues/stop  { sessionId }  -> { nudgesGenerated, nudges }
 // GET  /live-cues/status               -> engine snapshot + capability
 // GET  /live-cues/v2/settings           -> { enabled, source: env|setting|default, capability }       (6.76.2)
@@ -45,8 +47,12 @@ liveCuesRouter.post('/live-cues/start', async (req, res) => {
   if (!sessionId || !SESSION_ID.test(sessionId)) {
     return res.status(400).json({ error: 'sessionId required', reason: 'missing_session_id' })
   }
+  const kinds = (req.body as { kinds?: unknown } | undefined)?.kinds
+  if (kinds !== undefined && kinds !== 'legacy' && kinds !== 'extended') {
+    return res.status(400).json({ error: "kinds must be 'legacy' or 'extended'", reason: 'invalid_kinds' })
+  }
   try {
-    if (liveCuesV2Enabled()) return res.json(liveCuesV2().arm(sessionId))
+    if (liveCuesV2Enabled()) return res.json(liveCuesV2().arm(sessionId, kinds ? { kinds } : {}))
     const result = await armLiveCues(sessionId)
     return res.json(result)
   } catch (error) {