@gotcos/glasses-server 6.83.0 → 6.85.0

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

@@ -24,7 +24,15 @@ import { MAC_CAPTURE_ID } from './mac-recording.js'
 import { MacParakeetUnavailableError } from './mac-recording-asr.js'
 import { transcribeParakeet, type ParakeetResult, type ParakeetRunOptions } from './parakeet.js'
 import { isDeletionProneEngine, resolveHypotheses, RESOLVER_VERSION, type Hypothesis } from './stt-resolver.js'
-import { getVocabulary } from './profile.js'
+import { getVocabulary, getWhisperCorrections } from './profile.js'
+import { decoderContextWindow } from './glossary-learn.js'
+
+/** 6.83.1: the decoder's priming window, with correction-only forms put back to speech before the cut. */
+function decoderWindow(previousText?: string): string | undefined {
+  let corrections: Record<string, string> = {}
+  try { corrections = getWhisperCorrections() } catch { /* a test double without it reads as none */ }
+  return decoderContextWindow(previousText, corrections)
+}
 import { captureSpeakerMode, policyLabel } from './meeting-speaker-policy.js'
 import { durableAtomicWriteFileSync } from './atomic-fs.js'
 import { isMetalBatchPreempted } from './whisper-metal-gate.js'
@@ -526,7 +534,7 @@ async function decodeWhisperOnce(
   audioDir: string,
 ): Promise<HighQualityTranscriptionResult> {
   try {
-    return await deps.whisper(input, previousText?.slice(-250), { priority: 'batch', timestamps })
+    return await deps.whisper(input, decoderWindow(previousText), { priority: 'batch', timestamps })
   } catch (error) {
     // A live meeting took the GPU mid-segment. The truncated Metal output
     // was already discarded upstream (BLOCKER contract) — it is never
@@ -539,7 +547,7 @@ async function decodeWhisperOnce(
       + 'retrying once on CPU',
     )
     refreshPendingLease(audioDir)
-    return deps.whisper(input, previousText?.slice(-250), { priority: 'batch', forceCpu: true, forceCpuReason: 'preempt_retry', timestamps })
+    return deps.whisper(input, decoderWindow(previousText), { priority: 'batch', forceCpu: true, forceCpuReason: 'preempt_retry', timestamps })
   }
 }
 
@@ -1043,7 +1051,7 @@ function queueProgressiveWork(sessionId: string, state: ProgressiveSessionState)
       const identity = currentCheckpointIdentity()
       const enhanced = await asrFrontEnd(combined, identity.frontEnd)
       if (controller.signal.aborted || state.closed) return
-      const decoded = await transcribeHighQuality(enhanced, pending.previousText?.slice(-250), {
+      const decoded = await transcribeHighQuality(enhanced, decoderWindow(pending.previousText), {
         priority: 'batch',
         forceCpu: true,
         forceCpuReason: 'progressive_checkpoint',

package/server/lib/profile.ts

@@ -5,6 +5,7 @@ import { existsSync, readFileSync, mkdirSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { resolve, dirname } from 'node:path'
 import { atomicWriteFileSync } from './atomic-fs.js'
+import { looksLikeUrlEmailPath } from './glossary-learn.js'
 
 const APP_ROOT = resolve(import.meta.dirname, '../..')
 
@@ -136,7 +137,8 @@ export function getVocabulary(): string[] {
     if (typeof value !== 'string') return []
     const term = value.trim()
     const key = term.toLowerCase()
-    if (!term || PLACEHOLDER_VOCABULARY.has(key) || seen.has(key)) return []
+    // 6.83.1: a link, email, handle or path never steers the decoder, even hand-written here.
+    if (!term || PLACEHOLDER_VOCABULARY.has(key) || seen.has(key) || looksLikeUrlEmailPath(term)) return []
     seen.add(key)
     return [term]
   })

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/unsaved-audio-quarantine.ts

@@ -43,8 +43,16 @@ export interface QuarantineManifest {
   reason: string
   chunkFiles: number
   bytes: number
+  /** 6.83.2: a shorter clock for this one capture (a Mac capture discarded with no sound). Never longer than the global one. */
+  retentionMs?: number
 }
 
+/** 6.83.2: how long a discarded no-sound Mac capture stays quarantined: long enough to undo a wrong discard by hand. */
+export const DISCARDED_RETENTION_MS = 24 * 60 * 60 * 1000
+
+/** The receipt a discard writes, so the capture is terminal (`no_speech`) and never recovered on its own. */
+export interface QuarantineReceipt { outcome: 'no_speech'; discarded: true; chunkFiles?: number; note: string }
+
 export interface UnsavedCapture {
   sessionId: string
   dirName: string
@@ -57,6 +65,12 @@ export interface UnsavedCapture {
   recovered: boolean
 }
 
+/** The clock that applies to one capture: its own when it set a shorter one, else the global retention. */
+export function effectiveRetentionMs(manifest: { retentionMs?: unknown } | null, retentionMs: number): number {
+  const own = manifest?.retentionMs
+  return typeof own === 'number' && Number.isFinite(own) && own > 0 ? Math.min(retentionMs, own) : retentionMs
+}
+
 export function unsavedAudioRoot(): string {
   return dataPath('unsaved-audio')
 }
@@ -99,6 +113,7 @@ export function quarantineSessionAudio(
   sourceDir: string,
   reason: string,
   root: string = unsavedAudioRoot(),
+  options: { retentionMs?: number; receipt?: QuarantineReceipt } = {},
 ): string | null {
   const sessionId = basename(sourceDir)
   try {
@@ -114,6 +129,7 @@ export function quarantineSessionAudio(
       reason,
       chunkFiles: countChunkWavs(target),
       bytes: dirBytes(target),
+      ...(options.retentionMs ? { retentionMs: options.retentionMs } : {}),
     }
     try {
       writeFileSync(resolve(target, QUARANTINE_MANIFEST), `${JSON.stringify(manifest)}\n`, {
@@ -121,6 +137,19 @@ export function quarantineSessionAudio(
         mode: 0o600,
       })
     } catch { /* manifest is observability; the audio move already succeeded */ }
+    if (options.receipt) {
+      // 6.83.2: a discarded capture is terminal. The receipt is what keeps the auto-recover sweep and the
+      // unsaved-captures count off it (listUnsavedCaptures reads it as recovered, readCaptureDisposition as no_speech).
+      try {
+        writeFileSync(resolve(target, RECOVERED_RECEIPT), `${JSON.stringify({
+          schemaVersion: 1,
+          recoveredAt: new Date().toISOString(),
+          chunkFiles: manifest.chunkFiles,
+          words: 0,
+          ...options.receipt,
+        })}\n`, { encoding: 'utf8', mode: 0o600 })
+      } catch { /* the audio is quarantined either way; without the receipt it is merely listed as recoverable */ }
+    }
     return target
   } catch {
     // Rename failed (cross-device, permissions, race). Leave the source alone —
@@ -220,6 +249,7 @@ export function listUnsavedCaptures(
     } catch { continue }
     const manifest = readManifest(dirPath)
     const atMs = quarantinedAtMs(dirPath, manifest)
+    const ownRetentionMs = effectiveRetentionMs(manifest, retentionMs)
     captures.push({
       sessionId: manifest?.sessionId ?? dir.replace(/\.\d+$/, ''),
       dirName: dir,
@@ -228,7 +258,7 @@ export function listUnsavedCaptures(
       chunkFiles: manifest?.chunkFiles ?? countChunkWavs(dirPath),
       bytes: manifest?.bytes ?? dirBytes(dirPath),
       reason: manifest?.reason ?? null,
-      expiresAt: atMs != null ? new Date(atMs + retentionMs).toISOString() : null,
+      expiresAt: atMs != null ? new Date(atMs + ownRetentionMs).toISOString() : null,
       recovered: existsSync(resolve(dirPath, RECOVERED_RECEIPT)),
     })
   }
@@ -248,9 +278,10 @@ export function purgeExpiredQuarantine(
     // sitting exactly at the retention boundary would otherwise lose its
     // audio mid-run, in the module whose thesis is "never delete evidence".
     if (isRecoveryActive(capture.dirName)) continue
-    const atMs = capture.quarantinedAt ? Date.parse(capture.quarantinedAt) : NaN
-    if (!Number.isFinite(atMs)) continue
-    if (Date.now() - atMs > retentionMs) {
+    // The capture's own expiry: a discarded no-sound capture sets a shorter clock (6.83.2).
+    const expiresMs = capture.expiresAt ? Date.parse(capture.expiresAt) : NaN
+    if (!Number.isFinite(expiresMs)) continue
+    if (Date.now() > expiresMs) {
       try {
         rmSync(resolve(root, capture.dirName), { recursive: true, force: true })
         purged.push(capture.dirName)
@@ -433,7 +464,7 @@ function dispositionOf(sessionId: string, dirPath: string, retentionMs: number):
     quarantineReason: manifest?.reason ?? null,
     savedFilename,
     recovering: isRecoveryActive(basename(dirPath)),
-    retainedUntil: atMs != null ? new Date(atMs + retentionMs).toISOString() : null,
+    retainedUntil: atMs != null ? new Date(atMs + effectiveRetentionMs(manifest, retentionMs)).toISOString() : null,
   }
 }
 

package/server/lib/whisper-local.ts

@@ -16,6 +16,7 @@ import crypto from 'node:crypto'
 import { batchTimestampsEnabled, parseNativeVadTimeline, remapBatchWords } from './whisper-batch-timing.js'
 import { readSttSettings, type FrontEndId } from './stt-settings.js'
 import { getVocabulary, getOwnerName, getWhisperCorrections } from './profile.js'
+import { decoderSafeContext } from './glossary-learn.js'
 import { stripBrandUrls } from './hallucination-filter.js'
 import {
   batchHqMetalEnabled,
@@ -1243,8 +1244,9 @@ export async function transcribeHighQuality(
   }
 }
 
-/** Build prompt with optional previous transcript context for continuity */
-function buildPrompt(context?: string, isQuiet?: boolean): string {
+/** Build prompt with optional previous transcript context for continuity.
+ *  Exported (6.83.1) only so tests can assert on the exact decoder prompt. */
+export function buildPrompt(context?: string, isQuiet?: boolean): string {
   // During quiet/silence audio, skip vocabulary prompt to reduce decoder bias
   if (isQuiet) return ''
   if (!context || context.length < 10) return getWhisperPrompt()
@@ -1259,6 +1261,9 @@ function buildPrompt(context?: string, isQuiet?: boolean): string {
   // prior chunk would otherwise feed back through this context and re-seed the
   // next decode. Strip brand URLs from the priming context (output unaffected).
   if (STRIP_BRAND_URLS) sanitized = stripBrandUrls(sanitized)
+  // 6.83.1: a correction-only form ("/pricing") came from the corrections pass, not the
+  // speaker's audio; the decoder is primed with the spoken form instead (glossary-learn.ts).
+  sanitized = decoderSafeContext(sanitized, getWhisperCorrections())
   // Previous transcript helps Whisper maintain proper noun consistency,
   // continue sentences across chunk boundaries, and reduce hallucinations
   return PROMPT_V2 ? `${getWhisperPrompt()} ${sanitized}` : `${getWhisperPrompt()}. ${sanitized}`
@@ -1379,14 +1384,34 @@ function buildCorrections(): Array<[RegExp, string]> {
 
   // Escape correction keys before interpolation. Names such as "A.C.M.E."
   // are literal vocabulary, never regular-expression programs.
-  for (const [pattern, replacement] of Object.entries(getWhisperCorrections())) {
-    const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  // 6.83.1: the words of a multi-word key may be split by a run of spaces or tabs, or by one
+  // hyphen ("forward-slash  pricing"); never by a line break or a spaced dash (" - ").
+  for (const [pattern, replacement] of correctionOrder(getWhisperCorrections())) {
+    const escaped = pattern.trim().split(/\s+/).map(part => part.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('(?:[ \\t]+|-)')
     corrections.push([new RegExp(`\\b${escaped}\\b`, 'gi'), replacement])
   }
 
   return corrections
 }
 
+/**
+ * The profile's order, except that a key goes ahead of any earlier key whose words it
+ * contains (6.83.1): "forward slash build and price" runs before "forward slash build", or
+ * the shorter key would cut the longer phrase short. Chains the person relies on
+ * ("Myles" then "Miles Ukoma") keep their order, since neither key contains the other.
+ */
+export function correctionOrder(corrections: Record<string, string>): Array<[string, string]> {
+  const norm = (key: string) => ` ${key.trim().toLowerCase().split(/[\s-]+/).join(' ')} `
+  const out: Array<[string, string]> = []
+  for (const entry of Object.entries(corrections)) {
+    const mine = norm(entry[0])
+    const at = out.findIndex(([key]) => mine !== norm(key) && mine.includes(norm(key)))
+    if (at < 0) out.push(entry)
+    else out.splice(at, 0, entry)
+  }
+  return out
+}
+
 let _corrections: Array<[RegExp, string]> | null = null
 function getCorrections(): Array<[RegExp, string]> {
   if (!_corrections) _corrections = buildCorrections()
@@ -1399,7 +1424,8 @@ function getCorrections(): Array<[RegExp, string]> {
 export function applyCorrections(text: string): string {
   let result = text
   for (const [pattern, replacement] of getCorrections()) {
-    result = result.replace(pattern, replacement)
+    // A function, so a written form holding "$&" or "$1" is inserted literally (6.83.1).
+    result = result.replace(pattern, () => replacement)
   }
   return result
 }
@@ -1474,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/glossary.ts

@@ -8,7 +8,9 @@
 //     left unchanged). whisper_corrections is stored as a JSON STRING in the
 //     profile (legacy decoder contract), so the route encodes/decodes it here.
 //   POST /api/transcription-glossary/correction {heard, written, source} → learn
-//     ONE correction and its spelling (6.73.11, Fix a word), logged for undo.
+//     ONE correction and its spelling (6.73.11, Fix a word), logged for undo. A
+//     written link, email or path is a correction only (6.83.1): the answer adds
+//     correctionOnly: true and a note, and the vocabulary is untouched.
 //   GET  /api/transcription-glossary/recent → { entries } newest first.
 //   POST /api/transcription-glossary/correction/undo {id} → revert that entry.
 //   POST /api/transcription-glossary/vocabulary/add {term}, /vocabulary/remove {term},
@@ -32,6 +34,8 @@ import {
   MAX_TERM_LEN,
   addVocabulary,
   appendLog,
+  CORRECTION_ONLY_NOTE,
+  isCorrectionOnly,
   learnCorrection,
   looksLikeUrlEmailPath,
   parseLog,
@@ -219,7 +223,15 @@ export function glossaryLearnCorrection(body: unknown): Promise<Outcome> {
     if (!learned.ok) return { status: learned.status, body: { error: learned.error } }
     if (learned.unchanged) return { status: 200, body: { unchanged: true, entry: null, glossary: currentGlossary() } }
     commitWords(learned.words, appendLog(previousLog, learned.entry), previousLog)
-    return { status: 200, body: { unchanged: false, entry: learned.entry, glossary: currentGlossary() } }
+    // 6.83.1: a link, email or path is kept as a correction only; say so in words a client can show.
+    const correctionOnly = isCorrectionOnly(learned.entry.written)
+    return {
+      status: 200,
+      body: {
+        unchanged: false, entry: learned.entry, glossary: currentGlossary(),
+        ...(correctionOnly ? { correctionOnly: true, note: CORRECTION_ONLY_NOTE } : {}),
+      },
+    }
   })
 }
 

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'
@@ -296,6 +298,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 +480,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)".
@@ -660,7 +667,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,