@gotcos/glasses-server 6.42.1 → 6.43.1

package/server/lib/morning-brief-runtime.ts

@@ -0,0 +1,203 @@
+// Morning brief — the one production scheduler, wired to the real coordinator.
+//
+// Mirrors query-job-runtime.ts: the module owns the singleton so the router,
+// health, and index.ts all see the same instance, and tests construct their
+// own MorningBriefScheduler with fake deps instead of importing this file.
+
+import { existsSync, readFileSync, statSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { basename, join, resolve } from 'node:path'
+import { getActiveSessions, createSession } from './conversation.js'
+import { currentMessageEra, exchangeBelongsToEra } from './message-era.js'
+import { maxGlobalMsgNumInDir } from '../routes/message-ref.js'
+import { dataPath } from './data-dir.js'
+import { getOwnerName } from './profile.js'
+import { durableQueryJobsEnabled } from './query-job-feature.js'
+import { queryJobCoordinator } from './query-job-runtime.js'
+import { maintenanceAdmissionsOpen } from './maintenance-lifecycle.js'
+import { maxReservedGlobalMsgNum, registerMessageReservationSource } from './message-reservations.js'
+import { morningBriefPaths } from './morning-brief-config.js'
+import { MorningBriefScheduler } from './morning-brief-scheduler.js'
+import {
+  MorningBriefCoverageService,
+  type CalendarProbe,
+  type ContextProbe,
+  type MeetingsProbe,
+  type ReflectionProbe,
+  type SkillProbe,
+  type TasksProbe,
+} from './morning-brief-coverage.js'
+import {
+  listCosOperationsMeetingDays,
+  listCosOperationsMeetingMonths,
+  listDirectLibraryMeetingDays,
+  listDirectLibraryMeetingMonths,
+  resolveMeetingLibrary,
+} from './cos-operations-meetings.js'
+import { getMeetingStore } from './meeting-store.js'
+import { COS_SCRIPTS_DIR, callPython, contextSourceAvailable, pythonBridgeAvailable } from './python-bridge.js'
+import { resolveProviderWorkDir } from './launch-dir.js'
+
+/** Highest stamped message number in the active era: live sessions, the day
+ * archives, AND every number a not-yet-projected job or brief already holds.
+ * The same arithmetic /api/message-counter serves the phone. */
+export function currentMessageMax(): number {
+  const era = currentMessageEra()
+  let liveMax = 0
+  for (const session of getActiveSessions()) {
+    for (const exchange of (session as { exchanges?: Array<{ globalMsgNum?: unknown; messageEra?: unknown }> }).exchanges ?? []) {
+      if (!exchangeBelongsToEra(exchange, era)) continue
+      if (typeof exchange?.globalMsgNum === 'number' && exchange.globalMsgNum > liveMax) liveMax = exchange.globalMsgNum
+    }
+  }
+  return Math.max(liveMax, maxGlobalMsgNumInDir(dataPath('archive'), era), maxReservedGlobalMsgNum(era))
+}
+
+// ── Coverage probes (the same wells COS Control's Activity tiles read) ────────
+
+function sumDayCounts(months: string[], days: (month: string) => Array<{ count: number }>): number {
+  let total = 0
+  for (const month of months) for (const day of days(month)) total += day.count
+  return total
+}
+
+export function probeMeetings(): MeetingsProbe | null {
+  const library = resolveMeetingLibrary()
+  if (library.layout === 'direct') {
+    const months = listDirectLibraryMeetingMonths()
+    return { count: sumDayCounts(months, listDirectLibraryMeetingDays), newestMonth: months[0] ?? null, layout: library.layout }
+  }
+  if (library.layout === 'multi_domain') {
+    const months = listCosOperationsMeetingMonths('all')
+    return { count: sumDayCounts(months, month => listCosOperationsMeetingDays(month, 'all')), newestMonth: months[0] ?? null, layout: library.layout }
+  }
+  if (library.layout === 'invalid_explicit_root') return null
+  const store = getMeetingStore()
+  const months = store.listMonths()
+  return { count: sumDayCounts(months, month => store.listDayCounts(month)), newestMonth: months[0] ?? null, layout: 'standalone' }
+}
+
+export async function probeContext(): Promise<ContextProbe | null> {
+  if (contextSourceAvailable() === null) return null
+  const data = await callPython(['context-status'], 8_000) as {
+    memory?: { available?: unknown; total?: unknown; state?: unknown; reason?: unknown }
+    threads?: { available?: unknown; total?: unknown; active?: unknown; state?: unknown; reason?: unknown }
+  } | null
+  if (!data || typeof data !== 'object') return null
+  const num = (value: unknown) => typeof value === 'number' && Number.isFinite(value) ? value : 0
+  const state = (part?: { state?: unknown; reason?: unknown }) =>
+    typeof part?.state === 'string' ? part.state : typeof part?.reason === 'string' ? part.reason : undefined
+  return {
+    memory: { available: data.memory?.available === true, total: num(data.memory?.total), state: state(data.memory) },
+    threads: { available: data.threads?.available === true, total: num(data.threads?.total), active: num(data.threads?.active), state: state(data.threads) },
+  }
+}
+
+export async function probeCalendar(): Promise<CalendarProbe | null> {
+  if (!pythonBridgeAvailable()) return null
+  const data = await callPython(['calendar'], 8_000) as { meetings_today_count?: unknown; today_events?: unknown; data_source?: unknown } | null
+  if (!data || typeof data !== 'object') return null
+  const today = typeof data.meetings_today_count === 'number'
+    ? data.meetings_today_count
+    : Array.isArray(data.today_events) ? data.today_events.length : 0
+  return { todayCount: Math.max(0, Math.trunc(today)), ...(typeof data.data_source === 'string' ? { source: data.data_source } : {}) }
+}
+
+export async function probeTasks(): Promise<TasksProbe | null> {
+  if (!pythonBridgeAvailable()) return null
+  const data = await callPython(['tasks'], 8_000) as Record<string, unknown> | null
+  if (!data || typeof data !== 'object') return null
+  let open = 0
+  let files = 0
+  for (const rows of Object.values(data)) {
+    if (!Array.isArray(rows)) continue
+    files += 1
+    for (const row of rows) {
+      if (row && typeof row === 'object' && (row as { is_checked?: unknown }).is_checked !== true) open += 1
+    }
+  }
+  return { open, files }
+}
+
+const REFLECTION_LOG_MAX_BYTES = 8 * 1024 * 1024
+
+export function probeReflection(): ReflectionProbe | null {
+  if (!COS_SCRIPTS_DIR) return null
+  const file = resolve(COS_SCRIPTS_DIR, '.cos_reflect_log.jsonl')
+  let stat
+  try { stat = statSync(file) } catch { return null }
+  if (!stat.isFile()) return null
+  const newestAt = stat.mtime.toISOString()
+  if (stat.size > REFLECTION_LOG_MAX_BYTES) return { entries: -1, newestAt }
+  let entries = 0
+  try {
+    for (const line of readFileSync(file, 'utf8').split('\n')) if (line.trim()) entries += 1
+  } catch { return null }
+  return { entries, newestAt }
+}
+
+const SKILL_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,63}$/
+
+/** Where a skill would be found, in the order the prompt tells the agent to
+ * look. Returns a folder LABEL, never an absolute path. */
+export function probeSkill(rawName: string, workDir = resolveProviderWorkDir({ scriptsDir: COS_SCRIPTS_DIR }), home = homedir()): SkillProbe {
+  const name = rawName.trim().replace(/^\//, '')
+  if (!SKILL_NAME_RE.test(name) || basename(name) !== name) return { found: false }
+  const nested = name.replace(/:/g, '/')
+  const candidates: Array<[string, string]> = [
+    ['.claude/skills', join(workDir, '.claude', 'skills', name, 'SKILL.md')],
+    ['.agents/skills', join(workDir, '.agents', 'skills', name, 'SKILL.md')],
+    ['.agents/skills', join(workDir, '.agents', 'skills', nested, 'SKILL.md')],
+    ['.claude/commands', join(workDir, '.claude', 'commands', `${name}.md`)],
+    ['.claude/commands', join(workDir, '.claude', 'commands', `${nested}.md`)],
+    ['~/.claude/skills', join(home, '.claude', 'skills', name, 'SKILL.md')],
+    ['~/.claude/commands', join(home, '.claude', 'commands', `${name}.md`)],
+    ['~/.codex/prompts', join(home, '.codex', 'prompts', `${name}.md`)],
+  ]
+  for (const [where, path] of candidates) {
+    try { if (existsSync(path)) return { found: true, where } } catch { /* unreadable: keep looking */ }
+  }
+  return { found: false }
+}
+
+let scheduler: MorningBriefScheduler | null = null
+let unregisterReservations: (() => void) | null = null
+
+export function getMorningBriefScheduler(): MorningBriefScheduler {
+  if (!scheduler) {
+    const instance = new MorningBriefScheduler({
+      paths: morningBriefPaths(),
+      submit: raw => queryJobCoordinator.submit(raw),
+      findByClientGeneration: (clientJobId, generation) => queryJobCoordinator.getByClientGeneration(clientJobId, generation),
+      getSnapshot: jobId => queryJobCoordinator.getSnapshot(jobId),
+      createSession,
+      currentMessageEra,
+      currentMessageMax,
+      ownerName: getOwnerName,
+      durableJobsEnabled: durableQueryJobsEnabled,
+      admissionsOpen: maintenanceAdmissionsOpen,
+      coverage: new MorningBriefCoverageService({
+        meetings: probeMeetings,
+        context: probeContext,
+        calendar: probeCalendar,
+        tasks: probeTasks,
+        reflection: probeReflection,
+        skill: name => probeSkill(name),
+      }),
+    })
+    // The ledger row exists before the job does; its number must count.
+    unregisterReservations = registerMessageReservationSource(() => instance.liveReservations(currentMessageEra()))
+    scheduler = instance
+  }
+  return scheduler
+}
+
+export function startMorningBriefScheduler(): void {
+  getMorningBriefScheduler().start()
+}
+
+export function stopMorningBriefScheduler(): void {
+  scheduler?.stop()
+  unregisterReservations?.()
+  unregisterReservations = null
+}

package/server/lib/morning-brief-schedule.ts

@@ -0,0 +1,158 @@
+// Morning brief — pure schedule arithmetic in the user's zone.
+//
+// No dependency: Node's Intl is enough to read a wall clock in an IANA zone,
+// and the two operations the scheduler needs — "what local day and minute is
+// it now" and "when is HH:MM on day D as an instant" — are both derivable from
+// it. Kept free of timers and I/O so the fire/no-fire decision is a table of
+// inputs a test can enumerate: the Mac asleep through the slot, a weekend, a
+// zone change, a DST morning, a second tick in the same minute.
+
+import type { MorningBriefConfig, MorningBriefRun } from './morning-brief-config.js'
+import { MORNING_BRIEF_LIMITS } from './morning-brief-config.js'
+
+export interface LocalClock {
+  /** YYYY-MM-DD in the zone. */
+  day: string
+  /** Minutes since local midnight, 0..1439. */
+  minutes: number
+  /** 0 = Sunday … 6 = Saturday, in the zone. */
+  weekday: number
+  /** HH:MM in the zone. */
+  time: string
+}
+
+const WEEKDAY_INDEX: Record<string, number> = { Sun: 0, Mon: 1, Tue: 2, Wed: 3, Thu: 4, Fri: 5, Sat: 6 }
+const formatterCache = new Map<string, Intl.DateTimeFormat>()
+
+function formatter(timezone: string): Intl.DateTimeFormat {
+  let cached = formatterCache.get(timezone)
+  if (!cached) {
+    cached = new Intl.DateTimeFormat('en-US', {
+      timeZone: timezone,
+      hourCycle: 'h23',
+      weekday: 'short',
+      year: 'numeric',
+      month: '2-digit',
+      day: '2-digit',
+      hour: '2-digit',
+      minute: '2-digit',
+    })
+    formatterCache.set(timezone, cached)
+  }
+  return cached
+}
+
+/** Read the wall clock at `nowMs` in `timezone`. */
+export function localClock(nowMs: number, timezone: string): LocalClock {
+  const parts = formatter(timezone).formatToParts(new Date(nowMs))
+  const get = (type: Intl.DateTimeFormatPartTypes) => parts.find(part => part.type === type)?.value ?? ''
+  // `hourCycle: 'h23'` is honoured by modern ICU, but "24" has been observed
+  // from older builds at midnight. Normalise defensively.
+  const hour = Number(get('hour')) % 24
+  const minute = Number(get('minute'))
+  return {
+    day: `${get('year')}-${get('month')}-${get('day')}`,
+    minutes: hour * 60 + minute,
+    weekday: WEEKDAY_INDEX[get('weekday')] ?? new Date(nowMs).getUTCDay(),
+    time: `${String(hour).padStart(2, '0')}:${String(minute).padStart(2, '0')}`,
+  }
+}
+
+export function parseTime(time: string): number {
+  const [h, m] = time.split(':').map(Number)
+  return h * 60 + m
+}
+
+/** Shift a YYYY-MM-DD key by whole days (calendar arithmetic, zone-agnostic). */
+export function shiftDay(day: string, delta: number): string {
+  const [y, m, d] = day.split('-').map(Number)
+  const date = new Date(Date.UTC(y, m - 1, d + delta))
+  return `${date.getUTCFullYear()}-${String(date.getUTCMonth() + 1).padStart(2, '0')}-${String(date.getUTCDate()).padStart(2, '0')}`
+}
+
+/**
+ * The instant at which `day` reaches `minutes` past midnight in `timezone`.
+ * Two-pass offset correction: read the zone's wall clock at a UTC guess, apply
+ * the difference, and re-check once so a DST transition between the guess and
+ * the target lands on the right side. On a non-existent local time (spring
+ * forward) this returns the first instant after the gap.
+ */
+export function zonedInstant(day: string, minutes: number, timezone: string): number {
+  const [y, m, d] = day.split('-').map(Number)
+  let guess = Date.UTC(y, m - 1, d, Math.floor(minutes / 60), minutes % 60)
+  for (let pass = 0; pass < 2; pass++) {
+    const clock = localClock(guess, timezone)
+    const dayDelta = daysBetween(clock.day, day)
+    const diffMinutes = dayDelta * 1440 + (minutes - clock.minutes)
+    if (diffMinutes === 0) break
+    guess += diffMinutes * 60_000
+  }
+  return guess
+}
+
+function daysBetween(fromDay: string, toDay: string): number {
+  const [fy, fm, fd] = fromDay.split('-').map(Number)
+  const [ty, tm, td] = toDay.split('-').map(Number)
+  return Math.round((Date.UTC(ty, tm - 1, td) - Date.UTC(fy, fm - 1, fd)) / 86_400_000)
+}
+
+/** ISO instant of the next scheduled fire at or after `nowMs`, or null when
+ * the brief is disabled or no weekday is selected. */
+export function nextScheduledFire(config: MorningBriefConfig, nowMs: number): string | null {
+  if (!config.enabled || config.days.length === 0) return null
+  const target = parseTime(config.time)
+  const clock = localClock(nowMs, config.timezone)
+  for (let offset = 0; offset <= 7; offset++) {
+    const day = shiftDay(clock.day, offset)
+    const instant = zonedInstant(day, target, config.timezone)
+    const weekday = localClock(instant, config.timezone).weekday
+    if (!config.days.includes(weekday)) continue
+    if (instant >= nowMs) return new Date(instant).toISOString()
+  }
+  return null
+}
+
+export type FireDecision =
+  | { fire: true; day: string; attempt: number; resume?: MorningBriefRun }
+  | { fire: false; reason: 'disabled' | 'not_a_brief_day' | 'before_slot' | 'window_closed' | 'already_fired' | 'in_flight' | 'attempts_exhausted' | 'backoff' }
+
+/**
+ * Should the scheduled brief fire on this tick? The ledger is the memory: one
+ * completed submission per local day, bounded retries for a submission that
+ * failed (coordinator shutting down, store degraded), and a row that has no
+ * job id and no error is a crash between ledger write and admission — resumed
+ * by client identity rather than re-run.
+ */
+export function decideScheduledFire(
+  config: MorningBriefConfig,
+  runs: readonly MorningBriefRun[],
+  nowMs: number,
+): FireDecision {
+  if (!config.enabled) return { fire: false, reason: 'disabled' }
+  const clock = localClock(nowMs, config.timezone)
+  if (!config.days.includes(clock.weekday)) return { fire: false, reason: 'not_a_brief_day' }
+  const target = parseTime(config.time)
+  if (clock.minutes < target) return { fire: false, reason: 'before_slot' }
+  if (clock.minutes - target > config.catchUpMinutes) return { fire: false, reason: 'window_closed' }
+
+  const today = runs.filter(run => run.day === clock.day && run.trigger === 'scheduled')
+  const accepted = today.find(run => run.jobId)
+  if (accepted) return { fire: false, reason: 'already_fired' }
+  const last = today.at(-1)
+  if (!last) return { fire: true, day: clock.day, attempt: 1 }
+  const lastAt = Date.parse(last.firedAt)
+  if (!last.submitError) {
+    // Ledger row exists, no job id, no error: submission never reported back.
+    // Give it a moment (the write happens just before submit), then resume by
+    // identity so a lost admission is adopted instead of duplicated.
+    if (Number.isFinite(lastAt) && nowMs - lastAt < MORNING_BRIEF_LIMITS.attemptSpacingMs) {
+      return { fire: false, reason: 'in_flight' }
+    }
+    return { fire: true, day: clock.day, attempt: last.attempt, resume: last }
+  }
+  if (last.attempt >= MORNING_BRIEF_LIMITS.scheduledAttemptsPerDay) return { fire: false, reason: 'attempts_exhausted' }
+  if (Number.isFinite(lastAt) && nowMs - lastAt < MORNING_BRIEF_LIMITS.attemptSpacingMs) {
+    return { fire: false, reason: 'backoff' }
+  }
+  return { fire: true, day: clock.day, attempt: last.attempt + 1 }
+}