@gotcos/glasses-server 6.45.3 → 6.45.4

package/server/lib/prompt-tail-guard.ts

@@ -0,0 +1,257 @@
+// The tail of a dictated prompt: keep what was said, drop what the decoder made up.
+//
+// Chris, 2026-09-12: a prompt closed with "I'm going to go to the bathroom" after
+// he had stopped talking. The interactive path runs whisper without VAD on
+// purpose (a short prompt must never be trimmed), and a decoder handed trailing
+// silence plus a vocabulary prompt finishes the sentence it thinks it heard.
+//
+// Miles's constraint governs everything here: "as long as we don't end up
+// cutting the final portion of a user's prompt. It's only going to be when we
+// see things like 'Thanks for watching,' 'I need to go to the bathroom,' and
+// random shit like that that we want to reject it."
+//
+// Two rules, each on the LAST sentence, at most `TAIL_MAX_DROPS` times:
+//
+//   (a) lexicon   the whole sentence is a known filler — anchored start to end,
+//                 so "put the risks at the end" and "the webinar about thanks
+//                 for watching screens" never match (QA 2026-09-12 found the
+//                 unanchored form eating both). Applies with or without a VAD.
+//   (b) evidence  the VAD MEASURED the audio, the sentence's tokens start at
+//                 least `TAIL_SILENCE_MIN_SEC` after the last speech it heard,
+//                 AND whisper's own mean token probability for the sentence is
+//                 under `TAIL_LOW_CONFIDENCE`. Two independent signals must
+//                 agree; either alone keeps the text.
+//
+// Rule (b) never empties a chunk in which the VAD heard any speech: if the only
+// sentence left is low-confidence, it stays. A chunk empties only when every
+// sentence was a filler, or the VAD measured the whole chunk as silence and the
+// decoder was unsure of what it wrote there. A VAD that did not run (model
+// absent, audio too short, internal error) reports UNKNOWN, never silence —
+// `TrimResult.measured` is required, because every fallback shape is otherwise
+// identical to real silence.
+//
+// Token alignment is by characters, not by whitespace words: whisper-cli emits
+// one entry per TOKEN, and "bathroom." can be three of them.
+
+import { isSileroAvailable, trimSilence } from './vad-silero.js'
+import type { WhisperWord } from './whisper-local.js'
+
+/** A sentence that starts this long after the last measured speech was decoded from silence. */
+export const TAIL_SILENCE_MIN_SEC = 1.0
+/** Below this mean token probability whisper is guessing. Calibrated on ten of
+ *  Miles's real prompt chunks (2026-09-12, large-v3): trailing sentences scored
+ *  0.72 to 1.00, one real sentence in a noisy room 0.43 — which is why this
+ *  number never acts alone. */
+export const TAIL_LOW_CONFIDENCE = 0.45
+/** Never more than this many trailing sentences. */
+export const TAIL_MAX_DROPS = 2
+/** Only the last window of a long chunk is measured. The shared Silero instance
+ *  is built with a 10 s buffer, and real prompt chunks are 2 to 7 s; a longer
+ *  chunk's earlier speech is treated as unknown, which can only KEEP text. */
+export const TAIL_WINDOW_SEC = 10
+
+/**
+ * Whole-sentence fillers. Each pattern is anchored at both ends AND closed —
+ * no free-text tail — so it matches a sentence that IS the filler and nothing
+ * that merely starts with its words. The re-validation of 2026-09-12 caught
+ * `.{0,30}` tails letting "Thanks for watching the demo.", "Transcript from the
+ * Silas call is in the folder." and "Subscribe me to the newsletter." through.
+ * "See you later", "the end", "transcribed by" and "translated by" are
+ * deliberately absent: each occurs in real dictation ("Translated by Friday."),
+ * and whisper's inventions are the caption-credit shapes below. A filler this
+ * list misses fails SAFE: the text stays.
+ */
+export const TAIL_FILLER_SENTENCES: readonly RegExp[] = [
+  /^(?:thanks?|thank you)(?: (?:all|everyone|guys|so much|very much))? for (?:watching|listening)(?:,? (?:everyone|everybody|guys|all))?[.!]?$/i,
+  /^(?:subtitles?|captions?) (?:by|provided by|created by) (?:the )?[\w.'’-]+(?: [\w.'’-]+){0,2}(?: community)?[.!]?$/i,
+  /^transcript(?:ion)? by [\w'’-]+\.(?:com|org|net|io|ai)[.!]?$/i,
+  /^(?:please )?(?:like(?:,)? (?:and )?)?(?:share(?:,)? (?:and )?)?subscribe(?: to (?:my|the|our) channel)?[.!]?$/i,
+  /^(?:don['’]?t|do not) forget to (?:like(?: and)? )?subscribe(?: to (?:my|the|our) channel)?[.!]?$/i,
+  /^(?:i(?:['’]ll| will)? )?see you(?: all| guys)? (?:next time|in the next (?:one|video|episode))[.!]?$/i,
+  /^(?:i(?:['’]m| am) (?:going to|gonna) |i (?:need|have|got) to |i gotta |let me |gonna )?(?:go (?:to )?)?(?:the )?(?:bathroom|restroom|toilet)(?: (?:real quick|really quick|right quick|quick|now))?[.!]?$/i,
+]
+
+export interface SpeechWindows {
+  /** True only when the VAD RAN over the audio (`TrimResult.measured`). */
+  available: boolean
+  /** Seconds from the start of the chunk to the end of the last speech the VAD
+   *  heard. 0 when it measured the whole chunk and heard nothing; the window
+   *  offset when only the tail was measured and it was silent; null when
+   *  unavailable. */
+  lastSpeechEndSec: number | null
+  /** Share of the MEASURED audio that was speech. */
+  speechRatio: number
+  /** True when the whole chunk was measured, false when only its last
+   *  `TAIL_WINDOW_SEC`. */
+  whole: boolean
+}
+
+export const SPEECH_UNKNOWN: SpeechWindows = { available: false, lastSpeechEndSec: null, speechRatio: 0, whole: false }
+
+const WAV_HEADER = 44
+const VAD_SAMPLE_RATE = 16_000
+
+/** The last `TAIL_WINDOW_SEC` of a 16 kHz mono 16-bit WAV, with a fresh header. */
+function tailWindow(wav: Buffer): { wav: Buffer; offsetSec: number; whole: boolean } {
+  if (wav.length <= WAV_HEADER) return { wav, offsetSec: 0, whole: true }
+  const channels = wav.readUInt16LE(22)
+  const rate = wav.readUInt32LE(24)
+  const bits = wav.readUInt16LE(34)
+  const blockAlign = Math.max(1, (channels * bits) / 8)
+  if (rate !== VAD_SAMPLE_RATE || channels !== 1 || bits !== 16) return { wav, offsetSec: 0, whole: true }
+  const bytesPerSec = rate * blockAlign
+  const pcmBytes = wav.length - WAV_HEADER
+  // A body that is not whole samples cannot be windowed on a sample boundary;
+  // hand it over untouched, where the VAD refuses it as unmeasured.
+  if (pcmBytes % blockAlign !== 0) return { wav, offsetSec: 0, whole: true }
+  if (pcmBytes <= TAIL_WINDOW_SEC * bytesPerSec) return { wav, offsetSec: 0, whole: true }
+  const tailBytes = Math.floor((TAIL_WINDOW_SEC * bytesPerSec) / blockAlign) * blockAlign
+  const start = wav.length - tailBytes
+  const out = Buffer.alloc(WAV_HEADER + tailBytes)
+  wav.copy(out, 0, 0, WAV_HEADER)
+  wav.copy(out, WAV_HEADER, start)
+  out.writeUInt32LE(36 + tailBytes, 4)
+  out.writeUInt32LE(tailBytes, 40)
+  return { wav: out, offsetSec: (start - WAV_HEADER) / bytesPerSec, whole: false }
+}
+
+/** Where the VAD heard speech in (the tail of) this chunk. */
+export function speechWindowsFromWav(wav: Buffer): SpeechWindows {
+  if (!isSileroAvailable()) return SPEECH_UNKNOWN
+  const window = tailWindow(wav)
+  let result: ReturnType<typeof trimSilence>
+  try {
+    result = trimSilence(window.wav)
+  } catch {
+    return SPEECH_UNKNOWN
+  }
+  if (result.measured !== true) return SPEECH_UNKNOWN
+  let lastEnd: number | null = null
+  for (const seg of result.segments) {
+    const end = (seg.startSample + seg.sampleCount) / VAD_SAMPLE_RATE + window.offsetSec
+    if (lastEnd === null || end > lastEnd) lastEnd = end
+  }
+  return {
+    available: true,
+    lastSpeechEndSec: lastEnd ?? window.offsetSec,
+    speechRatio: result.speechRatio,
+    whole: window.whole,
+  }
+}
+
+/** Sentence boundaries: a terminator followed by whitespace, except after an
+ *  abbreviation or an initial. Decimals never split (no whitespace inside). */
+export function splitSentences(text: string): string[] {
+  const raw = text.trim().split(/(?<=[.!?])\s+(?=\S)/)
+  const out: string[] = []
+  for (const piece of raw) {
+    const prev = out[out.length - 1]
+    if (prev !== undefined && /(?:^|\s)(?:dr|mr|mrs|ms|jr|sr|st|vs|etc|e\.g|i\.e|a\.m|p\.m|no|[a-z])\.$/i.test(prev)) {
+      out[out.length - 1] = `${prev} ${piece}`
+    } else {
+      out.push(piece)
+    }
+  }
+  return out.filter(s => s.length > 0)
+}
+
+function normalizeSentence(sentence: string): string {
+  return sentence.trim().replace(/^["'“”‘’(\[]+|["'“”‘’)\]]+$/g, '').replace(/\s+/g, ' ').trim()
+}
+
+/** Is this sentence, whole, a known filler? */
+export function matchesTailLexicon(sentence: string): boolean {
+  const s = normalizeSentence(sentence)
+  return s.length > 0 && TAIL_FILLER_SENTENCES.some(re => re.test(s))
+}
+
+export interface TailTokenStats {
+  startSec: number | null
+  meanProbability: number | null
+  /** Index of the sentence's first token, so a caller that drops the sentence
+   *  can trim its tokens before judging the one before it. */
+  tokenStart: number | null
+}
+
+/**
+ * The tokens that spell the last sentence, found by walking back from the end
+ * until the accumulated non-space characters cover it. Returns nulls when the
+ * tokens do not cover the text at all (alignment unknown): then rule (b) is
+ * inert and the sentence stays.
+ */
+export function tailTokenStats(words: WhisperWord[] | undefined, sentence: string): TailTokenStats {
+  const none = { startSec: null, meanProbability: null, tokenStart: null }
+  if (!words || words.length === 0) return none
+  const target = sentence.replace(/\s+/g, '').length
+  if (target === 0) return none
+  let acc = 0
+  let i = words.length
+  while (i > 0 && acc < target) {
+    i--
+    acc += String(words[i].word ?? '').replace(/\s+/g, '').length
+  }
+  if (acc < target) return none
+  const slice = words.slice(i)
+  // The tail must SPELL the sentence, not merely be as long as it: a
+  // correction that changed a token's length ("Carrot IQ" -> "CaratIQ") would
+  // otherwise shift the window and its start time. Mismatch fails safe.
+  const letters = (s: string) => s.toLowerCase().replace(/[^\p{L}\p{N}]/gu, '')
+  if (letters(slice.map(w => String(w.word ?? '')).join('')) !== letters(sentence)) return none
+  let sum = 0
+  let n = 0
+  for (const w of slice) {
+    if (typeof w.probability === 'number' && Number.isFinite(w.probability)) { sum += w.probability; n++ }
+  }
+  const start = typeof slice[0]?.start === 'number' && Number.isFinite(slice[0].start) ? slice[0].start : null
+  return { startSec: start, meanProbability: n > 0 ? sum / n : null, tokenStart: i }
+}
+
+export type TailDropReason = 'lexicon' | 'low_confidence_after_speech'
+
+export interface TailDrop {
+  text: string
+  reason: TailDropReason
+  startSec: number | null
+  meanProbability: number | null
+}
+
+export interface GuardedPromptTail {
+  text: string
+  dropped: TailDrop[]
+  lastSpeechEndSec: number | null
+}
+
+export function guardPromptTail(input: { text: string; words?: WhisperWord[]; speech: SpeechWindows }): GuardedPromptTail {
+  const sentences = splitSentences(input.text)
+  const dropped: TailDrop[] = []
+  const lastSpeechEnd = input.speech.available ? input.speech.lastSpeechEndSec : null
+  // Tokens still standing: a dropped sentence's tokens leave with it, so the
+  // sentence before it is judged against its own tokens.
+  let remaining = input.words
+  while (sentences.length > 0 && dropped.length < TAIL_MAX_DROPS) {
+    const last = sentences[sentences.length - 1]
+    let reason: TailDropReason | null = null
+    const stats = tailTokenStats(remaining, last)
+    if (matchesTailLexicon(last)) {
+      reason = 'lexicon'
+    } else if (lastSpeechEnd !== null) {
+      if (
+        stats.startSec !== null && stats.meanProbability !== null
+        && stats.startSec >= lastSpeechEnd + TAIL_SILENCE_MIN_SEC
+        && stats.meanProbability < TAIL_LOW_CONFIDENCE
+      ) {
+        // The last sentence standing is kept unless the VAD measured the WHOLE
+        // chunk and heard nothing in it: real speech somewhere means the
+        // decoder's low confidence here is not enough to empty the prompt.
+        const measuredSilentChunk = input.speech.whole && input.speech.speechRatio === 0
+        if (sentences.length === 1 && !measuredSilentChunk) break
+        reason = 'low_confidence_after_speech'
+      }
+    }
+    if (!reason) break
+    dropped.push({ text: last, reason, startSec: stats.startSec, meanProbability: stats.meanProbability })
+    sentences.pop()
+    if (remaining && stats.tokenStart !== null) remaining = remaining.slice(0, stats.tokenStart)
+  }
+  return { text: sentences.join(' '), dropped, lastSpeechEndSec: lastSpeechEnd }
+}

package/server/lib/speaker-embeddings.ts

@@ -88,7 +88,14 @@ const CALIBRATION_LOG = resolve(DATA_DIR, 'speaker-calibration.jsonl')
 // Thresholds
 const VERIFY_THRESHOLD = 0.65
 const SEARCH_THRESHOLD = 0.55
-const AUTO_ENROLL_THRESHOLD = 0.88    // High bar — must be very confident before auto-enrolling
+/** The bar `autoEnroll` enrols at. From 6.45.4 also the bar at which a held
+ *  group is offered as a person with one click ("high"): the identifier would
+ *  have written that sample itself. */
+export const AUTO_ENROLL_THRESHOLD = 0.88    // High bar — must be very confident before auto-enrolling
+/** The live path only ASKS autoEnroll about a chunk above this; autoEnroll
+ *  then applies AUTO_ENROLL_THRESHOLD. Named so transcribe-stream and the
+ *  held-voice panel read the same number (6.45.4). */
+export const AUTO_ENROLL_CANDIDATE_SIMILARITY = 0.72
 const AUTO_ENROLL_CONSENSUS = 2       // Must match N times in same session before enrolling
 // Raised 20 -> 40 on 2026-08-06. Measured, not guessed: search latency is 1 us
 // at 20, 40 AND 80 samples per speaker (77 speakers, sherpa SpeakerEmbeddingManager),

package/server/lib/training-audio-provenance.ts

@@ -49,7 +49,7 @@ export function trainingSourceFor(filename: string): string {
 export function isSampleFromSession(source: string | undefined | null, sessionId: string): boolean {
   const s = String(source ?? '')
   if (!sessionId) return false
-  for (const prefix of ['auto:', 'correction:', 'g2-training:']) {
+  for (const prefix of ['auto:', 'correction:', 'g2-training:', 'ext-group:']) {
     if (s.startsWith(prefix) && s.slice(prefix.length) === sessionId) return true
   }
   return false

package/server/lib/transcribe-audio.ts

@@ -1,3 +1,4 @@
+import type { WhisperWord } from './whisper-local.js'
 import {
   transcribeLocal,
   transcribeHighQuality,
@@ -28,6 +29,8 @@ export type TranscribeMode = 'hq' | 'fast'
 
 export interface TranscribeAudioResult {
   text: string
+  /** 6.45.4 — the decoder's timed words with token probability, when the backend produced them. */
+  words?: WhisperWord[]
   backend: string
   mode: TranscribeMode
   requestedMode: TranscribeMode
@@ -158,6 +161,7 @@ export async function transcribeAudioBuffer(
   }
 
   let text: string
+  let words: WhisperWord[] | undefined
   let backend: string
   let actualQuality: 'hq' | 'fast' | 'cloud'
   let degradationReason: string | undefined = effectiveMode !== requestedMode ? 'audio_too_long' : undefined
@@ -168,8 +172,9 @@ export async function transcribeAudioBuffer(
       // A0 (2026-07-30): ffmpeg enhance light (highpass=f=80) was measured dropping
       // leading speech on compose ("device just for your awareness"). Meeting batch
       // still enhances in meeting-batch-transcribe.ts — this path is prompt/interactive only.
-      const result = await transcribeHighQuality(audioBuffer, undefined, { priority: 'interactive' })
+      const result = await transcribeHighQuality(audioBuffer, undefined, { priority: 'interactive', words: true })
       text = result.text
+      words = result.words
       actualQuality = result.actualQuality
       if (result.actualQuality === 'hq') {
         backend = 'hq-large-v3'
@@ -183,6 +188,7 @@ export async function transcribeAudioBuffer(
       try {
         const result = await transcribeLocal(audioBuffer, undefined, undefined, { affectsCircuit })
         text = result.text
+        words = result.words
         backend = `fast-local-${result.backend}`
         actualQuality = 'fast'
       } catch (localErr: any) {
@@ -203,6 +209,7 @@ export async function transcribeAudioBuffer(
     try {
       const result = await transcribeLocal(audioBuffer, undefined, undefined, { affectsCircuit })
       text = result.text
+      words = result.words
       backend = `fast-local-${result.backend}`
       actualQuality = 'fast'
     } catch (localErr: any) {
@@ -270,6 +277,7 @@ export async function transcribeAudioBuffer(
 
   return {
     text: text.trim(),
+    ...(words && words.length > 0 ? { words } : {}),
     backend,
     mode: effectiveMode,
     requestedMode,

package/server/lib/vad-silero.ts

@@ -32,6 +32,11 @@ export interface TrimResult {
   trimmedWav: Buffer
   speechRatio: number
   segments: Array<{ startSample: number; sampleCount: number }>
+  /** True when the VAD ran over the audio and `segments` is its verdict. Absent
+   *  on every fallback (model not loaded, audio too short, internal error), which
+   *  otherwise look identical to measured silence. A reader deciding to drop
+   *  text on "no speech" must require this. (6.45.4: prompt-tail-guard) */
+  measured?: true
 }
 
 /** Initialize Silero VAD. Returns true if model loaded, false otherwise. */
@@ -124,7 +129,7 @@ export function trimSilence(wavBuffer: Buffer): TrimResult {
 
     if (speechSegments.length === 0 || totalSpeechSamples === 0) {
       // No speech detected — return original unchanged
-      return { trimmedWav: wavBuffer, speechRatio: 0.0, segments: [] }
+      return { trimmedWav: wavBuffer, speechRatio: 0.0, segments: [], measured: true }
     }
 
     // Concatenate speech segments into a single Float32Array
@@ -168,10 +173,10 @@ export function trimSilence(wavBuffer: Buffer): TrimResult {
 
     // Guard: if trimmed result is too small for Whisper, fall back to original
     if (trimmedWav.length < 100) {
-      return { trimmedWav: wavBuffer, speechRatio, segments: segmentInfo }
+      return { trimmedWav: wavBuffer, speechRatio, segments: segmentInfo, measured: true }
     }
 
-    return { trimmedWav, speechRatio, segments: segmentInfo }
+    return { trimmedWav, speechRatio, segments: segmentInfo, measured: true }
   } catch (err: any) {
     console.error('[silero-vad] trimSilence error:', err.message)
     return fallback

package/server/lib/voice-enrolment-selection.ts

@@ -82,10 +82,19 @@ export function dominantCoherentCluster(
   const n = embeddings.length
   if (n === 0) return { members: [], seed: -1 }
   if (n === 1) return { members: [0], seed: 0 }
+  return dominantCoherentClusterFromMatrix(pairwiseSimilarityMatrix(embeddings), embeddings.map((_, i) => i), floor)
+}
 
-  // Full pairwise matrix once: the refinement below reads it repeatedly, and
-  // recomputing a 192-dim cosine inside that loop is the difference between
-  // microseconds and seconds on a long meeting.
+/**
+ * Full pairwise cosine matrix, computed once. The refinement in
+ * `dominantCoherentClusterFromMatrix` reads it repeatedly, and recomputing a
+ * 192-dim cosine inside that loop is the difference between microseconds and
+ * seconds on a long meeting. Held-voice grouping (6.45.4) also builds it once
+ * for every sample in the retention window and then carves cluster after
+ * cluster out of the same matrix.
+ */
+export function pairwiseSimilarityMatrix(embeddings: Float32Array[]): number[][] {
+  const n = embeddings.length
   const sim: number[][] = Array.from({ length: n }, () => new Array<number>(n).fill(0))
   for (let i = 0; i < n; i++) {
     sim[i][i] = 1
@@ -95,14 +104,31 @@ export function dominantCoherentCluster(
       sim[j][i] = s
     }
   }
+  return sim
+}
+
+/**
+ * `dominantCoherentCluster` over a precomputed matrix and an explicit candidate
+ * set. `members` and `seed` are indices into the matrix (the same index space
+ * as `candidates`), so a caller carving several clusters out of one pool passes
+ * the survivors back in without renumbering anything. Same contract otherwise:
+ * a lone candidate is its own cluster; a crowd that agrees on nothing is EMPTY.
+ */
+export function dominantCoherentClusterFromMatrix(
+  sim: number[][],
+  candidates: number[],
+  floor: number = VOICE_COHERENCE_FLOOR,
+): CoherentCluster {
+  if (candidates.length === 0) return { members: [], seed: -1 }
+  if (candidates.length === 1) return { members: [candidates[0]], seed: candidates[0] }
 
   let bestSeed = -1
   let bestAgree: number[] = []
   let bestMean = -Infinity
-  for (let i = 0; i < n; i++) {
+  for (const i of candidates) {
     const agree: number[] = []
     let sum = 0
-    for (let j = 0; j < n; j++) {
+    for (const j of candidates) {
       if (i !== j && sim[i][j] >= floor) { agree.push(j); sum += sim[i][j] }
     }
     const meanSim = agree.length > 0 ? sum / agree.length : -Infinity

package/server/lib/whisper-local.ts

@@ -940,6 +940,11 @@ export async function transcribeHighQuality(
    *  an infinite loop. */
   opts: {
     priority?: 'interactive' | 'batch'
+    /** Ask whisper-cli for per-token timing and probability (`-ojf`) on an
+     *  interactive decode too. Batch always captures them. The prompt path
+     *  needs them for the tail guard (6.45.4): without this flag the guard's
+     *  confidence rule could never fire, which QA caught on 2026-09-12. */
+    words?: boolean
     forceCpu?: boolean
     forceCpuReason?: string
     threads?: number
@@ -965,8 +970,9 @@ export async function transcribeHighQuality(
   const tmpWav = join('/tmp', `cos-whisper-hq-${id}.wav`)
   const outBase = join('/tmp', `cos-whisper-hq-${id}`)
   const jsonPath = `${outBase}.json`
-  // Word clocks only on post-meeting CPU polish. Live stays compact JSON.
-  const captureBatchWords = opts.priority === 'batch'
+  // Word clocks on post-meeting CPU polish, and on any decode that asks for
+  // them (the prompt tail guard). Other live decodes stay compact JSON.
+  const captureWords = opts.priority === 'batch' || opts.words === true
 
   const modelPath = resolveBatchModel()
   const useLargeV3 = modelPath === BATCH_MODEL_LARGE_V3
@@ -1013,7 +1019,7 @@ export async function transcribeHighQuality(
         '-np',
         '--prompt', buildPrompt(context),
       ]
-      if (captureBatchWords) {
+      if (captureWords) {
         args.push('-ojf', '-of', outBase)
       }
       if (useVad) {
@@ -1120,7 +1126,7 @@ export async function transcribeHighQuality(
 
     let finalText = text
     let words: WhisperWord[] | undefined
-    if (captureBatchWords) {
+    if (captureWords) {
       try {
         if (existsSync(jsonPath)) {
           const parsed = parseWhisperCliFullJson(readFileSync(jsonPath, 'utf8'))
@@ -1142,7 +1148,7 @@ export async function transcribeHighQuality(
     const modelTag = useLargeV3 ? 'large-v3' : 'turbo'
     console.log(
       `[whisper-hq] Batch transcribed in ${elapsed}ms ` +
-      `(${modelTag}${useVad ? '+vad' : ''}${captureBatchWords ? '+words' : ''}` +
+      `(${modelTag}${useVad ? '+vad' : ''}${captureWords ? '+words' : ''}` +
       `${words ? `, ${words.length} words` : ''}` +
       // Device forensics: without these, "why is polish slow today" is
       // unanswerable after the fact.
@@ -1162,7 +1168,7 @@ export async function transcribeHighQuality(
     return words ? { text: corrected, words, ...metadata } : { text: corrected, ...metadata }
   } finally {
     try { unlinkSync(tmpWav) } catch { /* cleanup */ }
-    if (captureBatchWords) {
+    if (captureWords) {
       try { unlinkSync(jsonPath) } catch { /* cleanup */ }
     }
   }

package/server/routes/prompt-drafts.ts

@@ -16,6 +16,7 @@ import {
   transcriptQualityRank,
   type PromptDraftTranscriptRecord,
 } from '../lib/prompt-draft-store.js'
+import { SPEECH_UNKNOWN, guardPromptTail, speechWindowsFromWav } from '../lib/prompt-tail-guard.js'
 import {
   transcribeAudioBuffer,
   resolveTranscribeMode,
@@ -291,7 +292,15 @@ async function transcribeChunk(draftId: string, chunkIndex: number, audio: Buffe
       const policy = purpose === 'warm' ? 'local-only' as const : 'automatic' as const
       const result = await transcribeAudioBuffer(audio, { mode, policy })
       if (!isCurrentChunk(draftId, chunkIndex, audio)) return ''
-      const text = sanitizeTranscript(draftId, result.text)
+      // 6.45.4 — the sentence Whisper invents after the speaker stops. Never trims
+      // audio; drops a trailing sentence only on the junk lexicon or on silence
+      // plus the decoder's own low confidence (prompt-tail-guard.ts).
+      const guarded = guardPromptTail({ text: result.text, words: result.words, speech: speechWindowsFromWav(audio) })
+      for (const drop of guarded.dropped) {
+        console.warn(`[prompt-draft] tail_drop ${draftId}/${chunkIndex} ${purpose}/${mode} (${drop.reason}, start=${drop.startSec ?? '?'}s, lastSpeech=${guarded.lastSpeechEndSec ?? '?'}s, p=${drop.meanProbability?.toFixed(2) ?? '?'}): "${drop.text.slice(0, 100)}"`)
+      }
+      if (guarded.dropped.length > 0 && !guarded.text.trim()) throw new NoSpeechDetectedError(result.text)
+      const text = sanitizeTranscript(draftId, guarded.text)
       const record: PromptDraftTranscriptRecord = {
         text, hash, requestedMode: result.requestedMode, actualQuality: result.actualQuality,
         backend: result.backend, degraded: result.degraded,
@@ -497,7 +506,9 @@ promptDraftsRouter.post('/prompt-drafts/:draftId/peek', async (req, res) => {
       lease.setPhase('active')
       try {
         const result = await transcribeWhisperPreview(audio)
-        const text = sanitizeTranscript(draftId, result.text, false)
+        // 6.45.4: the same whole-sentence filler rule as the commit path, so an
+        // invented closing line never paints on the lens only to vanish later.
+        const text = sanitizeTranscript(draftId, guardPromptTail({ text: result.text, speech: SPEECH_UNKNOWN }).text, false)
         if (!text) return
         if (!loadPromptDraftMeta(draftId)) return
         emitDisplay({

package/server/routes/transcribe-stream.ts

@@ -39,7 +39,7 @@ import { errMsg } from '../lib/utils.js'
 import { transcribeLocal, applyCorrections, type WhisperWord } from '../lib/whisper-local.js'
 import { enhanceAudio } from '../lib/audio-enhance.js'
 import { trimSilence, isSileroAvailable } from '../lib/vad-silero.js'
-import { identifySpeaker, isEmbeddingAvailable, autoEnroll, getEmbeddingCount } from '../lib/speaker-embeddings.js'
+import { identifySpeaker, isEmbeddingAvailable, autoEnroll, getEmbeddingCount, AUTO_ENROLL_CANDIDATE_SIMILARITY } from '../lib/speaker-embeddings.js'
 import {
   assertOpenAIWhisperBudget,
   recordOpenAIWhisperUsage,
@@ -1157,7 +1157,9 @@ setInterval(() => {
         const dirPath = resolve(EXT_AUDIO_DIR, dir)
         try {
           const files = readdirSync(dirPath)
-          if (files.length === 0) { rmSync(dirPath, { recursive: true, force: true }); continue }
+          // 6.45.4: an emptied session (every held sample named or discarded)
+          // frees its per-session cap too, so the next stranger can be held.
+          if (files.length === 0) { rmSync(dirPath, { recursive: true, force: true }); extAudioCounts.delete(dir); continue }
           const { mtimeMs } = statSync(resolve(dirPath, files[0]))
           if (Date.now() - mtimeMs > EXT_AUDIO_TTL_MS) {
             rmSync(dirPath, { recursive: true, force: true })
@@ -1897,7 +1899,7 @@ function identifyChunkSpeaker(audioBuffer: Buffer, sessionId: string, chunkIndex
     console.log(`[speaker] Embedding: ${speaker} vs Amplitude: ${clientSpeaker} (sim: ${embeddingResult.similarity.toFixed(2)})`)
   }
 
-  if (embeddingResult.similarity >= 0.72 && speaker !== 'Ext') {
+  if (embeddingResult.similarity >= AUTO_ENROLL_CANDIDATE_SIMILARITY && speaker !== 'Ext') {
     const enrollResult = autoEnroll(speaker, audioBuffer, embeddingResult.similarity, sessionId)
     if (enrollResult.enrolled) {
       console.log(`[speaker] Auto-enrolled ${speaker} from G2 mic (sim: ${embeddingResult.similarity.toFixed(3)})`)