@gotcos/glasses-server 6.15.5 → 6.16.1

package/server/lib/whisper-local.ts

@@ -42,6 +42,49 @@ export interface WhisperSegment {
   words?: WhisperWord[]
 }
 
+export type HighQualityUnavailableReason =
+  | 'hq_disabled'
+  | 'whisper_cli_missing'
+  | 'turbo_model_missing'
+  | 'large_v3_model_missing'
+
+export interface HighQualityTranscriptionCapability {
+  hqAvailable: boolean
+  model: 'large-v3' | null
+  backend: 'whisper-cli' | null
+  reason: HighQualityUnavailableReason | null
+}
+
+export interface HighQualityTranscriptionResult {
+  text: string
+  words?: WhisperWord[]
+  model: 'large-v3' | 'turbo'
+  backend: 'whisper-cli' | 'whisper-server'
+  actualQuality: 'hq' | 'fast'
+  degradationReason?: HighQualityUnavailableReason
+}
+
+export function classifyHighQualityTranscriptionCapability(input: {
+  enabled: boolean
+  cliPresent: boolean
+  turboReady: boolean
+  largeV3Present: boolean
+}): HighQualityTranscriptionCapability {
+  if (!input.enabled) {
+    return { hqAvailable: false, model: null, backend: null, reason: 'hq_disabled' }
+  }
+  if (!input.cliPresent) {
+    return { hqAvailable: false, model: null, backend: null, reason: 'whisper_cli_missing' }
+  }
+  if (!input.turboReady) {
+    return { hqAvailable: false, model: null, backend: null, reason: 'turbo_model_missing' }
+  }
+  if (!input.largeV3Present) {
+    return { hqAvailable: false, model: null, backend: null, reason: 'large_v3_model_missing' }
+  }
+  return { hqAvailable: true, model: 'large-v3', backend: 'whisper-cli', reason: null }
+}
+
 interface WhisperJsonResponse {
   text?: unknown
 }
@@ -554,6 +597,20 @@ export function getWhisperHealth(): {
   }
 }
 
+/** Public, path-free truth about whether an HQ request can actually run the
+ * full large-v3 decoder. Keep this separate from generic Whisper liveness: the
+ * persistent turbo server may be healthy while HQ weights or the CLI are not. */
+export function getHighQualityTranscriptionCapability(): HighQualityTranscriptionCapability {
+  // cliAvailable also proves the turbo model exists. That fallback is part of
+  // the current decoder contract and is initialized once at process startup.
+  return classifyHighQualityTranscriptionCapability({
+    enabled: BATCH_LARGE_V3_ENABLED,
+    cliPresent: existsSync(WHISPER_CLI),
+    turboReady: cliAvailable,
+    largeV3Present: existsSync(BATCH_MODEL_LARGE_V3),
+  })
+}
+
 /**
  * Reconcile a cached unavailable flag with the daemon's live health endpoint.
  * Only successful inference resets the failure count: /health can be responsive
@@ -641,10 +698,18 @@ export async function transcribeHighQuality(
   audioBuffer: Buffer,
   context?: string,
   opts: { priority?: 'interactive' | 'batch' } = {},
-): Promise<{ text: string; words?: WhisperWord[] }> {
+): Promise<HighQualityTranscriptionResult> {
   if (!cliAvailable) {
     // Fall back to server (no beam search available via HTTP API)
-    return transcribeLocal(audioBuffer, context)
+    const fallback = await transcribeLocal(audioBuffer, context)
+    return {
+      text: fallback.text,
+      words: fallback.words,
+      model: 'turbo',
+      backend: fallback.backend === 'server' ? 'whisper-server' : 'whisper-cli',
+      actualQuality: 'fast',
+      degradationReason: existsSync(WHISPER_CLI) ? 'turbo_model_missing' : 'whisper_cli_missing',
+    }
   }
 
   const start = Date.now()
@@ -769,7 +834,17 @@ export async function transcribeHighQuality(
       `${words ? `, ${words.length} words` : ''}): ` +
       `"${corrected.slice(0, 80)}${corrected.length > 80 ? '...' : ''}"`,
     )
-    return words ? { text: corrected, words } : { text: corrected }
+    const metadata = useLargeV3
+      ? { model: 'large-v3' as const, backend: 'whisper-cli' as const, actualQuality: 'hq' as const }
+      : {
+          model: 'turbo' as const,
+          backend: 'whisper-cli' as const,
+          actualQuality: 'fast' as const,
+          degradationReason: BATCH_LARGE_V3_ENABLED
+            ? 'large_v3_model_missing' as const
+            : 'hq_disabled' as const,
+        }
+    return words ? { text: corrected, words, ...metadata } : { text: corrected, ...metadata }
   } finally {
     try { unlinkSync(tmpWav) } catch { /* cleanup */ }
     if (captureBatchWords) {

package/server/routes/cli-debug.ts

@@ -8,6 +8,10 @@ import {
   getCodexRunConfig,
   listCodexRuns,
 } from '../lib/codex-run-ledger.js'
+import {
+  getCursorRunConfig,
+  listCursorRuns,
+} from '../lib/cursor-run-ledger.js'
 import {
   safeCliDebugResponse,
   safeLegacyClaudeResponse,
@@ -38,13 +42,17 @@ cliDebugRouter.get('/cli/debug', (req, res) => {
   const model = optionalClaudeModel(req.query.model)
   const claudeConfig = getClaudeRunConfig()
   const codexConfig = getCodexRunConfig()
+  const cursorConfig = getCursorRunConfig()
   const claudeRuns = listClaudeRuns(limit, sessionId, model)
   const codexRuns = listCodexRuns(limit, sessionId)
+  const cursorRuns = listCursorRuns(limit, sessionId)
   res.json(safeCliDebugResponse(
     claudeConfig,
     claudeRuns[0],
     codexConfig,
     codexRuns[0],
+    cursorConfig,
+    cursorRuns[0],
   ))
 })
 

package/server/routes/health.ts

@@ -8,13 +8,23 @@ import { getServerInstanceId } from '../lib/server-instance-id.js'
 import { localFirstMeetingsCapability } from '../lib/local-first-meetings-contract.js'
 import { isSileroAvailable } from '../lib/vad-silero.js'
 import { getAvailableCliSessionId } from '../lib/claude-bridge.js'
-import { isWhisperLocalAvailable, getWhisperHealth } from '../lib/whisper-local.js'
+import {
+  isWhisperLocalAvailable,
+  getWhisperHealth,
+  getHighQualityTranscriptionCapability,
+} from '../lib/whisper-local.js'
 import { getOpenAIWhisperBudgetState } from '../lib/openai-whisper-budget.js'
 import { getKeyStatus } from '../lib/openai-key.js'
 import {
   getCodexModelCatalog,
   getCodexModelCatalogSnapshot,
 } from '../lib/codex-model-catalog.js'
+import {
+  getCursorModelCatalog,
+  getCursorModelCatalogSnapshot,
+  isCursorProviderReady,
+  resolveAgentBinary,
+} from '../lib/cursor-model-catalog.js'
 import { isMediaProcessingReady } from '../lib/image-safety.js'
 import { G2_LENS_VARIANT_CAPABILITY } from '../lib/media-store.js'
 import { durableQueryJobsCapability } from '../lib/query-job-feature.js'
@@ -66,6 +76,7 @@ healthRouter.get('/health', async (_req, res) => {
     python: 'unknown',
     claude: 'unknown',
     codex: 'unknown',
+    cursor: 'unknown',
     uptime_seconds: Math.floor((Date.now() - serverMetrics.startedAt) / 1000),
     request_count: serverMetrics.requestCount,
   }
@@ -73,6 +84,7 @@ healthRouter.get('/health', async (_req, res) => {
   // Feature detection flags
   let claudeAvailable = false
   let codexAvailable = false
+  let cursorAvailable = false
 
   // Check Python venv (COS mode only)
   if (PYTHON_BIN) {
@@ -122,6 +134,36 @@ healthRouter.get('/health', async (_req, res) => {
     checks.codex = 'error'
   }
 
+  // Cursor Agent CLI — probe via `agent about` only (≤5s). Never use
+  // `agent status` (can hang on login UX while logged out).
+  try {
+    const agentBinary = resolveAgentBinary()
+    if (!agentBinary) {
+      checks.cursor = 'error'
+    } else {
+      await new Promise<void>((resolveCheck, reject) => {
+        execFile(agentBinary, ['about'], { timeout: 5000 }, (err, stdout, stderr) => {
+          if (err) return reject(err)
+          const combined = `${stdout}\n${stderr}`.trim()
+          const versionLine = combined.split('\n').map(line => line.trim()).find(line =>
+            /CLI Version|cursor|agent/i.test(line),
+          )
+          checks.cursor = versionLine ?? combined.split('\n')[0] ?? 'available'
+          resolveCheck()
+        })
+      })
+      await getCursorModelCatalog()
+      cursorAvailable = isCursorProviderReady()
+      if (!cursorAvailable) {
+        checks.cursor = typeof checks.cursor === 'string' && checks.cursor !== 'error'
+          ? `${checks.cursor} (models unresolved)`
+          : 'error'
+      }
+    }
+  } catch {
+    checks.cursor = 'error'
+  }
+
   // Check session cache freshness (COS mode only)
   if (COS_SCRIPTS_DIR) {
     try {
@@ -150,12 +192,14 @@ healthRouter.get('/health', async (_req, res) => {
   const durableJobs = durableQueryJobStatus()
   const localFirstMeetings = localFirstMeetingsCapability(getServerInstanceId())
   const transcription = getTranscriptionPolicySnapshot()
+  const transcriptionHq = getHighQualityTranscriptionCapability()
   const recovery = managedRuntimeCapability()
   const maintenance = maintenanceLifecycle.snapshot()
   const tts_local = getLocalTtsHealth()
   const features = {
     claude: claudeAvailable,
     codex: codexAvailable,
+    cursor: cursorAvailable,
     voice: keyStatus.hasKey || tts_local.ready,
     cos_pipeline: COS_MODE,
     whisper: isWhisperLocalAvailable(),
@@ -199,6 +243,10 @@ healthRouter.get('/health', async (_req, res) => {
   }
   const openai_whisper_budget = getOpenAIWhisperBudgetState()
   const codex_models = getCodexModelCatalogSnapshot()
+  // Unauthenticated /api/health publishes Cursor slot capability only; concrete
+  // agent binary paths stay on the authenticated /api/models surface.
+  const cursorSnapshot = getCursorModelCatalogSnapshot()
+  const { agentBinary: _cursorAgentBinary, ...cursor_models } = cursorSnapshot
   res.json({
     ...checks,
     server_version: managedServerVersion(),
@@ -212,8 +260,9 @@ healthRouter.get('/health', async (_req, res) => {
     openai_whisper_budget,
     tts_local,
     codex_models,
+    cursor_models,
     capabilities: {
-      transcription,
+      transcription: { ...transcription, hq: transcriptionHq },
       recovery,
       maintenance: {
         state: maintenance.state,
@@ -235,29 +284,38 @@ healthRouter.get('/health', async (_req, res) => {
   })
 })
 
-// Stable app slots backed by Codex's live model/list catalog. This route is
-// authenticated by the global /api middleware; ?refresh=1 forces discovery.
+// Stable app slots backed by Codex + Cursor live catalogs. Authenticated by
+// global /api middleware; ?refresh=1 forces discovery.
 healthRouter.get('/models', async (req, res) => {
-  const catalog = await getCodexModelCatalog(req.query.refresh === '1')
+  const forceRefresh = req.query.refresh === '1'
+  const catalog = await getCodexModelCatalog(forceRefresh)
+  const cursorCatalog = await getCursorModelCatalog(forceRefresh)
   const durableJobs = durableQueryJobStatus()
   const localFirstMeetings = localFirstMeetingsCapability(getServerInstanceId())
   const transcription = getTranscriptionPolicySnapshot()
+  const transcriptionHq = getHighQualityTranscriptionCapability()
+  const cursorOptions = cursorCatalog.options.filter(option => !!option.id)
   res.json({
     ...catalog,
+    options: [
+      ...(catalog.options ?? []),
+      ...cursorOptions,
+    ],
+    cursor: cursorCatalog,
+    cursorReady: isCursorProviderReady(),
     serverInstanceId: getServerInstanceId(),
     capabilities: {
       durableQueryJobs: {
         enabled: durableJobs.enabled,
         protocolVersion: durableJobs.protocolVersion,
       },
-      transcription,
+      transcription: { ...transcription, hq: transcriptionHq },
       cliDebug: CLI_DEBUG_CAPABILITY,
       recovery: managedRuntimeCapability(),
       ...(localFirstMeetings ? { localFirstMeetings } : {}),
     },
   })
 })
-
 // GET /api/cli-session — returns current CLI session ID for cross-device resume
 healthRouter.get('/cli-session', (req, res) => {
   const cosSessionId = req.query.sid as string | undefined

package/server/routes/openai-compat.ts

@@ -11,7 +11,9 @@ import {
   getCodexModelCatalog,
   resolveCodexPreferenceForModelId,
 } from '../lib/codex-model-catalog.js'
+import { resolveCursorPreferenceForModelId } from '../lib/cursor-model-catalog.js'
 import { tryInstantResponse } from '../lib/response-cache.js'
+
 import crypto from 'node:crypto'
 import { timingSafeTokenEqual } from '../lib/token-auth.js'
 import {
@@ -80,14 +82,31 @@ function validateAuth(req: any, res: any): boolean {
   return true
 }
 
+/**
+ * Pick the model id an OpenAI-compatible request asked for. A `?model=` on the
+ * completion URL wins over the request body, so an Even "Add Agent" endpoint
+ * can pin a slot even though the client hardcodes a generic body model.
+ */
+export function selectOpenAICompatibleModel(
+  bodyModel?: string,
+  urlModel?: string,
+): string | undefined {
+  const fromUrl = urlModel?.trim()
+  if (fromUrl) return fromUrl
+  const fromBody = bodyModel?.trim()
+  return fromBody || undefined
+}
+
 // Resolve model from OpenAI-compatible ids, stable app slots, or concrete ids
-// currently advertised by the live Codex catalog.
-function resolveModel(model?: string, _query?: string): ModelPreference {
+// currently advertised by the live Codex / Cursor catalogs.
+export function resolveModel(model?: string, _query?: string): ModelPreference {
   const normalized = normalizeModelPreference(model)
   if (normalized) return normalized
   if (model) {
     const catalogPreference = resolveCodexPreferenceForModelId(model)
     if (catalogPreference) return catalogPreference
+    const cursorPreference = resolveCursorPreferenceForModelId(model)
+    if (cursorPreference) return cursorPreference
   }
   if (model === 'cos-opus') return 'opus'
   if (model === 'cos-fable') return 'fable'
@@ -105,8 +124,9 @@ const MODEL_NAMES: Record<ModelPreference, string> = {
   haiku: 'cos-haiku',
   'codex-frontier': 'cos-gpt-frontier',
   'codex-balanced': 'cos-gpt-balanced',
+  'cursor-grok': 'cursor-grok',
+  'cursor-composer': 'cursor-composer',
 }
-
 // Extract the user's latest message from the OpenAI messages array
 function extractUserQuery(messages: Array<{ role: string; content: string }>): string {
   // Find the last user message
@@ -162,7 +182,11 @@ openaiCompatRouter.post('/v1/chat/completions', async (req, res) => {
   console.log(`[g2] Request: stream=${!!stream}, query="${query.slice(0, 50)}"`)
 
   const requestReceivedAt = Date.now()
-  const resolvedModel = resolveModel(model, query)
+  const selectedModel = selectOpenAICompatibleModel(
+    model,
+    typeof req.query.model === 'string' ? req.query.model : undefined,
+  )
+  const resolvedModel = resolveModel(selectedModel, query)
   const completionId = `chatcmpl-${crypto.randomUUID().slice(0, 12)}`
   const timestamp = Math.floor(Date.now() / 1000)
   const responseModel = MODEL_NAMES[resolvedModel]

package/server/routes/prompt-drafts.ts

@@ -199,6 +199,7 @@ async function transcribeChunk(draftId: string, chunkIndex: number, audio: Buffe
             actualQuality: warm?.actualQuality ?? (mode === 'hq' ? 'hq' : 'fast'),
             backend: warm?.backend ?? 'shared-inflight',
             degraded: warm?.degraded ?? false,
+            ...(warm?.degradationReason ? { degradationReason: warm.degradationReason } : {}),
           }, 'final')
         }
       }
@@ -221,6 +222,7 @@ async function transcribeChunk(draftId: string, chunkIndex: number, audio: Buffe
       const record: PromptDraftTranscriptRecord = {
         text, hash, requestedMode: result.requestedMode, actualQuality: result.actualQuality,
         backend: result.backend, degraded: result.degraded,
+        ...(result.degradationReason ? { degradationReason: result.degradationReason } : {}),
       }
       await markPromptDraftChunkTranscript(draftId, chunkIndex, record, purpose)
       console.log(`[prompt-draft] chunk ${draftId}/${chunkIndex}: ${result.elapsedMs.toFixed(1)}ms | ${result.backend} | ${purpose}/${mode} | ${text.length} chars`)
@@ -247,6 +249,7 @@ async function finalizeDraft(draftId: string, mode: 'hq' | 'fast', autoClean: Au
   const meta = loadPromptDraftMeta(draftId)
   if (!meta) throw Object.assign(new Error('draft not found'), { status: 404 })
   const texts: string[] = []
+  const transcriptRecords: PromptDraftTranscriptRecord[] = []
   for (const chunk of readPromptDraftChunks(draftId)) {
     try {
       const hash = audioHash(chunk.audioBuffer)
@@ -259,10 +262,27 @@ async function finalizeDraft(draftId: string, mode: 'hq' | 'fast', autoClean: Au
       }
       const current = loadPromptDraftMeta(draftId)
       const cached = current?.finalTranscripts?.[String(chunk.chunkIndex)] ?? current?.warmTranscripts?.[String(chunk.chunkIndex)]
-      const reusable = Boolean(cached && cached.hash === hash && (mode === 'fast' ? cached.actualQuality === 'fast' : cached.actualQuality === 'hq'))
+      // Reuse the exact requested-mode decode even when HQ truthfully degraded
+      // to turbo. Finalize's automatic policy would make the same local choice
+      // again after a successful turbo result, so a second decode adds latency
+      // without improving quality. Legacy records stay excluded because their
+      // decoder provenance was reconstructed during migration.
+      const reusable = Boolean(
+        cached
+        && cached.hash === hash
+        && cached.requestedMode === mode
+        && !cached.backend.startsWith('legacy'),
+      )
       const raw = reusable ? cached!.text : await transcribeChunk(draftId, chunk.chunkIndex, chunk.audioBuffer, mode, 'final')
       const text = sanitizeTranscript(draftId, raw, !reusable)
-      if (text.trim()) texts.push(text.trim())
+      if (text.trim()) {
+        texts.push(text.trim())
+        const latest = loadPromptDraftMeta(draftId)
+        const used = latest?.finalTranscripts?.[String(chunk.chunkIndex)]
+          ?? latest?.warmTranscripts?.[String(chunk.chunkIndex)]
+          ?? cached
+        if (used && used.hash === hash) transcriptRecords.push(used)
+      }
     } catch (err) {
       if (err instanceof NoSpeechDetectedError) continue
       throw err
@@ -275,7 +295,28 @@ async function finalizeDraft(draftId: string, mode: 'hq' | 'fast', autoClean: Au
   }
   const finalText = await cleanOutboundDictation(text, { ...autoClean, signal })
   const finalized = await markPromptDraftFinalized(draftId, finalText)
-  return { draftId, text: finalText, recovered: true, chunkCount: finalized.receivedChunkIndexes.length, missingChunks: getMissingChunkIndexes(finalized), expiresAt: finalized.expiresAt }
+  const qualities = transcriptRecords.map(record => record.actualQuality)
+  const actualQuality: 'hq' | 'fast' | 'cloud' = qualities.includes('cloud')
+    ? 'cloud'
+    : qualities.length > 0 && qualities.every(quality => quality === 'hq')
+      ? 'hq'
+      : 'fast'
+  const degraded = mode === 'hq' && (actualQuality !== 'hq' || transcriptRecords.some(record => record.degraded))
+  const backends = [...new Set(transcriptRecords.map(record => record.backend))]
+  const degradationReason = transcriptRecords.find(record => record.degradationReason)?.degradationReason
+  return {
+    draftId,
+    text: finalText,
+    recovered: true,
+    chunkCount: finalized.receivedChunkIndexes.length,
+    missingChunks: getMissingChunkIndexes(finalized),
+    expiresAt: finalized.expiresAt,
+    requestedMode: mode,
+    actualQuality,
+    degraded,
+    backend: backends.length === 1 ? backends[0] : 'mixed',
+    ...(degradationReason ? { degradationReason } : {}),
+  }
 }
 
 const prunedAtBoot = maintenanceAdmissionsOpen() ? prunePromptDrafts() : 0

package/server/routes/transcribe.ts

@@ -44,7 +44,15 @@ transcribeRouter.post('/transcribe', async (req, res) => {
 
     const result = await transcribeAudioBuffer(audioBuffer, { mode: resolveMode(req) })
     console.log(`[perf] /transcribe: ${result.elapsedMs.toFixed(1)}ms | mode=${result.mode} | ${result.backend} | ${result.audioBytes}b | ${result.text.length} chars`)
-    res.json({ text: result.text, backend: result.backend, mode: result.mode })
+    res.json({
+      text: result.text,
+      backend: result.backend,
+      mode: result.mode,
+      requestedMode: result.requestedMode,
+      actualQuality: result.actualQuality,
+      degraded: result.degraded,
+      ...(result.degradationReason ? { degradationReason: result.degradationReason } : {}),
+    })
   } catch (err: any) {
     if (err instanceof MaintenanceLifecycleError) {
       if (err.retryAfterSeconds != null) res.setHeader('Retry-After', String(err.retryAfterSeconds))

package/shared/model-preference.ts

@@ -3,7 +3,19 @@ export type ClaudeModelPreference = 'opus' | 'fable' | 'sonnet' | 'haiku'
 // Stable app-level slots. Concrete GPT model ids resolve at runtime from the
 // local Codex CLI catalog, so a shipped glasses app keeps tracking new releases.
 export type CodexModelPreference = 'codex-frontier' | 'codex-balanced'
-export type ModelPreference = ClaudeModelPreference | CodexModelPreference
+// Cursor Agent CLI slots. Concrete ids (composer-2.5 / cursor-grok-4.5-high)
+// resolve from `agent models` at runtime. Slots stay recognized in normalize
+// even when features.cursor is false so version skew fail-closes instead of
+// silently remapping to Claude.
+export type CursorModelPreference = 'cursor-grok' | 'cursor-composer'
+/** Cursor Agent CLI execution posture for glasses queries. */
+export type CursorExecutionMode = 'ask' | 'agent'
+export type ModelPreference = ClaudeModelPreference | CodexModelPreference | CursorModelPreference
+
+/** Invalid/omitted → ask (safe for old clients that don't send a mode). */
+export function normalizeCursorExecutionMode(value: unknown): CursorExecutionMode {
+  return value === 'agent' ? 'agent' : 'ask'
+}
 
 // Preserve the public server's established fast, broadly available default.
 export const DEFAULT_MODEL = 'sonnet' as const
@@ -11,6 +23,8 @@ export const CODEX_FRONTIER_MODEL: CodexModelPreference = 'codex-frontier'
 export const CODEX_BALANCED_MODEL: CodexModelPreference = 'codex-balanced'
 // Backward-compatible export for callers that predate the two-slot catalog.
 export const CODEX_HIGH_MODEL: CodexModelPreference = CODEX_FRONTIER_MODEL
+export const CURSOR_GROK_MODEL: CursorModelPreference = 'cursor-grok'
+export const CURSOR_COMPOSER_MODEL: CursorModelPreference = 'cursor-composer'
 // Existing 6.1–6.3 installs may pin the legacy codex-high slot. Frontier is its
 // migration target; Balanced remains auto-catalog even when this override is set.
 export const CODEX_MODEL_ID = process.env.COS_CODEX_MODEL?.trim() ?? ''
@@ -33,6 +47,8 @@ export const MODEL_OPTIONS: ModelPreference[] = [
   'sonnet',
   CODEX_FRONTIER_MODEL,
   CODEX_BALANCED_MODEL,
+  CURSOR_GROK_MODEL,
+  CURSOR_COMPOSER_MODEL,
 ]
 
 const MODEL_SET = new Set<ModelPreference>([
@@ -42,6 +58,8 @@ const MODEL_SET = new Set<ModelPreference>([
   'haiku',
   CODEX_FRONTIER_MODEL,
   CODEX_BALANCED_MODEL,
+  CURSOR_GROK_MODEL,
+  CURSOR_COMPOSER_MODEL,
 ])
 
 // Bare Claude tier aliases resolve to the newest model in that tier at spawn.
@@ -127,12 +145,22 @@ export function isCodexModel(model: ModelPreference): model is CodexModelPrefere
   return model === CODEX_FRONTIER_MODEL || model === CODEX_BALANCED_MODEL
 }
 
+export function isCursorModel(model: ModelPreference): model is CursorModelPreference {
+  return model === CURSOR_GROK_MODEL || model === CURSOR_COMPOSER_MODEL
+}
+
 export interface RuntimeCodexModelLabel {
   preference: CodexModelPreference
   displayName: string
 }
 
+export interface RuntimeCursorModelLabel {
+  preference: CursorModelPreference
+  displayName: string
+}
+
 const runtimeCodexLabels: Partial<Record<CodexModelPreference, string>> = {}
+const runtimeCursorLabels: Partial<Record<CursorModelPreference, string>> = {}
 
 export function setRuntimeCodexModelLabels(options: RuntimeCodexModelLabel[]): void {
   for (const option of options) {
@@ -147,6 +175,19 @@ export function resetRuntimeCodexModelLabels(): void {
   delete runtimeCodexLabels[CODEX_BALANCED_MODEL]
 }
 
+export function setRuntimeCursorModelLabels(options: RuntimeCursorModelLabel[]): void {
+  for (const option of options) {
+    if (!isCursorModel(option.preference)) continue
+    const label = typeof option.displayName === 'string' ? option.displayName.trim() : ''
+    if (label) runtimeCursorLabels[option.preference] = label
+  }
+}
+
+export function resetRuntimeCursorModelLabels(): void {
+  delete runtimeCursorLabels[CURSOR_GROK_MODEL]
+  delete runtimeCursorLabels[CURSOR_COMPOSER_MODEL]
+}
+
 export function modelLabel(model: ModelPreference): string {
   switch (model) {
     case 'fable': return 'Fable'
@@ -154,6 +195,8 @@ export function modelLabel(model: ModelPreference): string {
     case 'haiku': return 'Haiku'
     case 'codex-frontier': return runtimeCodexLabels[model] ?? 'GPT Frontier'
     case 'codex-balanced': return runtimeCodexLabels[model] ?? 'GPT Balanced'
+    case 'cursor-grok': return runtimeCursorLabels[model] ?? 'Grok 4.5 Fast'
+    case 'cursor-composer': return runtimeCursorLabels[model] ?? 'Composer 2.5 Fast'
     case 'opus':
     default:
       return 'Opus'
@@ -167,6 +210,8 @@ export function modelShortLabel(model: ModelPreference): string {
     case 'haiku': return 'Haiku'
     case 'codex-frontier': return 'GPT Max'
     case 'codex-balanced': return 'GPT Bal'
+    case 'cursor-grok': return 'Grok'
+    case 'cursor-composer': return 'Composer'
     case 'opus':
     default:
       return 'Opus'
@@ -180,6 +225,8 @@ export function modelButtonLabel(model: ModelPreference): string {
     case 'haiku': return 'HAIKU'
     case 'codex-frontier': return 'GPT MAX'
     case 'codex-balanced': return 'GPT BAL'
+    case 'cursor-grok': return 'GROK'
+    case 'cursor-composer': return 'CMP'
     case 'opus':
     default:
       return 'OPUS'
@@ -193,12 +240,13 @@ export function modelTag(model: ModelPreference): string {
     case 'haiku': return 'H'
     case 'codex-frontier': return 'GF'
     case 'codex-balanced': return 'GB'
+    case 'cursor-grok': return 'GK'
+    case 'cursor-composer': return 'C2'
     case 'opus':
     default:
       return 'O'
   }
 }
-
 export function modelBracketTag(model: ModelPreference): string {
   return ` [${modelTag(model)}]`
 }