@gotcos/glasses-server 6.27.5 → 6.27.7

package/server/lib/context-library-search.ts

@@ -0,0 +1,346 @@
+/**
+ * Memory and Threads lookup for COS Control.
+ *
+ * Keyword: local title/body scan. No model.
+ * Memories meaning: existing `cos_memory` index via bot_memory.py — one query
+ * embedding, no LLM, never the meeting Qdrant collection.
+ * Threads have no embedding index — keyword still works, semanticAvailable is false.
+ */
+
+import { execFile } from 'node:child_process'
+import { existsSync, readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import { COS_SCRIPTS_DIR, PYTHON_BIN } from './python-bridge.js'
+import {
+  hasFileMemory,
+  hasFileThreads,
+  readFileMemories,
+  readFileThreads,
+  resolveContextFilesRoot,
+} from './context-files.js'
+import { scoreKeywordMatch, tokenizeMeetingQuery } from './meeting-library-search.js'
+
+const HEAD_BYTES = 8_000
+const MAX_SCAN_FILES = 2_000
+const SEMANTIC_TIMEOUT_MS = 15_000
+export const MEMORY_SEMANTIC_SCRIPT = 'bot_memory.py'
+
+export interface ContextSearchHit {
+  id: string
+  title: string
+  snippet: string
+  kind: 'memory' | 'thread'
+  type?: string
+  created_at?: string
+  name?: string
+  domain?: string
+  meeting_count?: number
+  is_resolved?: boolean
+  topics?: string[]
+  keywordScore: number
+  semanticScore: number
+  match: 'keyword' | 'semantic' | 'both'
+}
+
+export interface ContextSearchResult {
+  hits: ContextSearchHit[]
+  keywordCount: number
+  semanticCount: number
+  semanticAvailable: boolean
+  semanticReason?: string
+}
+
+export function memorySemanticArgs(query: string, limit: number, script = MEMORY_SEMANTIC_SCRIPT): string[] {
+  return [script, 'search', '--query', query, '--limit', String(limit)]
+}
+
+export function memorySemanticAvailable(
+  scriptsDir: string | null = COS_SCRIPTS_DIR,
+  pythonBin: string | null = PYTHON_BIN,
+): { ok: boolean; reason?: string } {
+  if (!scriptsDir || !pythonBin) return { ok: false, reason: 'no_memory_embeddings' }
+  if (!existsSync(pythonBin)) return { ok: false, reason: 'no_memory_embeddings' }
+  const script = resolve(scriptsDir, MEMORY_SEMANTIC_SCRIPT)
+  if (!existsSync(script)) return { ok: false, reason: 'no_memory_embeddings' }
+  return { ok: true }
+}
+
+export function threadSemanticAvailable(): { ok: false; reason: 'no_thread_embeddings' } {
+  return { ok: false, reason: 'no_thread_embeddings' }
+}
+
+function head(text: string): string {
+  return text.slice(0, HEAD_BYTES)
+}
+
+export function keywordHitsFromRecords(
+  tokens: string[],
+  records: Array<{ id: string; title: string; haystack: string }>,
+  kind: 'memory' | 'thread',
+): ContextSearchHit[] {
+  const hits: ContextSearchHit[] = []
+  for (const record of records) {
+    if (!record.id) continue
+    const scored = scoreKeywordMatch(tokens, record.title, record.haystack)
+    if (scored.score <= 0) continue
+    hits.push({
+      id: record.id,
+      title: record.title,
+      snippet: scored.snippet,
+      kind,
+      keywordScore: scored.score,
+      semanticScore: 0,
+      match: 'keyword',
+    })
+  }
+  return hits.sort((a, b) => b.keywordScore - a.keywordScore)
+}
+
+function memoryRecordsForKeyword(): Array<{ id: string; title: string; haystack: string; extra: Partial<ContextSearchHit> }> {
+  const root = resolveContextFilesRoot()
+  if (!root || !hasFileMemory(root)) return []
+  return readFileMemories(root, MAX_SCAN_FILES).map(row => ({
+    id: row.id,
+    title: row.summary || row.id,
+    haystack: head(`${row.id}\n${row.summary}\n${row.type}\n${row.content}`),
+    extra: { type: row.type, created_at: row.created_at, domain: row.domain },
+  }))
+}
+
+function parseThreadBag(raw: unknown): Array<Record<string, unknown>> {
+  if (Array.isArray(raw)) return raw.filter(row => row && typeof row === 'object' && !Array.isArray(row)) as Array<Record<string, unknown>>
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return []
+  const threads = (raw as { threads?: unknown }).threads
+  return Array.isArray(threads)
+    ? threads.filter(row => row && typeof row === 'object' && !Array.isArray(row)) as Array<Record<string, unknown>>
+    : []
+}
+
+function threadHaystack(row: Record<string, unknown>): string {
+  const topics = Array.isArray(row.topics) ? row.topics.join(' ') : String(row.topics || '')
+  const meetings = Array.isArray(row.meetings)
+    ? row.meetings.map(item => {
+      if (typeof item === 'string') return item
+      if (item && typeof item === 'object' && !Array.isArray(item)) {
+        const meeting = item as Record<string, unknown>
+        return String(meeting.name || meeting.title || '')
+      }
+      return ''
+    }).join(' ')
+    : ''
+  const updates = Array.isArray(row.manual_updates)
+    ? row.manual_updates.map(item => {
+      if (!item || typeof item !== 'object' || Array.isArray(item)) return ''
+      return String((item as Record<string, unknown>).content || '')
+    }).join('\n')
+    : String(row.initial_note || '')
+  return head(`${row.id}\n${row.name}\n${topics}\n${meetings}\n${updates}`)
+}
+
+export function keywordHitsFromThreadCache(tokens: string[], scriptsDir: string | null = COS_SCRIPTS_DIR): ContextSearchHit[] {
+  if (!scriptsDir) return []
+  const files = ['.threads_cache.json', '.manual_threads.json']
+  const grouped = new Map<string, ContextSearchHit>()
+  for (const name of files) {
+    const path = resolve(scriptsDir, name)
+    if (!existsSync(path)) continue
+    let parsed: unknown
+    try {
+      parsed = JSON.parse(readFileSync(path, 'utf8'))
+    } catch {
+      continue
+    }
+    for (const row of parseThreadBag(parsed)) {
+      const id = String(row.id || '').trim()
+      const title = String(row.name || id).trim()
+      if (!id) continue
+      const scored = scoreKeywordMatch(tokens, title, threadHaystack(row))
+      if (scored.score <= 0) continue
+      const hit: ContextSearchHit = {
+        id,
+        title,
+        snippet: scored.snippet,
+        kind: 'thread',
+        domain: typeof row.domain === 'string' ? row.domain : undefined,
+        meeting_count: typeof row.meeting_count === 'number' ? row.meeting_count : undefined,
+        is_resolved: row.is_resolved === true || row.status === 'resolved',
+        topics: Array.isArray(row.topics) ? row.topics.map(String) : undefined,
+        keywordScore: scored.score,
+        semanticScore: 0,
+        match: 'keyword',
+      }
+      const existing = grouped.get(id)
+      if (!existing || hit.keywordScore > existing.keywordScore) grouped.set(id, hit)
+    }
+  }
+  return [...grouped.values()]
+}
+
+export function keywordSearchMemories(query: string): ContextSearchHit[] {
+  const tokens = tokenizeMeetingQuery(query)
+  if (tokens.length === 0) return []
+  const records = memoryRecordsForKeyword()
+  return keywordHitsFromRecords(tokens, records, 'memory').map(hit => {
+    const extra = records.find(row => row.id === hit.id)?.extra ?? {}
+    return { ...hit, ...extra, kind: 'memory' as const }
+  })
+}
+
+export function keywordSearchThreads(query: string): ContextSearchHit[] {
+  const tokens = tokenizeMeetingQuery(query)
+  if (tokens.length === 0) return []
+  const grouped = new Map<string, ContextSearchHit>()
+  const push = (hit: ContextSearchHit) => {
+    const existing = grouped.get(hit.id)
+    if (!existing || hit.keywordScore > existing.keywordScore) grouped.set(hit.id, hit)
+  }
+  const root = resolveContextFilesRoot()
+  if (root && hasFileThreads(root)) {
+    for (const row of readFileThreads(root, MAX_SCAN_FILES)) {
+      const title = row.name || row.id
+      const haystack = head(`${row.id}\n${title}\n${row.topics.join(' ')}\n${row.manual_updates.map(item => item.content).join('\n')}`)
+      const scored = scoreKeywordMatch(tokens, title, haystack)
+      if (scored.score <= 0) continue
+      push({
+        id: row.id,
+        title,
+        snippet: scored.snippet,
+        kind: 'thread',
+        domain: row.domain,
+        meeting_count: row.meeting_count,
+        is_resolved: row.is_resolved,
+        topics: row.topics,
+        keywordScore: scored.score,
+        semanticScore: 0,
+        match: 'keyword',
+      })
+    }
+  }
+  for (const hit of keywordHitsFromThreadCache(tokens)) push(hit)
+  return [...grouped.values()].sort((a, b) => b.keywordScore - a.keywordScore)
+}
+
+interface MemorySemanticRaw {
+  id?: string
+  type?: string
+  content?: string
+  summary?: string
+  created_at?: string
+  domain?: string
+  score?: number
+}
+
+function semanticHitFromMemory(raw: MemorySemanticRaw): ContextSearchHit | null {
+  const id = String(raw.id || '').trim()
+  if (!id) return null
+  const title = String(raw.summary || raw.content || id).trim()
+  const semanticScore = typeof raw.score === 'number' && Number.isFinite(raw.score)
+    ? Math.max(0, Math.min(1, raw.score))
+    : 0
+  return {
+    id,
+    title,
+    snippet: String(raw.content || raw.summary || '').replace(/\s+/g, ' ').trim().slice(0, 180),
+    kind: 'memory',
+    type: raw.type,
+    created_at: raw.created_at,
+    domain: raw.domain,
+    keywordScore: 0,
+    semanticScore,
+    match: 'semantic',
+  }
+}
+
+export function semanticSearchMemories(query: string, limit = 20): Promise<{
+  hits: ContextSearchHit[]
+  reason?: string
+}> {
+  const available = memorySemanticAvailable()
+  if (!available.ok) return Promise.resolve({ hits: [], reason: available.reason })
+  const script = resolve(COS_SCRIPTS_DIR!, MEMORY_SEMANTIC_SCRIPT)
+  return new Promise(resolvePromise => {
+    execFile(
+      PYTHON_BIN!,
+      memorySemanticArgs(query, limit, script),
+      { cwd: COS_SCRIPTS_DIR!, timeout: SEMANTIC_TIMEOUT_MS, maxBuffer: 2 * 1024 * 1024 },
+      (error, stdout) => {
+        if (error) {
+          resolvePromise({ hits: [], reason: 'no_memory_embeddings' })
+          return
+        }
+        try {
+          const parsed = JSON.parse(String(stdout)) as { results?: MemorySemanticRaw[] } | MemorySemanticRaw[]
+          const rows = Array.isArray(parsed) ? parsed : (Array.isArray(parsed.results) ? parsed.results : [])
+          resolvePromise({
+            hits: rows.flatMap(row => {
+              const hit = semanticHitFromMemory(row)
+              return hit ? [hit] : []
+            }),
+          })
+        } catch {
+          resolvePromise({ hits: [], reason: 'memory_parse_error' })
+        }
+      },
+    )
+  })
+}
+
+export function mergeContextSearchHits(
+  keywordHits: ContextSearchHit[],
+  semanticHits: ContextSearchHit[],
+  limit: number,
+): ContextSearchHit[] {
+  const merged = new Map<string, ContextSearchHit>()
+  for (const hit of keywordHits) merged.set(hit.id, { ...hit })
+  for (const hit of semanticHits) {
+    const existing = merged.get(hit.id)
+    if (!existing) {
+      merged.set(hit.id, hit)
+      continue
+    }
+    merged.set(hit.id, {
+      ...existing,
+      snippet: existing.snippet || hit.snippet,
+      semanticScore: Math.max(existing.semanticScore, hit.semanticScore),
+      match: existing.keywordScore > 0 && hit.semanticScore > 0 ? 'both' : existing.match,
+      type: existing.type || hit.type,
+      created_at: existing.created_at || hit.created_at,
+      domain: existing.domain || hit.domain,
+    })
+  }
+  return [...merged.values()]
+    .sort((a, b) => {
+      const bothDelta = Number(b.match === 'both') - Number(a.match === 'both')
+      if (bothDelta) return bothDelta
+      return Math.max(b.keywordScore, b.semanticScore) - Math.max(a.keywordScore, a.semanticScore)
+    })
+    .slice(0, Math.max(1, Math.min(limit, 50)))
+}
+
+export async function searchMemories(options: { query: string; limit?: number }): Promise<ContextSearchResult> {
+  const query = options.query.trim()
+  const limit = Math.max(1, Math.min(options.limit ?? 20, 50))
+  const keywordHits = keywordSearchMemories(query)
+  const semantic = await semanticSearchMemories(query, limit)
+  return {
+    hits: mergeContextSearchHits(keywordHits, semantic.hits, limit),
+    keywordCount: keywordHits.length,
+    semanticCount: semantic.hits.length,
+    semanticAvailable: !semantic.reason,
+    ...(semantic.reason ? { semanticReason: semantic.reason } : {}),
+  }
+}
+
+export async function searchThreads(options: { query: string; limit?: number }): Promise<ContextSearchResult> {
+  const query = options.query.trim()
+  const limit = Math.max(1, Math.min(options.limit ?? 20, 50))
+  const keywordHits = keywordSearchThreads(query)
+  const unavailable = threadSemanticAvailable()
+  return {
+    hits: mergeContextSearchHits(keywordHits, [], limit),
+    keywordCount: keywordHits.length,
+    semanticCount: 0,
+    semanticAvailable: false,
+    semanticReason: unavailable.reason,
+  }
+}

package/server/lib/cos-operations-meetings.ts

@@ -17,7 +17,7 @@ import { createHash } from 'node:crypto'
 import { basename, dirname, join, resolve } from 'node:path'
 import { discoveredDomains, domainAbbreviation as deriveAbbr, isSafeDomainName as safeName } from './domains.js'
 import type { MeetingDetail, MeetingMeta } from './meeting-store.js'
-import { MEETING_SOURCE_MAX_BYTES } from './meeting-store.js'
+import { MEETING_SOURCE_MAX_BYTES, meetingDayCountsFromNames, meetingListLimit } from './meeting-store.js'
 
 /**
  * The four domains of ONE user's COS. Retained as the documented example layout
@@ -151,7 +151,7 @@ const SIDECAR_HEAD_BYTES = 4096
  * them whole would make listing cost scale with total transcript size — and this
  * lister already reads every markdown file it finds.
  */
-function sidecarSessionId(monthDir: string, meetingFilename: string): string | undefined {
+export function sidecarSessionId(monthDir: string, meetingFilename: string): string | undefined {
   const sidecarName = meetingFilename.replace(/\.md$/, '.g2-chunks.json')
   if (sidecarName === meetingFilename) return undefined
   const path = join(monthDir, sidecarName)
@@ -520,11 +520,14 @@ export function findDirectLibraryMeetingBySessionId(sessionId: string): MeetingL
 export function listCosOperationsMeetings(options: {
   limit?: number
   domain?: string
+  month?: string
+  day?: string
 } = {}): CosOperationsMeetingMeta[] {
   const operationsDir = resolveCosOperationsDir()
   if (!operationsDir) return []
 
-  const limit = Math.min(Math.max(options.limit ?? 20, 1), 50)
+  const scoped = Boolean(options.month || options.day)
+  const limit = meetingListLimit(options.limit, scoped)
   const domainFilter = options.domain || 'all'
   const discovered = discoverMeetingDomains(operationsDir)
   const domains = domainFilter === 'all'
@@ -537,11 +540,12 @@ export function listCosOperationsMeetings(options: {
     const meetingsBase = join(operationsDir, domain, 'meetings')
     try {
       const months = readdirSync(meetingsBase)
-        .filter(d => /^\d{4}-\d{2}$/.test(d))
+        .filter(d => MONTH_PATTERN.test(d))
         .sort()
         .reverse()
 
       for (const month of months) {
+        if (options.month && month !== options.month) continue
         const monthDir = join(meetingsBase, month)
         try {
           const files = readdirSync(monthDir)
@@ -561,6 +565,7 @@ export function listCosOperationsMeetings(options: {
               meta.canonicalRecord = `operations/${domain}/meetings/${month}/${file}`
               const sessionId = sidecarSessionId(monthDir, file)
               if (sessionId) meta.sessionId = sessionId
+              if (options.day && meta.date !== options.day) continue
               allMeetings.push(meta)
             } catch { /* skip unreadable files */ }
           }
@@ -573,13 +578,57 @@ export function listCosOperationsMeetings(options: {
   return allMeetings.slice(0, limit)
 }
 
-export function listDirectLibraryMeetings(options: { limit?: number } = {}): CosOperationsMeetingMeta[] {
+/** Folder names only. Used by the Control calendar pager. */
+export function listCosOperationsMeetingMonths(domainFilter = 'all'): string[] {
+  const operationsDir = resolveCosOperationsDir()
+  if (!operationsDir) return []
+  const discovered = discoverMeetingDomains(operationsDir)
+  const domains = domainFilter === 'all'
+    ? discovered
+    : discovered.includes(domainFilter) ? [domainFilter] : []
+  const months = new Set<string>()
+  for (const domain of domains) {
+    const meetingsBase = join(operationsDir, domain, 'meetings')
+    try {
+      for (const month of readdirSync(meetingsBase).filter(name => MONTH_PATTERN.test(name))) {
+        months.add(month)
+      }
+    } catch { /* domain has no meetings dir */ }
+  }
+  return [...months].sort().reverse()
+}
+
+export function listCosOperationsMeetingDays(month: string, domainFilter = 'all'): Array<{ date: string; count: number }> {
+  if (!MONTH_PATTERN.test(month)) return []
+  const operationsDir = resolveCosOperationsDir()
+  if (!operationsDir) return []
+  const discovered = discoverMeetingDomains(operationsDir)
+  const domains = domainFilter === 'all'
+    ? discovered
+    : discovered.includes(domainFilter) ? [domainFilter] : []
+  const names: string[] = []
+  for (const domain of domains) {
+    const monthDir = join(operationsDir, domain, 'meetings', month)
+    try {
+      names.push(...readdirSync(monthDir).filter(name => name.endsWith('.md')))
+    } catch { /* missing month */ }
+  }
+  return meetingDayCountsFromNames(names)
+}
+
+export function listDirectLibraryMeetings(options: {
+  limit?: number
+  month?: string
+  day?: string
+} = {}): CosOperationsMeetingMeta[] {
   const inspection = resolveMeetingLibrary()
   if (inspection.layout !== 'direct' || !inspection.root) return []
-  const limit = Math.min(Math.max(options.limit ?? 20, 1), 50)
+  const scoped = Boolean(options.month || options.day)
+  const limit = meetingListLimit(options.limit, scoped)
   const all: CosOperationsMeetingMeta[] = []
   let candidates = 0
   for (const month of readdirSync(inspection.root).filter(name => MONTH_PATTERN.test(name)).sort().reverse()) {
+    if (options.month && month !== options.month) continue
     const monthDir = safeChildDirectory(inspection.root, join(inspection.root, month))
     if (!monthDir) continue
     for (const file of readdirSync(monthDir).filter(name => name.endsWith('.md')).sort().reverse()) {
@@ -594,6 +643,7 @@ export function listDirectLibraryMeetings(options: { limit?: number } = {}): Cos
       meta.mutable = false
       const sessionId = sidecarSessionId(monthDir, file)
       if (sessionId) meta.sessionId = sessionId
+      if (options.day && meta.date !== options.day) continue
       all.push(meta)
     }
     if (candidates > MAX_LIST_CANDIDATES) break
@@ -602,6 +652,25 @@ export function listDirectLibraryMeetings(options: { limit?: number } = {}): Cos
   return all.slice(0, limit)
 }
 
+export function listDirectLibraryMeetingMonths(): string[] {
+  const inspection = resolveMeetingLibrary()
+  const root = inspection.root
+  if (inspection.layout !== 'direct' || !root) return []
+  return readdirSync(root)
+    .filter(name => MONTH_PATTERN.test(name) && safeChildDirectory(root, join(root, name)))
+    .sort()
+    .reverse()
+}
+
+export function listDirectLibraryMeetingDays(month: string): Array<{ date: string; count: number }> {
+  if (!MONTH_PATTERN.test(month)) return []
+  const inspection = resolveMeetingLibrary()
+  if (inspection.layout !== 'direct' || !inspection.root) return []
+  const monthDir = safeChildDirectory(inspection.root, join(inspection.root, month))
+  if (!monthDir) return []
+  return meetingDayCountsFromNames(readdirSync(monthDir).filter(name => name.endsWith('.md')))
+}
+
 export function getCosOperationsMeetingDetail(
   domain: string,
   month: string,

package/server/lib/cursor-model-catalog.ts

@@ -19,8 +19,10 @@ const DEFAULT_REFRESH_TIMEOUT_MS = 7_000
 
 /**
  * Stable slot → CLI model id mapping.
- * Prefer high reasoning + fast variants so Grok/Composer are latency-comparable.
- * Composer has no separate "high" id — only base vs `-fast`.
+ * Composer stays pinned (no versioned high-fast family). Grok high-fast is
+ * chosen at catalog build: newest `cursor-grok-<ver>-high-fast` in `agent
+ * models`. This grok id is only the fallback when the live list has none.
+ * `xhigh-fast` is a different SKU and is never selected here.
  */
 export const CURSOR_SLOT_MODEL_IDS = {
   'cursor-grok': 'cursor-grok-4.5-high-fast',
@@ -28,10 +30,43 @@ export const CURSOR_SLOT_MODEL_IDS = {
 } as const satisfies Record<CursorModelPreference, string>
 
 const SLOT_DISPLAY_FALLBACK = {
-  'cursor-grok': 'Grok 4.5 Fast',
+  'cursor-grok': 'Grok Fast',
   'cursor-composer': 'Composer 2.5 Fast',
 } as const satisfies Record<CursorModelPreference, string>
 
+const GROK_HIGH_FAST_RE = /^cursor-grok-(\d+(?:\.\d+)*)-high-fast$/i
+
+export function parseCursorGrokHighFastVersion(id: string): number[] | null {
+  const match = GROK_HIGH_FAST_RE.exec(id.trim())
+  if (!match) return null
+  return match[1].split('.').map(part => Number(part))
+}
+
+export function compareVersionTuples(a: number[], b: number[]): number {
+  const length = Math.max(a.length, b.length)
+  for (let index = 0; index < length; index++) {
+    const left = a[index] ?? 0
+    const right = b[index] ?? 0
+    if (left !== right) return left - right
+  }
+  return 0
+}
+
+/** Newest `cursor-grok-*-high-fast`. Ignores low/medium/xhigh and non-fast. */
+export function selectNewestCursorGrokHighFast(
+  models: CursorCatalogModel[],
+): CursorCatalogModel | undefined {
+  let best: { model: CursorCatalogModel; version: number[] } | undefined
+  for (const model of models) {
+    const version = parseCursorGrokHighFastVersion(model.id)
+    if (!version) continue
+    if (!best || compareVersionTuples(version, best.version) > 0) {
+      best = { model, version }
+    }
+  }
+  return best?.model
+}
+
 export type CursorCatalogSource = 'cli' | 'disk-cache' | 'unavailable'
 
 export interface CursorCatalogModel {
@@ -100,20 +135,25 @@ export function buildCursorModelCatalog(
   refreshError?: string,
 ): CursorModelCatalog {
   const byId = new Map(models.map(model => [model.id, model]))
-  const slots: CursorModelPreference[] = [CURSOR_GROK_MODEL, CURSOR_COMPOSER_MODEL]
-  const options = slots.map((preference): CursorModelOption => {
-    const expectedId = CURSOR_SLOT_MODEL_IDS[preference]
-    const found = byId.get(expectedId)
-    return {
-      preference,
-      id: found?.id ?? '',
-      displayName: found?.displayName ?? SLOT_DISPLAY_FALLBACK[preference],
-    }
-  })
+  const grok = selectNewestCursorGrokHighFast(models)
+    ?? byId.get(CURSOR_SLOT_MODEL_IDS[CURSOR_GROK_MODEL])
+  const composer = byId.get(CURSOR_SLOT_MODEL_IDS[CURSOR_COMPOSER_MODEL])
+  const options: CursorModelOption[] = [
+    {
+      preference: CURSOR_GROK_MODEL,
+      id: grok?.id ?? '',
+      displayName: grok?.displayName ?? SLOT_DISPLAY_FALLBACK[CURSOR_GROK_MODEL],
+    },
+    {
+      preference: CURSOR_COMPOSER_MODEL,
+      id: composer?.id ?? '',
+      displayName: composer?.displayName ?? SLOT_DISPLAY_FALLBACK[CURSOR_COMPOSER_MODEL],
+    },
+  ]
 
   setRuntimeCursorModelLabels(options.filter(option => option.id).map(option => ({
     preference: option.preference,
-    displayName: option.preference === CURSOR_GROK_MODEL ? 'Grok 4.5 Fast' : 'Composer 2.5 Fast',
+    displayName: option.displayName,
   })))
 
   return {
@@ -242,6 +282,7 @@ export function resolveCursorModelOption(preference: CursorModelPreference): Cur
 export function resolveCursorPreferenceForModelId(modelId: string): CursorModelPreference | undefined {
   const normalized = modelId.trim().toLowerCase()
   if (!normalized) return undefined
+  if (parseCursorGrokHighFastVersion(normalized)) return CURSOR_GROK_MODEL
   for (const [preference, id] of Object.entries(CURSOR_SLOT_MODEL_IDS) as [CursorModelPreference, string][]) {
     if (id.toLowerCase() === normalized) return preference
   }