@gotcos/glasses-server 6.42.1 → 6.43.1

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

@@ -0,0 +1,376 @@
+// Morning brief — what each source can actually reach, and what a run produced.
+//
+// The Sources list names an INSTRUCTION ("Meetings", "Knowledge graph"); the
+// server can also say how deep the well is behind it: 2,312 meetings stored,
+// 6,705 memories and 66 threads, the /good-morning skill found under
+// .claude/skills. Miles (2026-09-01): "I'm assuming we should see all of these
+// stats when we turn it on." Those are the same numbers COS Control's Activity
+// tiles show, read from the same places, so the card agrees with the tiles.
+//
+// Two halves, both pure over injected probes so tests never touch a venv:
+//  - coverage: per-source state + one summary line, probes cached for a few
+//    minutes (they walk the meeting library and shell to the Python bridge);
+//  - section outcomes: after a run, which sections the answer actually opened,
+//    which came back "<Section>: unavailable", and which were silently skipped.
+//
+// A source the server cannot see at all (Slack, health, dashboards) is
+// `runtime`: the COS brain resolves it when the brief runs. That is a fact,
+// not a failure, and the summary says so instead of showing a dash.
+
+import type { MorningBriefConfig, MorningBriefSource, MorningBriefSourceId } from './morning-brief-config.js'
+import { MORNING_BRIEF_SOURCES } from './morning-brief-config.js'
+import { sectionInstruction } from './morning-brief-prompt.js'
+
+export type MorningBriefCoverageState = 'ready' | 'empty' | 'unavailable' | 'runtime'
+
+export interface MorningBriefSourceCoverage {
+  id: MorningBriefSourceId
+  state: MorningBriefCoverageState
+  /** One line for a settings row. Never a path, never a prompt. */
+  summary: string
+  counts?: Record<string, number>
+}
+
+export interface MorningBriefCoverage {
+  checkedAt: string
+  ttlMs: number
+  sources: MorningBriefSourceCoverage[]
+}
+
+export interface MeetingsProbe { count: number; newestMonth: string | null; layout: string }
+export interface ContextProbe {
+  memory: { available: boolean; total: number; state?: string }
+  threads: { available: boolean; total: number; active?: number; state?: string }
+}
+export interface CalendarProbe { todayCount: number; source?: string }
+export interface TasksProbe { open: number; files: number }
+export interface ReflectionProbe { entries: number; newestAt: string | null }
+export interface SkillProbe { found: boolean; where?: string }
+
+/** Every probe is optional: a standalone install has none of the pipeline
+ * ones, and `null` means "the server cannot see this" (runtime), not zero. */
+export interface MorningBriefCoverageProbes {
+  meetings?: () => MeetingsProbe | null
+  context?: () => Promise<ContextProbe | null>
+  calendar?: () => Promise<CalendarProbe | null>
+  tasks?: () => Promise<TasksProbe | null>
+  reflection?: () => ReflectionProbe | null
+  skill?: (name: string) => SkillProbe
+}
+
+export const MORNING_BRIEF_COVERAGE_TTL_MS = 5 * 60_000
+export const MORNING_BRIEF_COVERAGE_PROBE_TIMEOUT_MS = 8_000
+
+interface ProbeResults {
+  meetings: MeetingsProbe | null | undefined
+  context: ContextProbe | null | undefined
+  calendar: CalendarProbe | null | undefined
+  tasks: TasksProbe | null | undefined
+  reflection: ReflectionProbe | null | undefined
+}
+
+function n(value: number): string {
+  return Math.max(0, Math.trunc(value)).toLocaleString('en-US')
+}
+
+function plural(count: number, unit: string): string {
+  return `${n(count)} ${unit}${count === 1 ? '' : 's'}`
+}
+
+function str(options: MorningBriefSource['options'], key: string): string {
+  const value = options[key]
+  return typeof value === 'string' ? value.trim() : ''
+}
+
+function monthLabel(month: string | null): string {
+  if (!month || !/^\d{4}-\d{2}$/.test(month)) return ''
+  const [y, m] = month.split('-').map(Number)
+  const names = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
+  return names[m - 1] ? `${names[m - 1]} ${y}` : ''
+}
+
+function dayLabel(iso: string | null): string {
+  if (!iso) return ''
+  const ms = Date.parse(iso)
+  if (!Number.isFinite(ms)) return ''
+  const d = new Date(ms)
+  const names = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
+  return `${names[d.getUTCMonth()]} ${d.getUTCDate()}`
+}
+
+function unavailableReason(state?: string): string {
+  switch (state) {
+    case 'qdrant_unavailable': return 'memory store unreachable'
+    case 'bridge_error': return 'pipeline bridge failed'
+    case 'bridge_missing': return 'pipeline bridge missing'
+    case 'thread_store_unavailable': return 'thread store unreachable'
+    default: return state ? state.replace(/_/g, ' ') : 'unreachable'
+  }
+}
+
+const RUNTIME_SUMMARY: Record<'waiting' | 'health' | 'pulse', string> = {
+  waiting: 'Slack, email, and chat connectors are read by your COS when the brief runs.',
+  health: 'Any connected health source (Oura or similar) is read when the brief runs.',
+  pulse: 'Dashboards and metrics connectors are read when the brief runs.',
+}
+
+/** The coverage row for one source, from probe results already gathered. */
+export function describeSourceCoverage(
+  source: MorningBriefSource,
+  probes: ProbeResults,
+  skillProbe?: (name: string) => SkillProbe,
+): MorningBriefSourceCoverage {
+  const o = source.options
+  switch (source.id) {
+    case 'calendar': {
+      const probe = probes.calendar
+      if (probe === undefined || probe === null) {
+        return { id: source.id, state: 'runtime', summary: 'Calendars are read through your COS connectors when the brief runs.' }
+      }
+      const counts = { today: probe.todayCount }
+      if (probe.todayCount > 0) {
+        return { id: source.id, state: 'ready', summary: `${plural(probe.todayCount, 'event')} on today's calendar${probe.source ? ` (${probe.source.replace(/_/g, ' ')})` : ''}.`, counts }
+      }
+      return { id: source.id, state: 'empty', summary: 'Calendar reachable; nothing on it today.', counts }
+    }
+    case 'meetings': {
+      const probe = probes.meetings
+      if (probe === undefined || probe === null) {
+        return { id: source.id, state: 'empty', summary: 'No meeting library configured yet.' }
+      }
+      const counts = { stored: probe.count }
+      if (probe.count > 0) {
+        const newest = monthLabel(probe.newestMonth)
+        return { id: source.id, state: 'ready', summary: `${plural(probe.count, 'meeting')} stored${newest ? `, newest ${newest}` : ''}.`, counts }
+      }
+      return { id: source.id, state: 'empty', summary: 'Meeting library is empty so far.', counts }
+    }
+    case 'tasks': {
+      const probe = probes.tasks
+      if (probe === undefined || probe === null) {
+        return { id: source.id, state: 'runtime', summary: 'Task files in your workspace are read when the brief runs.' }
+      }
+      const counts = { open: probe.open, files: probe.files }
+      if (probe.open > 0) {
+        return { id: source.id, state: 'ready', summary: `${plural(probe.open, 'open task')} across ${plural(probe.files, 'task file')}.`, counts }
+      }
+      return { id: source.id, state: 'empty', summary: 'Task files reachable; nothing open.', counts }
+    }
+    case 'waiting':
+      return { id: source.id, state: 'runtime', summary: RUNTIME_SUMMARY.waiting }
+    case 'knowledge': {
+      const probe = probes.context
+      if (probe === undefined || probe === null) {
+        return { id: source.id, state: 'empty', summary: 'No memory or thread store yet; this section skips itself.' }
+      }
+      const memoryOk = probe.memory.available
+      const threadsOk = probe.threads.available
+      const counts = { memories: probe.memory.total, threads: probe.threads.total, activeThreads: probe.threads.active ?? 0 }
+      if (!memoryOk && !threadsOk) {
+        return { id: source.id, state: 'unavailable', summary: `Memory and threads unreachable (${unavailableReason(probe.memory.state)}).`, counts }
+      }
+      const parts: string[] = []
+      if (memoryOk) parts.push(plural(probe.memory.total, 'memory').replace('memorys', 'memories'))
+      else parts.push(`memories ${unavailableReason(probe.memory.state)}`)
+      if (threadsOk) {
+        const active = probe.threads.active ?? 0
+        parts.push(`${plural(probe.threads.total, 'thread')}${active > 0 ? ` (${n(active)} active)` : ''}`)
+      } else {
+        parts.push(`threads ${unavailableReason(probe.threads.state)}`)
+      }
+      const total = (memoryOk ? probe.memory.total : 0) + (threadsOk ? probe.threads.total : 0)
+      return {
+        id: source.id,
+        state: total > 0 ? (memoryOk && threadsOk ? 'ready' : 'unavailable') : 'empty',
+        summary: `${parts.join(' · ')}.`,
+        counts,
+      }
+    }
+    case 'reflection': {
+      const probe = probes.reflection
+      if (probe === undefined || probe === null) {
+        return { id: source.id, state: 'runtime', summary: 'Journals and reflection logs in your workspace are read when the brief runs.' }
+      }
+      const counts = { entries: probe.entries }
+      if (probe.entries > 0) {
+        const newest = dayLabel(probe.newestAt)
+        return { id: source.id, state: 'ready', summary: `${plural(probe.entries, 'reflection')} on record${newest ? `, newest ${newest}` : ''}.`, counts }
+      }
+      return { id: source.id, state: 'empty', summary: 'Reflection log present but empty.', counts }
+    }
+    case 'health':
+      return { id: source.id, state: 'runtime', summary: RUNTIME_SUMMARY.health }
+    case 'reading': {
+      const text = str(o, 'text') || 'proverbs'
+      return text.toLowerCase() === 'proverbs'
+        ? { id: source.id, state: 'ready', summary: 'Public-domain KJV Proverbs, one chapter per calendar day. Nothing to connect.' }
+        : { id: source.id, state: 'ready', summary: `Public-domain reading from "${text}", matched to the date.` }
+    }
+    case 'pulse':
+      return { id: source.id, state: 'runtime', summary: str(o, 'instruction') ? `${RUNTIME_SUMMARY.pulse} Instruction set.` : RUNTIME_SUMMARY.pulse }
+    case 'skill': {
+      const name = str(o, 'name')
+      if (!name) return { id: source.id, state: 'empty', summary: 'Name a skill to run as this section.' }
+      const slash = name.startsWith('/') ? name : `/${name}`
+      if (!skillProbe) return { id: source.id, state: 'runtime', summary: `${slash} is looked up in the workspace when the brief runs.` }
+      const probe = skillProbe(name)
+      return probe.found
+        ? { id: source.id, state: 'ready', summary: `${slash} found under ${probe.where ?? 'the workspace'}.` }
+        : { id: source.id, state: 'unavailable', summary: `${slash} not found under .claude/skills, .agents/skills, .claude/commands, or ~/.codex/prompts.` }
+    }
+    case 'custom': {
+      const instruction = str(o, 'instruction')
+      return instruction
+        ? { id: source.id, state: 'ready', summary: 'Runs as written.' }
+        : { id: source.id, state: 'empty', summary: 'Write an instruction to add this section.' }
+    }
+  }
+}
+
+function withTimeout<T>(work: Promise<T>, ms: number): Promise<T | null> {
+  return new Promise<T | null>(resolve => {
+    const timer = setTimeout(() => resolve(null), ms)
+    timer.unref?.()
+    work.then(value => { clearTimeout(timer); resolve(value) }, () => { clearTimeout(timer); resolve(null) })
+  })
+}
+
+export interface MorningBriefCoverageServiceOptions {
+  now?: () => number
+  ttlMs?: number
+  probeTimeoutMs?: number
+  log?: (line: string) => void
+}
+
+/**
+ * Cached probe results + per-call source rows. The probes are the expensive
+ * part (a library walk, a Python shell-out); the rows are recomputed on every
+ * call from the CURRENT config so a renamed skill or a cleared instruction is
+ * reflected immediately without re-probing.
+ */
+export class MorningBriefCoverageService {
+  private cache: { at: number; results: ProbeResults } | null = null
+  private inFlight: Promise<ProbeResults> | null = null
+  private readonly now: () => number
+  private readonly ttlMs: number
+  private readonly probeTimeoutMs: number
+
+  constructor(private readonly probes: MorningBriefCoverageProbes, options: MorningBriefCoverageServiceOptions = {}) {
+    this.now = options.now ?? Date.now
+    this.ttlMs = options.ttlMs ?? MORNING_BRIEF_COVERAGE_TTL_MS
+    this.probeTimeoutMs = options.probeTimeoutMs ?? MORNING_BRIEF_COVERAGE_PROBE_TIMEOUT_MS
+  }
+
+  invalidate(): void {
+    this.cache = null
+  }
+
+  async describe(config: MorningBriefConfig, force = false): Promise<MorningBriefCoverage> {
+    const results = await this.results(force)
+    const sources = config.sources.map(source => describeSourceCoverage(source, results, this.probes.skill))
+    return { checkedAt: new Date(this.cache?.at ?? this.now()).toISOString(), ttlMs: this.ttlMs, sources }
+  }
+
+  private results(force: boolean): Promise<ProbeResults> {
+    if (!force && this.cache && this.now() - this.cache.at < this.ttlMs) return Promise.resolve(this.cache.results)
+    if (this.inFlight) return this.inFlight
+    this.inFlight = this.probeAll().then(results => {
+      this.cache = { at: this.now(), results }
+      return results
+    }).finally(() => { this.inFlight = null })
+    return this.inFlight
+  }
+
+  private async probeAll(): Promise<ProbeResults> {
+    const sync = <T>(fn: (() => T | null) | undefined): T | null | undefined => {
+      if (!fn) return undefined
+      try { return fn() } catch { return null }
+    }
+    const async = <T>(fn: (() => Promise<T | null>) | undefined): Promise<T | null | undefined> => {
+      if (!fn) return Promise.resolve(undefined)
+      let started: Promise<T | null>
+      try { started = fn() } catch { return Promise.resolve(null) }
+      return withTimeout(started, this.probeTimeoutMs)
+    }
+    const [context, calendar, tasks] = await Promise.all([
+      async(this.probes.context),
+      async(this.probes.calendar),
+      async(this.probes.tasks),
+    ])
+    return {
+      meetings: sync(this.probes.meetings),
+      context,
+      calendar,
+      tasks,
+      reflection: sync(this.probes.reflection),
+    }
+  }
+}
+
+// ── Section outcomes ──────────────────────────────────────────────────────────
+
+export interface MorningBriefSectionRef {
+  id: MorningBriefSourceId
+  label: string
+}
+
+export type MorningBriefSectionState = 'present' | 'unavailable' | 'skipped' | 'missing' | 'pending'
+
+export interface MorningBriefSectionOutcome extends MorningBriefSectionRef {
+  state: MorningBriefSectionState
+}
+
+const KNOWN_IDS = new Set<MorningBriefSourceId>(MORNING_BRIEF_SOURCES.map(spec => spec.id))
+
+/** Sources that opt out silently when there is nothing behind them. */
+const SILENT_SKIP = new Set<MorningBriefSourceId>(['knowledge', 'reflection', 'health'])
+
+/** The sections a brief for `day` will carry, in order, from the config the
+ * run was fired with. Stored on the ledger row so a later config change does
+ * not rewrite what an old run was asked for. */
+export function briefSections(config: MorningBriefConfig, day: string): MorningBriefSectionRef[] {
+  const out: MorningBriefSectionRef[] = []
+  for (const source of config.sources) {
+    if (!source.enabled || !KNOWN_IDS.has(source.id)) continue
+    const section = sectionInstruction(source, day)
+    if (section) out.push({ id: source.id, label: section.label })
+  }
+  return out
+}
+
+function normalize(line: string): string {
+  return line.replace(/[*_#`>]/g, '').replace(/\s+/g, ' ').trim().toLowerCase()
+}
+
+/**
+ * Read a finished brief back against the sections it was asked for. Purely
+ * textual: a label on its own line (or opening one) is "present"; the
+ * "<Section>: unavailable" contract from the prompt is "unavailable"; a
+ * silent-skip section with no label is "skipped"; anything else is "missing".
+ * A skill section has no label in the skill-only prompt, so it is "present"
+ * unless the answer says the skill was not found.
+ */
+export function sectionOutcomes(sections: readonly MorningBriefSectionRef[], answer: string): MorningBriefSectionOutcome[] {
+  const lines = answer.split(/\r?\n/).map(normalize).filter(Boolean)
+  const text = lines.join('\n')
+  return sections.map(section => {
+    const label = normalize(section.label)
+    if (section.id === 'skill') {
+      if (lines.length === 0) return { ...section, state: 'missing' as const }
+      const slash = label.replace(/^skill\s+/, '')
+      const notFound = new RegExp(`${escapeRegExp(slash)}[^\\n]{0,80}(does not exist|not found|no such skill|could not (?:find|locate)|is not defined)`, 'i')
+      const notFoundBefore = new RegExp(`(does not exist|not found|no such skill|could not (?:find|locate))[^\\n]{0,80}${escapeRegExp(slash)}`, 'i')
+      return { ...section, state: notFound.test(text) || notFoundBefore.test(text) ? 'unavailable' as const : 'present' as const }
+    }
+    // The prompt's unavailable line uses a sentence-case name, not the shouted label.
+    const unavailable = new RegExp(`^${escapeRegExp(label)}\\s*[:\\-–—]\\s*unavailable`, 'i')
+    if (lines.some(line => unavailable.test(line))) return { ...section, state: 'unavailable' as const }
+    const opened = lines.some(line => line === label || line.startsWith(`${label}:`) || line.startsWith(`${label} -`) || line.startsWith(`${label} —`))
+    if (opened) return { ...section, state: 'present' as const }
+    return { ...section, state: SILENT_SKIP.has(section.id) ? 'skipped' as const : 'missing' as const }
+  })
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}

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

@@ -0,0 +1,263 @@
+// Morning brief — the prompt composer.
+//
+// Pure: config + clock in, one prompt string out. The prompt is what the user's
+// own COS agent receives as a durable query job at the scheduled minute, so it
+// carries everything the agent needs and nothing the server cannot vouch for:
+//
+//  - the read-only contract (nobody is watching; never send, create, or edit);
+//  - the sections, in the user's order, each with its window and its own
+//    "unavailable" rule so a missing connector produces one honest line, not a
+//    fabricated one;
+//  - the glasses formatting contract (plain text, short labelled lines) so the
+//    result renders on a 576x288 lens without a second pass.
+//
+// Deterministic for a given (config, day): the scheduled slot, not the actual
+// firing minute, is what appears in the prompt. That is what lets a retry after
+// a crashed submission re-admit as the SAME job by client identity instead of
+// conflicting on a different prompt body.
+
+import type { MorningBriefConfig, MorningBriefSource, MorningBriefSourceId } from './morning-brief-config.js'
+import { MORNING_BRIEF_SOURCES } from './morning-brief-config.js'
+import { parseTime, shiftDay } from './morning-brief-schedule.js'
+
+/** Well under the 48,000-char durable-job ceiling, with room for the largest
+ * legal combination of free-text options. */
+export const MORNING_BRIEF_PROMPT_MAX_CHARS = 16_000
+
+export interface MorningBriefPromptInput {
+  config: MorningBriefConfig
+  /** Local calendar day the brief is for (YYYY-MM-DD in config.timezone). */
+  day: string
+  ownerName: string
+  trigger: 'scheduled' | 'manual'
+}
+
+const WEEKDAY_NAMES = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
+const MONTH_NAMES = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']
+
+function describeDay(day: string): string {
+  const [y, m, d] = day.split('-').map(Number)
+  const weekday = WEEKDAY_NAMES[new Date(Date.UTC(y, m - 1, d)).getUTCDay()]
+  return `${weekday}, ${MONTH_NAMES[m - 1]} ${d}, ${y}`
+}
+
+function lastBusinessDay(day: string): string {
+  let candidate = shiftDay(day, -1)
+  for (let i = 0; i < 7; i++) {
+    const [y, m, d] = candidate.split('-').map(Number)
+    const weekday = new Date(Date.UTC(y, m - 1, d)).getUTCDay()
+    if (weekday !== 0 && weekday !== 6) return candidate
+    candidate = shiftDay(candidate, -1)
+  }
+  return candidate
+}
+
+function plural(n: number, unit: string): string {
+  return `${n} ${unit}${n === 1 ? '' : 's'}`
+}
+
+function str(options: MorningBriefSource['options'], key: string): string {
+  const value = options[key]
+  return typeof value === 'string' ? value.trim() : ''
+}
+
+function num(options: MorningBriefSource['options'], key: string, fallback: number): number {
+  const value = options[key]
+  return typeof value === 'number' && Number.isFinite(value) ? value : fallback
+}
+
+function bool(options: MorningBriefSource['options'], key: string, fallback: boolean): boolean {
+  const value = options[key]
+  return typeof value === 'boolean' ? value : fallback
+}
+
+/** One section's instruction. Returns null when the source has nothing to say
+ * (a custom section with no instruction, a skill with no name). */
+export function sectionInstruction(source: MorningBriefSource, day: string): { label: string; body: string } | null {
+  const o = source.options
+  switch (source.id) {
+    case 'calendar':
+      return {
+        label: 'CALENDAR',
+        body: [
+          `Today's commitments in time order, each on one line: start time, title, who it is with when that matters.`,
+          `Name the first commitment of the day and how much open time exists before it.`,
+          bool(o, 'includeTomorrow', false) ? `Then tomorrow's first commitment on one line.` : '',
+          `Read every calendar this workspace can reach (connectors, local calendar helpers, cached calendar files). If none can be read, write "Calendar: unavailable" with the reason.`,
+        ].filter(Boolean).join(' '),
+      }
+    case 'meetings': {
+      const lookback = num(o, 'lookbackDays', 3)
+      const horizon = num(o, 'horizonDays', 7)
+      return {
+        label: 'FROM RECENT MEETINGS',
+        body: [
+          `Meetings synced in the last ${plural(lookback, 'day')} (the last business day before ${day} was ${lastBusinessDay(day)}).`,
+          `Surface only items with a hard edge: a decision that was made, a deadline inside the next ${plural(horizon, 'day')}, a dollar figure, or a named owner.`,
+          `Read the meeting's summary and decisions; never paste an extracted action-item list verbatim, and when a number or date matters, quote it from the transcript.`,
+          `Three to five items ranked by consequence, one line each: the decision or open question, then the hard edge.`,
+          `If nothing decision-grade happened, say so in one line.`,
+        ].join(' '),
+      }
+    }
+    case 'tasks': {
+      const horizon = num(o, 'horizonDays', 7)
+      const overdue = bool(o, 'includeOverdue', true)
+      return {
+        label: 'DUE',
+        body: [
+          `Open tasks from this workspace's task files due within ${plural(horizon, 'day')}${overdue ? ', overdue items first' : ''}.`,
+          `One line each: the task, its owner if not the wearer, and the date. Cap at seven. Skip anything already marked done.`,
+        ].join(' '),
+      }
+    }
+    case 'waiting': {
+      const lookback = num(o, 'lookbackDays', 7)
+      return {
+        label: 'WAITING ON YOU',
+        body: [
+          `Across every channel this workspace can read (Slack, email, chat connectors), from the last ${plural(lookback, 'day')}:`,
+          `direct mentions with no reply from the wearer, questions addressed to the wearer with no answer beneath them, and threads that moved after the wearer's last message.`,
+          `Up to five, ranked by consequence. Each line names the channel or sender, who is waiting, and the ask.`,
+          `Never claim something is unread; report only what is verifiable. If no channel can be read, write "Waiting on you: unavailable" with the reason.`,
+        ].join(' '),
+      }
+    }
+    case 'knowledge': {
+      const lookback = num(o, 'lookbackDays', 7)
+      return {
+        label: 'MOVING',
+        body: [
+          `From memory, threads, and the knowledge graph this workspace keeps: the two or three relationships, projects, or people that moved in the last ${plural(lookback, 'day')} and why it matters today.`,
+          `One line each. Cite the thread or entity by name. Skip this section silently if the workspace has no memory or graph.`,
+        ].join(' '),
+      }
+    }
+    case 'reflection':
+      return {
+        label: 'CARRY THIS',
+        body: [
+          `From recent reflection logs, journal entries, or correction records in this workspace: the one theme that recurs across at least two periods.`,
+          `State the pattern in one line and the single behaviour to carry into today in a second line. Do not grade. Skip silently if there is no reflection history.`,
+        ].join(' '),
+      }
+    case 'health':
+      return {
+        label: 'BODY',
+        body: `Last night's sleep and readiness from any connected health source, one line, with the one adjustment it implies. Skip silently if no health source is connected.`,
+      }
+    case 'reading': {
+      const text = str(o, 'text') || 'proverbs'
+      const [, , d] = day.split('-').map(Number)
+      if (text.toLowerCase() === 'proverbs') {
+        return {
+          label: 'OPENING',
+          body: [
+            `Proverbs chapter ${d} (the calendar day) in the public-domain King James Version, presented as numbered verses.`,
+            `Then one verse from it that genuinely speaks to today's shape, named, with a two-sentence connection. Never substitute a copyrighted translation; if the exact KJV text cannot be verified, say so and skip the chapter.`,
+          ].join(' '),
+        }
+      }
+      return {
+        label: 'OPENING',
+        body: `A short public-domain reading from "${text}" matched to today's date, then one line on why it fits. Never reproduce copyrighted text.`,
+      }
+    }
+    case 'pulse': {
+      const instruction = str(o, 'instruction')
+      return {
+        label: 'PULSE',
+        body: [
+          instruction
+            ? `The numbers the wearer steers by: ${instruction}`
+            : `The numbers the wearer steers by, from any dashboard, report, or metrics connector this workspace has.`,
+          `Use the most recent complete period (yesterday, or the last business day). Render quantitative comparisons as bar fills with a direction glyph and the delta, for example "Grocery 162 ██████████ ▼ -7%".`,
+          `Name the strongest positive and the clearest pain. If the source cannot be read, write "Pulse: unavailable" with the reason; never imply data you did not pull.`,
+        ].join(' '),
+      }
+    }
+    case 'skill': {
+      const name = str(o, 'name')
+      if (!name) return null
+      const slash = name.startsWith('/') ? name : `/${name}`
+      return {
+        label: `SKILL ${slash}`,
+        body: [
+          `Run this workspace's ${slash} skill exactly as it is defined (look under .claude/skills, .agents/skills, .claude/commands, and ~/.codex/prompts) and use its output for this section.`,
+          `Do not summarise it away; it was written for this purpose. If the skill does not exist, write one line saying so and continue with the other sections.`,
+        ].join(' '),
+      }
+    }
+    case 'custom': {
+      const instruction = str(o, 'instruction')
+      if (!instruction) return null
+      return { label: 'ALSO', body: instruction }
+    }
+  }
+}
+
+const KNOWN_IDS = new Set<MorningBriefSourceId>(MORNING_BRIEF_SOURCES.map(spec => spec.id))
+
+/** Compose the brief prompt. Enabled sources become numbered sections in the
+ * user's order; a section whose source has nothing to say is skipped. */
+export function composeMorningBriefPrompt(input: MorningBriefPromptInput): string {
+  const { config, day, ownerName, trigger } = input
+  const slotMinutes = parseTime(config.time)
+  const slot = `${String(Math.floor(slotMinutes / 60)).padStart(2, '0')}:${String(slotMinutes % 60).padStart(2, '0')}`
+  const sections = config.sources
+    .filter(source => source.enabled && KNOWN_IDS.has(source.id))
+    .map(source => sectionInstruction(source, day))
+    .filter((section): section is { label: string; body: string } => section !== null)
+
+  const skillOnly = sections.length === 1 && sections[0].label.startsWith('SKILL ')
+
+  const lines: string[] = []
+  lines.push(`Morning brief for ${ownerName || 'the wearer'}. ${describeDay(day)}, ${slot} ${config.timezone}.${trigger === 'manual' ? ' Requested now rather than on the schedule.' : ''}`)
+  lines.push('')
+  lines.push(
+    'This is the start-of-day brief that waits in the COS Glasses inbox before the wearer opens it. Nobody is watching this run: do not ask questions, do not pause for confirmation, and do not stop early. ' +
+    'It is read-only. Do not send messages or email, create or change calendar events, edit tasks, or write files other than any journal or log a skill you run is already designed to keep.',
+  )
+  lines.push('')
+  lines.push(
+    'Evidence discipline: every line must come from something you actually read in this workspace or through its connectors. ' +
+    'When a source cannot be read, give that section one line, "<Section>: unavailable (reason)", and move on. Never invent a meeting, a message, a number, or a name. ' +
+    'An aside is not a finding; include only items with a hard edge (a decision, a date, a dollar figure, an owner).',
+  )
+  lines.push('')
+
+  if (sections.length === 0) {
+    lines.push('No sections are enabled. Reply with exactly one line: "Morning brief: no sources selected. Choose sources in COS Control or the companion app."')
+  } else if (skillOnly) {
+    lines.push('Content:')
+    lines.push(`1. ${sections[0].label}. ${sections[0].body}`)
+  } else {
+    lines.push('Sections, in this order, each opened by its label on its own line:')
+    sections.forEach((section, index) => {
+      lines.push(`${index + 1}. ${section.label}. ${section.body}`)
+    })
+  }
+  lines.push('')
+
+  if (config.closingInstruction) {
+    lines.push(`Also: ${config.closingInstruction}`)
+    lines.push('')
+  }
+
+  lines.push(
+    'Format for the glasses: plain text only. No markdown headings, tables, or bullet symbols; a section is its label on one line followed by short lines. ' +
+    'Keep every line under 60 characters where you can, because the lens is 576 pixels wide and wraps silently. Keep the whole brief under about 60 lines; ' +
+    (skillOnly
+      ? 'if the skill\'s own output format is longer, keep it intact rather than trimming it.'
+      : 'trim from the bottom of each section, not from the top.'),
+  )
+  lines.push(
+    'End with one line beginning "Order your energy:" naming the single posture for the day, grounded in the sections above.',
+  )
+  lines.push('Do not say "here is" or "I found". Do not add a preamble or a sign-off.')
+
+  const prompt = lines.join('\n')
+  return prompt.length > MORNING_BRIEF_PROMPT_MAX_CHARS
+    ? `${prompt.slice(0, MORNING_BRIEF_PROMPT_MAX_CHARS - 1)}…`
+    : prompt
+}