@gotcos/glasses-server 6.45.1 → 6.45.3

package/CHANGELOG.md

@@ -1,3 +1,22 @@
+## 6.45.3
+
+The phone can list the skills this Mac will actually run.
+
+- `GET /api/skills` returns the slash catalog from the selected workspace (`.agents/skills`, then `.claude/skills`) plus `~/.claude/skills`. Nested agent folders flatten with `:`. Generated `source-command-*` duplicates stay out. Paths never leave the box.
+- COS Glasses 6.9.468 paints that list on Views instead of a hardcoded cheat sheet.
+- A held voice can be heard before it is named. `GET /api/voice/ext-audio` lists `chunkIndices` per held session and `GET /api/voice/ext-audio/:sessionId/sample?chunk=<index>` serves that one chunk (no `chunk` still serves the newest). COS Control's Add-a-voice panel uses it to play portions of a session before naming it (Queen, 2026-09-12: "no way to listen to the voices that are here").
+- Recent is a rolling window. `GET /api/sessions/today/all-messages` keeps its path for COS Control and the phone but now answers with the newest 30 messages (`?limit=` up to 100) across every live session and as many archived days as it takes, deduplicated against their archive mirrors. Messages leave Recent only by ageing out of the window; nothing is hidden by the calendar. Control's Recent view and the phone's history recovery read this without change.
+- Yesterday's turns no longer vanish for a day. The archive mirror ran every 24 h from boot (21:25 on the current uptime), so finished sessions from the previous local day were neither "today" for `GET /api/sessions/today/all-messages` nor in any day archive until the evening; on 2026-09-12 07:00 Control showed no turns while ten from the 11th sat live in `sessions.json`. The mirror now runs at boot, at the next local midnight, and lazily from the today and archive-listing routes, once per local day. `checkYesterdayArchive` keys on the local day like everything else.
+
+## 6.45.2
+
+The G2 Sessions list answers in under a second again instead of eleven, and loading it no longer stalls the rest of the server.
+
+- Memoize Claude Desktop alias heads by file mtime and share one alias map across a list request. `findAgentSessionFile` rebuilt the map from every `local_*.json` (564 files, 119 MB) and stat'ed every transcript on each call, and the list route called it once per live row and once per held thread: sixteen loads per request measured 2026-09-10. It is one load now, and an unchanged file costs one lstat. The finder stats only the transcript it matched.
+- Probe Codex writer locks with one batched, asynchronous `lsof` per list, started alongside the walk and cached for ten seconds, served stale for up to a minute while a refresh runs behind it. The per-lock synchronous probe cost 2.3 s of whole-system descriptor scan per listed Codex row with a lock on disk and blocked the event loop for that long; a `/api/health` poll measured 2.5 s during one list. The attach and turn gates still run the synchronous probe at the moment of the write; the snapshot only feeds the display hint. The detail route reads the same snapshot.
+- Measured on the same Mac, same eight running rows: cold list 2.6 s (was 11.4 to 12.5 s), warm list 0.5 s, detail open 72 ms (was about 650 ms), longest health poll during a list 19 ms (was 2,524 ms). `lsof` exits 1 whenever any requested file has no holder while still listing the others; the batch reads that as the ordinary mixed result rather than a failed probe.
+- Match the resolved spelling of a lock path. `lsof` prints the kernel's path (`/private/var/...` for a `/var/...` lock on macOS, and the target of any symlinked `CODEX_HOME`), so a holder reached through a symlink read as nobody. The attach and turn gates never depended on that reading; the running hint did.
+
 ## 6.45.1
 
 Knowledge opens with a bounded graph and supports verified question plans for COS Control 0.5.208.

package/package.json

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

package/server/index.ts

@@ -62,6 +62,7 @@ import { liveCuesRouter } from './routes/live-cues.js'
 import { tasksRouter } from './routes/tasks.js'
 import { memoryRouter } from './routes/memory.js'
 import { threadsRouter } from './routes/threads.js'
+import { skillsRouter } from './routes/skills.js'
 import { shutdownLiveCues } from './lib/live-cues-engine.js'
 import { prewarmContext } from './lib/context-builder.js'
 import { preWarmCLI } from './lib/claude-bridge.js'
@@ -671,6 +672,7 @@ app.use('/api', meetingRouter)
 app.use('/api', meetingsRouter)
 app.use('/api', memoryRouter)
 app.use('/api', threadsRouter)
+app.use('/api', skillsRouter)
 app.use('/api', openaiKeyRouter)
 // v6.3.0 — Message History, cross-day 'reference message N', and history
 // recovery for public npx users (previously full-COS-server only).

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

@@ -709,10 +709,41 @@ export function peekClaudeDesktopHead(text: string): { title: string; cwd: strin
 
 type ClaudeDesktopHead = ReturnType<typeof peekClaudeDesktopHead> & { file: string; mtimeMs: number }
 
+/** The alias map one request shares. Null marks an id whose alias records conflict. */
+export type ClaudeAliasMap = Map<string, ClaudeDesktopHead | null>
+
+/**
+ * Per-file memo of the parsed desktop head, keyed by path, invalidated by (mtime, size).
+ *
+ * MEASURED 2026-09-10 on the owner's Mac: 564 `local_*.json` records, 292 of them
+ * over the 256 KB head window, 119 MB read and prefix-parsed per load, 635 ms per
+ * load — and the list route loaded it SIXTEEN times per request (twice in the walk,
+ * once per live row, once per held thread), which was 1.9 GB and ten of the twelve
+ * seconds the G2 Sessions page waited. 547 of the 564 files were older than a week
+ * and had not changed. A record is re-read only when its stat moves; an unchanged
+ * file costs one lstat. Entries for files that vanish are dropped on the next load
+ * of their root, so the memo never outgrows the directory it mirrors.
+ *
+ * `desktopAliasStats` is the test seam: a load that hits the memo reports it there,
+ * so "read once per mtime" is asserted by counting reads rather than by timing.
+ */
+const desktopHeadMemo = new Map<string, { mtimeMs: number; size: number; head: ReturnType<typeof peekClaudeDesktopHead> }>()
+export const desktopAliasStats = { loads: 0, reads: 0, memoHits: 0 }
+
+/** Tests only: forget every memoized head and zero the counters. */
+export function resetDesktopAliasMemo(): void {
+  desktopHeadMemo.clear()
+  desktopAliasStats.loads = 0
+  desktopAliasStats.reads = 0
+  desktopAliasStats.memoHits = 0
+}
+
 /** Explicit Desktop→CLI aliases only. A conflicting alias cannot select a transcript. */
-export async function loadClaudeDesktopAliases(root: string): Promise<Map<string, ClaudeDesktopHead | null>> {
-  const aliases = new Map<string, ClaudeDesktopHead | null>()
+export async function loadClaudeDesktopAliases(root: string): Promise<ClaudeAliasMap> {
+  const aliases: ClaudeAliasMap = new Map()
   if (!root) return aliases
+  desktopAliasStats.loads += 1
+  const seen = new Set<string>()
   for (const account of await dirents(root)) {
     for (const workspace of await dirents(join(root, account))) {
       const dir = join(root, account, workspace)
@@ -722,7 +753,18 @@ export async function loadClaudeDesktopAliases(root: string): Promise<Map<string
         if (!CLAUDE_UUID_JSONL.test(id + '.jsonl')) continue
         const file = join(dir, name), st = await fileStat(file)
         if (!st?.isFile) continue
-        const head = { ...peekClaudeDesktopHead(await readWindow(file, false)), file, mtimeMs: st.mtimeMs }
+        seen.add(file)
+        const memo = desktopHeadMemo.get(file)
+        let peeked: ReturnType<typeof peekClaudeDesktopHead>
+        if (memo && memo.mtimeMs === st.mtimeMs && memo.size === st.size) {
+          peeked = memo.head
+          desktopAliasStats.memoHits += 1
+        } else {
+          peeked = peekClaudeDesktopHead(await readWindow(file, false))
+          desktopHeadMemo.set(file, { mtimeMs: st.mtimeMs, size: st.size, head: peeked })
+          desktopAliasStats.reads += 1
+        }
+        const head = { ...peeked, file, mtimeMs: st.mtimeMs }
         const previous = aliases.get(id)
         if (previous === null) continue
         if (previous && previous.cliSessionId !== head.cliSessionId) aliases.set(id, null)
@@ -730,6 +772,10 @@ export async function loadClaudeDesktopAliases(root: string): Promise<Map<string
       }
     }
   }
+  const prefix = root.endsWith('/') ? root : root + '/'
+  for (const key of desktopHeadMemo.keys()) {
+    if (key.startsWith(prefix) && !seen.has(key)) desktopHeadMemo.delete(key)
+  }
   return aliases
 }
 
@@ -932,8 +978,9 @@ export async function listClaudeSessions(
   starredIds: ReadonlySet<string> = new Set(),
   desktopSessionsRoot = '',
   dropped: AgentSessionListDropped = emptySessionListDropped(),
+  preloadedAliases?: ClaudeAliasMap,
 ): Promise<AgentSessionRow[]> {
-  const aliases = await loadClaudeDesktopAliases(desktopSessionsRoot)
+  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 }
   const canonicalStars = new Set([...starredIds].map(canonical))
   const canonicalLive = new Set([...liveIds].map(canonical))
@@ -1210,9 +1257,9 @@ export async function listCursorSessions(
   ]
 }
 
-async function enrichLiveClaude(row: AgentSessionRow, roots: AgentSessionRoots): Promise<AgentSessionRow> {
+async function enrichLiveClaude(row: AgentSessionRow, roots: AgentSessionRoots, aliases?: ClaudeAliasMap): Promise<AgentSessionRow> {
   if (row.provider !== 'claude') return row
-  const found = await findAgentSessionFile('claude', row.session_id, roots)
+  const found = await findAgentSessionFile('claude', row.session_id, roots, new Date(), aliases)
   if (!found) return row
   const peek = await peekClaudeDiscussion(found)
   const firstPrompt = await firstClaudeUserTitle(found)
@@ -1275,14 +1322,17 @@ export async function listAgentSessions(
   limit = AGENT_SESSION_LIST_LIMIT,
   sort: AgentSessionSort = 'updated',
   dropped: AgentSessionListDropped = emptySessionListDropped(),
+  preloadedAliases?: ClaudeAliasMap,
 ): Promise<AgentSessionRow[]> {
   const originalStars = await loadClaudeStarredIds(roots.claudeDesktopConfig)
-  const aliases = await loadClaudeDesktopAliases(roots.claudeCodeSessions)
+  // ONE alias load for the whole walk. Before this the walk loaded it here AND
+  // inside listClaudeSessions AND once per live row through the finder.
+  const aliases = preloadedAliases ?? await loadClaudeDesktopAliases(roots.claudeCodeSessions)
   const canonical = (id: string) => { const cli = aliases.get(id)?.cliSessionId; return cli && CLAUDE_UUID_JSONL.test(cli + '.jsonl') ? cli : id }
   const starredIds = new Set([...originalStars].map(canonical))
   live = live.map(row => row.provider === 'claude' ? { ...row, session_id: canonical(normalizeClaudeSessionId(row.session_id)) } : row)
   const cursorPinned = await loadCursorPinnedIds(roots.cursorWorkspaceStorage)
-  const enrichedLive = (await Promise.all(live.map(row => enrichLiveClaude(row, roots))))
+  const enrichedLive = (await Promise.all(live.map(row => enrichLiveClaude(row, roots, aliases))))
     .filter(entry => !isKeepWarmSessionTitle(entry.display_label))
     .map(entry => {
       if (entry.provider === 'claude' && starredIds.has(normalizeClaudeSessionId(entry.session_id))) {
@@ -1297,7 +1347,7 @@ export async function listAgentSessions(
   const cap = AGENT_SESSION_PER_PROVIDER_LIMIT
   let rows = dedupeSessions([
     ...enrichedLive,
-    ...await listClaudeSessions(roots.claudeProjects, now, liveIds, cap, starredIds, roots.claudeCodeSessions, dropped),
+    ...await listClaudeSessions(roots.claudeProjects, now, liveIds, cap, starredIds, roots.claudeCodeSessions, dropped, aliases),
     ...await listCodexSessions(roots.codexSessions, now, cap, dropped),
     ...await listCursorSessions(roots.cursorProjects, now, cap, roots.cursorComposerDb, cursorPinned, dropped),
   ])
@@ -1326,20 +1376,26 @@ export async function findAgentSessionFile(
   sessionId: string,
   roots: AgentSessionRoots,
   now = new Date(),
+  preloadedAliases?: ClaudeAliasMap,
 ): Promise<string | null> {
   if (!isSafeSessionId(sessionId)) return null
   const needle = sessionId.trim().toLowerCase()
   if (provider === 'claude') {
-    const aliases = await loadClaudeDesktopAliases(roots.claudeCodeSessions)
+    // A caller that resolves several ids in one request (the list route: every
+    // live row, then every held thread) hands the map in; each call used to
+    // rebuild it from disk, which is the 16-loads-per-request the memo above
+    // describes. Absent, the memo still makes a rebuild cheap.
+    const aliases = preloadedAliases ?? await loadClaudeDesktopAliases(roots.claudeCodeSessions)
+    // Names only. This used to lstat every transcript on this Mac (1,697 of
+    // them) to keep directories out of the candidate set, on every call. The
+    // isFile check now runs on the one id that matched, below.
     const files = new Map<string, string[]>()
     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)) continue
-        const file = join(dir, name)
-        if (!(await fileStat(file))?.isFile) continue
         const id = name.slice(0, -6).toLowerCase()
-        files.set(id, [...(files.get(id) || []), file])
+        files.set(id, [...(files.get(id) || []), join(dir, name)])
       }
     }
     const exact = aliases.has(needle) || files.has(needle)
@@ -1351,7 +1407,10 @@ export async function findAgentSessionFile(
     }
     for (const id of files.keys()) if (exact ? id === needle : id.startsWith(needle)) ids.add(id)
     if (ids.size !== 1) return null
-    const matches = files.get([...ids][0]) || []
+    const matches: string[] = []
+    for (const file of files.get([...ids][0]) || []) {
+      if ((await fileStat(file))?.isFile) matches.push(file)
+    }
     return matches.length === 1 ? matches[0] : null
   }
   if (provider === 'codex') {

package/server/lib/archive.ts

@@ -3,6 +3,7 @@
 // Each day's archive contains one or more "chats" (split by context breaks)
 // Summaries are generated via `claude -p --model sonnet`, budget-capped per day.
 
+import { localDay } from './local-day.js'
 import { chmodSync, mkdirSync, readdirSync } from 'node:fs'
 import { resolve, dirname } from 'node:path'
 import { fileURLToPath } from 'node:url'
@@ -549,7 +550,7 @@ export function getArchiveDayMessages(
 
 /** Check if yesterday needs archiving (handles overnight server restarts) */
 export function checkYesterdayArchive(): void {
-  const yesterday = new Date(Date.now() - 86_400_000).toISOString().slice(0, 10)
+  const yesterday = localDay(Date.now() - 86_400_000)
   const existing = loadArchive(yesterday)
   if (!existing) {
     // No yesterday archive exists — but we can't archive sessions that are already expired

package/server/lib/conversation.ts

@@ -288,11 +288,55 @@ async function runDailyArchiveMirror(): Promise<void> {
   if (mirrored > 0) updateGlassesSessionCache()
 }
 
+// 6.45.3 — the mirror runs at every LOCAL DAY ROLLOVER, not only every 24 h from
+// boot. With a server started at 21:24 the interval landed at 21:25 each evening,
+// so a whole day's finished sessions sat in a blind spot until then: not "today"
+// for `GET /api/sessions/today/all-messages`, not yet in any day archive. On
+// 2026-09-12 07:00 Control showed "No turns today" (true) and no archive for
+// 2026-09-11 (ten turns, #125 to #134, still live in sessions.json). Three
+// triggers now: boot, a timer aimed at the next local midnight, and a lazy check
+// from the routes that read the day views, so yesterday appears on the first
+// read after midnight. Serialized: one run at a time, once per local day.
+let lastMirrorDay = ''
+let mirrorInFlight: Promise<void> | null = null
+
+/** Milliseconds until thirty seconds past the next local midnight; never less than a second. */
+export function msUntilNextLocalDay(now = Date.now()): number {
+  const d = new Date(now)
+  const next = new Date(d.getFullYear(), d.getMonth(), d.getDate() + 1, 0, 0, 30)
+  return Math.max(1_000, next.getTime() - now)
+}
+
+/** Mirror prior-day sessions once per local day. Returns true when a run happened. */
+export async function ensureArchiveMirrorForDay(now = Date.now()): Promise<boolean> {
+  const today = localDay(now)
+  if (lastMirrorDay === today) return false
+  if (!mirrorInFlight) {
+    mirrorInFlight = runDailyArchiveMirror()
+      .then(() => { lastMirrorDay = today })
+      .finally(() => { mirrorInFlight = null })
+  }
+  await mirrorInFlight
+  return true
+}
+
+/** Test seam: forget the last mirrored day. */
+export function __resetArchiveMirrorForTests(): void {
+  lastMirrorDay = ''
+}
+
+function scheduleArchiveMirrorAtNextLocalDay(): void {
+  const timer = setTimeout(() => {
+    ensureArchiveMirrorForDay()
+      .catch(err => console.error('[conversation] mirror rollover error:', err))
+      .finally(scheduleArchiveMirrorAtNextLocalDay)
+  }, msUntilNextLocalDay())
+  timer.unref?.()
+}
+
 // Fire-and-forget at boot so module load isn't blocked on disk + LLM fallback I/O.
-runDailyArchiveMirror().catch(err => console.error('[conversation] mirror boot error:', err))
-setInterval(() => {
-  runDailyArchiveMirror().catch(err => console.error('[conversation] mirror interval error:', err))
-}, 24 * 60 * 60_000)
+ensureArchiveMirrorForDay().catch(err => console.error('[conversation] mirror boot error:', err))
+scheduleArchiveMirrorAtNextLocalDay()
 
 // Track whether session is brand new (for first-query notification)
 const newSessions = new Set<string>()

package/server/lib/meeting-batch-progress.ts

@@ -5,6 +5,7 @@
 import { existsSync, readdirSync, readFileSync, statSync, writeFileSync, unlinkSync } from 'node:fs'
 import { basename, join } from 'node:path'
 import { dataPath } from './data-dir.js'
+import { MeetingFinalizationJobStore, type MeetingFinalizationJob } from './meeting-finalization-jobs.js'
 import { listActiveRecoveries } from './unsaved-audio-quarantine.js'
 
 export const BATCH_PROGRESS_FILENAME = '_batch_progress.json'
@@ -211,27 +212,69 @@ function markerFresh(dir: string, maxAgeMs = 15 * 60_000): boolean {
   }
 }
 
+export interface MeetingSyncSnapshotOptions {
+  /** Test seam. Production health omits this and reads the durable job store
+   *  when `root` is the live pending-batch directory. Custom roots stay empty
+   *  unless the caller injects jobs, so unit tests cannot inherit live handoff. */
+  finalizationJobs?: MeetingFinalizationJob[]
+}
+
+function listFinalizationJobsForSnapshot(
+  root: string,
+  options?: MeetingSyncSnapshotOptions,
+): MeetingFinalizationJob[] {
+  if (options && 'finalizationJobs' in options) return options.finalizationJobs ?? []
+  if (root !== pendingBatchRoot()) return []
+  try {
+    return new MeetingFinalizationJobStore().list()
+  } catch {
+    return []
+  }
+}
+
+function finalizationSyncRow(job: MeetingFinalizationJob): MeetingSyncMeeting {
+  const phase: MeetingSyncMeeting['phase'] = job.phase === 'ops_pending'
+    ? 'persisting'
+    : job.phase === 'batch_pending'
+      ? 'hq_polish'
+      : 'queued'
+  const label = job.phase === 'ops_pending'
+    ? 'Saving to meeting library · do not update/restart'
+    : job.phase === 'batch_pending'
+      ? 'HQ polish · pending handoff'
+      : 'Finishing capture · do not update/restart'
+  return {
+    meetingId: job.sessionId,
+    phase,
+    percent: null,
+    segmentsDone: null,
+    segmentsTotal: null,
+    chunkFiles: 0,
+    updatedAt: job.updatedAt,
+    label,
+  }
+}
+
 /** Snapshot of pending HQ polish work for /api/health and COS Control. */
 export function getMeetingSyncSnapshot(
   root: string = pendingBatchRoot(),
+  options?: MeetingSyncSnapshotOptions,
 ): MeetingSyncSnapshot {
   const meetings: MeetingSyncMeeting[] = []
   const retained: MeetingSyncRetainedMeeting[] = []
-  if (!existsSync(root)) {
-    return { active: false, percent: null, label: 'Idle', blocksRestart: false, meetings, retained }
-  }
-
   let dirs: string[] = []
-  try {
-    dirs = readdirSync(root).filter(name => {
-      try {
-        return statSync(join(root, name)).isDirectory()
-      } catch {
-        return false
-      }
-    })
-  } catch {
-    return { active: false, percent: null, label: 'Idle', blocksRestart: false, meetings, retained }
+  if (existsSync(root)) {
+    try {
+      dirs = readdirSync(root).filter(name => {
+        try {
+          return statSync(join(root, name)).isDirectory()
+        } catch {
+          return false
+        }
+      })
+    } catch {
+      dirs = []
+    }
   }
 
   for (const name of dirs) {
@@ -341,6 +384,17 @@ export function getMeetingSyncSnapshot(
     })
   }
 
+  // After HQ polish clears pending-batch progress, the durable finalizer still
+  // holds meeting_batch_finalization while it writes the library copy. Control
+  // then showed Meeting sync Idle with restart locked (2026-09-09 local 6.45.1
+  // rollout). Same contract as active recoveries: this window is active work.
+  const seen = new Set(meetings.map(meeting => meeting.meetingId))
+  for (const job of listFinalizationJobsForSnapshot(root, options)) {
+    if (seen.has(job.sessionId)) continue
+    seen.add(job.sessionId)
+    meetings.push(finalizationSyncRow(job))
+  }
+
   if (meetings.length === 0) {
     const label = retained.length > 0
       ? `Idle · ${retained.length} retained batch${retained.length === 1 ? '' : 'es'}`

package/server/lib/occupancy-probes.ts

@@ -34,7 +34,8 @@
 //     That is the intended chain: detector_unavailable is for "no such install",
 //     probe_failed is for "the mechanism exists and broke".
 
-import { execFileSync } from 'node:child_process'
+import { execFile, execFileSync } from 'node:child_process'
+import { readdir } from 'node:fs/promises'
 import {
   closeSync,
   constants as fsConstants,
@@ -44,6 +45,7 @@ import {
   openSync,
   readFileSync,
   readdirSync,
+  realpathSync,
   statSync,
 } from 'node:fs'
 import { homedir } from 'node:os'
@@ -358,6 +360,7 @@ export function lockHolders(path: string): number[] {
   // `--` terminates option parsing so a path can never be read as a flag; `-w`
   // suppresses mount-point warnings that would otherwise make a successful probe
   // look like the failure case below.
+  lockSnapshotStats.single += 1
   return interpretLockHolders(runProbe(LSOF_BIN, ['-w', '-t', '--', path], LOCK_PROBE_TIMEOUT_MS), path)
 }
 
@@ -407,6 +410,280 @@ export function interpretLockHolders(out: ProbeOutcome, path: string): number[]
   return [...pids]
 }
 
+// ------------------------------------------------------------- batched lock probe
+//
+// MEASURED 2026-09-10. One `lsof -t` on one lock is a whole-system descriptor scan:
+// 2.25 to 2.35 s on this Mac across three runs, and `lockHolders` runs it with
+// `execFileSync`, so every listed Codex row that still has a writer lock on disk
+// froze the ENTIRE glasses server for that long — a `/api/health` poll measured
+// 2.52 s during one list request. Seven locks sat in `thread-writer-locks`, all held
+// open by the Codex app. Passing all seven paths to a single lsof cost 3.07 s, one
+// scan instead of seven, and the async form leaves the event loop free.
+//
+// THIS IS FOR THE DISPLAY HINT ONLY. `lockHolders` above is unchanged and is what
+// the write gate (`threadOccupancy` at attach and turn time) keeps calling: a fresh
+// synchronous probe at the moment of the write. A snapshot can be up to
+// LOCK_SNAPSHOT_TTL_MS stale, which is fine for a badge and not for a gate.
+//
+// Doubt stays doubt. A path lsof named in a status error is checked with our own
+// lstat exactly as the single probe does: absent means no holders, anything else is
+// recorded as doubt and the wrapper THROWS for that path, so the scan marks the
+// thread degraded rather than free.
+
+/** How long a lock snapshot is FRESH: a list inside this window spawns nothing. */
+export const LOCK_SNAPSHOT_TTL_MS = 10_000
+/**
+ * How long a STALE snapshot may still answer while a refresh runs behind it. A
+ * reopen between 10 s and 60 s after the last probe gets the old badge at once and
+ * the new one on the next poll; past 60 s the list waits for a fresh probe. The
+ * held-lock badge changes on the scale of minutes (a Codex window opening or
+ * closing), so a minute of lag on a display hint is the whole price.
+ */
+export const LOCK_SNAPSHOT_MAX_AGE_MS = 60_000
+
+export interface LockHolderSnapshot {
+  /** Locks directory the snapshot describes. */
+  dir: string
+  /** Epoch ms the probe finished. */
+  at: number
+  /** Holders per lock path. A path present with [] was probed and nobody holds it. */
+  holders: Map<string, number[]>
+  /** Paths the probe could not settle, with the reason. */
+  doubt: Map<string, string>
+}
+
+/**
+ * Counters for tests. `probes` is batched lsof runs; `single` is the synchronous
+ * per-lock `lockHolders` runs, which a list served from a snapshot must never make.
+ */
+export const lockSnapshotStats = { probes: 0, single: 0 }
+
+function refuseUnlessLockPath(path: string): void {
+  if (typeof path !== 'string' || path.length === 0 || path.includes('\0')) {
+    throw new Error('batchLockHolders: refusing an unusable path')
+  }
+  const name = basename(path)
+  if (!name.endsWith('.lock') || !NATIVE_THREAD_ID_RE.test(name.slice(0, -'.lock'.length))) {
+    throw new Error('batchLockHolders: refusing a path that is not a <native-thread-id>.lock')
+  }
+}
+
+/**
+ * Turn one batched `lsof -F pn` run into holders per requested path, or throw when
+ * the run as a whole cannot be trusted.
+ *
+ * Field output is one record per line: `p<pid>` opens a process, then `f<fd>` and
+ * `n<path>` pairs follow for each descriptor. Paths lsof was not asked about are
+ * ignored. A requested path missing from stdout is unheld unless stderr carries a
+ * `status error on <path>` for it, in which case our own lstat decides between
+ * absent (no holders) and doubt.
+ */
+/**
+ * The spellings under which lsof may report a requested lock.
+ *
+ * lsof prints the kernel's resolved path, not the caller's: a lock reached through
+ * macOS's `/var` symlink comes back as `/private/var/...`, and a symlinked
+ * CODEX_HOME does the same. Requested paths keep the caller's spelling as the map
+ * key; the match accepts either spelling. Unresolvable paths keep only the literal.
+ */
+function lsofPathSpellings(path: string): string[] {
+  try {
+    const resolved = realpathSync.native(path)
+    return resolved === path ? [path] : [path, resolved]
+  } catch {
+    return [path]
+  }
+}
+
+export function interpretBatchLockHolders(out: ProbeOutcome, paths: readonly string[]): { holders: Map<string, number[]>; doubt: Map<string, string> } {
+  const holders = new Map<string, number[]>()
+  const doubt = new Map<string, string>()
+  const wanted = new Set(paths)
+  const requestedBySpelling = new Map<string, string[]>()
+  for (const path of wanted) {
+    for (const spelling of lsofPathSpellings(path)) {
+      const list = requestedBySpelling.get(spelling) ?? []
+      list.push(path)
+      requestedBySpelling.set(spelling, list)
+    }
+  }
+  if (!out.ok) {
+    if (out.spawnError !== null) throw new Error(`batchLockHolders: lsof unavailable (${out.spawnError})`)
+    if (out.killed) throw new Error('batchLockHolders: lsof timed out')
+    // MEASURED: lsof exits 1 whenever ANY requested file has no holder, while
+    // still printing the holders of the others. So exit 1 is the ordinary mixed
+    // reading for a batch and its stdout is parsed like a clean run; empty
+    // stdout on exit 1 is "nobody holds any of them". Only another status is a
+    // run this reading cannot trust.
+    if (out.status !== 1) {
+      throw new Error(`batchLockHolders: lsof failed (status=${out.status}) ${out.stderr.trim().slice(0, 160)}`)
+    }
+  }
+  const pidsByPath = new Map<string, Set<number>>()
+  let pid: number | null = null
+  for (const raw of out.stdout.split('\n')) {
+    const line = raw.trimEnd()
+    if (line.length === 0) continue
+    const tag = line[0], value = line.slice(1)
+    if (tag === 'p') {
+      if (!/^\d+$/.test(value)) throw new Error('batchLockHolders: unrecognised lsof output')
+      const parsed = Number(value)
+      if (!isProbablePid(parsed)) throw new Error('batchLockHolders: lsof reported an implausible pid')
+      pid = parsed
+    } else if (tag === 'n') {
+      if (pid === null) throw new Error('batchLockHolders: unrecognised lsof output')
+      const requested = requestedBySpelling.get(value)
+      if (!requested) continue
+      for (const path of requested) {
+        const set = pidsByPath.get(path) ?? new Set<number>()
+        set.add(pid)
+        pidsByPath.set(path, set)
+      }
+    }
+    // `f` and any other field is descriptor detail this reading does not use.
+  }
+  for (const path of wanted) {
+    const pids = pidsByPath.get(path)
+    if (pids) {
+      holders.set(path, [...pids])
+      continue
+    }
+    if (out.stderr.includes(`status error on ${path}:`)) {
+      if (presence(path) === 'absent') holders.set(path, [])
+      else doubt.set(path, 'lsof could not inspect the lock')
+      continue
+    }
+    holders.set(path, [])
+  }
+  return { holders, doubt }
+}
+
+function runProbeAsync(bin: string, args: string[], timeoutMs: number): Promise<ProbeOutcome> {
+  return new Promise(resolve => {
+    execFile(bin, args, {
+      encoding: 'utf8',
+      timeout: timeoutMs,
+      killSignal: 'SIGKILL',
+      maxBuffer: PROBE_MAX_BUFFER,
+      env: probeEnv(),
+    }, (error: any, stdout, stderr) => {
+      if (!error) {
+        resolve({ ok: true, stdout: String(stdout), stderr: String(stderr ?? ''), status: 0, killed: false, spawnError: null })
+        return
+      }
+      const spawned = typeof error?.status === 'number' || typeof error?.code === 'number' || typeof error?.signal === 'string'
+      resolve({
+        ok: false,
+        stdout: String(error?.stdout ?? stdout ?? ''),
+        stderr: String(error?.stderr ?? stderr ?? ''),
+        status: typeof error?.code === 'number' ? error.code : (typeof error?.status === 'number' ? error.status : null),
+        killed: Boolean(error?.killed) || Boolean(error?.signal),
+        spawnError: spawned ? null : String(error?.code ?? error?.message ?? 'spawn failed'),
+      })
+    })
+  })
+}
+
+/**
+ * Holders for many locks in ONE lsof, off the event loop. Empty input spawns nothing.
+ * Throws when the run cannot be trusted; per-path doubt is returned, not thrown.
+ */
+export async function batchLockHolders(paths: readonly string[], timeoutMs = LOCK_PROBE_TIMEOUT_MS): Promise<{ holders: Map<string, number[]>; doubt: Map<string, string> }> {
+  const unique = [...new Set(paths)]
+  for (const path of unique) refuseUnlessLockPath(path)
+  if (unique.length === 0) return { holders: new Map(), doubt: new Map() }
+  lockSnapshotStats.probes += 1
+  const out = await runProbeAsync(LSOF_BIN, ['-w', '-F', 'pn', '--', ...unique], timeoutMs)
+  return interpretBatchLockHolders(out, unique)
+}
+
+let lockSnapshot: LockHolderSnapshot | null = null
+let lockSnapshotInFlight: { dir: string; promise: Promise<LockHolderSnapshot> } | null = null
+
+/** Tests only: drop the cached snapshot and zero the probe counter. */
+export function resetLockSnapshot(): void {
+  lockSnapshot = null
+  lockSnapshotInFlight = null
+  lockSnapshotStats.probes = 0
+  lockSnapshotStats.single = 0
+}
+
+/** The cached snapshot for this locks dir if it is not past MAX_AGE, else null. No I/O. */
+export function peekCodexLockSnapshot(locksDir: string, now = Date.now()): LockHolderSnapshot | null {
+  if (!lockSnapshot || lockSnapshot.dir !== locksDir) return null
+  return now - lockSnapshot.at <= LOCK_SNAPSHOT_MAX_AGE_MS ? lockSnapshot : null
+}
+
+/**
+ * Every lock in the directory, probed in one lsof, cached for LOCK_SNAPSHOT_TTL_MS.
+ *
+ * Reads the directory itself rather than taking the caller's thread ids, so it can be
+ * started before the session walk knows which rows it will list and run alongside
+ * it. Concurrent callers share one in-flight probe. A missing or unreadable
+ * directory yields an EMPTY snapshot: the scan's `fileExists` check already skips a
+ * lock that is not there, and a lock it does find that the snapshot does not cover
+ * falls back to the synchronous probe in `withLockSnapshot`.
+ */
+export async function codexLockSnapshot(locksDir: string, now = Date.now()): Promise<LockHolderSnapshot> {
+  const cached = peekCodexLockSnapshot(locksDir, now)
+  if (cached && now - cached.at <= LOCK_SNAPSHOT_TTL_MS) return cached
+  const inFlight = lockSnapshotInFlight && lockSnapshotInFlight.dir === locksDir ? lockSnapshotInFlight.promise : null
+  // Stale but inside MAX_AGE: answer now, refresh behind the answer.
+  if (cached) {
+    if (!inFlight) void startLockProbe(locksDir, now).catch(() => { /* the next caller retries */ })
+    return cached
+  }
+  if (inFlight) return inFlight
+  return startLockProbe(locksDir, now)
+}
+
+async function startLockProbe(locksDir: string, now: number): Promise<LockHolderSnapshot> {
+  const promise = (async () => {
+    let names: string[] = []
+    try {
+      names = await readdir(locksDir)
+    } catch {
+      names = []
+    }
+    const paths = names
+      .filter(name => name.endsWith('.lock') && NATIVE_THREAD_ID_RE.test(name.slice(0, -'.lock'.length)))
+      .map(name => join(locksDir, name))
+    const result = await batchLockHolders(paths)
+    // Aged from the moment the probe was ASKED for, not from when lsof finished:
+    // a reading is only as fresh as its start, and the caller's clock is the
+    // test seam.
+    const snapshot: LockHolderSnapshot = { dir: locksDir, at: now, holders: result.holders, doubt: result.doubt }
+    lockSnapshot = snapshot
+    return snapshot
+  })()
+  lockSnapshotInFlight = { dir: locksDir, promise }
+  try {
+    return await promise
+  } finally {
+    if (lockSnapshotInFlight?.promise === promise) lockSnapshotInFlight = null
+  }
+}
+
+/**
+ * A probe set whose `lockHolders` answers from the snapshot for the paths it covers.
+ *
+ * A covered path answers synchronously with no spawn; a path in `doubt` THROWS, which
+ * is the same signal the live probe sends and lands the thread on degraded; a path
+ * the snapshot never saw (a lock created after the directory was read) goes to the
+ * wrapped probe, so the fallback is the exact behaviour that shipped before.
+ */
+export function withLockSnapshot(probes: OccupancyProbes, snapshot: LockHolderSnapshot): OccupancyProbes {
+  return {
+    ...probes,
+    lockHolders: (path: string) => {
+      const doubt = snapshot.doubt.get(path)
+      if (doubt !== undefined) throw new Error(`lockHolders: ${doubt}`)
+      const held = snapshot.holders.get(path)
+      return held !== undefined ? [...held] : probes.lockHolders(path)
+    },
+  }
+}
+
 /** Supplies the pid -> process-start map that is the only route to a self-owned verdict. */
 export type SpawnLedgerAccessor = () => ReadonlyMap<number, number>
 

package/server/lib/recent-messages.ts

@@ -0,0 +1,56 @@
+// 6.45.3 — "Recent" is a rolling window of the newest messages, not a calendar day.
+//
+// Miles, 2026-09-12: "The recent messages should just be a rolling count of 30,
+// where, as messages age out of that top 30, they're no longer present in the
+// recent tab. At any rate, we should never end up in a situation where messages
+// are hidden." The old view was keyed on the local day, so at 07:00 the answer
+// was empty while ten turns from the previous evening sat in the live store.
+//
+// The window is assembled from every live session (era-filtered) and then from
+// archived days newest-first, only as many days as it takes to fill the window.
+// Live copies and their archive mirrors are the same turn: dedup on
+// `sessionId|timestamp`, the key the day view has used since the NTP-skew fix.
+
+export interface RecentMessageCandidate {
+  sessionId?: string
+  timestamp: number
+}
+
+export const RECENT_MESSAGES_DEFAULT_LIMIT = 30
+export const RECENT_MESSAGES_MAX_LIMIT = 100
+
+export function recentMessagesLimit(raw: unknown): number {
+  const n = typeof raw === 'string' ? Number.parseInt(raw, 10) : typeof raw === 'number' ? raw : NaN
+  if (!Number.isFinite(n) || n < 1) return RECENT_MESSAGES_DEFAULT_LIMIT
+  return Math.min(RECENT_MESSAGES_MAX_LIMIT, Math.floor(n))
+}
+
+/**
+ * The newest `limit` messages, chronological (oldest first, like the day view).
+ * `archiveDaysNewestFirst` is consulted lazily, one day at a time, and only
+ * while the window is not yet full.
+ */
+export function selectRecentMessages<T extends RecentMessageCandidate>(
+  live: T[],
+  archiveDaysNewestFirst: Iterable<() => T[]>,
+  limit: number,
+): T[] {
+  const seen = new Set<string>()
+  const keyOf = (m: RecentMessageCandidate) => `${m.sessionId ?? ''}|${m.timestamp}`
+  const candidates: T[] = []
+  const take = (rows: T[]) => {
+    for (const row of rows) {
+      const key = keyOf(row)
+      if (seen.has(key)) continue
+      seen.add(key)
+      candidates.push(row)
+    }
+  }
+  take(live)
+  for (const readDay of archiveDaysNewestFirst) {
+    if (candidates.length >= limit) break
+    take(readDay())
+  }
+  candidates.sort((a, b) => a.timestamp - b.timestamp)
+  return candidates.length > limit ? candidates.slice(candidates.length - limit) : candidates
+}

package/server/lib/workspace-skills.ts

@@ -0,0 +1,209 @@
+// Catalog of skills the glasses agent can actually run: the selected COS
+// workspace plus the user's global Claude skills. Labels only — never paths.
+//
+// Walk matches skill_sync.py: `.agents/skills` is canonical (nested folders
+// flatten with `:`), `.claude/skills` is a one-level mirror, `source-command-*`
+// is excluded as a generated duplicate. User skills live in `~/.claude/skills`.
+
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { basename, join, relative } from 'node:path'
+import { COS_SCRIPTS_DIR } from './python-bridge.js'
+import { resolveProviderWorkDir } from './launch-dir.js'
+
+export const SKILLS_CATALOG_SCHEMA = 1
+export const SKILLS_CATALOG_MAX = 200
+const SKILL_FILE_MAX_BYTES = 8_192
+const SKILL_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,63}$/
+const EXCLUDE_PREFIXES = ['source-command-']
+
+export interface WorkspaceSkill {
+  name: string
+  slash: string
+  description: string
+  group: string
+  where: 'workspace' | 'user'
+}
+
+export interface WorkspaceSkillsCatalog {
+  schemaVersion: number
+  skills: WorkspaceSkill[]
+}
+
+export function parseSkillFrontmatter(text: string): Record<string, string> {
+  const src = text.replace(/^\uFEFF/, '')
+  if (!src.startsWith('---')) return {}
+  const end = src.indexOf('\n---', 3)
+  if (end < 0) return {}
+  const block = src.slice(3, end).replace(/^\r?\n/, '')
+  const out: Record<string, string> = {}
+  const lines = block.split(/\r?\n/)
+  let i = 0
+  while (i < lines.length) {
+    const line = lines[i]
+    const match = /^([A-Za-z_][\w-]*):\s*(.*)$/.exec(line)
+    if (!match) { i += 1; continue }
+    const key = match[1]
+    let raw = match[2].trim()
+    if (raw === '>' || raw === '>-' || raw === '|' || raw === '|-') {
+      const parts: string[] = []
+      i += 1
+      while (i < lines.length && /^\s+\S/.test(lines[i]) && !/^[A-Za-z_][\w-]*:/.test(lines[i])) {
+        parts.push(lines[i].trim())
+        i += 1
+      }
+      out[key] = unquote(parts.join(' '))
+      continue
+    }
+    out[key] = unquote(raw)
+    i += 1
+  }
+  return out
+}
+
+function unquote(value: string): string {
+  const trimmed = value.trim()
+  if ((trimmed.startsWith('"') && trimmed.endsWith('"')) || (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+    return trimmed.slice(1, -1).replace(/\\"/g, '"').replace(/\\'/g, "'").trim()
+  }
+  return trimmed
+}
+
+function excludedName(name: string): boolean {
+  return EXCLUDE_PREFIXES.some(prefix => name === prefix.slice(0, -1) || name.startsWith(prefix))
+}
+
+function skillNameFromRel(rel: string): string | null {
+  const parts = rel.split(/[/\\]/).filter(part => part && part !== '.')
+  if (parts.length === 0 || parts.some(part => part.startsWith('.') || excludedName(part))) return null
+  const name = parts.join(':')
+  return SKILL_NAME_RE.test(name) ? name : null
+}
+
+function readSkillFile(path: string): { name?: string; description: string } | null {
+  let stat
+  try { stat = statSync(path) } catch { return null }
+  if (!stat.isFile() || stat.size <= 0) return null
+  const bytes = Math.min(stat.size, SKILL_FILE_MAX_BYTES)
+  let text: string
+  try {
+    text = readFileSync(path, { encoding: 'utf8' }).slice(0, bytes)
+  } catch {
+    return null
+  }
+  const meta = parseSkillFrontmatter(text)
+  const description = (meta.description || '').replace(/\s+/g, ' ').trim().slice(0, 160)
+  const name = meta.name && SKILL_NAME_RE.test(meta.name) && !excludedName(meta.name) ? meta.name : undefined
+  return { name, description }
+}
+
+function walkImmediateSkills(root: string): Array<{ rel: string; path: string }> {
+  let entries
+  try { entries = readdirSync(root, { withFileTypes: true }) } catch { return [] }
+  const found: Array<{ rel: string; path: string }> = []
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith('.')) continue
+    const path = join(root, entry.name, 'SKILL.md')
+    if (existsSync(path)) found.push({ rel: entry.name, path })
+  }
+  return found
+}
+
+function walkNestedSkills(root: string): Array<{ rel: string; path: string }> {
+  const found: Array<{ rel: string; path: string }> = []
+  const stack = [root]
+  while (stack.length) {
+    const dir = stack.pop()!
+    let entries
+    try { entries = readdirSync(dir, { withFileTypes: true }) } catch { continue }
+    for (const entry of entries) {
+      if (entry.name.startsWith('.') || entry.name === 'node_modules') continue
+      const full = join(dir, entry.name)
+      if (entry.isDirectory()) {
+        stack.push(full)
+        continue
+      }
+      if (entry.isFile() && entry.name === 'SKILL.md') {
+        const rel = relative(root, dir)
+        if (rel && rel !== '.') found.push({ rel, path: full })
+      }
+    }
+  }
+  return found
+}
+
+function groupFor(name: string, where: WorkspaceSkill['where']): string {
+  const colon = name.indexOf(':')
+  if (colon > 0) return name.slice(0, colon).replace(/[-_]/g, ' ').toUpperCase()
+  return where === 'user' ? 'USER' : 'WORKSPACE'
+}
+
+function addSkill(
+  seen: Map<string, WorkspaceSkill>,
+  rel: string,
+  path: string,
+  where: WorkspaceSkill['where'],
+): void {
+  if (seen.size >= SKILLS_CATALOG_MAX) return
+  const fromDir = skillNameFromRel(rel)
+  if (!fromDir) return
+  const parsed = readSkillFile(path)
+  if (!parsed) return
+  // Directory name is the loader identity. Frontmatter `name` is a label; if it
+  // disagrees with the folder (common on generated mirrors), keep the folder.
+  const name = parsed.name && basename(rel) === parsed.name ? parsed.name : fromDir
+  if (seen.has(name) || excludedName(name)) return
+  seen.set(name, {
+    name,
+    slash: `/${name}`,
+    description: parsed.description,
+    group: groupFor(name, where),
+    where,
+  })
+}
+
+export function listWorkspaceSkills(options: {
+  workDir?: string
+  home?: string
+} = {}): WorkspaceSkill[] {
+  const workDir = options.workDir ?? resolveProviderWorkDir({ scriptsDir: COS_SCRIPTS_DIR })
+  const home = options.home ?? homedir()
+  const seen = new Map<string, WorkspaceSkill>()
+
+  if (workDir) {
+    const agents = join(workDir, '.agents', 'skills')
+    if (existsSync(agents)) {
+      for (const skill of walkNestedSkills(agents)) addSkill(seen, skill.rel, skill.path, 'workspace')
+    }
+    const claude = join(workDir, '.claude', 'skills')
+    if (existsSync(claude)) {
+      for (const skill of walkImmediateSkills(claude)) addSkill(seen, skill.rel, skill.path, 'workspace')
+    }
+  }
+
+  const userClaude = join(home, '.claude', 'skills')
+  if (existsSync(userClaude)) {
+    for (const skill of walkImmediateSkills(userClaude)) addSkill(seen, skill.rel, skill.path, 'user')
+  }
+
+  return [...seen.values()].sort((a, b) => {
+    if (a.group !== b.group) {
+      if (a.group === 'WORKSPACE') return -1
+      if (b.group === 'WORKSPACE') return 1
+      if (a.group === 'USER') return 1
+      if (b.group === 'USER') return -1
+      return a.group.localeCompare(b.group)
+    }
+    return a.name.localeCompare(b.name)
+  })
+}
+
+export function workspaceSkillsCatalog(options?: {
+  workDir?: string
+  home?: string
+}): WorkspaceSkillsCatalog {
+  return {
+    schemaVersion: SKILLS_CATALOG_SCHEMA,
+    skills: listWorkspaceSkills(options),
+  }
+}

package/server/routes/agent-sessions.ts

@@ -26,9 +26,12 @@ import {
   findAgentSessionFile,
   listAgentSessions,
   emptySessionListDropped,
+  loadClaudeDesktopAliases,
   loadCursorComposerNames,
   parseAgentSession,
   type AgentProvider,
+  type AgentSessionRoots,
+  type ClaudeAliasMap,
   type AgentSessionRow,
   type AgentSessionSort,
 } from '../lib/agent-session-store.js'
@@ -43,7 +46,15 @@ import {
   type OccupiedScan,
   type OccupiedThread,
 } from '../lib/occupied-threads.js'
-import { realOccupancyDirs, realOccupancyProbes } from '../lib/occupancy-probes.js'
+import {
+  codexLockSnapshot,
+  peekCodexLockSnapshot,
+  realOccupancyDirs,
+  realOccupancyProbes,
+  withLockSnapshot,
+  type LockHolderSnapshot,
+} from '../lib/occupancy-probes.js'
+import type { OccupancyDirs } from '../lib/thread-occupancy.js'
 import { cosSpawnedPids } from '../lib/agent-session-ownership-store.js'
 
 export const agentSessionsRouter = Router()
@@ -86,12 +97,17 @@ function toSearchHit(row: AgentSessionSearchHit) {
  * seconds or minutes before the user acts and a desktop session opened in that gap
  * is exactly the race the per-write probe exists to catch.
  */
-function runningThreads(rows: readonly AgentSessionRow[]): OccupiedScan {
+function runningThreads(rows: readonly AgentSessionRow[], dirs: OccupancyDirs, snapshot: LockHolderSnapshot | null): OccupiedScan {
   try {
-    const dirs = realOccupancyDirs()
     // The spawn ledger is what lets a turn COS itself queued read as ours rather
     // than as a foreign desktop window holding the thread.
-    const probes = realOccupancyProbes(cosSpawnedPids)
+    //
+    // Codex lock holders come from ONE batched lsof taken for the whole request
+    // (see `codexLockSnapshot`), not one 2.3 s synchronous scan per listed row.
+    // With no snapshot — the batch failed — the wrapped probe runs exactly as
+    // before, so the worst case is the old cost, never a wrong verdict.
+    const base = realOccupancyProbes(cosSpawnedPids)
+    const probes = snapshot ? withLockSnapshot(base, snapshot) : base
     const byProvider = new Map<string, string[]>()
     for (const row of rows) {
       if (row.provider !== 'claude' && row.provider !== 'codex') continue
@@ -137,13 +153,14 @@ function runningThreads(rows: readonly AgentSessionRow[]): OccupiedScan {
 async function transcriptMtimes(
   scan: OccupiedScan,
   rows: readonly AgentSessionRow[],
+  roots: AgentSessionRoots,
+  aliases: ClaudeAliasMap,
 ): Promise<Map<string, number | null>> {
   const mtimes = new Map<string, number | null>()
   if (scan.occupied.size === 0) return mtimes
 
   const providerById = new Map<string, AgentProvider>()
   for (const row of rows) providerById.set(row.session_id, row.provider)
-  const roots = agentSessionRoots()
 
   await Promise.all([...scan.occupied.keys()].map(async threadId => {
     try {
@@ -155,7 +172,8 @@ async function transcriptMtimes(
         mtimes.set(threadId, null)
         return
       }
-      const file = await findAgentSessionFile(provider, threadId, roots)
+      // The shared alias map: this used to rebuild it from 564 files per held thread.
+      const file = await findAgentSessionFile(provider, threadId, roots, new Date(), aliases)
       mtimes.set(threadId, file ? (await stat(file)).mtimeMs : null)
     } catch {
       mtimes.set(threadId, null)
@@ -222,11 +240,16 @@ function runningForThread(provider: AgentProvider, threadId: string, mtimeMs: nu
   }
   if (provider !== 'claude' && provider !== 'codex') return { occupied: new Map(), degraded: false }
   try {
+    const dirs = realOccupancyDirs()
+    // A detail open inside LOCK_SNAPSHOT_TTL_MS of a list answers from that list's
+    // snapshot; otherwise the single synchronous probe runs as it always has.
+    const snapshot = peekCodexLockSnapshot(dirs.codexLocksDir)
+    const base = realOccupancyProbes(cosSpawnedPids)
     const scan = occupiedThreads(
       provider,
       [threadId],
-      realOccupancyProbes(cosSpawnedPids),
-      realOccupancyDirs(),
+      snapshot ? withLockSnapshot(base, snapshot) : base,
+      dirs,
     )
     return withActiveRecently(scan, new Map([[threadId, mtimeMs]]), Date.now())
   } catch (error) {
@@ -281,14 +304,26 @@ agentSessionsRouter.get('/agent-sessions', async (req, res) => {
   try {
     const limit = boundedInteger(req.query.limit, AGENT_SESSION_LIST_LIMIT, 1, AGENT_SESSION_LIST_MAX)
     const sort = asSort(req.query.sort)
+    const roots = agentSessionRoots()
+    const dirs = realOccupancyDirs()
+    // The lock probe is a 2-3 s lsof that needs only the locks directory, so it
+    // starts NOW and runs under the walk instead of after it. A failed batch is
+    // logged and the scan below falls back to the per-lock probe.
+    const snapshotPromise: Promise<LockHolderSnapshot | null> = codexLockSnapshot(dirs.codexLocksDir).catch(error => {
+      console.error(`[agent-sessions] lock snapshot failed: ${error instanceof Error ? error.message : error}`)
+      return null
+    })
+    // ONE alias load per request, shared by the walk, every live row and every
+    // held thread. Measured 2026-09-10: sixteen loads of 119 MB before this line.
+    const aliases = await loadClaudeDesktopAliases(roots.claudeCodeSessions)
     const live = await liveClaudeRows()
     const dropped = emptySessionListDropped()
-    const sessions = await listAgentSessions(agentSessionRoots(), new Date(), live, limit, sort, dropped)
-    const scan = runningThreads(sessions)
+    const sessions = await listAgentSessions(roots, new Date(), live, limit, sort, dropped, aliases)
+    const scan = runningThreads(sessions, dirs, await snapshotPromise)
     // Freshness is layered on AFTER occupancy, and only over what occupancy
     // found. Cursor has no process occupancy, so the list does not invent a
     // working hint from jsonl mtime — detail still can, from the file it stat'ed.
-    const running = withActiveRecently(scan, await transcriptMtimes(scan, sessions), Date.now())
+    const running = withActiveRecently(scan, await transcriptMtimes(scan, sessions, roots, aliases), Date.now())
     res.json({
       sessions: sessions.map(row => withRunning(toEntry(row), running)),
       total: sessions.length,

package/server/routes/archive.ts

@@ -2,6 +2,7 @@
 import { Router } from 'express'
 import { listArchiveDateStrings, archiveDir, archiveIndexPath, loadArchive, getArchiveChats, getArchiveDayMessages, appendToArchive } from '../lib/archive.js'
 import { getArchiveChatMessagesNumbered } from './message-ref.js'
+import { ensureArchiveMirrorForDay } from '../lib/conversation.js'
 import { searchArchive, MAX_LIMIT, DEFAULT_LIMIT } from '../lib/archive-search.js'
 import { refreshArchiveIndex } from '../lib/archive-index.js'
 import { getActiveSessions } from '../lib/conversation.js'
@@ -24,6 +25,8 @@ archiveRouter.param('date', (req, res, next, date) => {
 
 // GET /api/archive — list all archive dates with summaries
 archiveRouter.get('/archive', async (_req, res) => {
+  // 6.45.3 — the listing files yesterday's finished sessions before it answers.
+  await ensureArchiveMirrorForDay().catch(() => {})
   // Index-backed. The previous implementation parsed every day file to reach four
   // summary fields; see archive-index.ts for the measurements that killed it.
   const { entries, rebuilt, fromCache } = await refreshArchiveIndex(archiveDir(), archiveIndexPath())

package/server/routes/sessions.ts

@@ -2,9 +2,10 @@
 import { Router } from 'express'
 import { readFileSync } from 'fs'
 import { join } from 'path'
-import { getRecentSessions, getHistory, sessionExists, addContextBreak, endSession, getSessionRaw, getActiveSessions, resolveExchangePairModel } from '../lib/conversation.js'
+import { getRecentSessions, getHistory, sessionExists, addContextBreak, endSession, getSessionRaw, getActiveSessions, resolveExchangePairModel, ensureArchiveMirrorForDay } from '../lib/conversation.js'
 import { buildSessionLogEntry, writeSessionLog } from '../lib/session-log.js'
-import { getArchiveDayMessages } from '../lib/archive.js'
+import { getArchiveDayMessages, listArchiveDateStrings } from '../lib/archive.js'
+import { recentMessagesLimit, selectRecentMessages } from '../lib/recent-messages.js'
 import { localDay } from '../lib/local-day.js'
 import { clearCodexEngineSession } from '../lib/codex-engine-sessions.js'
 import { mergeMediaAttachmentRefs, type MediaAttachmentRef } from '../../shared/media-attachment.js'
@@ -282,16 +283,23 @@ sessionsRouter.get('/sessions/today/live-chats', (_req, res) => {
   res.json({ chats })
 })
 
-// GET /api/sessions/today/all-messages — merged view of today's archived + live session messages.
-// Dedup key is `sessionId|timestamp` (was bare timestamp, which collided on NTP skew or
-// same-ms adds). `sessionId` is always known for live exchanges; archive messages fall
-// back to the archived chat's sessionId via getArchiveDayMessages.
-sessionsRouter.get('/sessions/today/all-messages', (_req, res) => {
+// GET /api/sessions/today/all-messages — the newest messages, live + archived, one window.
+// 6.45.3 — the path keeps its name for the two clients that call it (COS Control's
+// Recent view, the phone's history recovery) but the view is a ROLLING WINDOW of the
+// newest `limit` (default 30, `?limit=` up to 100) across every live session and as many
+// archived days as it takes, not a calendar day. Dedup key is `sessionId|timestamp`
+// (was bare timestamp, which collided on NTP skew or same-ms adds); `sessionId` is
+// always known for live exchanges; archive messages fall back to the archived chat's
+// sessionId via getArchiveDayMessages. `date` stays in the response for compatibility.
+sessionsRouter.get('/sessions/today/all-messages', async (req, res) => {
+  // 6.45.3 — first read after midnight files yesterday before answering.
+  await ensureArchiveMirrorForDay().catch(() => {})
   const todayDate = localDay()
+  const limit = recentMessagesLimit(req.query.limit)
   const activeEra = currentMessageEraState()
   const era = activeEra.era
 
-  const archivedMessages = getArchiveDayMessages(todayDate)
+  const archivedDay = (date: string) => getArchiveDayMessages(date)
     .filter(m => exchangeBelongsToEra(m, era))
     .map(m => {
       const globalMsgNum = m.globalMsgNum ?? m.no
@@ -323,8 +331,7 @@ sessionsRouter.get('/sessions/today/all-messages', (_req, res) => {
   }> = []
   const liveSessions = getActiveSessions()
   for (const session of liveSessions) {
-    const sessionDay = localDay(session.lastActivity)
-    if (sessionDay !== todayDate) continue
+    // Every live session, whatever day it last spoke: the window decides, not the calendar.
     for (let i = 0; i < session.exchanges.length; i++) {
       const ex = session.exchanges[i]
       if (ex.role === 'user') {
@@ -358,17 +365,13 @@ sessionsRouter.get('/sessions/today/all-messages', (_req, res) => {
     }
   }
 
-  // Merge, dedup by (sessionId, timestamp), sort chronologically.
-  const seen = new Set<string>()
-  const keyOf = (m: { sessionId?: string; timestamp: number }) => `${m.sessionId ?? ''}|${m.timestamp}`
-  const merged = [...archivedMessages, ...liveMessages]
-    .filter(m => {
-      const k = keyOf(m as any)
-      if (seen.has(k)) return false
-      seen.add(k)
-      return true
-    })
-    .sort((a, b) => a.timestamp - b.timestamp)
+  // Newest `limit` across live sessions and archived days (newest day first, read
+  // only while the window is short), dedup by (sessionId, timestamp), chronological.
+  const merged = selectRecentMessages(
+    liveMessages as Array<(typeof liveMessages)[number] | ReturnType<typeof archivedDay>[number]>,
+    listArchiveDateStrings().map(date => () => archivedDay(date)),
+    limit,
+  )
 
-  res.json({ messages: merged, date: todayDate })
+  res.json({ messages: merged, date: todayDate, window: { kind: 'recent', limit } })
 })

package/server/routes/skills.ts

@@ -0,0 +1,13 @@
+// GET /api/skills — slash commands the glasses agent can run from this Mac.
+// Workspace `.agents/skills` (canonical) + `.claude/skills` + `~/.claude/skills`.
+// Authenticated by the /api token middleware. Paths never leave the box.
+
+import { Router } from 'express'
+import { workspaceSkillsCatalog } from '../lib/workspace-skills.js'
+
+export const skillsRouter = Router()
+
+skillsRouter.get('/skills', (_req, res) => {
+  res.set('Cache-Control', 'private, no-store')
+  res.json(workspaceSkillsCatalog())
+})

package/server/routes/voice.ts

@@ -13,6 +13,7 @@ import { dataPath } from '../lib/data-dir.js'
 import { purgeSpeakerCalibrationRows, relabelSpeakerCalibrationRows } from '../lib/speaker-calibration-log.js'
 import { trainingSourceFor } from '../lib/training-audio-provenance.js'
 import { sendAudioFile } from '../lib/send-audio.js'
+import { extAudioChunkPath, listExtAudioChunks } from '../lib/meeting-audio-archive.js'
 import { getVoiceDirectorySnapshot, invalidateVoiceDirectory } from '../lib/voice-directory.js'
 import { greedyDiversitySelect } from '../lib/voice-enrolment-selection.js'
 import { fanOutSpeakerRename, type SpeakerRenameFanOut } from '../lib/speaker-rename-fanout.js'
@@ -336,6 +337,10 @@ voiceRouter.get('/voice/ext-audio', (_req, res) => {
         chunks: wavFiles.length,
         ageHours: parseFloat(ageHours),
         expiresIn: `${Math.max(0, 72 - parseFloat(ageHours)).toFixed(1)}h`,
+        // 6.45.3 — the chunk indices a reviewer can ask to hear (`?chunk=` on
+        // the sample route). Queen, 2026-09-12: the Add-a-voice panel let her
+        // name a session but not listen to it; naming is a guess without this.
+        chunkIndices: listExtAudioChunks(d.name),
       }
     }).filter(s => s.chunks > 0)
 
@@ -496,6 +501,8 @@ voiceRouter.get('/voice/profiles/:name/sample', (req, res) => {
 })
 
 // GET /api/voice/ext-audio/:sessionId/sample — hear an unidentified voice.
+// 6.45.3 — `?chunk=<index>` picks one held chunk (indices come from the listing's
+// `chunkIndices`); without it the newest chunk is served, as before.
 voiceRouter.get('/voice/ext-audio/:sessionId/sample', (req, res) => {
   res.set('Cache-Control', 'private, no-store')
   const sessionId = String(req.params.sessionId ?? '')
@@ -504,6 +511,21 @@ voiceRouter.get('/voice/ext-audio/:sessionId/sample', (req, res) => {
     res.status(400).json({ error: 'Invalid sessionId', reason: 'invalid_session_id' })
     return
   }
+  const chunkRaw = req.query.chunk
+  if (chunkRaw !== undefined) {
+    const chunkIndex = Number.parseInt(String(chunkRaw), 10)
+    if (!Number.isInteger(chunkIndex) || chunkIndex < 0) {
+      res.status(400).json({ error: 'Invalid chunk', reason: 'invalid_chunk' })
+      return
+    }
+    const chunkWav = extAudioChunkPath(sessionId, chunkIndex)
+    if (!chunkWav) {
+      res.status(404).json({ error: 'No ext-audio retained for that chunk', reason: 'no_ext_audio_chunk' })
+      return
+    }
+    sendAudioFile(res, chunkWav)
+    return
+  }
   const wav = existsSync(dirPath) ? newestWav(dirPath) : null
   if (!wav) {
     res.status(404).json({