@gotcos/glasses-server 6.16.1 → 6.16.3

package/.env.example

@@ -95,6 +95,13 @@ BIND_HOST=0.0.0.0
 # Power users running the COS Starter Kit can point the glasses at their
 # pipeline to inherit live tasks/calendar/people context. Omit for standalone.
 # COS_SCRIPTS_DIR=/path/to/your/cos/operations/scripts
+#
+# G2 "Review Meetings" reads COS meeting markdown from an operations tree:
+#   {COS_OPERATIONS_DIR}/{quilt|personal|…}/meetings/YYYY-MM/*.md
+# Prefer an explicit ops root (each COS layout can differ). If unset, the
+# server falls back to COS_SCRIPTS_DIR/.. then to local G2 recordings only.
+# COS_OPERATIONS_DIR=/path/to/your/cos/operations
+# COS_MEETINGS_ROOT=/path/to/your/cos/operations   # alias for COS_OPERATIONS_DIR
 
 # Telegram session/activity notifications remain OFF even if the COS scripts
 # directory contains .telegram_config.json. Enable export explicitly:

package/CHANGELOG.md

@@ -1,3 +1,18 @@
+## 6.16.3
+
+- **Cursor Agent mode on durable jobs.** Glasses Settings → Agent now reaches
+  the CLI (`--force` / no `--mode ask`). Public 6.16.1–6.16.2 accepted Cursor
+  models but dropped `cursorExecutionMode` before query-job execution, so every
+  turn stayed Ask and Shell was Rejected. Parse + forward `agent`|`ask`; omit
+  still defaults to ask for old clients.
+
+## 6.16.2
+
+- **COS operations meetings library.** G2 Review Meetings can list markdown from
+  a configurable COS `operations/` tree via `COS_OPERATIONS_DIR` /
+  `COS_MEETINGS_ROOT`, with fallback to `COS_SCRIPTS_DIR/..`, then standalone
+  recordings. Opt-in per install — no hardcoded COS layout.
+
 ## 6.16.1
 
 - **Cursor Agent models (Composer 2.5 / Grok 4.5).** Managed installs now ship

package/package.json

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

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

@@ -0,0 +1,365 @@
+/**
+ * Optional COS operations meeting library.
+ *
+ * When configured, G2 "Review Meetings" reads markdown from a COS-style tree:
+ *   {operationsDir}/{domain}/meetings/YYYY-MM/*.md
+ *
+ * Resolution order:
+ *   1. COS_OPERATIONS_DIR  — explicit operations/ root (preferred)
+ *   2. COS_MEETINGS_ROOT   — alias for the same path
+ *   3. COS_SCRIPTS_DIR/..  — classic Starter Kit layout (operations/scripts → operations)
+ *
+ * Standalone installs leave all of these unset and keep using MeetingStore
+ * (~/.cos-glasses/data/recordings).
+ */
+
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs'
+import { basename, join, resolve } from 'node:path'
+import type { MeetingDetail, MeetingMeta } from './meeting-store.js'
+import { MEETING_SOURCE_MAX_BYTES } from './meeting-store.js'
+
+export const COS_MEETING_DOMAINS = ['quilt', 'sprocket_rocket', 'hermit_crabs', 'personal'] as const
+
+const DOMAIN_ABBR: Record<string, string> = {
+  quilt: 'Q',
+  sprocket_rocket: 'SR',
+  hermit_crabs: 'HC',
+  personal: 'P',
+}
+
+const DETAIL_CHUNK_ESTIMATE_CHARS = 1700
+
+export type CosOperationsMeetingMeta = MeetingMeta & { time?: string }
+
+function envPath(name: string): string | null {
+  const raw = process.env[name]?.trim()
+  if (!raw) return null
+  return resolve(raw)
+}
+
+/** Resolve the COS operations directory, or null in standalone mode.
+ * Reads process.env on each call so tests and Control env updates stay live. */
+export function resolveCosOperationsDir(): string | null {
+  const explicit = envPath('COS_OPERATIONS_DIR') || envPath('COS_MEETINGS_ROOT')
+  if (explicit && existsSync(explicit)) return explicit
+  const scriptsDir = envPath('COS_SCRIPTS_DIR')
+  if (scriptsDir) {
+    const inferred = resolve(scriptsDir, '..')
+    if (existsSync(inferred)) return inferred
+  }
+  return null
+}
+
+export function cosOperationsMeetingsConfigured(): boolean {
+  return resolveCosOperationsDir() != null
+}
+
+function boundedMeetingSource(content: string): { sourceContent: string; sourceTruncated: boolean } {
+  const bytes = Buffer.from(content, 'utf8')
+  if (bytes.length <= MEETING_SOURCE_MAX_BYTES) return { sourceContent: content, sourceTruncated: false }
+  let end = MEETING_SOURCE_MAX_BYTES
+  while (end > 0 && (bytes[end] & 0xc0) === 0x80) end -= 1
+  return { sourceContent: bytes.subarray(0, end).toString('utf8'), sourceTruncated: true }
+}
+
+function parseDurationMinutes(duration: string): number | undefined {
+  if (!duration) return undefined
+  const normalized = duration.toLowerCase()
+  const colonMatch = normalized.match(/\b(\d+):(\d{2})\b/)
+  if (colonMatch) return Number(colonMatch[1]) * 60 + Number(colonMatch[2])
+
+  let total = 0
+  const hourMatch = normalized.match(/(\d+(?:\.\d+)?)\s*(?:h|hr|hrs|hour|hours)\b/)
+  if (hourMatch) total += Math.round(Number(hourMatch[1]) * 60)
+
+  const minuteMatch = normalized.match(/(\d+)\s*(?:m|min|mins|minute|minutes)\b/)
+  if (minuteMatch) total += Number(minuteMatch[1])
+
+  if (total > 0) return total
+
+  const bareNumber = normalized.match(/^\s*(\d+)\s*$/)
+  return bareNumber ? Number(bareNumber[1]) : undefined
+}
+
+function normalizeMeetingTime(hourText: string, minuteText: string, meridiemText = ''): string | undefined {
+  let hour = Number(hourText)
+  const minute = Number(minuteText)
+  if (!Number.isInteger(hour) || !Number.isInteger(minute) || minute < 0 || minute > 59) return undefined
+  const meridiem = meridiemText.trim().toUpperCase()
+  if (meridiem) {
+    if (hour < 1 || hour > 12 || !['AM', 'PM'].includes(meridiem)) return undefined
+    if (meridiem === 'AM' && hour === 12) hour = 0
+    if (meridiem === 'PM' && hour !== 12) hour += 12
+  } else if (hour < 0 || hour > 23) {
+    return undefined
+  }
+  return `${String(hour).padStart(2, '0')}:${String(minute).padStart(2, '0')}`
+}
+
+export function extractMeetingDateTime(content: string, filename: string): { date: string; time?: string } {
+  const metadata = content.match(/\*\*Date(?::)?\*\*\s*(?:\|\s*)?((?:19|20)\d{2}-\d{2}-\d{2})(?:[ T]+(\d{1,2}):(\d{2})(?:\s*([AP]M))?)?/i)
+  if (metadata) {
+    const time = metadata[2] && metadata[3]
+      ? normalizeMeetingTime(metadata[2], metadata[3], metadata[4])
+      : undefined
+    return { date: metadata[1], ...(time ? { time } : {}) }
+  }
+
+  const g2 = filename.match(/_((?:19|20)\d{2}-\d{2}-\d{2})_(\d{2})(\d{2})(?:\D|$)/)
+  if (g2) {
+    const time = normalizeMeetingTime(g2[2], g2[3])
+    return { date: g2[1], ...(time ? { time } : {}) }
+  }
+
+  const dateMatch = filename.match(/^((?:19|20)\d{2}-\d{2}-\d{2})/)
+  return { date: dateMatch ? dateMatch[1] : 'unknown' }
+}
+
+export function compareMeetingsNewestFirst(a: CosOperationsMeetingMeta, b: CosOperationsMeetingMeta): number {
+  const aKey = `${a.date || '0000-00-00'}T${a.time || '00:00'}`
+  const bKey = `${b.date || '0000-00-00'}T${b.time || '00:00'}`
+  return bKey.localeCompare(aKey)
+    || b.filename.localeCompare(a.filename)
+    || b.domain.localeCompare(a.domain)
+}
+
+export function matchRenamedMeetingFilename(
+  requestedFilename: string,
+  candidates: Array<{ filename: string; content: string }>,
+): string | undefined {
+  const requested = extractMeetingDateTime('', requestedFilename)
+  if (requested.date === 'unknown' || !requested.time) return undefined
+  const matches = candidates.filter(candidate => {
+    const timestamp = extractMeetingDateTime(candidate.content, candidate.filename)
+    return timestamp.date === requested.date && timestamp.time === requested.time
+  })
+  return matches.length === 1 ? matches[0].filename : undefined
+}
+
+function parseMeetingMeta(content: string, filename: string, domain: string): CosOperationsMeetingMeta {
+  const name = basename(filename, '.md')
+  const titleMatch = content.match(/^#\s+(.+)$/m)
+  let title: string
+  if (titleMatch) {
+    title = titleMatch[1].trim()
+  } else {
+    const parts = name.split('_').slice(1)
+    title = parts.join(' ').slice(0, 50)
+  }
+
+  const { date, time } = extractMeetingDateTime(content, filename)
+  const sourceMatch = content.match(/\*\*Source\*\*\s*\|\s*(.+)/i)
+    || content.match(/\*\*Source:\*\*\s*(.+)/i)
+  const source = sourceMatch ? sourceMatch[1].replace(/\s*\|?\s*$/, '').trim() : ''
+
+  const durationMatch = content.match(/\*\*Duration\*\*\s*\|\s*(.+)/i)
+    || content.match(/\*\*Duration:\*\*\s*(.+)/i)
+  const duration = durationMatch ? durationMatch[1].replace(/\s*\|?\s*$/, '').trim() : ''
+  const durationMinutes = parseDurationMinutes(duration)
+
+  return {
+    filename,
+    title: title || 'Untitled Meeting',
+    date,
+    ...(time ? { time } : {}),
+    domain,
+    domainAbbr: DOMAIN_ABBR[domain] || '?',
+    source,
+    duration,
+    durationMinutes,
+    month: '',
+  }
+}
+
+function extractSummary(content: string): string {
+  const summaryMatch = content.match(/## Summary\s*\n([\s\S]*?)(?=\n##|\n$|$)/)
+  if (summaryMatch) return summaryMatch[1].trim().slice(0, 2000)
+  return ''
+}
+
+function extractTopics(content: string): string[] {
+  const topicsMatch = content.match(/## Topics Discussed\s*\n([\s\S]*?)(?=\n##|\n$|$)/)
+  if (!topicsMatch) return []
+  return topicsMatch[1]
+    .split('\n')
+    .filter(l => l.trim().startsWith('-') || l.trim().startsWith('*'))
+    .map(l => l.replace(/^[-*]\s*/, '').trim())
+    .filter(Boolean)
+    .slice(0, 10)
+}
+
+function extractActionItems(content: string): Array<{ task: string; owner: string }> {
+  const actionsMatch = content.match(/## (?:Action Items|Tasks|Next Steps)\s*\n([\s\S]*?)(?=\n##|\n$|$)/)
+  if (!actionsMatch) return []
+  return actionsMatch[1]
+    .split('\n')
+    .filter(l => l.trim().startsWith('-') || l.trim().startsWith('*') || l.trim().match(/^\[/))
+    .map(l => {
+      const cleaned = l.replace(/^[-*]\s*/, '').replace(/^\[.\]\s*/, '').replace(/`\[REVIEW\]`\s*/i, '').trim()
+      const ownerMatch = cleaned.match(/\(\*\*(.+?)\*\*\)\s*$/)
+      const owner = ownerMatch ? ownerMatch[1] : ''
+      const task = ownerMatch ? cleaned.replace(ownerMatch[0], '').trim() : cleaned
+      return { task, owner }
+    })
+    .filter(i => i.task.length > 0)
+    .slice(0, 15)
+}
+
+function extractDecisions(content: string): string[] {
+  const match = content.match(/## Decisions(?: Made)?\s*\n([\s\S]*?)(?=\n##|\n$|$)/)
+  if (!match) return []
+  return match[1]
+    .split('\n')
+    .filter(l => l.trim().startsWith('-') || l.trim().startsWith('*'))
+    .map(l => l.replace(/^[-*]\s*/, '').trim())
+    .filter(Boolean)
+    .slice(0, 10)
+}
+
+function extractAttendees(content: string): string[] {
+  const match = content.match(/## Attendees\s*\n([\s\S]*?)(?=\n##|\n$|$)/)
+  if (!match) return []
+  return match[1]
+    .split('\n')
+    .filter(l => l.trim().startsWith('-') || l.trim().startsWith('*'))
+    .map(l => {
+      const cleaned = l.replace(/^[-*]\s*/, '').trim()
+      const nameMatch = cleaned.match(/^\*\*(.+?)\*\*/) || cleaned.match(/^([^(]+)/)
+      return nameMatch ? nameMatch[1].trim() : cleaned
+    })
+    .filter(Boolean)
+    .slice(0, 20)
+}
+
+function withMeetingListInsights(meta: CosOperationsMeetingMeta, content: string): CosOperationsMeetingMeta {
+  const summary = extractSummary(content)
+  const topics = extractTopics(content)
+  const decisions = extractDecisions(content)
+  const actionItems = extractActionItems(content)
+  const attendees = extractAttendees(content)
+  const header = `${meta.title}\n${meta.date}${meta.time ? ` ${meta.time}` : ''} • ${meta.domainAbbr} • ${meta.duration || meta.source}\n\n`
+  const detailCharEstimate = [
+    header,
+    summary,
+    topics.join('\n'),
+    decisions.join('\n'),
+    actionItems.map(a => `${a.owner ? `[${a.owner}] ` : ''}${a.task}`).join('\n'),
+    attendees.join(', '),
+  ].join('\n\n').trim().length
+
+  return {
+    ...meta,
+    detailCharEstimate,
+    estimatedDetailPages: Math.max(1, Math.ceil(detailCharEstimate / DETAIL_CHUNK_ESTIMATE_CHARS)),
+    topicCount: topics.length,
+    decisionCount: decisions.length,
+    actionCount: actionItems.length,
+    attendeeCount: attendees.length,
+  }
+}
+
+export function listCosOperationsMeetings(options: {
+  limit?: number
+  domain?: string
+} = {}): CosOperationsMeetingMeta[] {
+  const operationsDir = resolveCosOperationsDir()
+  if (!operationsDir) return []
+
+  const limit = Math.min(Math.max(options.limit ?? 20, 1), 50)
+  const domainFilter = options.domain || 'all'
+  const domains = domainFilter === 'all'
+    ? [...COS_MEETING_DOMAINS]
+    : COS_MEETING_DOMAINS.includes(domainFilter as typeof COS_MEETING_DOMAINS[number])
+      ? [domainFilter]
+      : []
+
+  const allMeetings: CosOperationsMeetingMeta[] = []
+
+  for (const domain of domains) {
+    const meetingsBase = join(operationsDir, domain, 'meetings')
+    try {
+      const months = readdirSync(meetingsBase)
+        .filter(d => /^\d{4}-\d{2}$/.test(d))
+        .sort()
+        .reverse()
+        .slice(0, 3)
+
+      for (const month of months) {
+        const monthDir = join(meetingsBase, month)
+        try {
+          const files = readdirSync(monthDir)
+            .filter(f => f.endsWith('.md'))
+            .sort()
+            .reverse()
+
+          for (const file of files) {
+            try {
+              const filepath = join(monthDir, file)
+              const content = readFileSync(filepath, 'utf-8')
+              const meta = withMeetingListInsights(parseMeetingMeta(content.slice(0, 4000), file, domain), content)
+              meta.month = month
+              allMeetings.push(meta)
+            } catch { /* skip unreadable files */ }
+          }
+        } catch { /* skip unreadable months */ }
+      }
+    } catch { /* domain has no meetings dir */ }
+  }
+
+  allMeetings.sort(compareMeetingsNewestFirst)
+  return allMeetings.slice(0, limit)
+}
+
+export function getCosOperationsMeetingDetail(
+  domain: string,
+  month: string,
+  filename: string,
+): MeetingDetail | null {
+  const operationsDir = resolveCosOperationsDir()
+  if (!operationsDir) return null
+
+  if (!(COS_MEETING_DOMAINS as readonly string[]).includes(domain)) return null
+  if (!/^\d{4}-\d{2}$/.test(month) || basename(filename) !== filename || !filename.endsWith('.md')) {
+    return null
+  }
+
+  const monthDir = join(operationsDir, domain, 'meetings', month)
+  let resolvedFilename = filename
+  let filepath = join(monthDir, resolvedFilename)
+
+  try {
+    statSync(filepath)
+  } catch {
+    let candidates: Array<{ filename: string; content: string }> = []
+    try {
+      candidates = readdirSync(monthDir)
+        .filter(candidate => candidate.endsWith('.md'))
+        .map(candidate => ({
+          filename: candidate,
+          content: readFileSync(join(monthDir, candidate), 'utf8').slice(0, 4000),
+        }))
+    } catch {
+      return null
+    }
+    const renamed = matchRenamedMeetingFilename(filename, candidates)
+    if (!renamed) return null
+    resolvedFilename = renamed
+    filepath = join(monthDir, resolvedFilename)
+  }
+
+  const content = readFileSync(filepath, 'utf-8')
+  const meta = parseMeetingMeta(content, resolvedFilename, domain)
+  meta.month = month
+  const source = boundedMeetingSource(content)
+
+  return {
+    ...meta,
+    summary: extractSummary(content),
+    topics: extractTopics(content),
+    decisions: extractDecisions(content),
+    actionItems: extractActionItems(content),
+    attendees: extractAttendees(content),
+    transcript: content,
+    ...source,
+  }
+}

package/server/lib/query-job-runtime.ts

@@ -238,6 +238,8 @@ const runner: QueryJobRunner = async ({ jobId, turnId, request, signal, callback
     {
       abortSignal: signal,
       effort: validEffort,
+      // Companion sends agent|ask; omit/unknown → ask (safe default for old clients).
+      cursorExecutionMode: request.cursorExecutionMode === 'agent' ? 'agent' : 'ask',
       clientJobId: request.clientJobId,
       generation: request.generation,
       sessionLockHeld: true,

package/server/lib/query-job-store.ts

@@ -455,6 +455,7 @@ export class QueryJobStore {
           sessionId: request.sessionId,
           ...(request.model ? { requestedModel: request.model } : {}),
           ...(request.effort ? { effort: request.effort } : {}),
+          ...(request.cursorExecutionMode ? { cursorExecutionMode: request.cursorExecutionMode } : {}),
           ...(request.messageEra ? { messageEra: request.messageEra } : {}),
           ...(request.globalMsgNum ? { globalMsgNum: request.globalMsgNum } : {}),
           ...(request.handoffCode ? { handoffCode: request.handoffCode } : {}),

package/server/lib/query-job-types.ts

@@ -61,6 +61,8 @@ export interface QueryJobRequest {
   sessionId: string
   model?: string
   effort?: string
+  /** Cursor ask|agent. Omitted means ask on the server (old clients). */
+  cursorExecutionMode?: string
   messageEra?: string
   globalMsgNum?: number
   reference?: QueryJobPromptReference
@@ -119,6 +121,7 @@ export interface QueryJobSnapshot extends QueryJobProviderLinkage {
   sessionId: string
   requestedModel?: string
   effort?: string
+  cursorExecutionMode?: string
   messageEra?: string
   globalMsgNum?: number
   handoffCode?: string
@@ -239,6 +242,10 @@ export function parseQueryJobRequest(raw: unknown): QueryJobRequest {
 
   const model = optionalString(input.model, 'model', 64)
   const effort = optionalString(input.effort, 'effort', 32)
+  const cursorExecutionModeRaw = optionalString(input.cursorExecutionMode, 'cursor_execution_mode', 16)
+  const cursorExecutionMode = cursorExecutionModeRaw === 'agent' || cursorExecutionModeRaw === 'ask'
+    ? cursorExecutionModeRaw
+    : undefined
   const messageEra = optionalString(input.messageEra, 'message_era', 80)
   const handoffCode = optionalString(input.handoffCode, 'handoff_code', 128)
   const clientQueueItemId = optionalString(input.clientQueueItemId, 'client_queue_item_id', 120)
@@ -277,6 +284,7 @@ export function parseQueryJobRequest(raw: unknown): QueryJobRequest {
     sessionId,
     ...(model ? { model } : {}),
     ...(effort ? { effort } : {}),
+    ...(cursorExecutionMode ? { cursorExecutionMode } : {}),
     ...(messageEra ? { messageEra } : {}),
     ...(globalMsgNum ? { globalMsgNum } : {}),
     ...(reference ? { reference } : {}),

package/server/routes/meetings.ts

@@ -1,8 +1,13 @@
-// Standalone meeting archive backed only by the public server's private data
-// directory. No COS operations paths, classifiers, or user-specific stores.
+// Meeting archive: COS operations tree when configured, else standalone recordings.
 
 import { Router } from 'express'
 import { getMeetingStore, MeetingStore, MeetingStoreError } from '../lib/meeting-store.js'
+import {
+  cosOperationsMeetingsConfigured,
+  getCosOperationsMeetingDetail,
+  listCosOperationsMeetings,
+  resolveCosOperationsDir,
+} from '../lib/cos-operations-meetings.js'
 
 export function createMeetingsRouter(store: MeetingStore = getMeetingStore()): Router {
   const router = Router()
@@ -14,7 +19,18 @@ export function createMeetingsRouter(store: MeetingStore = getMeetingStore()): R
       const limit = Number.isFinite(rawLimit) ? rawLimit : 20
       const domain = typeof req.query.domain === 'string' ? req.query.domain : 'all'
       res.set('Cache-Control', 'private, no-store')
-      res.json({ meetings: store.list({ limit, domain }) })
+
+      if (cosOperationsMeetingsConfigured()) {
+        const meetings = listCosOperationsMeetings({ limit, domain })
+        res.json({
+          meetings,
+          source: 'cos_operations',
+          operationsDir: resolveCosOperationsDir(),
+        })
+        return
+      }
+
+      res.json({ meetings: store.list({ limit, domain }), source: 'standalone_recordings' })
     } catch (error) {
       sendMeetingStoreError(res, error)
     }
@@ -32,6 +48,17 @@ export function createMeetingsRouter(store: MeetingStore = getMeetingStore()): R
         return
       }
       res.set('Cache-Control', 'private, no-store')
+
+      if (cosOperationsMeetingsConfigured()) {
+        const detail = getCosOperationsMeetingDetail(domain, month, filename)
+        if (detail) {
+          res.json(detail)
+          return
+        }
+        // Fall through to standalone store for G2-local recordings that share
+        // the same API shape when ops lookup misses.
+      }
+
       res.json(store.detail(domain, month, filename))
     } catch (error) {
       sendMeetingStoreError(res, error)
@@ -43,6 +70,19 @@ export function createMeetingsRouter(store: MeetingStore = getMeetingStore()): R
   router.get('/meetings/:domain/:month/:filename', (req, res) => {
     try {
       res.set('Cache-Control', 'private, no-store')
+
+      if (cosOperationsMeetingsConfigured()) {
+        const detail = getCosOperationsMeetingDetail(
+          req.params.domain,
+          req.params.month,
+          req.params.filename,
+        )
+        if (detail) {
+          res.json(detail)
+          return
+        }
+      }
+
       res.json(store.detail(req.params.domain, req.params.month, req.params.filename))
     } catch (error) {
       sendMeetingStoreError(res, error)