@gotcos/glasses-server 6.79.1 → 6.80.0

package/server/routes/prompt-drafts.ts

@@ -44,6 +44,11 @@ import { dictationSlotForMode, legacyDictationKey, type DictationPlan } from '..
 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'
@@ -85,7 +90,9 @@ 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'
+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 {
@@ -99,8 +106,20 @@ function routeAutoClean(req: { body?: any; query?: any }): AutoCleanRequest {
 
 async function cleanOutboundDictation(
   text: string,
-  opts: AutoCleanRequest & { bucket: PolishBucket; signal?: AbortSignal },
-): Promise<{ text: string; polishSkipped?: PolishSkipped }> {
+  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
@@ -129,22 +148,37 @@ async function cleanOutboundDictation(
   const model = opts.model ?? 'haiku'
   const autoCleanBreaker = autoCleanBreakers[model]
   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()
   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_${opts.bucket}`,
     })
-    return { text: 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 { text: cleaned, polishSkipped: 'failed' }
+    return { text: cleaned, polishSkipped: 'failed', ...(prewarm ? { prewarm } : {}) }
   }
 }
 
@@ -165,17 +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 { text: finalText, polishSkipped } = await cleanOutboundDictation(text, {
+  const { text: finalText, polishSkipped, prewarm } = await cleanOutboundDictation(text, {
     enabled: true,
     model,
     bucket: surface,
     signal: abort.signal,
+    prewarmToken: rawToken,
   })
   // 6.79.1: polishSkipped only when the model did not polish, so a polished answer is unchanged.
-  res.json({ text: finalText, surface, polished: finalText !== text, ...(polishSkipped ? { polishSkipped } : {}) })
+  // 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> {

package/server/routes/query.ts

@@ -8,8 +8,9 @@ import { errMsg } from '../lib/utils.js'
 import {
   isCursorModel,
   normalizeEffortPreference,
-  normalizeModelPreference,
 } from '../../shared/model-preference.js'
+import { parsePreference } from '../../shared/key-preference.js'
+import type { KeyProfileTurn } from '../lib/key-profile-routing.js'
 import { QueryAttachmentError, resolveQueryAttachments } from '../lib/query-attachments.js'
 import { getMediaStore } from '../lib/media-store.js'
 import { mergeMediaAttachmentRefs } from '../../shared/media-attachment.js'
@@ -19,6 +20,8 @@ import {
   maintenanceErrorPayload,
 } from '../lib/maintenance-lifecycle.js'
 import { currentMessageEra, LEGACY_MESSAGE_ERA } from '../lib/message-era.js'
+import { keyAnswerDoneFields } from '../lib/key-answer-fields.js'
+import { isProfilePreference } from '../../shared/key-preference.js'
 
 const TOOL_STATUS_MESSAGES: Record<string, string> = {
   WebSearch: 'Searching web...',
@@ -92,8 +95,11 @@ queryRouter.post('/query', async (req, res) => {
     return res.status(400).json({ error: 'query string or attachment required' })
   }
 
-  // Validate model if provided
-  const validModel = normalizeModelPreference(model)
+  // Validate model if provided. Key lanes K1 (plan 5.2): Accept. A `profile:<id>` is passed to
+  // model-router as is (it runs on the profile or is refused there); every family guard below
+  // reads the closed slot, so a model slot behaves exactly as before.
+  const requestedBinding = parsePreference(model)
+  const validModel = requestedBinding?.kind === 'model' ? requestedBinding.value : undefined
   const validEffort = normalizeEffortPreference(effort)
 
   // Validate globalMsgNum if provided
@@ -136,12 +142,17 @@ queryRouter.post('/query', async (req, res) => {
     done = true
   })
 
+  // Set only by model-router's onKeyProfileTurn: the binding is the turn's model on the stream.
+  let keyTurn: KeyProfileTurn | undefined
   try {
     const sid = await callModelStreaming(resolvedQuery || '', sessionId, {
+      ...(requestedBinding?.kind === 'model' ? {} : {
+        onKeyProfileTurn: (turn: KeyProfileTurn) => { keyTurn = turn },
+      }),
       onStart: (model, sid, cliSessionId, metadata) => {
         streamSessionId = sid
         if (!done) {
-          const payload = { model, sessionId: sid, cliSessionId, ...metadata }
+          const payload = { model: keyTurn ? keyTurn.binding : model, sessionId: sid, cliSessionId, ...metadata }
           res.write(`event: start\ndata: ${JSON.stringify(payload)}\n\n`)
           emitDisplay({ type: 'start', data: payload })
         }
@@ -192,7 +203,8 @@ queryRouter.post('/query', async (req, res) => {
             const attachments = mergeMediaAttachmentRefs(attachmentRefs, metadata?.outputAttachments)
             const { outputAttachments: _outputAttachments, ...runMetadata } = metadata ?? {}
             const payload = {
-              text: fullText, sessionId: streamSessionId, model, cliSessionId, ...runMetadata,
+              text: fullText, sessionId: streamSessionId, model: keyTurn ? keyTurn.binding : model, cliSessionId, ...runMetadata,
+              ...keyAnswerDoneFields(runMetadata),
               ...(attachments.length > 0 ? { attachments } : {}),
             }
             res.write(`event: done\ndata: ${JSON.stringify(payload)}\n\n`)
@@ -215,7 +227,7 @@ queryRouter.post('/query', async (req, res) => {
           maintenanceLease.release()
         }
       },
-    }, validModel, imageInputs,
+    }, requestedBinding?.kind === 'profile' ? model as KeyProfileTurn['binding'] : validModel, imageInputs,
       // Pass reference if provided (for "recall message N" feature)
       reference && typeof reference === 'object' && reference.query && reference.response
         ? { query: String(reference.query), response: String(reference.response) }
@@ -228,6 +240,8 @@ queryRouter.post('/query', async (req, res) => {
         requestAttachments: attachmentRefs,
         attachmentPromptBlock: resolvedAttachments.promptBlock,
         ...(validModel && isCursorModel(validModel) ? { cursorExecutionMode } : {}),
+        // QA U9: the one-turn plan-limit offer runs on the key without binding the session.
+        ...(req.body.keyTurnOnly === true && isProfilePreference(model) ? { keyTurnOnly: true } : {}),
       },
     )
   } catch (err: unknown) {

package/shared/key-preference.ts

@@ -0,0 +1,57 @@
+// Key lanes (K1, plan v4 section 5.1): the ONE parser that may read a key profile out of a model
+// preference. `isModelPreference` and `normalizeModelPreference` (model-preference.ts) stay
+// closed and unchanged, so every site that does not call parsePreference keeps refusing a
+// profile exactly as 6.79.0 does. Call this only at the sites plan 5.2 marks Accept.
+//
+// Encoding: a profile-bound preference is `profile:<id>`. The prefix keeps a profile id from ever
+// colliding with a model slot name (`opus` is a valid id shape). On `/v1` a profile is offered as
+// `cos-key-<id>` (plan 9.4), handled before `resolveModel` and only for profiles that opt in.
+import { normalizeModelPreference, type ModelPreference } from './model-preference.js'
+
+export const KEY_PROFILE_ID_RE = /^[a-z0-9][a-z0-9-]{0,31}$/
+export const KEY_PROFILE_PREFERENCE_PREFIX = 'profile:'
+export const V1_KEY_MODEL_PREFIX = 'cos-key-'
+
+export type ParsedPreference =
+  | { kind: 'model'; value: ModelPreference }
+  | { kind: 'profile'; id: string }
+
+export function isKeyProfileId(value: unknown): value is string {
+  return typeof value === 'string' && KEY_PROFILE_ID_RE.test(value)
+}
+
+/** `profile:<id>`, or throws on a malformed id (a caller bug, never user input). */
+export function profilePreference(id: string): string {
+  if (!isKeyProfileId(id)) throw new Error('invalid key profile id')
+  return KEY_PROFILE_PREFERENCE_PREFIX + id
+}
+
+/**
+ * A model slot (normalized exactly as normalizeModelPreference does, so `codex-high` still
+ * migrates), a `profile:<id>`, or undefined for anything else. Never throws.
+ */
+export function parsePreference(value: unknown): ParsedPreference | undefined {
+  const model = normalizeModelPreference(value)
+  if (model) return { kind: 'model', value: model }
+  if (typeof value !== 'string' || !value.startsWith(KEY_PROFILE_PREFERENCE_PREFIX)) return undefined
+  const id = value.slice(KEY_PROFILE_PREFERENCE_PREFIX.length)
+  return isKeyProfileId(id) ? { kind: 'profile', id } : undefined
+}
+
+/** True only for a well-formed `profile:<id>`. A model slot is false. */
+export function isProfilePreference(value: unknown): boolean {
+  return parsePreference(value)?.kind === 'profile'
+}
+
+/** `/v1` model name for a profile (plan 9.4). */
+export function v1KeyModelName(id: string): string {
+  if (!isKeyProfileId(id)) throw new Error('invalid key profile id')
+  return V1_KEY_MODEL_PREFIX + id
+}
+
+/** The profile id in a `cos-key-<id>` `/v1` model name, or undefined. */
+export function parseV1KeyModelName(value: unknown): string | undefined {
+  if (typeof value !== 'string' || !value.startsWith(V1_KEY_MODEL_PREFIX)) return undefined
+  const id = value.slice(V1_KEY_MODEL_PREFIX.length)
+  return isKeyProfileId(id) ? id : undefined
+}

package/shared/model-preference.ts

@@ -208,7 +208,23 @@ export function resetRuntimeCursorModelLabels(): void {
   delete runtimeCursorLabels[CURSOR_COMPOSER_MODEL]
 }
 
-export function modelLabel(model: ModelPreference): string {
+/**
+ * Key lanes K1 (plan 5.2 labels): a caller that renders a key-profile turn passes the profile
+ * record, and its label wins. With no profile passed every label below is the 6.79.0 one,
+ * including the `'Opus'` default. `isModelPreference` stays closed: a profile is never a slot.
+ */
+export interface ModelLabelProfile {
+  label: string
+}
+
+function profileLabel(profile: ModelLabelProfile | undefined, max: number): string | undefined {
+  const label = typeof profile?.label === 'string' ? profile.label.trim() : ''
+  return label ? Array.from(label).slice(0, max).join('') : undefined
+}
+
+export function modelLabel(model: ModelPreference, profile?: ModelLabelProfile): string {
+  const fromProfile = profileLabel(profile, 40)
+  if (fromProfile) return fromProfile
   switch (model) {
     case 'fable': return 'Fable'
     case 'sonnet': return 'Sonnet'
@@ -224,7 +240,9 @@ export function modelLabel(model: ModelPreference): string {
   }
 }
 
-export function modelShortLabel(model: ModelPreference): string {
+export function modelShortLabel(model: ModelPreference, profile?: ModelLabelProfile): string {
+  const fromProfile = profileLabel(profile, 12)
+  if (fromProfile) return fromProfile
   switch (model) {
     case 'fable': return 'Fable'
     case 'sonnet': return 'Sonnet'