@gotcos/glasses-server 6.83.0 → 6.84.0

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
 }

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/meeting.ts

@@ -6,7 +6,7 @@ import { readSpeakerPolicy, writeSpeakerPolicy, isSpeakerMode } from '../lib/mee
 
 import { existsSync, readdirSync, readFileSync, rmSync, statSync, unlinkSync } from 'node:fs'
 import { isWorthRecovering } from '../lib/quarantine-auto-recover.js'
-import { resolve } from 'node:path'
+import { basename, resolve } from 'node:path'
 import { createHash } from 'node:crypto'
 import { Router } from 'express'
 import { emitDisplay } from '../lib/display-bus.js'
@@ -129,6 +129,7 @@ import {
   analyzeTranscriptGaps,
   deleteSession,
   assertMacCaptureComplete,
+  discardSilentMacCapture,
   drainSessionAudioWrites,
   durableSessionRecoveryHasRun,
   getSessionChunkEntries,
@@ -805,6 +806,80 @@ export function createMeetingRouter(deps: MeetingRouteDependencies = {}): Router
     })
   })
 
+  // ── 6.83.2: discard a stranded Mac capture that held no sound ──────────────────────
+  // POST /meeting/sessions/:id/discard {confirm: true, serverInstanceId}. COS Control offers it only for a capture the
+  // server called no_speech or whose audio was all zeros; the server re-checks everything itself
+  // (transcribe-stream.ts discardSilentMacCapture) and never touches a capture with speech. Without `confirm: true`
+  // it answers 400 confirmation_required with what it WOULD do, and changes nothing.
+  router.post('/meeting/sessions/:sessionId/discard', async (req, res) => {
+    const sessionId = String(req.params.sessionId ?? '')
+    if (!/^[A-Za-z0-9:_-]{3,96}$/.test(sessionId)) {
+      res.status(400).json({ error: 'Invalid sessionId', reason: 'invalid_session_id' })
+      return
+    }
+    res.set('Cache-Control', 'private, no-store')
+    if (!MAC_CAPTURE_ID.test(sessionId)) {
+      res.status(400).json({ error: 'Only a Mac recording can be discarded here', reason: 'not_mac_capture' })
+      return
+    }
+    const body = (req.body ?? {}) as Record<string, unknown>
+    const serverInstanceId = getServerInstanceId()
+    if (!serverInstanceId) {
+      res.status(503).json({ error: 'Server identity unavailable', reason: 'server_identity_unavailable' })
+      return
+    }
+    const pin = suppliedServerPin(req, body.serverInstanceId)
+    if (!pin) {
+      res.status(400).json({ error: 'Server identity pin required', reason: 'server_identity_pin_required' })
+      return
+    }
+    if (pin !== serverInstanceId) {
+      res.status(409).json({ error: 'Server identity mismatch', reason: 'server_instance_mismatch' })
+      return
+    }
+    if (store.findBySessionId(sessionId)) {
+      res.status(409).json({ error: 'This recording is saved as a meeting', reason: 'already_saved' })
+      return
+    }
+    if (savingSessions.has(sessionId)) {
+      res.status(409).json({ error: 'This recording is being saved', reason: 'saving' })
+      return
+    }
+    const confirmed = body.confirm === true
+    const result = await discardSilentMacCapture(sessionId, { dryRun: !confirmed })
+    if (!result.ok && result.reason === 'session_not_found') {
+      // Already discarded (a retry after a lost answer): the quarantine says so, and the answer is the same.
+      const disposition = readCaptureDisposition(sessionId)
+      if (disposition?.quarantineReason === 'discarded_no_sound') {
+        res.json({ sessionId, discarded: true, replayed: true, quarantined: disposition.dirName, retainedUntil: disposition.retainedUntil })
+        return
+      }
+      res.status(404).json({ error: 'The server holds no live session for this recording', reason: 'session_not_found' })
+      return
+    }
+    if (!result.ok) {
+      const message: Record<string, string> = {
+        has_speech: 'This recording has speech; save it instead',
+        asr_in_progress: 'Audio is still being transcribed; try again in a moment',
+        chunk_in_progress: 'An audio chunk is still arriving; try again in a moment',
+        not_idle: 'This recording is still receiving audio',
+        not_mac_capture: 'Only a Mac recording can be discarded here',
+      }
+      res.status(409).json({ error: message[result.reason ?? ''] ?? 'Not discarded', reason: result.reason, receivedCount: result.receivedCount })
+      return
+    }
+    if (!confirmed) {
+      res.status(400).json({
+        error: 'Confirmation required', reason: 'confirmation_required',
+        preview: { sessionId, chunkFiles: result.chunkFiles, receivedCount: result.receivedCount, retentionHours: 24 },
+      })
+      return
+    }
+    console.warn(`[meeting/discard] Discarded no-sound Mac capture ${sessionId}: ${result.receivedCount} chunk(s) received, audio quarantined for 24 h`)
+    res.json({ sessionId, discarded: true, replayed: false, quarantined: result.quarantined ? basename(result.quarantined) : null,
+      chunkFiles: result.chunkFiles, receivedCount: result.receivedCount, retainedUntil: result.retainedUntil })
+  })
+
   // ── Stop a live G2 meeting from the Mac (COS Control) ────────────────────────────
   // The Mac never saves a live G2 session itself (lib/meeting-stop-requests.ts says why).
   // It asks the glasses: POST records the request and puts `meeting_stop_requested` on the

package/server/routes/prompt-drafts.ts

@@ -49,7 +49,9 @@ import {
   discardPolishPrewarm, isPrewarmModel, prewarmEnabled, PrewarmUnavailableError, runWarmPolish,
   startPolishPrewarm, takePolishPrewarm,
 } from '../lib/dictation-prewarm.js'
-import { getVocabulary } from '../lib/profile.js'
+import { getVocabulary, getWhisperCorrections } from '../lib/profile.js'
+import { correctionOnlyForms } from '../lib/glossary-learn.js'
+import { polishLinkProblem, renderSpokenPaths, spokenPathsEnabled } from '../lib/dictation-format.js'
 import { createBreaker } from '../lib/claude-circuit.js'
 import { logTokenAudit } from '../lib/token-audit.js'
 import { emitDisplay } from '../lib/display-bus.js'
@@ -90,7 +92,7 @@ const autoCleanBreakers = {
 const autoCleanDefaultEnabled = () => ['1', 'true', 'on'].includes((process.env.COS_DICTATION_AUTOCLEAN ?? '').toLowerCase())
 
 /** 6.79.1, additive on finalize answers: why the polish model did not run (or did not finish). */
-export type PolishSkipped = 'disabled' | 'too_long' | 'breaker_open' | 'daily_cap' | 'failed' | 'clean'
+export type PolishSkipped = 'disabled' | 'too_long' | 'breaker_open' | 'daily_cap' | 'failed' | 'clean' | 'link_guard'
 /** 6.79.2, additive when finalize was given a prewarmToken: what became of that warm process. */
 export type PrewarmOutcome = 'used' | 'missed' | 'discarded'
 
@@ -144,6 +146,9 @@ async function polishOutboundDictation(
   }
   // 6.79.1: um/uh never survive a skipped polish. Meeting lines stay faithful.
   if (opts.bucket !== 'meeting' && fillerPassEnabled()) cleaned = stripDisfluencies(cleaned)
+  // 6.83.1: "forward slash pricing," is "/pricing," even when the model is skipped. One word
+  // at a phrase end only; slugs of several words are the model's (dictation-format.ts).
+  if (opts.bucket !== 'meeting' && spokenPathsEnabled()) cleaned = renderSpokenPaths(cleaned)
   if (!(opts.enabled ?? autoCleanDefaultEnabled())) return { text: cleaned, polishSkipped: 'disabled' }
   const model = opts.model ?? 'haiku'
   const autoCleanBreaker = autoCleanBreakers[model]
@@ -174,6 +179,14 @@ async function polishOutboundDictation(
       source: 'g2-dictation-autoclean', model, inputChars: cleaned.length, outputChars: polished.length,
       durationMs: Date.now() - startedAt, caller: `dictation_autoclean_${opts.bucket}`,
     })
+    // 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
+    // pasting a URL nobody said. The call still counted: it ran.
+    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: polished || cleaned, ...(prewarm ? { prewarm } : {}) }
   } catch (err: any) {
     autoCleanBreaker.recordFailure()

package/server/routes/transcribe-stream.ts

@@ -1,7 +1,7 @@
 import { MacParakeetUnavailableError, transcribeMacParakeet } from '../lib/mac-recording-asr.js'
 import { getMeetingStore } from '../lib/meeting-store.js'
 import { appendAutonomousSaveLog, getStopIntentStore, savedChunkReplay, type StopIntent } from '../lib/meeting-stop-intents.js'
-import { MAC_AUDIO, MAC_CAPTURE_ID, persistMacChunkReceipt, macError, registerMacRecording, requireMacRecording, readMacRecording, validateMacWav } from '../lib/mac-recording.js'
+import { MAC_AUDIO, MAC_CAPTURE_ID, closeMacRecording, persistMacChunkReceipt, macError, registerMacRecording, requireMacRecording, readMacRecording, validateMacWav } from '../lib/mac-recording.js'
 import { AUTO_ENROLL_THRESHOLD } from '../lib/voiceprint-floor.js'
 import { readSpeakerPolicy, policyLabel, type SpeakerMode } from '../lib/meeting-speaker-policy.js'
 // POST /api/transcribe-stream — Streaming transcription for continuous meeting capture
@@ -15,7 +15,8 @@ import { chmodSync, readFileSync, writeFileSync, existsSync, lstatSync, mkdirSyn
 import { writeFile } from 'node:fs/promises'
 import { resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
-import { getVocabulary, getOwnerName, getOwnerSpeakerLabel } from '../lib/profile.js'
+import { getVocabulary, getOwnerName, getOwnerSpeakerLabel, getWhisperCorrections } from '../lib/profile.js'
+import { decoderContextWindow } from '../lib/glossary-learn.js'
 import { getOpenAIKey } from '../lib/openai-key.js'
 import { getTranscriptionPolicySnapshot, isOpenAIWhisperFallbackReady } from '../lib/transcription-policy.js'
 import { STRANDED_STALE_MS } from '../lib/stranded-sessions.js'
@@ -81,12 +82,14 @@ import {
 } from '../lib/even-hub-speaker-role.js'
 import { archiveSessionAudio, runMeetingAudioRetention } from '../lib/meeting-audio-archive.js'
 import {
+  DISCARDED_RETENTION_MS,
   countChunkWavs,
   listUnsavedCaptures,
   purgeExpiredQuarantine,
   quarantineSessionAudio,
   readCaptureDisposition,
   sweepOrphanedSessionAudio,
+  type QuarantineReceipt,
 } from '../lib/unsaved-audio-quarantine.js'
 import {
   STALE_ACTIVE_SESSION_DIR_NAME,
@@ -1728,11 +1731,14 @@ export function getMeetingSessionStatus(sessionId: string, now = Date.now()): Me
   }
 }
 
+/** 6.83.2: a close that quarantines under its own reason, clock and terminal receipt (the Mac discard). */
+type CloseQuarantine = { reason: string; retentionMs?: number; receipt?: QuarantineReceipt }
+
 function closeTranscriptSession(
   sessionId: string,
   reason: ClosedTranscriptSession['reason'],
-  options: { preserveAudio?: boolean } = {},
-): void {
+  options: { preserveAudio?: boolean; quarantine?: CloseQuarantine } = {},
+): string | null {
   // Progressive HQ is disposable cache state. Every terminal session path —
   // save, expiry, quarantine, or abandonment — must release the single owner.
   void stopProgressiveHqSession(sessionId)
@@ -1751,7 +1757,7 @@ function closeTranscriptSession(
     maxChunkIndex,
     reason,
   })
-  finishClosingTranscriptSession(sessionId, { ...options, closeReason: reason })
+  return finishClosingTranscriptSession(sessionId, { ...options, closeReason: reason })
 }
 
 /** Delete session after save */
@@ -1759,10 +1765,11 @@ export function deleteSession(sessionId: string, options: { preserveAudio?: bool
   closeTranscriptSession(sessionId, 'saved', options)
 }
 
+/** Where a close put the session's chunk audio (the quarantine dir), or null when it moved none. */
 function finishClosingTranscriptSession(
   sessionId: string,
-  options: { preserveAudio?: boolean; closeReason?: ClosedTranscriptSession['reason'] },
-): void {
+  options: { preserveAudio?: boolean; closeReason?: ClosedTranscriptSession['reason']; quarantine?: CloseQuarantine },
+): string | null {
   sessions.delete(sessionId)
   sessionAudioBytes.delete(sessionId)
   sessionAudioWrites.delete(sessionId)
@@ -1794,6 +1801,7 @@ function finishClosingTranscriptSession(
     if (countChunkWavs(audioDir) > 0) {
       const target = quarantineSessionAudio(audioDir, 'close_saved_residual_chunks')
       if (target) console.warn(`[transcribe-stream] Saved-close left chunk audio behind; quarantined: ${sessionId} → ${target}`)
+      return target
     } else {
       try { rmSync(audioDir, { recursive: true, force: true }) } catch {}
     }
@@ -1801,13 +1809,114 @@ function finishClosingTranscriptSession(
     // Any non-saved close (expired, error, …) with chunk audio still on disk
     // is an unsaved capture. Quarantine it — never delete evidence (6.19.0).
     if (countChunkWavs(audioDir) > 0) {
-      const target = quarantineSessionAudio(audioDir, `close_${options.closeReason ?? 'unknown'}`)
+      const quarantine = options.quarantine
+      const target = quarantineSessionAudio(audioDir, quarantine?.reason ?? `close_${options.closeReason ?? 'unknown'}`, undefined,
+        quarantine ? { retentionMs: quarantine.retentionMs, receipt: quarantine.receipt } : {})
       if (target) console.warn(`[transcribe-stream] Quarantined unsaved session-audio on close: ${sessionId} → ${target}`)
       else console.error(`[transcribe-stream] Quarantine move failed on close, source retained: ${sessionId}`)
+      return target
     } else {
       try { rmSync(audioDir, { recursive: true, force: true }) } catch {}
     }
   }
+  return null
+}
+
+// ── 6.83.2: discard a stranded Mac capture that holds no sound ─────────────────────
+// Miles, 2026-10-21: Record on Mac captured a 21-minute Zoom call as 211 chunks of exact zeros (macOS returns
+// zeros, not an error, when system audio recording is not allowed). The save refused it (no_speech), and the
+// capture then sat in the stranded list with a Save that can never work. COS Control asks the server to let it go.
+//
+// What it may touch: a Mac capture (Control is its only uploader, so nothing else will send it a chunk) that is in
+// memory, holds NO canonical chunk (no transcribed text, so no speech), has finished ASR on every chunk it received
+// (an in-flight chunk could still become speech), is idle past EMPTY_SESSION_STALE_MS, and has no chunk upload in
+// progress. Anything else is refused and left exactly as it was. The audio is never deleted here: it moves into the
+// existing quarantine with a terminal no_speech receipt and a 24-hour clock (DISCARDED_RETENTION_MS).
+export type MacDiscardRefusal =
+  | 'session_not_found' | 'not_mac_capture' | 'has_speech' | 'asr_in_progress' | 'not_idle' | 'chunk_in_progress'
+
+export interface MacDiscardResult {
+  ok: boolean
+  reason?: MacDiscardRefusal
+  sessionId: string
+  /** The quarantine dir the audio moved into, or null when the capture held no chunk audio. */
+  quarantined: string | null
+  chunkFiles: number
+  receivedCount: number
+  retainedUntil: string | null
+}
+
+export const MAC_DISCARD_IDLE_MS = EMPTY_SESSION_STALE_MS
+
+/** Why a session may not be discarded, or null when it may. Pure over the session's ledger. */
+export function macDiscardRefusal(input: {
+  sessionId: string
+  present: boolean
+  canonicalCount: number
+  receivedIndices: number[]
+  asrCompletedIndices: number[]
+  silentForMs: number
+  chunkInProgress: boolean
+}): MacDiscardRefusal | null {
+  if (!MAC_CAPTURE_ID.test(input.sessionId)) return 'not_mac_capture'
+  if (!input.present) return 'session_not_found'
+  if (input.canonicalCount > 0) return 'has_speech'
+  const completed = new Set(input.asrCompletedIndices)
+  if (input.receivedIndices.some(index => !completed.has(index))) return 'asr_in_progress'
+  if (input.chunkInProgress) return 'chunk_in_progress'
+  if (input.silentForMs < MAC_DISCARD_IDLE_MS) return 'not_idle'
+  return null
+}
+
+export async function discardSilentMacCapture(sessionId: string, options: { now?: number; dryRun?: boolean } = {}): Promise<MacDiscardResult> {
+  const now = options.now ?? Date.now()
+  const refusalFor = () => {
+    const session = sessions.get(sessionId)
+    return {
+      session,
+      refusal: macDiscardRefusal({
+        sessionId,
+        present: !!session,
+        canonicalCount: session ? canonicalIndices(session).length : 0,
+        receivedIndices: session?.receivedIndices ?? [],
+        asrCompletedIndices: session?.asrCompletedIndices ?? [],
+        silentForMs: session ? now - session.lastActivityAt : 0,
+        chunkInProgress: macChunkLocks.has(sessionId),
+      }),
+    }
+  }
+  const empty = (reason: MacDiscardRefusal, receivedCount = 0): MacDiscardResult =>
+    ({ ok: false, reason, sessionId, quarantined: null, chunkFiles: 0, receivedCount, retainedUntil: null })
+  const first = refusalFor()
+  if (first.refusal) return empty(first.refusal, first.session?.receivedIndices?.length ?? 0)
+  if (options.dryRun) {
+    const audioDir = getSessionAudioDirectory(sessionId)
+    return { ok: true, sessionId, quarantined: null, chunkFiles: audioDir ? countChunkWavs(audioDir) : 0,
+      receivedCount: first.session?.receivedIndices?.length ?? 0, retainedUntil: null }
+  }
+  // Every chunk write this session started reaches disk before its directory moves.
+  await drainSessionAudioWrites(sessionId)
+  // Ask again after the await: a chunk may have arrived meanwhile.
+  const second = refusalFor()
+  if (second.refusal) return empty(second.refusal, second.session?.receivedIndices?.length ?? 0)
+  const receivedCount = second.session?.receivedIndices?.length ?? 0
+  const quarantined = closeTranscriptSession(sessionId, 'closed', {
+    quarantine: {
+      reason: 'discarded_no_sound',
+      retentionMs: DISCARDED_RETENTION_MS,
+      receipt: { outcome: 'no_speech', discarded: true, note: 'Discarded from COS Control: no sound was captured. Audio retained until its 24-hour clock clears it.' },
+    },
+  })
+  // A late chunk or a replayed start for this capture answers 410 from here on.
+  closeMacRecording(sessionId)
+  return {
+    ok: true,
+    sessionId,
+    quarantined,
+    chunkFiles: quarantined ? countChunkWavs(quarantined) : 0,
+    receivedCount,
+    retainedUntil: quarantined ? new Date(Date.now() + DISCARDED_RETENTION_MS).toISOString() : null,
+  }
 }
 
 function isIosAsrCandidateEnabled(): boolean {
@@ -1946,7 +2055,13 @@ function recentWhisperContext(sessionId: string, session: TranscriptSession): st
     .map(c => c.text)
     .join(' ')
   const cleanedContext = stripInlineHallucinations(recentText, sessionId)
-  return cleanedContext.length > 250 ? cleanedContext.slice(-250) : cleanedContext
+  // 6.83.1: correction-only forms ("/pricing") go back to speech BEFORE the 250-character cut.
+  return decoderContextWindow(cleanedContext, decoderCorrections()) ?? ''
+}
+
+/** The corrections map for the decoder window; a test double without it reads as none. */
+function decoderCorrections(): Record<string, string> {
+  try { return getWhisperCorrections() } catch { return {} }
 }
 
 function isCrossChunkRepeat(session: TranscriptSession, text: string): boolean {
@@ -2610,7 +2725,9 @@ export function assertMacCaptureComplete(sessionId: string, expectedChunkCount:
 
 // Manual Mac pilot: independent from iPhone candidate and cue rollout gates.
 transcribeStreamRouter.get('/mac-recording/capabilities', (_req, res) => {
-  res.set('Cache-Control', 'private, no-store').json({ available: true, ...MAC_AUDIO, serverInstanceId: getServerInstanceId() })
+  // 6.83.2: `discard` advertises POST /api/meeting/sessions/:id/discard for a stranded no-sound capture. Older
+  // servers omit it, and COS Control then discards only its own local copy and says so.
+  res.set('Cache-Control', 'private, no-store').json({ available: true, ...MAC_AUDIO, serverInstanceId: getServerInstanceId(), discard: true })
 })
 function requireMacPin(req: { get(name: string): string | undefined }): string {
   const pin = req.get('X-COS-Server-Instance')?.trim()