@gotcos/glasses-server 6.27.5 → 6.27.7

package/server/lib/video-upload-v2.ts

@@ -27,7 +27,12 @@ import { getMediaStore } from './media-store.js'
 import { MAX_CHUNKED_MEDIA_BYTES, MAX_VIDEO_DURATION_MS } from './rich-media-safety.js'
 
 export const VIDEO_UPLOAD_V2_PROTOCOL = 1
-export const VIDEO_UPLOAD_V2_CHUNK_BYTES = 256 * 1024
+/** New sessions only. In-flight drafts keep the chunkBytes baked into their
+ *  manifest — a 256 KiB upload that survives this upgrade must not be rewritten
+ *  to 1 MiB mid-transfer. The phone parser currently rejects advertised sizes
+ *  above 1 MiB and disables V2 entirely, so do not raise this without raising
+ *  that cap first. */
+export const VIDEO_UPLOAD_V2_CHUNK_BYTES = 1024 * 1024
 export const VIDEO_UPLOAD_V2_MAX_FRAME_BYTES = 256 * 1024
 export const VIDEO_UPLOAD_V2_MAX_FRAME_PACK_BYTES = 2 * 1024 * 1024
 export const VIDEO_UPLOAD_PHONE_FRAMES_MIN = 8
@@ -40,6 +45,9 @@ export const VIDEO_UPLOAD_V2_MAX_CONCURRENT = 8
 export const VIDEO_UPLOAD_V2_TOTAL_RESERVED_BYTES = 4 * 1024 * 1024 * 1024
 export const VIDEO_UPLOAD_V2_FREE_DISK_RESERVE_BYTES = 512 * 1024 * 1024
 export const VIDEO_UPLOAD_V2_ACCEPTED_MIMES = ['video/mp4', 'video/quicktime'] as const
+/** Idle receiving drafts older than this are stranded. Live PUTs refresh
+ *  updatedAtMs; a 1 MiB chunk on a clean link is seconds, not a minute. */
+export const VIDEO_UPLOAD_V2_STRANDED_IDLE_MS = 60_000
 
 const UPLOAD_ID_RE = /^vu_[0-9a-f]{24}$/
 const CLIENT_REQUEST_RE = /^[A-Za-z0-9._:-]{16,160}$/
@@ -57,6 +65,22 @@ export function isValidVideoUploadId(value: unknown): value is string {
   return typeof value === 'string' && UPLOAD_ID_RE.test(value)
 }
 
+/** Sideload/kill leftover: receiving, no writer, no bytes for idleMs.
+ *  Never true for finalizing or published — those are live work or receipts. */
+export function isStrandedReceivingVideoUpload(input: {
+  state: string
+  updatedAtMs: number
+  nowMs: number
+  activeWriters?: number
+  idleMs?: number
+}): boolean {
+  const idleMs = input.idleMs ?? VIDEO_UPLOAD_V2_STRANDED_IDLE_MS
+  if (input.state !== 'receiving') return false
+  if ((input.activeWriters ?? 0) > 0) return false
+  if (!Number.isFinite(input.updatedAtMs) || !Number.isFinite(input.nowMs) || idleMs < 0) return false
+  return input.nowMs - input.updatedAtMs >= idleMs
+}
+
 export type VideoUploadState = 'receiving' | 'finalizing' | 'published' | 'cancelled' | 'failed'
 
 interface AcceptedPart {
@@ -177,6 +201,17 @@ function parseIndex(value: unknown): number | null {
   return typeof raw === 'number' && Number.isSafeInteger(raw) && raw >= 0 ? raw : null
 }
 
+/** Exact byte length this session expects for original index `index`.
+ *  Non-final parts are the session's own chunkBytes (which may be 256 KiB on a
+ *  draft that started before the 1 MiB advertisement). The last part is the
+ *  remainder. Using the live constant here would accept a 1 MiB PUT into a
+ *  256 KiB slot and fail assembly, or reject a legitimate leftover last chunk. */
+function expectedOriginalPartBytes(manifest: VideoUploadManifest, index: number): number {
+  if (index < 0 || index >= manifest.chunkCount) return 0
+  if (index === manifest.chunkCount - 1) return manifest.totalBytes - index * manifest.chunkBytes
+  return manifest.chunkBytes
+}
+
 function sameInit(manifest: VideoUploadManifest, input: Required<Pick<VideoUploadManifest,
   'serverInstanceId' | 'totalBytes' | 'mime'>> & Pick<VideoUploadManifest, 'label' | 'capturedAt' | 'sessionId'>): boolean {
   return manifest.serverInstanceId === input.serverInstanceId
@@ -391,6 +426,46 @@ export class VideoUploadRegistry {
     })
   }
 
+  async clearStrandedReceiving(serverInstanceId?: string): Promise<{
+    cancelled: string[]
+    skipped: Array<{ uploadId: string; reason: string }>
+  }> {
+    const nowMs = this.now()
+    const cancelled: string[] = []
+    const skipped: Array<{ uploadId: string; reason: string }> = []
+    for (const manifest of [...this.manifests.values()]) {
+      if (manifest.state === 'finalizing') {
+        skipped.push({ uploadId: manifest.uploadId, reason: 'finalizing' })
+        continue
+      }
+      if (manifest.state !== 'receiving') continue
+      const activeWriters = this.activeWriters.get(manifest.uploadId) ?? 0
+      if (!isStrandedReceivingVideoUpload({
+        state: manifest.state,
+        updatedAtMs: manifest.updatedAtMs,
+        nowMs,
+        activeWriters,
+      })) {
+        skipped.push({
+          uploadId: manifest.uploadId,
+          reason: activeWriters > 0 ? 'active_writer' : 'recently_updated',
+        })
+        continue
+      }
+      try {
+        const progress = await this.cancel(manifest.uploadId, serverInstanceId)
+        if (progress) cancelled.push(manifest.uploadId)
+      } catch (error) {
+        if (error instanceof VideoUploadError && error.code === 'server_identity_mismatch') {
+          skipped.push({ uploadId: manifest.uploadId, reason: 'identity_mismatch' })
+          continue
+        }
+        throw error
+      }
+    }
+    return { cancelled, skipped }
+  }
+
   status(): VideoUploadStatus {
     this.sweepExpired()
     let receiving = 0; let finalizing = 0; let unacknowledgedPublished = 0; let failed = 0
@@ -442,8 +517,8 @@ export class VideoUploadRegistry {
   ): Promise<VideoUploadProgress> {
     const index = parseIndex(indexValue)
     if (index === null || bytes.length === 0) throw new VideoUploadError('video_upload_invalid', 'valid non-empty part required')
-    const max = kind === 'original' ? VIDEO_UPLOAD_V2_CHUNK_BYTES : VIDEO_UPLOAD_V2_MAX_FRAME_BYTES
-    if (bytes.length > max) throw new VideoUploadError('video_upload_invalid', 'part exceeds its byte ceiling', { maxBytes: max })
+    const advertisedMax = kind === 'original' ? VIDEO_UPLOAD_V2_CHUNK_BYTES : VIDEO_UPLOAD_V2_MAX_FRAME_BYTES
+    if (bytes.length > advertisedMax) throw new VideoUploadError('video_upload_invalid', 'part exceeds its byte ceiling', { maxBytes: advertisedMax })
     this.activeWriters.set(uploadId, (this.activeWriters.get(uploadId) ?? 0) + 1)
     try {
       return await this.withLock(uploadId, () => {
@@ -451,6 +526,14 @@ export class VideoUploadRegistry {
         if (manifest.state !== 'receiving') throw new VideoUploadError('video_upload_busy', `upload is ${manifest.state}`)
         if (kind === 'original' && index >= manifest.chunkCount) throw new VideoUploadError('video_upload_invalid', 'chunk index exceeds declared upload')
         if (kind === 'frames' && index >= VIDEO_UPLOAD_PHONE_FRAMES_MAX) throw new VideoUploadError('video_upload_invalid', 'frame index exceeds pack limit')
+        if (kind === 'original') {
+          const expected = expectedOriginalPartBytes(manifest, index)
+          if (bytes.length !== expected) {
+            throw new VideoUploadError('video_upload_invalid', 'part does not match the session chunk size', {
+              expectedBytes: expected, receivedBytes: bytes.length, chunkBytes: manifest.chunkBytes,
+            })
+          }
+        }
         const collection = manifest[kind]
         const key = String(index)
         const digest = sha256(bytes)

package/server/routes/agent-sessions.ts

@@ -0,0 +1,201 @@
+// GET /api/agent-sessions
+// GET /api/agent-sessions/search?q=
+// GET /api/agent-sessions/:provider/:sessionId
+//
+// Same local stores COS Control reads for Activity → Sessions:
+// Claude jsonl, Codex rollouts, Cursor agent-transcripts.
+// Default list is last 7 days of writes (mtime), including pinned Codex
+// threads whose jsonl still lives in the original day folder.
+// `?sort=updated` matches Control's Updated clock: newest mtime first.
+// Stale pins stay in the payload but do not cluster at the top.
+// `?sort=opened` keeps the same window on session start instead.
+// Search scans titles, sidebar names, first prompts, and transcript heads
+// without the 7-day list window. Literal /search is registered first.
+// Does not need COS_SCRIPTS_DIR. Codex subagents stay out. Files over 32 MB
+// still appear in the list; detail remains capped.
+
+import { Router } from 'express'
+import { stat } from 'node:fs/promises'
+import {
+  AGENT_SESSION_LIST_LIMIT,
+  AGENT_SESSION_LIST_MAX,
+  AGENT_SESSION_MAX_FILE_BYTES,
+  AGENT_SESSION_WINDOW_HOURS,
+  agentSessionRoots,
+  findAgentSessionFile,
+  listAgentSessions,
+  loadCursorComposerNames,
+  parseAgentSession,
+  type AgentProvider,
+  type AgentSessionRow,
+  type AgentSessionSort,
+} from '../lib/agent-session-store.js'
+import { searchAgentSessions, type AgentSessionSearchHit } from '../lib/agent-session-search.js'
+import { claudeSessionNamesVisible, claudeSessionsDir, claudeSessionsEnabled, readClaudePeers } from './claude-sessions.js'
+import { workspaceFromCwd } from '../lib/claude-session-registry.js'
+
+export const agentSessionsRouter = Router()
+
+function boundedInteger(value: unknown, fallback: number, min: number, max: number): number {
+  const parsed = Number(value)
+  if (!Number.isFinite(parsed)) return fallback
+  return Math.max(min, Math.min(max, Math.trunc(parsed)))
+}
+
+function asProvider(value: string): AgentProvider | null {
+  if (value === 'claude' || value === 'codex' || value === 'cursor') return value
+  return null
+}
+
+function asSort(value: unknown): AgentSessionSort {
+  return String(value ?? '').toLowerCase() === 'opened' ? 'opened' : 'updated'
+}
+
+function toSearchHit(row: AgentSessionSearchHit) {
+  return {
+    ...toEntry(row),
+    snippet: row.snippet,
+    keywordScore: row.keywordScore,
+    semanticScore: row.semanticScore,
+    match: row.match,
+    score: Math.max(row.keywordScore, row.semanticScore),
+  }
+}
+
+function toEntry(row: AgentSessionRow) {
+  return {
+    session_id: row.session_id,
+    provider: row.provider,
+    slug: row.session_id,
+    custom_title: row.display_label,
+    display_label: row.display_label,
+    first_prompt: row.first_prompt || row.display_label,
+    discussion_summary: row.discussion_summary || '',
+    project: row.project,
+    created: row.created,
+    modified: row.modified,
+    duration_minutes: 0,
+    message_count: 0,
+    domain: '',
+    device_id: row.provider,
+    machine_spawned: false,
+    alive: row.alive,
+    state: row.state,
+    pinned: row.pinned,
+  }
+}
+
+async function liveClaudeRows(): Promise<AgentSessionRow[]> {
+  if (!claudeSessionsEnabled()) return []
+  const peers = await readClaudePeers(claudeSessionsDir(), undefined, claudeSessionNamesVisible())
+  return peers.filter(peer => peer.alive).map(peer => ({
+    session_id: peer.id,
+    provider: 'claude' as const,
+    display_label: peer.name || 'Claude session',
+    project: workspaceFromCwd(peer.workspace) || peer.workspace,
+    modified: peer.lastActiveAt ? new Date(peer.lastActiveAt).toISOString() : new Date().toISOString(),
+    created: peer.startedAt ? new Date(peer.startedAt).toISOString() : new Date().toISOString(),
+    alive: true,
+    state: 'running' as const,
+    pinned: false,
+  }))
+}
+
+agentSessionsRouter.get('/agent-sessions', async (req, res) => {
+  res.set('Cache-Control', 'private, no-store')
+  try {
+    const limit = boundedInteger(req.query.limit, AGENT_SESSION_LIST_LIMIT, 1, AGENT_SESSION_LIST_MAX)
+    const sort = asSort(req.query.sort)
+    const live = await liveClaudeRows()
+    const sessions = await listAgentSessions(agentSessionRoots(), new Date(), live, limit, sort)
+    res.json({
+      sessions: sessions.map(toEntry),
+      total: sessions.length,
+      windowHours: AGENT_SESSION_WINDOW_HOURS,
+      sort,
+      enabled: true,
+    })
+  } catch (error) {
+    console.error(`[agent-sessions] list failed: ${error instanceof Error ? error.message : error}`)
+    res.status(500).json({ error: 'Failed to read agent sessions', reason: 'agent_sessions_read_failed' })
+  }
+})
+
+agentSessionsRouter.get('/agent-sessions/search', async (req, res) => {
+  res.set('Cache-Control', 'private, no-store')
+  const query = typeof req.query.q === 'string' ? req.query.q.trim() : ''
+  if (query.length < 2) {
+    res.status(400).json({ error: 'q must be at least 2 characters', reason: 'invalid_query' })
+    return
+  }
+  try {
+    const limit = boundedInteger(req.query.limit, 20, 1, 50)
+    const result = await searchAgentSessions({ query, limit })
+    res.json({
+      ...result,
+      hits: result.hits.map(toSearchHit),
+    })
+  } catch (error) {
+    console.error(`[agent-sessions] search failed: ${error instanceof Error ? error.message : error}`)
+    res.status(500).json({ error: 'Failed to search agent sessions', reason: 'agent_sessions_search_failed' })
+  }
+})
+
+agentSessionsRouter.get('/agent-sessions/:provider/:sessionId', async (req, res) => {
+  res.set('Cache-Control', 'private, no-store')
+  const provider = asProvider(String(req.params.provider ?? '').toLowerCase())
+  const sessionId = String(req.params.sessionId ?? '')
+  if (!provider) {
+    res.status(400).json({ error: 'provider must be claude, codex, or cursor', reason: 'bad_provider' })
+    return
+  }
+  try {
+    const found = await findAgentSessionFile(provider, sessionId, agentSessionRoots())
+    if (!found) {
+      res.status(404).json({ error: 'Session not found', reason: 'session_not_found' })
+      return
+    }
+    const st = await stat(found)
+    if (st.size > AGENT_SESSION_MAX_FILE_BYTES) {
+      res.status(413).json({ error: 'Session too large to open', reason: 'session_too_large' })
+      return
+    }
+    const parsed = await parseAgentSession(provider, found)
+    if (provider === 'cursor') {
+      const names = await loadCursorComposerNames(agentSessionRoots().cursorComposerDb)
+      const named = names.get(parsed.session_id) || names.get(sessionId)
+      if (named) parsed.display_label = named
+    }
+    const modified = st.mtime.toISOString()
+    res.json({
+      session_id: parsed.session_id,
+      provider: parsed.provider,
+      slug: parsed.session_id,
+      custom_title: parsed.display_label,
+      display_label: parsed.display_label,
+      first_prompt: parsed.first_prompt,
+      discussion_summary: parsed.discussion_summary || '',
+      project: parsed.project,
+      created: modified,
+      modified,
+      duration_minutes: 0,
+      message_count: parsed.user_message_count + parsed.assistant_message_count,
+      user_message_count: parsed.user_message_count,
+      assistant_message_count: parsed.assistant_message_count,
+      domain: '',
+      device_id: parsed.provider,
+      machine_spawned: false,
+      tools_used: {},
+      files_touched: [],
+      git_branch: parsed.git_branch || 'unknown',
+      has_subagents: false,
+      total_input_tokens: 0,
+      total_output_tokens: 0,
+      file_size_bytes: parsed.file_size_bytes,
+      omitted_tools: parsed.omitted_tools,
+    })
+  } catch (error) {
+    console.error(`[agent-sessions] detail failed: ${error instanceof Error ? error.message : error}`)
+    res.status(500).json({ error: 'Failed to read agent session', reason: 'agent_sessions_read_failed' })
+  }
+})

package/server/routes/media.ts

@@ -620,6 +620,16 @@ mediaRouter.post('/media/video-upload/init', (req: Request, res: Response) => {
   }
 })
 
+mediaRouter.post('/media/video-upload/clear-stranded', async (req: Request, res: Response) => {
+  try {
+    const serverInstanceId = requireCurrentServerIdentity(req)
+    const result = await getVideoUploadRegistry().clearStrandedReceiving(serverInstanceId)
+    res.json({ ok: true, ...result })
+  } catch (err) {
+    sendMediaError(res, err)
+  }
+})
+
 mediaRouter.get('/media/video-upload/:uploadId', (req: Request, res: Response) => {
   try {
     const serverInstanceId = requireCurrentServerIdentity(req)

package/server/routes/meetings.ts

@@ -7,10 +7,19 @@ import {
   getDirectLibraryMeetingDetail,
   getCosOperationsMeetingDetail,
   listDirectLibraryMeetings,
+  listDirectLibraryMeetingDays,
+  listDirectLibraryMeetingMonths,
   listCosOperationsMeetings,
+  listCosOperationsMeetingDays,
+  listCosOperationsMeetingMonths,
   resolveMeetingLibrary,
 } from '../lib/cos-operations-meetings.js'
 import type { MeetingMeta } from '../lib/meeting-store.js'
+import { meetingListLimit } from '../lib/meeting-store.js'
+import { searchMeetingLibrary } from '../lib/meeting-library-search.js'
+
+const MONTH_QUERY = /^\d{4}-(0[1-9]|1[0-2])$/
+const DAY_QUERY = /^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/
 
 function withStandaloneIdentity(meeting: MeetingMeta): MeetingMeta {
   return {
@@ -21,7 +30,7 @@ function withStandaloneIdentity(meeting: MeetingMeta): MeetingMeta {
   }
 }
 
-function mergeMeetingSources(groups: MeetingMeta[][], limit: number): MeetingMeta[] {
+function mergeMeetingSources(groups: MeetingMeta[][], limit: number, max = 50): MeetingMeta[] {
   const seenSessions = new Set<string>()
   const seenExact = new Set<string>()
   const merged: MeetingMeta[] = []
@@ -40,18 +49,67 @@ function mergeMeetingSources(groups: MeetingMeta[][], limit: number): MeetingMet
   }
   merged.sort((a, b) => `${b.date}T${b.time || '00:00'}`.localeCompare(`${a.date}T${a.time || '00:00'}`)
     || b.filename.localeCompare(a.filename))
-  return merged.slice(0, Math.min(Math.max(limit, 1), 50))
+  return merged.slice(0, Math.min(Math.max(limit, 1), max))
+}
+
+function parseListFilters(query: { month?: unknown; day?: unknown }): {
+  month?: string
+  day?: string
+  error?: { status: number; body: { error: string; reason: string } }
+} {
+  const rawMonth = typeof query.month === 'string' ? query.month : ''
+  const rawDay = typeof query.day === 'string' ? query.day : ''
+  if (rawMonth && !MONTH_QUERY.test(rawMonth)) {
+    return { error: { status: 400, body: { error: 'Invalid month', reason: 'invalid_month' } } }
+  }
+  if (rawDay && !DAY_QUERY.test(rawDay)) {
+    return { error: { status: 400, body: { error: 'Invalid day', reason: 'invalid_day' } } }
+  }
+  if (rawDay && rawMonth && !rawDay.startsWith(`${rawMonth}-`)) {
+    return { error: { status: 400, body: { error: 'day is not in month', reason: 'month_day_mismatch' } } }
+  }
+  const day = rawDay || undefined
+  const month = rawMonth || (day ? day.slice(0, 7) : undefined)
+  return { month, day }
+}
+
+function mergeDayCounts(
+  groups: Array<Array<{ date: string; count: number }>>,
+): Array<{ date: string; count: number }> {
+  const counts = new Map<string, number>()
+  for (const group of groups) {
+    for (const { date, count } of group) {
+      counts.set(date, (counts.get(date) ?? 0) + count)
+    }
+  }
+  return [...counts.entries()]
+    .sort((a, b) => a[0].localeCompare(b[0]))
+    .map(([date, count]) => ({ date, count }))
+}
+
+function uniqueSortedMonths(groups: string[][]): string[] {
+  return [...new Set(groups.flat())].sort().reverse()
 }
 
 export function createMeetingsRouter(store: MeetingStore = getMeetingStore()): Router {
   const router = Router()
 
   // GET /api/meetings?limit=20&domain=all
+  // Optional month=YYYY-MM and day=YYYY-MM-DD raise the cap to 200 and
+  // return `months` / `days` for the Control calendar. G2 omits those
+  // filters and still receives at most 50 rows.
   router.get('/meetings', (req, res) => {
     try {
       const rawLimit = typeof req.query.limit === 'string' ? Number.parseInt(req.query.limit, 10) : 20
-      const limit = Number.isFinite(rawLimit) ? rawLimit : 20
       const domain = typeof req.query.domain === 'string' ? req.query.domain : 'all'
+      const filters = parseListFilters(req.query)
+      if (filters.error) {
+        res.status(filters.error.status).json(filters.error.body)
+        return
+      }
+      const scoped = Boolean(filters.month || filters.day)
+      const limit = meetingListLimit(Number.isFinite(rawLimit) ? rawLimit : 20, scoped)
+      const sourceLimit = scoped ? 200 : 50
       res.set('Cache-Control', 'private, no-store')
 
       const library = resolveMeetingLibrary()
@@ -65,17 +123,33 @@ export function createMeetingsRouter(store: MeetingStore = getMeetingStore()): R
         return
       }
 
+      const listOptions = { limit: sourceLimit, domain, month: filters.month, day: filters.day }
+
       if (library.layout === 'direct') {
         const operations = cosOperationsMeetingsConfigured()
-          ? listCosOperationsMeetings({ limit: 50, domain })
+          ? listCosOperationsMeetings(listOptions)
           : []
         const direct = domain === 'all' || domain === 'library'
-          ? listDirectLibraryMeetings({ limit: 50 })
+          ? listDirectLibraryMeetings({ limit: sourceLimit, month: filters.month, day: filters.day })
+          : []
+        const standalone = store.list(listOptions).map(withStandaloneIdentity)
+        const meetings = mergeMeetingSources([operations, direct, standalone], limit, sourceLimit)
+        const months = uniqueSortedMonths([
+          ...(cosOperationsMeetingsConfigured() ? [listCosOperationsMeetingMonths(domain)] : []),
+          ...(domain === 'all' || domain === 'library' ? [listDirectLibraryMeetingMonths()] : []),
+          store.listMonths(),
+        ])
+        const days = filters.month
+          ? mergeDayCounts([
+            ...(cosOperationsMeetingsConfigured() ? [listCosOperationsMeetingDays(filters.month, domain)] : []),
+            ...(domain === 'all' || domain === 'library' ? [listDirectLibraryMeetingDays(filters.month)] : []),
+            store.listDayCounts(filters.month),
+          ])
           : []
-        const standalone = store.list({ limit: 50, domain }).map(withStandaloneIdentity)
-        const meetings = mergeMeetingSources([operations, direct, standalone], limit)
         res.json({
           meetings,
+          months,
+          days,
           source: operations.length > 0 ? 'mixed_library' : 'direct_library',
           layout: 'direct',
           root: library.root,
@@ -87,9 +161,16 @@ export function createMeetingsRouter(store: MeetingStore = getMeetingStore()): R
       }
 
       if (library.layout === 'multi_domain') {
-        const meetings = listCosOperationsMeetings({ limit, domain })
+        const meetings = listCosOperationsMeetings({
+          limit,
+          domain,
+          month: filters.month,
+          day: filters.day,
+        })
         res.json({
           meetings,
+          months: listCosOperationsMeetingMonths(domain),
+          days: filters.month ? listCosOperationsMeetingDays(filters.month, domain) : [],
           source: 'cos_operations',
           layout: 'multi_domain',
           root: library.root,
@@ -100,8 +181,42 @@ export function createMeetingsRouter(store: MeetingStore = getMeetingStore()): R
         return
       }
 
-      const meetings = store.list({ limit, domain }).map(withStandaloneIdentity)
-      res.json({ meetings, source: 'standalone_recordings', layout: 'standalone', meetingCount: meetings.length })
+      const meetings = store.list({
+        limit,
+        domain,
+        month: filters.month,
+        day: filters.day,
+      }).map(withStandaloneIdentity)
+      res.json({
+        meetings,
+        months: store.listMonths(),
+        days: filters.month ? store.listDayCounts(filters.month) : [],
+        source: 'standalone_recordings',
+        layout: 'standalone',
+        meetingCount: meetings.length,
+      })
+    } catch (error) {
+      sendMeetingStoreError(res, error)
+    }
+  })
+
+  // Literal path before /meetings/:domain/:month/:filename.
+  router.get('/meetings/search', async (req, res) => {
+    try {
+      const query = typeof req.query.q === 'string' ? req.query.q.trim() : ''
+      if (query.length < 2) {
+        res.status(400).json({ error: 'q must be at least 2 characters', reason: 'invalid_query' })
+        return
+      }
+      const rawLimit = typeof req.query.limit === 'string' ? Number.parseInt(req.query.limit, 10) : 20
+      const domain = typeof req.query.domain === 'string' ? req.query.domain : 'all'
+      res.set('Cache-Control', 'private, no-store')
+      const result = await searchMeetingLibrary({
+        query,
+        domain,
+        limit: Number.isFinite(rawLimit) ? rawLimit : 20,
+      }, store)
+      res.json(result)
     } catch (error) {
       sendMeetingStoreError(res, error)
     }

package/server/routes/memory.ts

@@ -1,5 +1,6 @@
 import { Router } from 'express'
 import { callPython, contextSourceAvailable, pythonBridgeState } from '../lib/python-bridge.js'
+import { searchMemories } from '../lib/context-library-search.js'
 
 /**
  * Is there anything to serve — a Python bridge OR plain files on disk?
@@ -78,6 +79,25 @@ memoryRouter.get('/memory/overview', async (_req, res) => {
   }
 })
 
+memoryRouter.get('/memory/search', async (req, res) => {
+  const query = typeof req.query.q === 'string' ? req.query.q.trim() : ''
+  if (query.length < 2) {
+    res.status(400).json({ error: 'q must be at least 2 characters', reason: 'invalid_query' })
+    return
+  }
+  const rawLimit = typeof req.query.limit === 'string' ? Number.parseInt(req.query.limit, 10) : 20
+  res.set('Cache-Control', 'private, no-store')
+  try {
+    const result = await searchMemories({
+      query,
+      limit: Number.isFinite(rawLimit) ? rawLimit : 20,
+    })
+    res.json(result)
+  } catch {
+    res.status(503).json({ error: 'memory_search_unavailable', reason: 'memory_search_unavailable' })
+  }
+})
+
 memoryRouter.get('/memory/:id', async (req, res) => {
   if (!MEMORY_ID_PATTERN.test(req.params.id)) {
     res.status(400).json({ error: 'invalid_memory_id' })

package/server/routes/message-ref.ts

@@ -7,6 +7,7 @@
 //
 //   GET /api/message/:num     → { globalMsgNum, date, query, response }  (404 when unknown)
 //   GET /api/message-counter  → { max, era }
+//   POST /api/message-era/reset { confirm: true } → archive live sessions, start at #1
 //
 // Resolution order (per the prompt-queue/archive plan): live in-memory
 // sessions first (covers the mirror's 15-minute lag), then day archives
@@ -24,6 +25,7 @@ import {
   currentMessageEra,
   exchangeBelongsToEra,
 } from '../lib/message-era.js'
+import { MessageEraResetError, resetLiveMessageEra } from '../lib/message-era-reset.js'
 
 // v6.3.0 — read archives from the SAME persistent location the archive-mirror
 // writes to (~/.cos-glasses/data/archive via dataPath), not a package-relative
@@ -203,6 +205,20 @@ function resolveFromLiveSessions(
 
 export const messageRefRouter = Router()
 
+messageRefRouter.post('/message-era/reset', async (req, res) => {
+  try {
+    const result = await resetLiveMessageEra({ confirm: req.body?.confirm === true })
+    res.json(result)
+  } catch (err) {
+    if (err instanceof MessageEraResetError) {
+      res.status(err.status).json({ error: err.message, code: err.code })
+      return
+    }
+    console.error('[message-era] reset failed:', err)
+    res.status(500).json({ error: 'Archive failed; message count was not reset.', code: 'archive_failed' })
+  }
+})
+
 messageRefRouter.get('/message/:num', (req, res) => {
   const num = Number.parseInt(req.params.num, 10)
   if (!Number.isFinite(num) || num < 1) {

package/server/routes/threads.ts

@@ -1,9 +1,29 @@
 import { Router } from 'express'
 import { callPython, contextSourceAvailable, pythonBridgeState } from '../lib/python-bridge.js'
+import { searchThreads } from '../lib/context-library-search.js'
 import { THREAD_ID_PATTERN, normalizeThreadDetail, normalizeThreads } from '../lib/cos-context-browser.js'
 
 export const threadsRouter = Router()
 
+threadsRouter.get('/threads/search', async (req, res) => {
+  const query = typeof req.query.q === 'string' ? req.query.q.trim() : ''
+  if (query.length < 2) {
+    res.status(400).json({ error: 'q must be at least 2 characters', reason: 'invalid_query' })
+    return
+  }
+  const rawLimit = typeof req.query.limit === 'string' ? Number.parseInt(req.query.limit, 10) : 20
+  res.set('Cache-Control', 'private, no-store')
+  try {
+    const result = await searchThreads({
+      query,
+      limit: Number.isFinite(rawLimit) ? rawLimit : 20,
+    })
+    res.json(result)
+  } catch {
+    res.status(503).json({ error: 'threads_search_unavailable', reason: 'threads_search_unavailable' })
+  }
+})
+
 threadsRouter.get('/threads/:id', async (req, res) => {
   if (!THREAD_ID_PATTERN.test(req.params.id)) {
     res.status(400).json({ error: 'invalid_thread_id' })