@gotcos/glasses-server 7.0.18 → 7.0.29

package/server/lib/agent-session-store.ts

@@ -35,6 +35,16 @@ export interface AgentSessionListDropped {
   age: number
   limit: number
   oversized: number
+  /** Step 2a (Q1 FIX 1): kept rows (COS pins, folder members, COS-started sessions) past KEPT_LIST_MAX. Present only
+   *  when something was dropped, so an older reader of `dropped` sees the shape it knows. */
+  kept?: number
+}
+
+/** Step 2a (Q1 FIX 1): the most kept rows one list answer carries, on top of `limit`. Native pins are not counted
+ *  here; they stay inside `limit` as before. */
+export const KEPT_LIST_MAX = 40
+function countKeptOverflow(dropped: AgentSessionListDropped, n: number): void {
+  if (n > 0) dropped.kept = (dropped.kept ?? 0) + n
 }
 
 export function emptySessionListDropped(): AgentSessionListDropped {
@@ -1058,6 +1068,11 @@ export async function listClaudeSessions(
   desktopSessionsRoot = '',
   dropped: AgentSessionListDropped = emptySessionListDropped(),
   preloadedAliases?: ClaudeAliasMap,
+  /** Step 2a: canonical ids the COS organizer keeps (COS pins, folder members). Listed at any age and outside `cap`,
+   *  like a native pin, but `pinned` stays the native star only. */
+  keep: ReadonlySet<string> = new Set(),
+  /** Which kept ids win when KEPT_LIST_MAX must choose: lower first (0 COS pins and folders, 1 COS-started). */
+  keepRank: (id: string) => number = () => 0,
 ): Promise<AgentSessionRow[]> {
   const aliases = preloadedAliases ?? await loadClaudeDesktopAliases(desktopSessionsRoot)
   const canonical = (id: string) => { const cli = aliases.get(id)?.cliSessionId; return cli && CLAUDE_UUID_JSONL.test(cli + '.jsonl') ? cli : id }
@@ -1072,6 +1087,7 @@ export async function listClaudeSessions(
   const seen = new Set<string>()
   const pinnedCandidates: Array<{ file: string; native: string; project: string; mtimeMs: number; birthtimeMs: number; desktop?: string }> = []
   const recentCandidates: Array<{ file: string; native: string; project: string; mtimeMs: number; birthtimeMs: number; desktop?: string }> = []
+  const keptCandidates: typeof recentCandidates = []
   for (const folder of await dirents(projectsRoot)) {
     const dir = join(projectsRoot, folder)
     const dirSt = await fileStat(dir)
@@ -1084,7 +1100,9 @@ export async function listClaudeSessions(
       const file = join(dir, name)
       const st = await fileStat(file)
       if (!st?.isFile) continue
-      const pinned = canonicalStars.has(native.toLowerCase())
+      const starred = canonicalStars.has(native.toLowerCase())
+      const kept = !starred && keep.has(native.toLowerCase())
+      const pinned = starred || kept
       const fresh = now.getTime() - st.mtimeMs <= AGENT_SESSION_MAX_AGE_MS
       if (!pinned && !fresh) {
         dropped.age += 1
@@ -1099,17 +1117,18 @@ export async function listClaudeSessions(
         desktop: desktopByCli.get(native)?.file,
       }
       seen.add(native.toLowerCase())
-      if (pinned) pinnedCandidates.push(candidate)
+      if (starred) pinnedCandidates.push(candidate)
+      else if (kept) keptCandidates.push(candidate)
       else recentCandidates.push(candidate)
     }
   }
-  for (const starred of canonicalStars) {
+  for (const starred of new Set([...canonicalStars, ...keep])) {
     if (seen.has(starred) || canonicalLive.has(starred) || canonicalLive.has(starred.slice(0, 8))) continue
     const desktop = desktopByCli.get(starred)?.file
     if (!desktop) continue
     const st = await fileStat(desktop)
     if (!st?.isFile) continue
-    pinnedCandidates.push({
+    ;(canonicalStars.has(starred) ? pinnedCandidates : keptCandidates).push({
       file: '',
       native: starred,
       project: '',
@@ -1120,6 +1139,7 @@ export async function listClaudeSessions(
     seen.add(starred)
   }
   pinnedCandidates.sort((a, b) => b.mtimeMs - a.mtimeMs)
+  keptCandidates.sort((a, b) => (keepRank(a.native.toLowerCase()) - keepRank(b.native.toLowerCase())) || b.mtimeMs - a.mtimeMs)
   recentCandidates.sort((a, b) => b.mtimeMs - a.mtimeMs)
 
   const toRows = async (candidates: typeof recentCandidates, limit: number): Promise<AgentSessionRow[]> => {
@@ -1166,8 +1186,13 @@ export async function listClaudeSessions(
     return rows
   }
 
+  const keptLimitBefore = dropped.limit
+  const keptRows = await toRows(keptCandidates, KEPT_LIST_MAX)
+  countKeptOverflow(dropped, dropped.limit - keptLimitBefore)
+  dropped.limit = keptLimitBefore
   return [
     ...await toRows(pinnedCandidates, Math.max(pinnedCandidates.length, 0)),
+    ...keptRows,
     ...await toRows(recentCandidates, Math.max(0, cap)),
   ]
 }
@@ -1177,27 +1202,36 @@ export async function listCodexSessions(
   now: Date,
   cap = AGENT_SESSION_PER_PROVIDER_LIMIT,
   dropped: AgentSessionListDropped = emptySessionListDropped(),
+  /** Step 2a: thread ids the COS organizer keeps; see listClaudeSessions. */
+  keep: ReadonlySet<string> = new Set(),
+  keepRank: (id: string) => number = () => 0,
 ): Promise<AgentSessionRow[]> {
   const names = await loadCodexThreadNames(sessionsRoot)
   const pinnedIds = await loadCodexPinnedIds(sessionsRoot)
   const pinnedCandidates: Array<{ file: string; name: string; mtimeMs: number; birthtimeMs: number }> = []
   const recentCandidates: Array<{ file: string; name: string; mtimeMs: number; birthtimeMs: number }> = []
+  const keptCandidates: typeof recentCandidates = []
   for (const file of await listCodexJsonlFiles(sessionsRoot)) {
     const st = await fileStat(file)
     if (!st?.isFile) continue
     const name = file.split('/').pop() || file
     const fileId = idFromCodexFilename(name)
-    const pinned = fileId ? pinnedIds.has(fileId) : false
+    const nativePin = fileId ? pinnedIds.has(fileId) : false
+    const kept = !nativePin && (fileId ? keep.has(fileId) : false)
+    const pinned = nativePin || kept
     const fresh = now.getTime() - st.mtimeMs <= AGENT_SESSION_MAX_AGE_MS
     if (!pinned && !fresh) {
       dropped.age += 1
       continue
     }
     const candidate = { file, name, mtimeMs: st.mtimeMs, birthtimeMs: st.birthtimeMs }
-    if (pinned) pinnedCandidates.push(candidate)
+    if (nativePin) pinnedCandidates.push(candidate)
+    else if (kept) keptCandidates.push(candidate)
     else recentCandidates.push(candidate)
   }
   pinnedCandidates.sort((a, b) => b.mtimeMs - a.mtimeMs)
+  const codexRank = (c: { name: string }) => keepRank(idFromCodexFilename(c.name) ?? '')
+  keptCandidates.sort((a, b) => (codexRank(a) - codexRank(b)) || b.mtimeMs - a.mtimeMs)
   recentCandidates.sort((a, b) => b.mtimeMs - a.mtimeMs)
 
   const toRows = async (candidates: typeof recentCandidates, limit: number): Promise<AgentSessionRow[]> => {
@@ -1251,8 +1285,12 @@ export async function listCodexSessions(
   }
 
   const pinnedRows = await toRows(pinnedCandidates, Math.max(pinnedCandidates.length, 0))
+  const keptLimitBefore = dropped.limit
+  const keptRows = await toRows(keptCandidates, KEPT_LIST_MAX)
+  countKeptOverflow(dropped, dropped.limit - keptLimitBefore)
+  dropped.limit = keptLimitBefore
   const recentRows = await toRows(recentCandidates, Math.max(0, cap))
-  return [...pinnedRows, ...recentRows]
+  return [...pinnedRows, ...keptRows, ...recentRows]
 }
 
 export async function listCursorSessions(
@@ -1262,15 +1300,19 @@ export async function listCursorSessions(
   composerDb = '',
   pinnedIds: ReadonlySet<string> = new Set(),
   dropped: AgentSessionListDropped = emptySessionListDropped(),
+  /** Step 2a: composer ids the COS organizer keeps; see listClaudeSessions. */
+  keep: ReadonlySet<string> = new Set(),
+  keepRank: (id: string) => number = () => 0,
 ): Promise<AgentSessionRow[]> {
   const composerNames = composerDb ? await loadCursorComposerNames(composerDb) : new Map<string, string>()
+  const retained = (id: string) => pinnedIds.has(id.toLowerCase()) || keep.has(id.toLowerCase())
   const byId = new Map<string, { file: string; sessionDir: string; project: string; mtimeMs: number; birthtimeMs: number }>()
   for (const folder of await dirents(projectsRoot)) {
     if (folder.includes('var-folders') || folder.includes('private-var')) continue
     const transcripts = join(projectsRoot, folder, 'agent-transcripts')
     for (const sessionDir of await dirents(transcripts)) {
       if (sessionDir === 'subagents') continue
-      const pinned = pinnedIds.has(sessionDir.toLowerCase())
+      const pinned = retained(sessionDir)
       if (folder === 'empty-window' && !pinned) continue
       const file = join(transcripts, sessionDir, `${sessionDir}.jsonl`)
       const st = await fileStat(file)
@@ -1295,9 +1337,12 @@ export async function listCursorSessions(
       byId.set(sessionDir, existing ? preferCursorCopy(next, existing) : next)
     }
   }
-  const pinnedCandidates = [...byId.values()].filter(c => pinnedIds.has(c.sessionDir.toLowerCase()))
-  const recentCandidates = [...byId.values()].filter(c => !pinnedIds.has(c.sessionDir.toLowerCase()))
+  const nativePin = (id: string) => pinnedIds.has(id.toLowerCase())
+  const pinnedCandidates = [...byId.values()].filter(c => nativePin(c.sessionDir))
+  const keptCandidates = [...byId.values()].filter(c => !nativePin(c.sessionDir) && retained(c.sessionDir))
+  const recentCandidates = [...byId.values()].filter(c => !retained(c.sessionDir))
   pinnedCandidates.sort((a, b) => b.mtimeMs - a.mtimeMs)
+  keptCandidates.sort((a, b) => (keepRank(a.sessionDir.toLowerCase()) - keepRank(b.sessionDir.toLowerCase())) || b.mtimeMs - a.mtimeMs)
   recentCandidates.sort((a, b) => b.mtimeMs - a.mtimeMs)
 
   const toRows = async (candidates: typeof recentCandidates, limit: number): Promise<AgentSessionRow[]> => {
@@ -1334,8 +1379,13 @@ export async function listCursorSessions(
     return rows
   }
 
+  const keptLimitBefore = dropped.limit
+  const keptRows = await toRows(keptCandidates, KEPT_LIST_MAX)
+  countKeptOverflow(dropped, dropped.limit - keptLimitBefore)
+  dropped.limit = keptLimitBefore
   return [
     ...await toRows(pinnedCandidates, Math.max(pinnedCandidates.length, 0)),
+    ...keptRows,
     ...await toRows(recentCandidates, Math.max(0, cap)),
   ]
 }
@@ -1407,6 +1457,12 @@ export async function listAgentSessions(
   sort: AgentSessionSort = 'updated',
   dropped: AgentSessionListDropped = emptySessionListDropped(),
   preloadedAliases?: ClaudeAliasMap,
+  /** Step 2a: canonical ids per provider the COS organizer keeps (COS pins, folder members). Kept rows are listed at
+   *  any age, outside the per-provider cap AND outside `limit`. Absent: exactly today's list. */
+  keep: Partial<Record<AgentProvider, ReadonlySet<string>>> = {},
+  /** Step 2a (Miles, 2026-11-10): sessions a COS job started in the last 7 days. Kept like `keep`, ranked after it when
+   *  the KEPT_LIST_MAX ceiling has to choose. */
+  started: Partial<Record<AgentProvider, ReadonlySet<string>>> = {},
 ): Promise<AgentSessionRow[]> {
   const originalStars = await loadClaudeStarredIds(roots.claudeDesktopConfig)
   // ONE alias load for the whole walk. Before this the walk loaded it here AND
@@ -1429,15 +1485,26 @@ export async function listAgentSessions(
     })
   const liveIds = new Set(enrichedLive.flatMap(row => [row.session_id, row.session_id.slice(0, 8)]))
   const cap = AGENT_SESSION_PER_PROVIDER_LIMIT
+  // Kept Claude ids are canonical already (the organizer route canonicalizes on write); map again in case a Desktop
+  // id reached the store from an older path.
+  const keptClaude = new Set([...(keep.claude ?? [])].map(id => canonical(id).toLowerCase()))
+  const startedClaude = new Set([...(started.claude ?? [])].map(id => canonical(id).toLowerCase()))
+  const inSet = (row: AgentSessionRow, claude: Set<string>, other: Partial<Record<AgentProvider, ReadonlySet<string>>>) =>
+    row.provider === 'claude' ? claude.has(row.session_id.toLowerCase()) : (other[row.provider]?.has(row.session_id.toLowerCase()) ?? false)
+  /** 0: a COS pin or folder member; 1: COS-started; null: not kept. */
+  const keptTier = (row: AgentSessionRow): 0 | 1 | null => inSet(row, keptClaude, keep) ? 0 : inSet(row, startedClaude, started) ? 1 : null
+  const isKept = (row: AgentSessionRow) => keptTier(row) !== null
+  const union = (provider: Exclude<AgentProvider, 'claude'>) => new Set([...(keep[provider] ?? []), ...(started[provider] ?? [])])
+  const keptForWalk = { claude: new Set([...keptClaude, ...startedClaude]), codex: union('codex'), cursor: union('cursor') }
   let rows = dedupeSessions([
     ...enrichedLive,
-    ...await listClaudeSessions(roots.claudeProjects, now, liveIds, cap, starredIds, roots.claudeCodeSessions, dropped, aliases),
-    ...(await Promise.all(codexSessionRootsOf(roots).map(root => listCodexSessions(root, now, cap, dropped)))).flat(),
-    ...await listCursorSessions(roots.cursorProjects, now, cap, roots.cursorComposerDb, cursorPinned, dropped),
+    ...await listClaudeSessions(roots.claudeProjects, now, liveIds, cap, starredIds, roots.claudeCodeSessions, dropped, aliases, keptForWalk.claude, id => keptClaude.has(id) ? 0 : 1),
+    ...(await Promise.all(codexSessionRootsOf(roots).map(root => listCodexSessions(root, now, cap, dropped, keptForWalk.codex, id => keep.codex?.has(id) ? 0 : 1)))).flat(),
+    ...await listCursorSessions(roots.cursorProjects, now, cap, roots.cursorComposerDb, cursorPinned, dropped, keptForWalk.cursor, id => keep.cursor?.has(id) ? 0 : 1),
   ])
   if (sort === 'opened') {
     rows = rows.filter(entry => {
-      if (entry.alive) return true
+      if (entry.alive || isKept(entry)) return true
       const created = Date.parse(entry.created)
       return Number.isFinite(created) && now.getTime() - created <= AGENT_SESSION_MAX_AGE_MS
     })
@@ -1450,9 +1517,24 @@ export async function listAgentSessions(
     // pin-boosting here made the lens show July stars instead of today.
     rows.sort((a, b) => (b.modified || '').localeCompare(a.modified || ''))
   }
-  const extras = Math.max(0, rows.length - Math.max(0, limit))
-  if (extras) dropped.limit += extras
-  return rows.slice(0, limit)
+  // Step 2a: kept rows are not cut by `limit` but by their own ceiling, KEPT_LIST_MAX (Q1 FIX 1): COS pins and folder
+  // members first, then COS-started sessions, newest first in each. They keep their place in the sort order.
+  const max = Math.max(0, limit)
+  const keptRanked = rows.filter(isKept)
+    .sort((a, b) => (keptTier(a)! - keptTier(b)!) || (b.modified || '').localeCompare(a.modified || ''))
+  const keptAllowed = new Set(keptRanked.slice(0, KEPT_LIST_MAX))
+  countKeptOverflow(dropped, keptRanked.length - keptAllowed.size)
+  let taken = 0
+  let cut = 0
+  const out = rows.filter(entry => {
+    if (isKept(entry)) return keptAllowed.has(entry)
+    taken += 1
+    if (taken <= max) return true
+    cut += 1
+    return false
+  })
+  if (cut) dropped.limit += cut
+  return out
 }
 
 /**

package/server/lib/cos-started-sessions.ts

@@ -0,0 +1,101 @@
+/**
+ * Sessions a COS job started in the last 7 days (Miles, 2026-11-10 23:16, via the lead: "Yes, keep for 7 days").
+ *
+ * The 0b spike found that a session started from Work or Ask drops out of GET /api/agent-sessions within hours on a
+ * busy Mac (the per-agent cap of 20 showed only the newest 4.2 hours of Claude sessions). The list keeps these, like a
+ * COS pin, inside the same bounded keep ceiling (agent-session-store.ts KEPT_LIST_MAX).
+ *
+ * Read from the query-job journal (data/query-jobs/<YYYY-MM-DD>.jsonl): each job's `running` or `completed` record
+ * names its provider and native session (`cliSessionId` for Claude and Cursor, `codexThreadId` for Codex). Only ids,
+ * times and the request's kind are read, never prompts or answers.
+ *
+ * Only jobs a PERSON started count (Q1, 2026-11-10 23:3x). Every job records a session id (54 of 54 in the 8 days
+ * measured), so the job's `accepted` record decides. It is an ALLOWLIST (Q1's nit, lead 23:44), so a new kind of
+ * background job fails safe: a job counts only when its request has no `origin` (Ask from phone, lens or web, Work
+ * starts, Continue) or `origin.kind === 'task'` (a dispatched task), and no `maintenanceWorkflow`. That leaves out
+ * the scheduler's routines (the morning brief: 6 of 54), meeting consolidation (2 of 54) and any kind added later.
+ * A session id whose job's request record is not in the window is left out too (only a job that ran for more than
+ * a day; failing safe). Each day file is memoized on mtime and size, and a file that keeps
+ * changing (a job writing its deltas) is re-read at most every 30 seconds, so the 5-second list poll stays cheap.
+ */
+import { readdir, readFile, stat } from 'node:fs/promises'
+import { join } from 'node:path'
+import { dataPath } from './data-dir.js'
+
+export const COS_STARTED_WINDOW_MS = 7 * 24 * 3600 * 1000
+export const COS_STARTED_REREAD_MS = 30_000
+type Provider = 'claude' | 'codex' | 'cursor'
+interface Seen { provider: Provider; id: string; at: number; jobId: string }
+interface DayMemo { mtimeMs: number; size: number; readAt: number; seen: Seen[]; person: string[] }
+
+const memo = new Map<string, DayMemo>()
+export const cosStartedStats = { reads: 0 }
+export function __resetCosStartedForTests(): void { memo.clear(); cosStartedStats.reads = 0 }
+
+const DAY_FILE = /^(\d{4}-\d{2}-\d{2})\.jsonl$/
+const SAFE_ID = /^[A-Za-z0-9-]{8,64}$/
+
+/** True only for a request a person started: no origin, or a dispatched task; never a maintenance workflow. */
+export function isPersonJobRequest(request: unknown): boolean {
+  if (!request || typeof request !== 'object') return false
+  const r = request as { origin?: unknown; maintenanceWorkflow?: unknown }
+  if (r.maintenanceWorkflow != null) return false
+  if (r.origin == null) return true
+  return typeof r.origin === 'object' && (r.origin as { kind?: unknown }).kind === 'task'
+}
+
+function idsIn(text: string): { seen: Seen[]; person: string[] } {
+  const out: Seen[] = []
+  const person: string[] = []
+  for (const line of text.split('\n')) {
+    const hasRequest = line.includes('"request"')
+    if (!hasRequest && !line.includes('SessionId') && !line.includes('ThreadId')) continue
+    let record: any
+    try { record = JSON.parse(line) } catch { continue }
+    const jobId = typeof record?.jobId === 'string' ? record.jobId : ''
+    if (hasRequest && jobId && isPersonJobRequest(record?.request)) person.push(jobId)
+    const patch = record?.patch
+    if (!patch || typeof patch !== 'object') continue
+    const provider = patch.provider
+    const at = Date.parse(record.persistedAt ?? '')
+    const id = provider === 'codex' ? patch.codexThreadId : patch.cliSessionId
+    if ((provider === 'claude' || provider === 'codex' || provider === 'cursor') && typeof id === 'string' && SAFE_ID.test(id)) {
+      out.push({ provider, id: id.toLowerCase(), at: Number.isFinite(at) ? at : 0, jobId })
+    }
+  }
+  return { seen: out, person }
+}
+
+/** Native session ids per provider that a COS job started within `windowMs` of `now`. Never throws. */
+export async function cosStartedSessionIds(now = Date.now(), dir = dataPath('query-jobs'), windowMs = COS_STARTED_WINDOW_MS): Promise<Record<Provider, Set<string>>> {
+  const result: Record<Provider, Set<string>> = { claude: new Set(), codex: new Set(), cursor: new Set() }
+  let names: string[]
+  try { names = await readdir(dir) } catch { return result }
+  // One day of slack: a job's day file is its own partition day, and the window is measured from its record time.
+  const oldestDay = new Date(now - windowMs - 24 * 3600 * 1000).toISOString().slice(0, 10)
+  const memos: DayMemo[] = []
+  for (const name of names) {
+    const day = DAY_FILE.exec(name)?.[1]
+    if (!day || day < oldestDay) continue
+    const file = join(dir, name)
+    try {
+      const st = await stat(file)
+      if (!st.isFile()) continue
+      let m = memo.get(file)
+      const changed = !m || m.mtimeMs !== st.mtimeMs || m.size !== st.size
+      if (changed && (!m || now - m.readAt >= COS_STARTED_REREAD_MS)) {
+        cosStartedStats.reads++
+        m = { mtimeMs: st.mtimeMs, size: st.size, readAt: now, ...idsIn(await readFile(file, 'utf8')) }
+        memo.set(file, m)
+      }
+      if (m) memos.push(m)
+    } catch { /* a day file that cannot be read adds nothing */ }
+  }
+  // A job's request and its session id can sit in different day files, so person-started jobs are gathered first.
+  const person = new Set(memos.flatMap(m => m.person))
+  for (const m of memos) {
+    for (const s of m.seen) if (now - s.at <= windowMs && person.has(s.jobId)) result[s.provider].add(s.id)
+  }
+  for (const key of memo.keys()) if (!names.includes(key.split('/').pop() || '')) memo.delete(key)
+  return result
+}

package/server/lib/list-model-memo.ts

@@ -0,0 +1,85 @@
+/**
+ * `reported_model` on LIST rows without the list ever waiting on a model read (step 2a, S1_CONTRACT_step2a.md B3).
+ *
+ * The 6.62.0 QA rule W11 (routes/agent-sessions.ts) keeps model reads off the list path: a list of 60 rows must not
+ * hold a tail read per row. So list rows carry the model ONLY from this memo. After a list answers, `warmListModels`
+ * reads the rows the memo missed in the background: at most 4 at a time, Claude and Codex only, and a file that keeps
+ * changing is re-read at most once a minute (a Codex posture scan can be long). The value then appears on a later poll.
+ *
+ * The value and format are exactly the detail route's (session-continue-facts.ts): Claude a bare slug, Codex
+ * `<model> <effort>`. Cursor rows are not warmed here (their model sits in Cursor's database; the detail route has it).
+ */
+import { stat } from 'node:fs/promises'
+import { codexReportedModel, readCodexSessionPosture } from './codex-session-posture.js'
+import { readClaudeReportedModel, sanitizeReportedModel } from './session-continue-facts.js'
+
+export const LIST_MODEL_WARM_CONCURRENCY = 4
+export const LIST_MODEL_REREAD_MS = 60_000
+const MEMO_MAX = 2_000
+
+interface Memo { mtimeMs: number; size: number; readAt: number; model: string | null }
+const memo = new Map<string, Memo>()
+const inflight = new Set<string>()
+let running = 0
+const queue: Array<() => Promise<void>> = []
+export const listModelStats = { reads: 0 }
+
+type Provider = 'claude' | 'codex' | 'cursor'
+const keyOf = (provider: Provider, file: string) => `${provider}:${file}`
+
+/** The memo's model for this file, or undefined. Never reads the file's contents. A value read within the last
+ *  minute is served even if the file has moved on since (a busy session's model rarely changes mid-minute). */
+export function cachedListModel(provider: Provider, file: string | undefined, fileMtimeMs: number | null, now = Date.now()): string | undefined {
+  if (!file) return undefined
+  const m = memo.get(keyOf(provider, file))
+  if (!m || m.model === null) return undefined
+  // `modified` on a row is an ISO time (whole milliseconds); the memo holds the stat's fractional mtime.
+  if (fileMtimeMs === null || Math.floor(m.mtimeMs) === Math.floor(fileMtimeMs) || now - m.readAt < LIST_MODEL_REREAD_MS) return m.model
+  return undefined
+}
+
+async function readModel(provider: Provider, file: string): Promise<string | null> {
+  listModelStats.reads++
+  if (provider === 'claude') return readClaudeReportedModel(file)
+  if (provider === 'codex') return sanitizeReportedModel(codexReportedModel(await readCodexSessionPosture(file)))
+  return null
+}
+
+function pump(): void {
+  while (running < LIST_MODEL_WARM_CONCURRENCY && queue.length) {
+    const job = queue.shift()!
+    running++
+    void job().finally(() => { running--; pump() })
+  }
+}
+
+/** Queue background reads for the rows the memo misses. Returns at once; never throws. */
+export function warmListModels(rows: ReadonlyArray<{ provider: Provider; file?: string }>, now = Date.now()): void {
+  for (const row of rows) {
+    if (row.provider === 'cursor' || !row.file) continue
+    const key = keyOf(row.provider, row.file)
+    if (inflight.has(key)) continue
+    const m = memo.get(key)
+    if (m && now - m.readAt < LIST_MODEL_REREAD_MS) continue
+    inflight.add(key)
+    const { provider, file } = row
+    queue.push(async () => {
+      try {
+        const st = await stat(file)
+        const prev = memo.get(key)
+        if (prev && prev.mtimeMs === st.mtimeMs && prev.size === st.size) { prev.readAt = Date.now(); return }
+        const model = await readModel(provider, file)
+        memo.delete(key)
+        memo.set(key, { mtimeMs: st.mtimeMs, size: st.size, readAt: Date.now(), model })
+        while (memo.size > MEMO_MAX) memo.delete(memo.keys().next().value!)
+      } catch { /* unknown stays unknown */ } finally { inflight.delete(key) }
+    })
+  }
+  pump()
+}
+
+/** Tests only. */
+export async function __drainListModelWarmForTests(): Promise<void> {
+  while (running > 0 || queue.length > 0) await new Promise(resolve => setTimeout(resolve, 5))
+}
+export function __resetListModelMemoForTests(): void { memo.clear(); inflight.clear(); queue.length = 0; listModelStats.reads = 0 }

package/server/lib/model-efforts.ts

@@ -0,0 +1,40 @@
+/**
+ * Each agent's efforts for /api/models (Sessions chat-style layout, step 2a; S1_CONTRACT_step2a.md section C).
+ *
+ * One source for every picker, web and Mac: ghost report item 6 found the model and effort lists hard-coded in seven
+ * places. The values are exactly what POST /api/query-jobs accepts as `effort` (EFFORT_OPTIONS; anything else is
+ * dropped by the job route today, ghost item 5), and each entry says what the agent actually runs with it, from the
+ * same mapping functions the bridges call. Cursor's bridge takes no effort, so its list is empty.
+ */
+import {
+  DEFAULT_EFFORT,
+  EFFORT_OPTIONS,
+  effortLabel,
+  resolveCliEffortFlag,
+  resolveCodexReasoningEffort,
+  type EffortPreference,
+} from '../../shared/model-preference.js'
+import { resolveOllamaThink } from './ollama-bridge.js'
+
+export interface EffortChoice { value: EffortPreference; label: string; runs: string }
+export interface ModelEfforts {
+  default: EffortPreference
+  byAgent: { claude: EffortChoice[]; codex: EffortChoice[]; ollama: EffortChoice[]; cursor: EffortChoice[] }
+}
+
+export function modelEfforts(env: NodeJS.ProcessEnv = process.env): ModelEfforts {
+  const choices = (runs: (effort: EffortPreference) => string): EffortChoice[] =>
+    EFFORT_OPTIONS.map(value => ({ value, label: effortLabel(value), runs: runs(value) }))
+  return {
+    default: DEFAULT_EFFORT,
+    byAgent: {
+      // `--effort`; Ultracode is a COS choice that runs Claude at xhigh.
+      claude: choices(e => resolveCliEffortFlag(e)),
+      // `model_reasoning_effort`.
+      codex: choices(e => resolveCodexReasoningEffort(e)),
+      // Ollama's `think` (COS_OLLAMA_THINK, when set, pins it whatever the effort).
+      ollama: choices(e => { const think = resolveOllamaThink(env.COS_OLLAMA_THINK, e); return think === false ? 'off' : think === true ? 'on' : think }),
+      cursor: [],
+    },
+  }
+}