@gotcos/glasses-server 6.45.2 → 6.45.3

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotcos/glasses-server",
-  "version": "6.45.2",
+  "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/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/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/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({