@gotcos/glasses-server 6.27.6 → 6.27.9

package/CHANGELOG.md

@@ -1,3 +1,109 @@
+## Unreleased
+
+## 6.27.9
+- **Large sessions open instead of 413ing.** `GET /api/agent-sessions/:provider/:id`
+  answered `413 Session too large to open` for any transcript over 32 MiB, so the
+  biggest sessions — the ones most worth reviewing before a follow-up — returned
+  nothing at all. A 67 MB transcript is not exotic; this repo's own 2026-08-13 session
+  is 70 MB. Oversized files are now read as a bounded **head (256 KiB) + tail
+  (768 KiB)**. That 70 MB session parses in **7 ms** and yields a 1,286-char digest
+  with both the opening ask and the most recent turns.
+- Slicing at an arbitrary byte offset is safe because `parseJsonLine` returns null for
+  the fragmentary first line of the tail window and the loop skips it.
+- **`truncated` is reported, and the counts stop pretending.** On a partial read the
+  message counts are counts of what was READ. The digest therefore prints
+  `… middle of a large session not read …` instead of a turn number it cannot know —
+  a confidently wrong "… 12 earlier turns …" on a 4,000-turn session is the same
+  dishonesty as a silent cap.
+- **Slash-command scaffolding no longer eats the two best slots.** `collectTurn` now
+  applies the existing `isWrapperPrompt` filter and `<user_query>` stripping, so a
+  digest opens with the real ask rather than `<command-message>…`.
+- Window sizes are injectable. With production defaults any quick-to-build fixture is
+  smaller than head+tail combined, so a test would read the whole file and pass
+  identically with windowing REMOVED — it did, until a mutation caught it. The test
+  now pins the read count and fails when windowing is dropped.
+
+## 6.27.8
+- **Session bodies get a real digest.** `GET /api/agent-sessions/:provider/:id` adds
+  `discussion_digest`: up to **2000 chars** of what actually happened — the opening
+  ask, the most recent user turns in order, and where the assistant left off.
+- **The list row is untouched at 180.** Miles: "it should be in the body not the
+  title, the row should be no more than the 180 characters." `discussion_summary`
+  keeps its 180-char budget for the single-line row; the digest is a separate field
+  the detail page reads. One shared field could not serve both — a 2000-char gist
+  appended to a row destroys it.
+- **No LLM, no extra reads.** `parseAgentSession` already streams every line of the
+  transcript to count turns; it was discarding the middle. The digest is assembled
+  from turns it is already parsing, so it costs no tokens and no additional I/O.
+- **Elision is stated, never silent.** The store keeps the opening turns plus a
+  60-turn recent window so a 900-turn session cannot balloon memory, and passes the
+  TRUE turn count so the `… N earlier turns …` line reports what was really dropped
+  rather than what the buffer happened to hold.
+- Opening turns are reserved BEFORE recency. Filling from the end first starved the
+  original ask out of a 40-turn session entirely — caught by its own test.
+- Older clients ignore the field; older servers omit it and the glasses fall back to
+  the 180-char summary.
+
+## 6.27.7
+- **`GET /api/agent-sessions` ships in the public package.** Claude Code, Codex,
+  and Cursor transcripts from this Mac, last 7 days of writes. Glasses 6.8.360
+  uses this instead of the Claude-only COS cache. Stock 6.27.6 404s that route.
+- **Sessions list matches Control Updated.** Newest write first. Stale pins stay
+  in the payload (any age) but do not cluster at the top — that is Control's
+  Pinned clock, which glasses does not have.
+- **Session discussion gist.** Agent-session list and detail include
+  `discussion_summary`: first real user turn plus the latest assistant prose
+  from a cheap transcript peek. No LLM. Glasses use it on the session row and
+  detail; older clients ignore the field. `first_prompt` on the list is the
+  first user turn, not a copy of the sidebar title.
+- **Sessions lookup.** `GET /api/agent-sessions/search?q=` runs keyword over
+  sidebar names, `/rename` titles, first prompts, and the first ~8k of user
+  transcript — including chats older than the 7-day list window. Meaning search
+  embeds the query once against those same texts (OpenAI key, no LLM). Keyword
+  still returns if embeddings are down. Literal path, registered before
+  `/agent-sessions/:provider/:sessionId`.
+- **Sessions Pinned includes Claude Desktop stars and Cursor
+  `pinnedComposers`.** Same rule as ChatGPT `pinned-thread-ids`: starred
+  Claude sessions (including Desktop-only blobs with no `~/.claude` jsonl)
+  and Cursor sidebar pins stay in the list at any age. Keep-warm `ready`
+  rows still stay out.
+- **Sessions hide CLI keep-warm `ready` rows** and Control provider-proof
+  prompts so real chats fill the list.
+- **Sessions keep ChatGPT pins and Cursor sidebar names.** Codex
+  `pinned-thread-ids` stay in the list even when the jsonl is weeks old.
+  Cursor rows use `composerHeaders.name` (the sidebar title) and skip the
+  `empty-window` duplicate of the same chat.
+- **Memory and Threads lookup.** `GET /api/memory/search?q=` and
+  `GET /api/threads/search?q=` run keyword over local notes (first ~8k of each
+  file, ~2k file budget) then, for memories only, one embedding against the
+  existing `cos_memory` index via `bot_memory.py`. Threads have no embedding
+  index — `semanticAvailable` is false and keyword still works. Literal paths,
+  registered before `/:id`. Does not search meeting Qdrant. Additive; list and
+  detail are unchanged.
+- **Meeting library calendar filters.** `GET /api/meetings` accepts `month=YYYY-MM`
+  and `day=YYYY-MM-DD`, raises the cap to 200 when either is set, and returns
+  `months` plus per-day counts for that month. Unfiltered G2 lists stay at the
+  existing 50-row cap. Additive — extra fields are ignored by older clients.
+- **Meeting lookup.** `GET /api/meetings/search?q=` runs keyword over title,
+  summary, and filename, then meaning search against the existing Qdrant
+  meeting index (one query embedding, no LLM). Keyword still returns if Qdrant
+  is down. Literal path, registered before `/meetings/:domain/:month/:filename`.
+- **Reset live message count.** `POST /api/message-era/reset` with `{ confirm: true }`
+  snapshots live sessions into the day archive, then starts short-numbering at
+  #1. History is not deleted — ARCHIVE / Message History still resolve old
+  stamps. Refuses without confirm, while a query is in flight, or if archive
+  fails. Disk mtime is enough; no server restart. CLI
+  `reset-message-era.ts --confirm` uses the same path.
+- **Grok slot tracks newest high-fast.** `cursor-grok` now resolves to the
+  newest `cursor-grok-<ver>-high-fast` from `agent models` (today 4.6). Low,
+  medium, xhigh, and non-fast ids are ignored. Composer stays pinned to
+  `composer-2.5-fast`. No EHPK change: the phone still sends the stable slot.
+- **Clear stranded video uploads.** Sideload, crash, or a killed composer can
+  leave a `receiving` draft for 4 hours. That draft holds `blocksRestart`, so
+  Repair and Update stall on it instead of clearing it. `POST /api/media/video-upload/clear-stranded`
+  cancels receiving drafts with no active writer and no bytes for 60 seconds.
+  Finalizing and published receipts are left alone.
+
 ## 6.27.6
 - **V2 original chunks are 1 MiB.** Same sequential one-in-flight loop, same
   ArrayBuffer bodies, same GET-progress resume. A 244 MB clip goes from 953

package/README.md

@@ -43,10 +43,10 @@ without silently losing completed replies.
   `npm install -g @anthropic-ai/claude-code` (**never with `sudo`**), then run
   `claude` and finish the browser sign-in
   _or_ **Codex CLI** (GPT Frontier/Balanced) — https://developers.openai.com/codex/, then `codex login`
-- _Optional:_ **Cursor Agent CLI** for Composer 2.5 Fast and Grok 4.5 Fast.
+- _Optional:_ **Cursor Agent CLI** for Composer 2.5 Fast and the newest Grok high-fast.
   Ensure `agent` is on `PATH`, run `agent login`, and verify `agent models`
-  lists `composer-2.5-fast` and `cursor-grok-4.5-high-fast`. COS exposes the
-  Cursor slots only after both models resolve; it never silently substitutes
+  lists `composer-2.5-fast` and a `cursor-grok-*-high-fast` id. COS maps
+  `cursor-grok` to the newest high-fast it finds; it never silently substitutes
   Claude or Codex.
 - **Even G2 glasses** + the **COS Glasses** app from the Even Hub
 - `brew install whisper-cpp` for free local voice (the launcher can download the model)
@@ -108,7 +108,7 @@ range is the exact Tailscale/CGNAT allocation (`100.64.0.0/10`), not all of
   WebView reloads, and network handoffs, then reattaches without duplicate work
   or duplicate replies
 - Choose Opus, Fable, Sonnet, GPT Frontier, GPT Balanced, Composer 2.5 Fast, or
-  Grok 4.5 Fast. Cursor slots fail closed when the local CLI or concrete model
+  the newest Grok high-fast. Cursor slots fail closed when the local CLI or concrete model
   is unavailable; optional redacted tool activity streams only to the
   authenticated query that requested it
 - Message History + cross-day "reference message N" — your chats are archived by day

package/bin/cli.cjs

@@ -179,11 +179,11 @@ function cursorCliState() {
       stdio: ['ignore', 'pipe', 'pipe'],
       timeout: 7000,
     })
-    const required = ['composer-2.5-fast', 'cursor-grok-4.5-high-fast']
+    const grokHighFast = /cursor-grok-\d+(?:\.\d+)*-high-fast/.test(models)
     return {
       binary,
       version,
-      auth: required.every((model) => models.includes(model)) ? 'ready' : 'models-unresolved',
+      auth: models.includes('composer-2.5-fast') && grokHighFast ? 'ready' : 'models-unresolved',
     }
   } catch (err) {
     const output = `${err.stdout?.toString() || ''}\n${err.stderr?.toString() || ''}`
@@ -230,13 +230,13 @@ if (codexVersion) {
 }
 if (cursor.binary) {
   if (cursor.auth === 'ready') {
-    console.log(green('  ✓') + ` Cursor Agent ${cursor.version} ` + dim('(Composer 2.5 / Grok 4.5)'))
+    console.log(green('  ✓') + ` Cursor Agent ${cursor.version} ` + dim('(Composer 2.5 / newest Grok high-fast)'))
   } else if (cursor.auth === 'signed-out') {
     console.log(yellow('  ⚠') + ` Cursor Agent ${cursor.version} installed — sign-in required`)
     console.log('    Run: ' + bold('agent login'))
   } else if (cursor.auth === 'models-unresolved') {
     console.log(yellow('  ⚠') + ` Cursor Agent ${cursor.version} installed — required models unresolved`)
-    console.log('    Verify: ' + bold('agent models') + ' includes Composer 2.5 Fast and Grok 4.5 Fast')
+    console.log('    Verify: ' + bold('agent models') + ' includes Composer 2.5 Fast and a cursor-grok-*-high-fast id')
   } else {
     console.log(yellow('  ⚠') + ` Cursor Agent ${cursor.version} installed — readiness unavailable`)
     console.log('    Verify: ' + bold('agent models'))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotcos/glasses-server",
-  "version": "6.27.6",
+  "version": "6.27.9",
   "description": "COS Glasses \u2014 self-hosted AI heads-up-display server for Even G2 smart glasses, powered by Claude Code, Codex, or Cursor Agent CLI",
   "type": "module",
   "bin": {

package/server/index.ts

@@ -18,6 +18,7 @@ import { queryRouter } from './routes/query.js'
 import { providerProofRouter } from './routes/provider-proof.js'
 import { transcribeRouter } from './routes/transcribe.js'
 import { sessionIndexRouter } from './routes/session-index.js'
+import { agentSessionsRouter } from './routes/agent-sessions.js'
 import { claudeSessionsRouter } from './routes/claude-sessions.js'
 import { displayRouter } from './routes/display.js'
 import { transcribeStreamRouter } from './routes/transcribe-stream.js'
@@ -274,6 +275,8 @@ app.use('/api', transcribeRouter)
 // Ported from cos-glasses-app in 6.24.0. The companion's Sessions tab has been
 // calling this and getting a 404 since the managed-runtime cutover.
 app.use('/api', sessionIndexRouter)
+// Claude + Codex + Cursor transcripts from this Mac. Same 7-day window as Control.
+app.use('/api', agentSessionsRouter)
 // Presence view of Claude Code sessions on this Mac. Dark unless
 // COS_CLAUDE_SESSIONS_ENABLED=1 — it projects another product's 0700 state dir.
 app.use('/api', claudeSessionsRouter)

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

@@ -0,0 +1,447 @@
+/**
+ * Sessions lookup for COS Control.
+ *
+ * Keyword: local title / sidebar name / first prompt / transcript scan. No model.
+ * Semantic: one OpenAI query embedding scored against those same texts.
+ * Sessions have no Qdrant collection — this is not meeting or memory search.
+ * The 7-day list window does not apply; older chats stay findable.
+ */
+
+import { join } from 'node:path'
+import { scoreKeywordMatch, tokenizeMeetingQuery } from './meeting-library-search.js'
+import { tryGetOpenAIKey } from './openai-key.js'
+import {
+  AGENT_SESSION_MAX_FILE_BYTES,
+  CLAUDE_UUID_JSONL,
+  agentSessionRoots,
+  createdFromCodexFilename,
+  dirents,
+  fileStat,
+  findClaudeDesktopFile,
+  firstClaudeUserTitle,
+  firstLineTitle,
+  idFromCodexFilename,
+  isKeepWarmSessionTitle,
+  isSkippedCursorFolder,
+  isWrapperPrompt,
+  isoFromMtime,
+  lastCustomTitle,
+  listCodexJsonlFiles,
+  loadClaudeStarredIds,
+  loadCodexPinnedIds,
+  loadCodexThreadNames,
+  loadCursorComposerNames,
+  loadCursorPinnedIds,
+  parseJsonLine,
+  payloadText,
+  peekClaudeDesktopHead,
+  peekCodexMeta,
+  preferCursorCopy,
+  readWindow,
+  workspaceLabel,
+  type AgentProvider,
+  type AgentSessionRoots,
+  type AgentSessionRow,
+} from './agent-session-store.js'
+
+const HEAD_TEXT = 8_000
+const MAX_SCAN_FILES = 400
+const SEMANTIC_DOC_CAP = 120
+const SEMANTIC_MIN = 0.28
+const EMBED_MODEL = 'text-embedding-3-small'
+const EMBED_TIMEOUT_MS = 12_000
+const EMBED_BATCH = 64
+
+export interface AgentSessionSearchHit extends AgentSessionRow {
+  snippet: string
+  keywordScore: number
+  semanticScore: number
+  match: 'keyword' | 'semantic' | 'both'
+}
+
+export interface AgentSessionSearchResult {
+  hits: AgentSessionSearchHit[]
+  keywordCount: number
+  semanticCount: number
+  semanticAvailable: boolean
+  semanticReason?: string
+}
+
+export type EmbedTexts = (texts: string[]) => Promise<number[][] | { reason: string }>
+
+interface SearchDoc {
+  row: AgentSessionRow
+  title: string
+  haystack: string
+}
+
+function clip(text: string, max = HEAD_TEXT): string {
+  return text.replace(/\s+/g, ' ').trim().slice(0, max)
+}
+
+function extractUserText(provider: AgentProvider, raw: string): string {
+  const parts: string[] = []
+  for (const line of raw.split('\n')) {
+    const obj = parseJsonLine(line)
+    if (!obj) continue
+    if (provider === 'claude') {
+      if (obj.isSidechain === true || obj.toolUseResult) continue
+      if (obj.type === 'custom-title' && typeof obj.customTitle === 'string') {
+        parts.push(obj.customTitle)
+        continue
+      }
+      if (obj.type !== 'user') continue
+      const message = obj.message && typeof obj.message === 'object' ? obj.message as Record<string, unknown> : null
+      const body = message ? payloadText(message) : null
+      if (body && !isWrapperPrompt(body)) parts.push(firstLineTitle(body) || body)
+    } else if (provider === 'codex') {
+      if (obj.type !== 'response_item' || !obj.payload || typeof obj.payload !== 'object') continue
+      const payload = obj.payload as Record<string, unknown>
+      if (payload.type !== 'message' || payload.role === 'developer' || payload.role === 'assistant') continue
+      const body = payloadText(payload)
+      if (body && !isWrapperPrompt(body)) parts.push(firstLineTitle(body) || body)
+    } else {
+      if (obj.role !== 'user') continue
+      const message = obj.message && typeof obj.message === 'object' ? obj.message as Record<string, unknown> : null
+      const body = message ? payloadText(message) : null
+      if (!body) continue
+      const title = firstLineTitle(body)
+      if (title && !isWrapperPrompt(title)) parts.push(title)
+    }
+    if (parts.join('\n').length >= HEAD_TEXT) break
+  }
+  return clip(parts.join('\n'))
+}
+
+async function transcriptHaystack(provider: AgentProvider, path: string): Promise<string> {
+  const head = await readWindow(path, false)
+  const tail = await readWindow(path, true)
+  const raw = head === tail ? head : `${head}\n${tail}`
+  return extractUserText(provider, raw)
+}
+
+export function cosineSimilarity(a: number[], b: number[]): number {
+  if (a.length === 0 || a.length !== b.length) return 0
+  let dot = 0
+  let left = 0
+  let right = 0
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i]
+    left += a[i] * a[i]
+    right += b[i] * b[i]
+  }
+  if (left <= 0 || right <= 0) return 0
+  return dot / (Math.sqrt(left) * Math.sqrt(right))
+}
+
+export async function defaultEmbedTexts(texts: string[]): Promise<number[][] | { reason: string }> {
+  const key = tryGetOpenAIKey()
+  if (!key) return { reason: 'no_session_embeddings' }
+  if (texts.length === 0) return []
+  const vectors: number[][] = new Array(texts.length)
+  for (let offset = 0; offset < texts.length; offset += EMBED_BATCH) {
+    const slice = texts.slice(offset, offset + EMBED_BATCH).map(text => text.slice(0, HEAD_TEXT))
+    try {
+      const response = await fetch('https://api.openai.com/v1/embeddings', {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${key}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ model: EMBED_MODEL, input: slice }),
+        signal: AbortSignal.timeout(EMBED_TIMEOUT_MS),
+      })
+      if (!response.ok) return { reason: 'embeddings_unreachable' }
+      const parsed = await response.json() as { data?: Array<{ embedding?: number[]; index?: number }> }
+      const rows = Array.isArray(parsed.data) ? parsed.data : []
+      for (const row of rows) {
+        const index = typeof row.index === 'number' ? row.index : 0
+        if (Array.isArray(row.embedding)) vectors[offset + index] = row.embedding
+      }
+    } catch {
+      return { reason: 'embeddings_unreachable' }
+    }
+  }
+  if (vectors.some(row => !Array.isArray(row) || row.length === 0)) return { reason: 'embeddings_unreachable' }
+  return vectors
+}
+
+function pushDoc(docs: SearchDoc[], next: SearchDoc) {
+  const key = `${next.row.provider}:${next.row.session_id.toLowerCase()}`
+  const existing = docs.find(doc => `${doc.row.provider}:${doc.row.session_id.toLowerCase()}` === key)
+  if (!existing) {
+    docs.push(next)
+    return
+  }
+  if (next.haystack.length > existing.haystack.length) existing.haystack = next.haystack
+  if (next.title && (existing.title.endsWith(' session') || next.title.length > existing.title.length)) {
+    existing.title = next.title
+    existing.row = { ...existing.row, display_label: next.title }
+  }
+}
+
+async function collectClaudeDocs(roots: AgentSessionRoots, docs: SearchDoc[], budget: { remaining: number }) {
+  const starred = await loadClaudeStarredIds(roots.claudeDesktopConfig)
+  for (const folder of await dirents(roots.claudeProjects)) {
+    const dir = join(roots.claudeProjects, folder)
+    for (const name of await dirents(dir)) {
+      if (!CLAUDE_UUID_JSONL.test(name) || budget.remaining <= 0) continue
+      const file = join(dir, name)
+      const st = await fileStat(file)
+      if (!st?.isFile) continue
+      budget.remaining -= 1
+      const native = name.slice(0, -6)
+      const custom = await lastCustomTitle(file)
+      const first = await firstClaudeUserTitle(file)
+      const users = await transcriptHaystack('claude', file)
+      const title = custom || first || 'Claude session'
+      if (isKeepWarmSessionTitle(title)) continue
+      const haystack = clip(`${title}\n${custom || ''}\n${first || ''}\n${workspaceLabel(folder)}\n${users}`)
+      pushDoc(docs, {
+        title,
+        haystack,
+        row: {
+          session_id: native,
+          provider: 'claude',
+          display_label: title,
+          project: workspaceLabel(folder),
+          modified: isoFromMtime(st.mtimeMs),
+          created: isoFromMtime(st.birthtimeMs),
+          alive: false,
+          state: 'recent',
+          pinned: starred.has(native.toLowerCase()),
+        },
+      })
+    }
+  }
+  for (const starredId of starred) {
+    if (docs.some(doc => doc.row.provider === 'claude' && doc.row.session_id.toLowerCase() === starredId)) continue
+    if (budget.remaining <= 0) break
+    const desktop = await findClaudeDesktopFile(roots.claudeCodeSessions, starredId)
+    if (!desktop) continue
+    const st = await fileStat(desktop)
+    if (!st?.isFile) continue
+    budget.remaining -= 1
+    const head = peekClaudeDesktopHead(await readWindow(desktop, false))
+    const title = head.title || 'Claude session'
+    if (isKeepWarmSessionTitle(title)) continue
+    pushDoc(docs, {
+      title,
+      haystack: clip(`${title}\n${head.cwd}\n${workspaceLabel(head.cwd)}`),
+      row: {
+        session_id: starredId,
+        provider: 'claude',
+        display_label: title,
+        project: workspaceLabel(head.cwd),
+        modified: isoFromMtime(st.mtimeMs),
+        created: isoFromMtime(st.birthtimeMs),
+        alive: false,
+        state: 'recent',
+        pinned: true,
+      },
+    })
+  }
+}
+
+async function collectCodexDocs(roots: AgentSessionRoots, docs: SearchDoc[], budget: { remaining: number }) {
+  const names = await loadCodexThreadNames(roots.codexSessions)
+  const pinned = await loadCodexPinnedIds(roots.codexSessions)
+  for (const file of await listCodexJsonlFiles(roots.codexSessions)) {
+    if (budget.remaining <= 0) break
+    const st = await fileStat(file)
+    if (!st?.isFile) continue
+    budget.remaining -= 1
+    const meta = await peekCodexMeta(file)
+    if (!meta || meta.subagent) continue
+    const name = file.split('/').pop() || file
+    const native = meta.id || name.slice(0, -6)
+    const thread = names.get(native) || ''
+    const title = thread || meta.title || 'Codex session'
+    if (isKeepWarmSessionTitle(title)) continue
+    const users = await transcriptHaystack('codex', file)
+    const created = meta.created || createdFromCodexFilename(name) || isoFromMtime(st.birthtimeMs)
+    pushDoc(docs, {
+      title,
+      haystack: clip(`${title}\n${thread}\n${meta.title}\n${meta.cwd}\n${users}`),
+      row: {
+        session_id: native,
+        provider: 'codex',
+        display_label: title,
+        project: workspaceLabel(meta.cwd),
+        modified: isoFromMtime(st.mtimeMs),
+        created,
+        alive: false,
+        state: 'recent',
+        pinned: pinned.has(native.toLowerCase()) || Boolean(idFromCodexFilename(name) && pinned.has(idFromCodexFilename(name)!)),
+      },
+    })
+  }
+}
+
+async function collectCursorDocs(
+  roots: AgentSessionRoots,
+  docs: SearchDoc[],
+  budget: { remaining: number },
+  now: Date,
+) {
+  const composerNames = await loadCursorComposerNames(roots.cursorComposerDb)
+  const pinnedIds = await loadCursorPinnedIds(roots.cursorWorkspaceStorage)
+  const byId = new Map<string, { file: string; project: string; mtimeMs: number; birthtimeMs: number }>()
+  for (const folder of await dirents(roots.cursorProjects)) {
+    if (isSkippedCursorFolder(folder)) continue
+    const transcripts = join(roots.cursorProjects, folder, 'agent-transcripts')
+    for (const sessionDir of await dirents(transcripts)) {
+      if (sessionDir === 'subagents') continue
+      if (folder === 'empty-window' && !pinnedIds.has(sessionDir.toLowerCase())) continue
+      const file = join(transcripts, sessionDir, `${sessionDir}.jsonl`)
+      const st = await fileStat(file)
+      if (!st?.isFile) continue
+      if (st.size > AGENT_SESSION_MAX_FILE_BYTES && !pinnedIds.has(sessionDir.toLowerCase())) continue
+      const next = { file, project: workspaceLabel(folder), mtimeMs: st.mtimeMs, birthtimeMs: st.birthtimeMs }
+      const existing = byId.get(sessionDir)
+      byId.set(sessionDir, existing ? preferCursorCopy({ ...next, sessionDir }, { ...existing, sessionDir }) : next)
+    }
+  }
+  const ranked = [...byId.entries()].sort((a, b) => b[1].mtimeMs - a[1].mtimeMs)
+  for (const [sessionDir, candidate] of ranked) {
+    if (budget.remaining <= 0) break
+    budget.remaining -= 1
+    const sidebar = composerNames.get(sessionDir) || ''
+    const users = await transcriptHaystack('cursor', candidate.file)
+    const title = sidebar || users.split('\n')[0] || 'Cursor session'
+    if (isKeepWarmSessionTitle(title)) continue
+    pushDoc(docs, {
+      title,
+      haystack: clip(`${title}\n${sidebar}\n${candidate.project}\n${users}`),
+      row: {
+        session_id: sessionDir,
+        provider: 'cursor',
+        display_label: title,
+        project: candidate.project,
+        modified: isoFromMtime(candidate.mtimeMs),
+        created: isoFromMtime(candidate.birthtimeMs),
+        alive: now.getTime() - candidate.mtimeMs < 180_000,
+        state: now.getTime() - candidate.mtimeMs < 180_000 ? 'running' : 'recent',
+        pinned: pinnedIds.has(sessionDir.toLowerCase()),
+      },
+    })
+  }
+}
+
+export async function collectAgentSessionSearchDocs(
+  roots: AgentSessionRoots = agentSessionRoots(),
+  cap = MAX_SCAN_FILES,
+  now = new Date(),
+): Promise<SearchDoc[]> {
+  const docs: SearchDoc[] = []
+  const share = Math.max(1, Math.ceil(Math.min(cap, MAX_SCAN_FILES) / 3))
+  await collectClaudeDocs(roots, docs, { remaining: share })
+  await collectCodexDocs(roots, docs, { remaining: share })
+  await collectCursorDocs(roots, docs, { remaining: share }, now)
+  docs.sort((a, b) => (b.row.modified || '').localeCompare(a.row.modified || ''))
+  return docs.slice(0, Math.max(1, Math.min(cap, MAX_SCAN_FILES)))
+}
+
+export function keywordSearchSessions(docs: SearchDoc[], query: string): AgentSessionSearchHit[] {
+  const tokens = tokenizeMeetingQuery(query)
+  if (tokens.length === 0) return []
+  const hits: AgentSessionSearchHit[] = []
+  for (const doc of docs) {
+    const scored = scoreKeywordMatch(tokens, doc.title, doc.haystack)
+    if (scored.score <= 0) continue
+    hits.push({
+      ...doc.row,
+      snippet: scored.snippet || doc.title,
+      keywordScore: scored.score,
+      semanticScore: 0,
+      match: 'keyword',
+    })
+  }
+  return hits.sort((a, b) => b.keywordScore - a.keywordScore)
+}
+
+export async function semanticSearchSessions(
+  docs: SearchDoc[],
+  query: string,
+  limit: number,
+  embedTexts: EmbedTexts = defaultEmbedTexts,
+): Promise<{ hits: AgentSessionSearchHit[]; reason?: string }> {
+  const pool = docs.slice(0, SEMANTIC_DOC_CAP)
+  if (pool.length === 0) return { hits: [] }
+  const embedded = await embedTexts([query, ...pool.map(doc => clip(`${doc.title}\n${doc.haystack}`, 1_500))])
+  if (!Array.isArray(embedded)) return { hits: [], reason: embedded.reason }
+  const [queryVec, ...docVecs] = embedded
+  if (!queryVec) return { hits: [], reason: 'embeddings_unreachable' }
+  const hits: AgentSessionSearchHit[] = []
+  for (let i = 0; i < pool.length; i++) {
+    const score = cosineSimilarity(queryVec, docVecs[i] || [])
+    if (score < SEMANTIC_MIN) continue
+    const doc = pool[i]
+    hits.push({
+      ...doc.row,
+      snippet: clip(doc.haystack, 180),
+      keywordScore: 0,
+      semanticScore: Math.max(0, Math.min(1, score)),
+      match: 'semantic',
+    })
+  }
+  return {
+    hits: hits.sort((a, b) => b.semanticScore - a.semanticScore).slice(0, Math.max(1, Math.min(limit, 50))),
+  }
+}
+
+export function mergeSessionSearchHits(
+  keywordHits: AgentSessionSearchHit[],
+  semanticHits: AgentSessionSearchHit[],
+  limit: number,
+): AgentSessionSearchHit[] {
+  const merged = new Map<string, AgentSessionSearchHit>()
+  const keyFor = (hit: AgentSessionSearchHit) => `${hit.provider}:${hit.session_id.toLowerCase()}`
+  for (const hit of keywordHits) merged.set(keyFor(hit), { ...hit })
+  for (const hit of semanticHits) {
+    const key = keyFor(hit)
+    const existing = merged.get(key)
+    if (!existing) {
+      merged.set(key, hit)
+      continue
+    }
+    merged.set(key, {
+      ...existing,
+      snippet: existing.snippet || hit.snippet,
+      semanticScore: Math.max(existing.semanticScore, hit.semanticScore),
+      match: existing.keywordScore > 0 && hit.semanticScore > 0 ? 'both' : existing.match,
+    })
+  }
+  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 searchAgentSessions(options: {
+  query: string
+  limit?: number
+  roots?: AgentSessionRoots
+  embedTexts?: EmbedTexts
+  now?: Date
+}): Promise<AgentSessionSearchResult> {
+  const query = options.query.trim()
+  const limit = Math.max(1, Math.min(options.limit ?? 20, 50))
+  const docs = await collectAgentSessionSearchDocs(
+    options.roots ?? agentSessionRoots(),
+    MAX_SCAN_FILES,
+    options.now,
+  )
+  const keywordHits = keywordSearchSessions(docs, query)
+  const semantic = await semanticSearchSessions(docs, query, limit, options.embedTexts ?? defaultEmbedTexts)
+  return {
+    hits: mergeSessionSearchHits(keywordHits, semantic.hits, limit),
+    keywordCount: keywordHits.length,
+    semanticCount: semantic.hits.length,
+    semanticAvailable: !semantic.reason,
+    ...(semantic.reason ? { semanticReason: semantic.reason } : {}),
+  }
+}