@gotcos/glasses-server 6.79.0 → 6.79.2

package/server/routes/prompt-drafts.ts

@@ -2,8 +2,7 @@ import { isDictationCleanModel, type DictationCleanModel } from '../lib/dictatio
 import { Router } from 'express'
 import { createHash } from 'node:crypto'
 import type { Response } from 'express'
-import { existsSync, mkdirSync, readFileSync } from 'node:fs'
-import { resolve, dirname } from 'node:path'
+import { resolve } from 'node:path'
 import {
   createPromptDraft,
   loadPromptDraftMeta,
@@ -43,11 +42,16 @@ import { transcribeWhisperPreview } from '../lib/whisper-preview.js'
 import { currentDictationPlan, runParakeetDictation } from '../lib/dictation-stt.js'
 import { dictationSlotForMode, legacyDictationKey, type DictationPlan } from '../lib/stt-settings.js'
 import { autoCleanDictation, AUTOCLEAN_MAX_CHARS } from '../lib/dictation-clean.js'
+import { fillerPassEnabled, stripDisfluencies } from '../lib/dictation-fillers.js'
+import { polishBudgetExhausted, recordPolishCall, type PolishBucket } from '../lib/dictation-polish-budget.js'
+import { polishNeed, skipCleanEnabled } from '../lib/dictation-polish-need.js'
+import {
+  discardPolishPrewarm, isPrewarmModel, prewarmEnabled, PrewarmUnavailableError, runWarmPolish,
+  startPolishPrewarm, takePolishPrewarm,
+} from '../lib/dictation-prewarm.js'
 import { getVocabulary } from '../lib/profile.js'
 import { createBreaker } from '../lib/claude-circuit.js'
 import { logTokenAudit } from '../lib/token-audit.js'
-import { atomicWriteFileSync } from '../lib/atomic-fs.js'
-import { dataPath } from '../lib/data-dir.js'
 import { emitDisplay } from '../lib/display-bus.js'
 import {
   acquireMaintenanceWork,
@@ -83,26 +87,12 @@ const autoCleanBreakers = {
   'luna-5.6-fast': createBreaker({ label: 'dictation-autoclean-luna' }),
   haiku: createBreaker({ label: 'dictation-autoclean-haiku' }),
 }
-const autoCleanCountFile = () => process.env.COS_DICTATION_AUTOCLEAN_COUNT_FILE || dataPath('.dictation_autoclean_count.json')
 const autoCleanDefaultEnabled = () => ['1', 'true', 'on'].includes((process.env.COS_DICTATION_AUTOCLEAN ?? '').toLowerCase())
-const autoCleanDailyCap = () => {
-  const value = Number.parseInt(process.env.COS_DICTATION_AUTOCLEAN_MAX_PER_DAY || '200', 10)
-  return Number.isFinite(value) && value > 0 ? value : 200
-}
-function autoCleanCountToday(): number {
-  try {
-    const raw = JSON.parse(readFileSync(autoCleanCountFile(), 'utf-8'))
-    if (raw?.date === new Date().toISOString().slice(0, 10) && Number.isFinite(raw?.count)) return raw.count
-  } catch {}
-  return 0
-}
-function recordAutoCleanCall(): void {
-  try {
-    const file = autoCleanCountFile()
-    if (!existsSync(dirname(file))) mkdirSync(dirname(file), { recursive: true })
-    atomicWriteFileSync(file, JSON.stringify({ date: new Date().toISOString().slice(0, 10), count: autoCleanCountToday() + 1 }), { mode: 0o600 })
-  } catch {}
-}
+
+/** 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'
+/** 6.79.2, additive when finalize was given a prewarmToken: what became of that warm process. */
+export type PrewarmOutcome = 'used' | 'missed' | 'discarded'
 
 interface AutoCleanRequest { enabled?: boolean; model?: DictationCleanModel }
 function routeAutoClean(req: { body?: any; query?: any }): AutoCleanRequest {
@@ -114,7 +104,22 @@ function routeAutoClean(req: { body?: any; query?: any }): AutoCleanRequest {
   return { enabled, model: isDictationCleanModel(rawModel) ? rawModel : undefined }
 }
 
-async function cleanOutboundDictation(text: string, opts: AutoCleanRequest & { signal?: AbortSignal }): Promise<string> {
+async function cleanOutboundDictation(
+  text: string,
+  opts: AutoCleanRequest & { bucket: PolishBucket; signal?: AbortSignal; prewarmToken?: string },
+): Promise<{ text: string; polishSkipped?: PolishSkipped; prewarm?: PrewarmOutcome }> {
+  const result = await polishOutboundDictation(text, opts)
+  // A warm process the model call did not take must not sit until its TTL.
+  if (opts.prewarmToken && !result.prewarm) {
+    return { ...result, prewarm: discardPolishPrewarm(opts.prewarmToken) ? 'discarded' : 'missed' }
+  }
+  return result
+}
+
+async function polishOutboundDictation(
+  text: string,
+  opts: AutoCleanRequest & { bucket: PolishBucket; signal?: AbortSignal; prewarmToken?: string },
+): Promise<{ text: string; polishSkipped?: PolishSkipped; prewarm?: PrewarmOutcome }> {
   let cleaned = applyNegativeRules(applyCorrections(text)).replace(/\s+/g, ' ').trim() || text
   // applyCorrections above is an EXACT string map, so it only fixes misspellings someone
   // already hand-authored. A novel miss ("Rileyy" for Riley, "Exampel" for Example) sails
@@ -137,24 +142,43 @@ async function cleanOutboundDictation(text: string, opts: AutoCleanRequest & { s
   } catch (fuzzyErr: any) {
     console.warn(`[prompt-draft] Fuzzy correction failed (non-fatal): ${fuzzyErr?.message ?? fuzzyErr}`)
   }
-  if (!(opts.enabled ?? autoCleanDefaultEnabled())) return cleaned
+  // 6.79.1: um/uh never survive a skipped polish. Meeting lines stay faithful.
+  if (opts.bucket !== 'meeting' && fillerPassEnabled()) cleaned = stripDisfluencies(cleaned)
+  if (!(opts.enabled ?? autoCleanDefaultEnabled())) return { text: cleaned, polishSkipped: 'disabled' }
   const model = opts.model ?? 'haiku'
   const autoCleanBreaker = autoCleanBreakers[model]
-  if (cleaned.length > AUTOCLEAN_MAX_CHARS || autoCleanBreaker.isOpen() || autoCleanCountToday() >= autoCleanDailyCap()) return cleaned
+  if (cleaned.length > AUTOCLEAN_MAX_CHARS) return { text: cleaned, polishSkipped: 'too_long' }
+  // 6.79.2, off by default: nothing for the model to fix (see dictation-polish-need.ts).
+  if (skipCleanEnabled() && polishNeed(cleaned) === null) return { text: cleaned, polishSkipped: 'clean' }
+  if (autoCleanBreaker.isOpen()) return { text: cleaned, polishSkipped: 'breaker_open' }
+  if (polishBudgetExhausted(opts.bucket)) return { text: cleaned, polishSkipped: 'daily_cap' }
   const startedAt = Date.now()
-  recordAutoCleanCall()
+  recordPolishCall(opts.bucket)
+  // 6.79.2: a warm process started at key press answers without the CLI's start-up cost.
+  const warmEntry = opts.prewarmToken ? takePolishPrewarm(opts.prewarmToken, model) : null
+  let prewarm: PrewarmOutcome | undefined = opts.prewarmToken ? 'missed' : undefined
   try {
-    const polished = (await autoCleanDictation(cleaned, getVocabulary(), { model, signal: opts.signal })).trim()
+    let polished: string | null = null
+    if (warmEntry) {
+      try {
+        polished = (await runWarmPolish(warmEntry, cleaned, getVocabulary(), { signal: opts.signal })).trim()
+        prewarm = 'used'
+      } catch (err) {
+        // Nothing was sent: the cold path below is the same call, not a second one.
+        if (!(err instanceof PrewarmUnavailableError)) throw err
+      }
+    }
+    if (polished === null) polished = (await autoCleanDictation(cleaned, getVocabulary(), { model, signal: opts.signal })).trim()
     autoCleanBreaker.recordSuccess()
     logTokenAudit({
       source: 'g2-dictation-autoclean', model, inputChars: cleaned.length, outputChars: polished.length,
-      durationMs: Date.now() - startedAt, caller: 'dictation_autoclean',
+      durationMs: Date.now() - startedAt, caller: `dictation_autoclean_${opts.bucket}`,
     })
-    return polished || cleaned
+    return { text: polished || cleaned, ...(prewarm ? { prewarm } : {}) }
   } catch (err: any) {
     autoCleanBreaker.recordFailure()
     console.warn(`[prompt-draft] auto-clean failed (glossary-only): ${err?.message ?? err}`)
-    return cleaned
+    return { text: cleaned, polishSkipped: 'failed', ...(prewarm ? { prewarm } : {}) }
   }
 }
 
@@ -175,15 +199,50 @@ promptDraftsRouter.post('/dictation/finalize', async (req, res) => {
   if (model !== undefined && !isDictationCleanModel(model)) {
     return res.status(400).json({ error: 'invalid_autoclean_model' })
   }
+  const rawToken = req.body?.prewarmToken
+  if (rawToken !== undefined && (typeof rawToken !== 'string' || !PREWARM_TOKEN.test(rawToken))) {
+    return res.status(400).json({ error: 'invalid_prewarm_token' })
+  }
 
   const abort = new AbortController()
   res.on('close', () => { if (!res.writableEnded) abort.abort() })
-  const finalText = await cleanOutboundDictation(text, {
+  const { text: finalText, polishSkipped, prewarm } = await cleanOutboundDictation(text, {
     enabled: true,
     model,
+    bucket: surface,
     signal: abort.signal,
+    prewarmToken: rawToken,
   })
-  res.json({ text: finalText, surface, polished: finalText !== text })
+  // 6.79.1: polishSkipped only when the model did not polish, so a polished answer is unchanged.
+  // 6.79.2: prewarm only when the request carried a prewarmToken.
+  res.json({
+    text: finalText, surface, polished: finalText !== text,
+    ...(polishSkipped ? { polishSkipped } : {}), ...(prewarm ? { prewarm } : {}),
+  })
+})
+
+const PREWARM_TOKEN = /^[0-9a-f-]{36}$/
+
+/** 6.79.2: start the polish process at key press. Fire and forget: every refusal is a normal
+ * answer, and finalize without a token (or with a dead one) spawns as before. */
+promptDraftsRouter.post('/dictation/polish/prewarm', (req, res) => {
+  const model = req.body?.model ?? 'haiku'
+  const surface = req.body?.surface ?? 'message'
+  if (!isDictationCleanModel(model)) return res.status(400).json({ error: 'invalid_autoclean_model' })
+  if (surface !== 'message' && surface !== 'meeting') return res.status(400).json({ error: 'invalid_surface' })
+  if (!prewarmEnabled()) return res.status(409).json({ error: 'prewarm_unavailable', reason: 'disabled' })
+  if (!isPrewarmModel(model)) return res.status(409).json({ error: 'prewarm_unavailable', reason: 'model' })
+  if (autoCleanBreakers[model].isOpen()) return res.status(409).json({ error: 'prewarm_unavailable', reason: 'breaker_open' })
+  if (polishBudgetExhausted(surface)) return res.status(409).json({ error: 'prewarm_unavailable', reason: 'daily_cap' })
+  try {
+    res.json(startPolishPrewarm(model))
+  } catch (err: any) {
+    res.status(409).json({ error: 'prewarm_unavailable', reason: 'cli' })
+  }
+})
+
+promptDraftsRouter.delete('/dictation/polish/prewarm/:token', (req, res) => {
+  res.json({ discarded: discardPolishPrewarm(req.params.token) })
 })
 
 async function readRawBody(req: AsyncIterable<Buffer | Uint8Array | string>): Promise<Buffer> {
@@ -446,7 +505,7 @@ async function finalizeDraft(draftId: string, mode: 'hq' | 'fast', autoClean: Au
     await markPromptDraftError(draftId, 'No speech detected')
     throw new NoSpeechDetectedError()
   }
-  const finalText = await cleanOutboundDictation(text, { ...autoClean, signal })
+  const { text: finalText, polishSkipped } = await cleanOutboundDictation(text, { ...autoClean, bucket: 'prompt_draft', signal })
   const finalized = await markPromptDraftFinalized(draftId, finalText)
   const qualities = transcriptRecords.map(record => record.actualQuality)
   const actualQuality: 'hq' | 'fast' | 'cloud' = qualities.includes('cloud')
@@ -474,6 +533,8 @@ async function finalizeDraft(draftId: string, mode: 'hq' | 'fast', autoClean: Au
     // 6.73.0, additive.
     engine: engines.length === 1 ? engines[0] : engines.length === 0 ? plan.engine : 'mixed',
     ...(engineReason ? { engineReason } : {}),
+    // 6.79.1, additive.
+    ...(polishSkipped ? { polishSkipped } : {}),
   }
 }