@gotcos/glasses-server 6.45.4 → 6.46.0

package/CHANGELOG.md

@@ -1,3 +1,25 @@
+## 6.46.0
+
+Name held voice samples and preview the meeting labels they will change. Paired Control build: 0.5.223.
+
+- Individual held samples can suggest an existing voice using the same second-best-sample scoring as groups, with a clear margin and owner-proximity caution. Suggestions remain proposals.
+- Naming returns a server-stored preview first. Apply checks the preview, voice store, raw chunk map and each meeting copy again, holds the COS sync lock where available, and writes chunk-scoped confirmations. Wider matches must agree with the named samples and the updated voice profile in their source meeting.
+- Corrected labels reach HQ word speakers, live chunks and operations copies. Transcript words remain unchanged; only fully aligned turn labels change. Newer speaker corrections survive re-import. Search catches up through the existing indexing queue; graph staleness is explicit.
+- Each naming has durable copy receipts and Undo. Interrupted work requires review. Undo restores eligible labels, retains enrolled voice samples, and never resurrects deleted audio. Held audio is deleted after successful meeting receipts.
+- Existing-name matching resolves stored spelling before preview. Owner naming requires an explicit acknowledgement and stronger acoustic match. Older clients cannot apply the new naming contract without a preview.
+- Voice-profile merges retain stronger source evidence before applying oldest-first eviction within a source tier. Training audio has its own retention capacity, independent of profile size, and freed slots are usable without a restart.
+- Compatibility: 6.45.5 safely ignores chunk-scoped confirmations. It does not understand reverted batch history; keep 6.46.0 for naming recovery and Undo history after rollback.
+
+## 6.45.5
+
+Sessions carry their last real activity and last tool (2026-09-13), for the phone Sessions list in COS Glasses 6.9.470.
+
+- `GET /api/agent-sessions` rows and `GET /api/agent-sessions/:provider/:sessionId` add `last_activity_at` (ISO time of the newest Claude user or assistant record, or the newest Codex `response_item`) and `last_tool` (the most recent tool call in the latest turn: Claude `tool_use`, Codex function, custom tool, local shell and web search calls) when the transcript has them. Both are omitted otherwise, and Cursor rows are unchanged, so an older client sees the payload it always did.
+- Why: a Claude Desktop relaunch appends bookkeeping records (`queue-operation` and similar) to every open transcript, so the file time moved with nobody working. On 2026-09-13, 18 of 60 listed rows shared one relaunch timestamp and sorted as the newest sessions on the Mac.
+- `running_active` ("working now") is judged by the last real record when it is known and older than the file write (`activityClockMs`), so a relaunch no longer reads as 30 seconds of work on every held session.
+- Cost: `lib/agent-session-activity.ts` reads the last 256 KiB of each listed transcript and widens x4 up to 16 MiB only when that tail holds no conversation record (measured record sizes reach 1.7 MB for Claude and 11.9 MB for Codex). Reads are memoized on mtime and size, least recently used evicted first, and at most 8 transcripts are read at once. Rows carry their resolved transcript path server-side only; `toEntry` projects named fields, so the path never reaches the wire.
+- Tests: `agent-session-activity.test.ts` (relaunch bookkeeping ignored, newest tool of the latest turn only, a tool result keeps the turn open whichever marker it carries, a parsing half line dropped, every Codex tool kind, widening and its cap, re-reads on mtime or size change and not otherwise, LRU eviction, the working-now clock, bounded concurrency) and route tests for a Codex thread and a Claude thread after a relaunch, with no path on the list or the detail, plus a Claude thread this process holds: a relaunch write does not read as working on the list or the detail, and a record inside the 30 s window still does.
+
 ## 6.45.4
 
 Two things from 2026-09-12: a dictated prompt that ended in a sentence nobody said, and held voices that could only be named one meeting at a time. Both went through a four-validator QA pass against a copy of Miles's live store before they shipped; what that pass corrected is recorded inline.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gotcos/glasses-server",
-  "version": "6.45.4",
-  "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",
+  "version": "6.46.0",
+  "description": "COS Glasses \u2014 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": {
     "glasses-server": "bin/cli.cjs",

package/server/index.ts

@@ -51,6 +51,7 @@ import { promptDraftsRouter } from './routes/prompt-drafts.js'
 import { cliDebugRouter } from './routes/cli-debug.js'
 import { maintenanceRouter } from './routes/maintenance.js'
 import { ttsRouter } from './routes/tts.js'
+import { recoverInterruptedNaming } from './lib/held-naming-batches.js'
 import { voiceRouter } from './routes/voice.js'
 import { glossaryRouter } from './routes/glossary.js'
 import { handoffsRouter } from './routes/handoffs.js'
@@ -684,6 +685,7 @@ app.use('/api', promptDraftsRouter)
 app.use('/api', cliDebugRouter)
 app.use('/api', maintenanceRouter)
 app.use('/api', ttsRouter)
+recoverInterruptedNaming()
 app.use('/api', voiceRouter)
 app.use('/api', glossaryRouter)
 app.use('/api', handoffsRouter)

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

@@ -0,0 +1,200 @@
+// When a Claude or Codex session last DID something, and the last tool it called.
+//
+// 6.45.5. Miles, 2026-09-13, on the phone's Sessions list: the status and the order should
+// be "reflective". They were not, because both came from the transcript FILE's write time.
+// A Claude Desktop relaunch appends bookkeeping records (`queue-operation` and friends) to
+// every open transcript, so 18 of 60 rows shared one relaunch timestamp and sorted as the
+// newest work on the Mac while their last real turn was days old.
+//
+// The answer is in the records themselves: Claude writes a `timestamp` on every user and
+// assistant record, and Codex on every `response_item`. The newest record is at the end,
+// so the reader starts from the tail and widens only when the tail holds no conversation
+// record. Records can be very large: measured on this Mac over seven days, the biggest
+// single records were 1.7 MB (Claude) and 11.9 MB (Codex). Reads are memoized on the
+// file's mtime and size, so a steady list poll re-reads nothing that did not change.
+//
+// Cursor agent transcripts carry no per-record clock, so they answer null and the client
+// keeps using the file time, exactly as before.
+
+import { open, stat } from 'node:fs/promises'
+import { AGENT_SESSION_LIST_MAX, type AgentProvider } from './agent-session-store.js'
+
+/** First window read from the end of a transcript. */
+export const ACTIVITY_TAIL_BYTES = 256 * 1024
+/** Largest window the reader widens to (x4 each step) when the tail holds no conversation record. */
+export const ACTIVITY_TAIL_MAX_BYTES = 16 * 1024 * 1024
+/** Memo entries kept, least recently used evicted first: several full lists' worth. */
+export const ACTIVITY_MEMO_MAX = AGENT_SESSION_LIST_MAX * 6
+/** Transcripts read at once on a cold list, so 80 rows never hold 80 descriptors. */
+export const ACTIVITY_READ_CONCURRENCY = 8
+
+export interface SessionActivity {
+  /** ISO time of the newest user or assistant record (Claude) or response item (Codex). */
+  lastActivityAt: string | null
+  /** Name of the most recent tool call in the latest turn. */
+  lastTool: string | null
+}
+
+const NONE: SessionActivity = Object.freeze({ lastActivityAt: null, lastTool: null })
+const memo = new Map<string, { mtimeMs: number; size: number; value: SessionActivity }>()
+let fileReads = 0
+
+const CODEX_TOOL_KINDS: Record<string, (payload: Record<string, unknown>) => string | null> = {
+  function_call: payload => (typeof payload.name === 'string' && payload.name ? payload.name : null),
+  custom_tool_call: payload => (typeof payload.name === 'string' && payload.name ? payload.name : null),
+  local_shell_call: () => 'local_shell',
+  web_search_call: () => 'web_search',
+}
+
+function isoOrNull(value: unknown): string | null {
+  if (typeof value !== 'string' || !value) return null
+  const ms = Date.parse(value)
+  return Number.isFinite(ms) ? new Date(ms).toISOString() : null
+}
+
+function claudeToolName(message: unknown): string | null {
+  if (!message || typeof message !== 'object') return null
+  const content = (message as { content?: unknown }).content
+  if (!Array.isArray(content)) return null
+  for (let i = content.length - 1; i >= 0; i--) {
+    const block = content[i] as { type?: unknown; name?: unknown } | null
+    if (block && block.type === 'tool_use' && typeof block.name === 'string' && block.name) return block.name
+  }
+  return null
+}
+
+/** A user record that starts a turn, as opposed to one that returns a tool result. */
+function claudeTurnStart(obj: Record<string, unknown>): boolean {
+  if (obj.type !== 'user' || obj.toolUseResult) return false
+  const content = (obj.message as { content?: unknown } | undefined)?.content
+  return !(Array.isArray(content) && content.some(block => (block as { type?: unknown } | null)?.type === 'tool_result'))
+}
+
+/**
+ * Scan transcript text from the end. `startsMidFile` drops the first line, which a tail
+ * read almost always cuts in half.
+ *
+ * The last tool is looked for only inside the latest turn: once the scan passes the user
+ * message that started it, an older tool would describe work that is already over.
+ */
+export function activityFromTail(provider: AgentProvider, text: string, startsMidFile: boolean): SessionActivity {
+  if (provider === 'cursor') return NONE
+  const lines = text.split('\n')
+  if (startsMidFile) lines.shift()
+  let lastActivityAt: string | null = null
+  let lastTool: string | null = null
+  let turnOpen = true
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (lastActivityAt !== null && (lastTool !== null || !turnOpen)) break
+    const line = lines[i].trim()
+    if (!line) continue
+    let obj: Record<string, unknown>
+    try {
+      const parsed: unknown = JSON.parse(line)
+      if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) continue
+      obj = parsed as Record<string, unknown>
+    } catch {
+      continue
+    }
+    if (provider === 'claude') {
+      // Only conversation records count. Bookkeeping (`queue-operation`, `summary`,
+      // `custom-title`, `mode`...) is exactly what a relaunch writes.
+      if (obj.type !== 'user' && obj.type !== 'assistant') continue
+      if (lastActivityAt === null) lastActivityAt = isoOrNull(obj.timestamp)
+      if (turnOpen && lastTool === null && obj.type === 'assistant') lastTool = claudeToolName(obj.message)
+      if (claudeTurnStart(obj)) turnOpen = false
+    } else {
+      if (obj.type !== 'response_item' || !obj.payload || typeof obj.payload !== 'object') continue
+      const payload = obj.payload as Record<string, unknown>
+      if (lastActivityAt === null) lastActivityAt = isoOrNull(obj.timestamp)
+      const toolName = CODEX_TOOL_KINDS[String(payload.type ?? '')]
+      if (turnOpen && lastTool === null && toolName) lastTool = toolName(payload)
+      if (payload.type === 'message' && payload.role === 'user') turnOpen = false
+    }
+  }
+  return { lastActivityAt, lastTool }
+}
+
+/**
+ * Read one transcript's activity, memoized on mtime and size. Starts with the last
+ * ACTIVITY_TAIL_BYTES and widens x4 up to ACTIVITY_TAIL_MAX_BYTES only while no
+ * conversation record has been found. Any failure answers null fields.
+ */
+export async function readSessionActivity(
+  provider: AgentProvider,
+  file: string,
+  opts: { memoMax?: number } = {},
+): Promise<SessionActivity> {
+  if (provider === 'cursor' || !file) return NONE
+  try {
+    const st = await stat(file)
+    const hit = memo.get(file)
+    if (hit && hit.mtimeMs === st.mtimeMs && hit.size === st.size) {
+      memo.delete(file)
+      memo.set(file, hit)
+      return hit.value
+    }
+    let value: SessionActivity = NONE
+    const handle = await open(file, 'r')
+    fileReads += 1
+    try {
+      for (let window = ACTIVITY_TAIL_BYTES; ; window *= 4) {
+        const length = Math.min(st.size, window)
+        const start = st.size - length
+        const buffer = Buffer.alloc(length)
+        const { bytesRead } = await handle.read(buffer, 0, length, start)
+        value = activityFromTail(provider, buffer.subarray(0, bytesRead).toString('utf8'), start > 0)
+        if (value.lastActivityAt !== null || start === 0 || window >= ACTIVITY_TAIL_MAX_BYTES) break
+      }
+    } finally {
+      await handle.close()
+    }
+    const max = Math.max(1, opts.memoMax ?? ACTIVITY_MEMO_MAX)
+    memo.delete(file)
+    while (memo.size >= max) {
+      const oldest = memo.keys().next().value
+      if (oldest === undefined) break
+      memo.delete(oldest)
+    }
+    memo.set(file, { mtimeMs: st.mtimeMs, size: st.size, value })
+    return value
+  } catch {
+    return NONE
+  }
+}
+
+/**
+ * The clock "working now" is judged by: the last real record when it is known and older
+ * than the file write, else the write time. A relaunch's bookkeeping write moves the file
+ * time with nobody working, and used to read as 30 seconds of work on every held session.
+ */
+export function activityClockMs(mtimeMs: number, activity: SessionActivity | null | undefined): number {
+  const at = activity?.lastActivityAt ? Date.parse(activity.lastActivityAt) : Number.NaN
+  return Number.isFinite(at) && at < mtimeMs ? at : mtimeMs
+}
+
+/** Map with at most `limit` promises in flight, preserving order. */
+export async function mapWithConcurrency<T, R>(
+  items: readonly T[],
+  limit: number,
+  fn: (item: T, index: number) => Promise<R>,
+): Promise<R[]> {
+  const out = new Array<R>(items.length)
+  let next = 0
+  const workers = Array.from({ length: Math.max(1, Math.min(limit, items.length)) }, async () => {
+    while (next < items.length) {
+      const index = next++
+      out[index] = await fn(items[index], index)
+    }
+  })
+  await Promise.all(workers)
+  return out
+}
+
+/** Test seams. */
+export function clearSessionActivityMemo(): void {
+  memo.clear()
+}
+export function sessionActivityFileReads(): number {
+  return fileReads
+}

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

@@ -50,6 +50,10 @@ export interface AgentSessionRow {
   pinned: boolean
   first_prompt?: string
   discussion_summary?: string
+  /** 6.45.5: the transcript this row was read from, when the walk resolved one. Server
+   *  only: `toEntry` projects named fields, so this never reaches the wire. It lets the
+   *  list read each row's last activity without resolving the file a second time. */
+  file?: string
 }
 
 export interface AgentSessionRoots {
@@ -1076,6 +1080,7 @@ export async function listClaudeSessions(
         provider: 'claude',
         display_label: title,
         project,
+        file: candidate.file,
         modified: isoFromMtime(candidate.mtimeMs),
         created: isoFromMtime(candidate.birthtimeMs),
         alive: false,
@@ -1159,6 +1164,7 @@ export async function listCodexSessions(
         provider: 'codex',
         display_label: title,
         project: workspaceLabel(meta.cwd),
+        file: candidate.file,
         modified: isoFromMtime(candidate.mtimeMs),
         created,
         alive: false,
@@ -1288,6 +1294,7 @@ async function enrichLiveClaude(row: AgentSessionRow, roots: AgentSessionRoots,
     ...row,
     session_id: fullId,
     modified,
+    file: found,
     display_label: title || row.display_label || 'Claude session',
     ...discussionFields(title || row.display_label, firstPrompt || '', peek.latestAssistant),
   }

package/server/lib/cos-operations-meetings.ts

@@ -462,7 +462,7 @@ export function findCosOperationsMeetingBySessionId(sessionId: string): {
       const monthDir = join(meetingsBase, month)
       let sidecars: string[]
       try {
-        sidecars = readdirSync(monthDir).filter(f => f.endsWith('.g2-chunks.json')).sort().reverse()
+        sidecars = readdirSync(monthDir).filter(f => f.endsWith('.g2-chunks.json') && !/ \d+(\.[A-Za-z0-9-]+)*\.json$/.test(f)).sort().reverse()
       } catch { continue }
 
       for (const sidecarName of sidecars) {

package/server/lib/g2-ops-handoff.ts

@@ -23,6 +23,9 @@ const DOMAIN_REVIEW_MARKER = '<!-- g2-needs-domain-review -->'
 const HQ_PENDING_MARKER = '<!-- g2-hq-state: pending -->'
 const OPERATIONS_OWNED_SIDECAR_FIELDS = new Set([
   'blended_into',
+  'claimed_parent',
+  'correctionRevision',
+  'labelsNewerThanGraph',
   'dedupEvidence',
   'enrichmentState',
   'finalPath',
@@ -124,6 +127,12 @@ function parseSidecar(path: string): Record<string, unknown> | null {
   }
 }
 
+export function g2Revision(value: unknown): number {
+  if (value === undefined || value === null) return 0
+  if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0) throw new Error('Invalid G2 revision')
+  return value
+}
+
 /** Merge server-owned capture truth while preserving operations-owned match state. */
 export function mergeG2OperationsSidecar(
   sourcePath: string,
@@ -139,8 +148,8 @@ export function mergeG2OperationsSidecar(
     throw new Error(`Refusing G2 sidecar merge across sessions (${existingSession} != ${sourceSession})`)
   }
 
-  const priorRevision = Number(existing.lifecycleRevision ?? 0)
-  const nextRevision = Math.max(Number(options.revision ?? 0), Number(source.lifecycleRevision ?? 0))
+  const priorRevision = g2Revision(existing.lifecycleRevision)
+  const nextRevision = Math.max(g2Revision(options.revision), g2Revision(source.lifecycleRevision))
   if (Number.isFinite(priorRevision) && Number.isFinite(nextRevision) && nextRevision < priorRevision) {
     throw new Error(`Refusing regressing G2 sidecar revision ${nextRevision} < ${priorRevision}`)
   }
@@ -149,10 +158,19 @@ export function mergeG2OperationsSidecar(
   for (const field of OPERATIONS_OWNED_SIDECAR_FIELDS) {
     if (Object.prototype.hasOwnProperty.call(existing, field)) merged[field] = existing[field]
   }
+  const correctionFields = ['chunks', 'chunkEntries', 'speakers', 'batchSegments', 'batchApplied', 'correctionRevision', 'labelsNewerThanGraph']
+  if (g2Revision(existing.correctionRevision) > g2Revision(source.correctionRevision)) {
+    for (const field of correctionFields) {
+      if (Object.prototype.hasOwnProperty.call(existing, field)) merged[field] = existing[field]
+      else delete merged[field]
+    }
+  }
+  merged.correctionRevision = Math.max(g2Revision(existing.correctionRevision), g2Revision(source.correctionRevision))
+  merged.labelsNewerThanGraph = existing.labelsNewerThanGraph === true || source.labelsNewerThanGraph === true
   merged.lifecycleRevision = Math.max(priorRevision || 0, nextRevision || 0)
-  const inferredFinalHqState = source.batchApplied === true
+  const inferredFinalHqState = merged.batchApplied === true
     ? 'accepted'
-    : source.batchQualityReport
+    : merged.batchQualityReport
       ? 'rejected'
       : 'unavailable'
   merged.hqState = options.hqState
@@ -184,7 +202,11 @@ export function stageRecordingIntoOperations(
   const destDir = join(operationsDir, 'personal', 'meetings', month)
   mkdirSync(destDir, { recursive: true })
   const destPath = join(destDir, basename(localMeetingPath))
-  const patched = patchRecordingForG2Pipeline(readFileSync(localMeetingPath, 'utf8'), options)
+  const sourceSidecar = parseSidecar(localMeetingPath.replace(/\.md$/, '.g2-chunks.json'))
+  const destinationSidecar = parseSidecar(destPath.replace(/\.md$/, '.g2-chunks.json'))
+  const keepMarkdown = g2Revision(destinationSidecar?.correctionRevision) > g2Revision(sourceSidecar?.correctionRevision)
+  if (keepMarkdown && !existsSync(destPath)) throw new Error('Corrected operations markdown missing; refusing stale import')
+  const patched = keepMarkdown ? readFileSync(destPath, 'utf8') : patchRecordingForG2Pipeline(readFileSync(localMeetingPath, 'utf8'), options)
 
   const stem = basename(localMeetingPath, '.md')
   const localDir = dirname(localMeetingPath)