@gotcos/glasses-server 6.43.0 → 6.43.2

package/CHANGELOG.md

@@ -1,3 +1,52 @@
+## 6.43.2
+
+Managed-server updates pass their Claude readiness proof again.
+
+- **The proof no longer loads your MCP catalog.** COS Control verifies a
+  candidate server by running one real `claude -p --model haiku` query with
+  no tools. On Claude Code 2.1.251, `--tools ''` still loads every MCP
+  server's tool definitions, and on a Mac with a large fleet that alone was
+  about 244,000 tokens against Haiku's 200,000-token window: "Prompt is too
+  long", exit 1, zero API time, and the update rolled back to the previous
+  server every time (six attempts on 6.43.1). The proof now passes
+  `--strict-mcp-config` with an empty MCP config, which keeps it under
+  20,000 tokens and answers in about two seconds. Nothing else changed.
+
+## 6.43.1
+
+Two things the first night of the morning brief taught us, plus the depth
+behind each source.
+
+- **A running brief can no longer collide with your next message.** A brief
+  holds its number for the minutes it runs, but `/api/message-counter` only
+  counted exchanges that had already been projected, so a phone whose counter
+  last synced at boot could mint the same number for its next prompt. Numbers
+  held by admitted, not-yet-terminal durable jobs (and by the brief's own
+  ledger row, which exists before the job does) now count toward the ceiling.
+  New `lib/message-reservations.ts` registry; the job store keeps the number
+  on its always-in-memory identity so the answer is synchronous and survives
+  a restart. (The double #74 reported on 6.9.443 was the companion showing one
+  exchange twice; companion 6.9.445 fixes that side.)
+- **Sources show what is behind them.** `GET /api/morning-brief` now carries
+  `coverage`: one row per source with a state (`ready`, `empty`,
+  `unavailable`, `runtime`) and a summary line such as "2,312 meetings
+  stored, newest Sep 2026", "6,705 memories · 66 threads (12 active)", or
+  "/good-morning found under .claude/skills". Same wells COS Control's
+  Activity tiles read (meeting library, context status, the pipeline bridge
+  for calendar and tasks, the reflection log). Probes are cached for five
+  minutes and bounded to eight seconds each; a source the server cannot see
+  (Slack, health, dashboards) says so as `runtime` instead of showing a dash.
+  `GET /api/morning-brief/coverage?refresh=1` re-probes on demand.
+- **Each run records what it was asked for and what came back.** The ledger
+  row stores the sections the brief was composed with, and once the job
+  completes the run view reports each as `present`, `unavailable` (the
+  prompt's "<Section>: unavailable" line), `skipped` (silent-skip sections
+  with nothing behind them), or `missing`. A skill section is present unless
+  the answer says the skill was not found.
+
+No config migration: existing `config.json` and `runs.json` files load as
+they are; older run rows simply have no section outcome.
+
 ## 6.43.0
 
 The brief is waiting before you ask for it.

package/README.md

@@ -231,6 +231,13 @@ doubles it; a Mac asleep at the slot still fires inside a three-hour catch-up
 window; "Run now" is capped at five a day. Off entirely when Background jobs
 are off. The brief is read-only by contract.
 
+Since 6.43.1 the same `GET /api/morning-brief` response carries `coverage`,
+one row per source saying what the server can see behind it (meetings stored,
+memories and threads, whether the named skill exists) and every run reports
+which sections the answer actually opened. Numbers reserved by a running
+brief count toward `/api/message-counter`, so the phone never mints the same
+`#NNN` twice.
+
 ## Speaker diarization (opt-in)
 
 Without a voiceprint model this server does not classify speakers at all — it

package/package.json

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

package/server/lib/message-reservations.ts

@@ -0,0 +1,62 @@
+// Message-number reservations that are not exchanges yet.
+//
+// The phone mints its own #NNN from the `max` that /api/message-counter
+// reports, and a durable job carries the number it was minted with until its
+// terminal projection writes the exchange into the session. Between admission
+// and projection the number existed nowhere the counter looked, so a second
+// producer could mint it again: a running morning brief holds its number for
+// minutes while the phone's counter, which only re-syncs at boot, still sits
+// below it. (The double "#74" seen on 2026-09-01 turned out to be the phone
+// showing ONE exchange twice, a display-bus placeholder plus the hydrated
+// row, fixed in companion 6.9.445. The window this closes is real all the
+// same: the same night's ledger shows the brief holding #74 for 6m35s.)
+//
+// Every holder of a not-yet-projected number registers a source here. The
+// counter route and the brief's own reservation read the union. Sources
+// register themselves rather than being imported, because the morning-brief
+// runtime already imports the counter route (a direct import would cycle).
+
+import { exchangeBelongsToEra } from './message-era.js'
+
+export interface MessageReservation {
+  globalMsgNum: number
+  messageEra?: string
+  /** Diagnostic owner label, e.g. `job:<id>` or `brief:<day>`. Never a prompt. */
+  owner: string
+}
+
+export type MessageReservationSource = () => readonly MessageReservation[]
+
+const sources = new Set<MessageReservationSource>()
+
+export function registerMessageReservationSource(source: MessageReservationSource): () => void {
+  sources.add(source)
+  return () => { sources.delete(source) }
+}
+
+/** Every live reservation in `era`. A source that throws contributes nothing;
+ * the counter must never fail because one holder is mid-shutdown. */
+export function reservedGlobalMsgNums(era: string): MessageReservation[] {
+  const out: MessageReservation[] = []
+  for (const source of sources) {
+    let items: readonly MessageReservation[]
+    try { items = source() } catch { continue }
+    for (const item of items) {
+      if (!Number.isSafeInteger(item.globalMsgNum) || item.globalMsgNum <= 0) continue
+      if (!exchangeBelongsToEra(item, era)) continue
+      out.push(item)
+    }
+  }
+  return out
+}
+
+export function maxReservedGlobalMsgNum(era: string): number {
+  let max = 0
+  for (const item of reservedGlobalMsgNums(era)) if (item.globalMsgNum > max) max = item.globalMsgNum
+  return max
+}
+
+/** Test-only. */
+export function resetMessageReservationSourcesForTests(): void {
+  sources.clear()
+}

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

@@ -506,6 +506,8 @@ export interface MorningBriefRun {
   submitError?: { code: string; message: string }
   /** Terminal state copied from the job when last observed. */
   lastKnownStatus?: string
+  /** The sections this run was asked for, in order, from the config at fire time. */
+  sections?: Array<{ id: MorningBriefSourceId; label: string }>
 }
 
 export interface MorningBriefLedger {

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-runtime.ts

@@ -4,6 +4,9 @@
 // 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'
@@ -12,11 +15,32 @@ 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 plus the
- * day archives. The same arithmetic /api/message-counter serves the phone. */
+/** 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
@@ -26,14 +50,122 @@ export function currentMessageMax(): number {
       if (typeof exchange?.globalMsgNum === 'number' && exchange.globalMsgNum > liveMax) liveMax = exchange.globalMsgNum
     }
   }
-  return Math.max(liveMax, maxGlobalMsgNumInDir(dataPath('archive'), era))
+  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) {
-    scheduler = new MorningBriefScheduler({
+    const instance = new MorningBriefScheduler({
       paths: morningBriefPaths(),
       submit: raw => queryJobCoordinator.submit(raw),
       findByClientGeneration: (clientJobId, generation) => queryJobCoordinator.getByClientGeneration(clientJobId, generation),
@@ -44,7 +176,18 @@ export function getMorningBriefScheduler(): MorningBriefScheduler {
       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
 }
@@ -55,4 +198,6 @@ export function startMorningBriefScheduler(): void {
 
 export function stopMorningBriefScheduler(): void {
   scheduler?.stop()
+  unregisterReservations?.()
+  unregisterReservations = null
 }

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

@@ -36,6 +36,14 @@ import {
   serverTimezone,
 } from './morning-brief-config.js'
 import { composeMorningBriefPrompt } from './morning-brief-prompt.js'
+import {
+  briefSections,
+  sectionOutcomes,
+  type MorningBriefCoverage,
+  type MorningBriefCoverageService,
+  type MorningBriefSectionOutcome,
+} from './morning-brief-coverage.js'
+import type { MessageReservation } from './message-reservations.js'
 import { decideScheduledFire, localClock, nextScheduledFire } from './morning-brief-schedule.js'
 import type { QueryJobSnapshot } from './query-job-types.js'
 import { isTerminalQueryJobStatus } from './query-job-types.js'
@@ -57,6 +65,8 @@ export interface MorningBriefSchedulerDeps {
   ownerName: () => string
   durableJobsEnabled: () => boolean
   admissionsOpen: () => boolean
+  /** Per-source reach (counts behind each source). Absent on a bare harness. */
+  coverage?: MorningBriefCoverageService
   now?: () => number
   tickMs?: number
   log?: (line: string) => void
@@ -69,12 +79,14 @@ export class MorningBriefRunError extends Error {
   }
 }
 
-export interface MorningBriefRunView extends MorningBriefRun {
+export interface MorningBriefRunView extends Omit<MorningBriefRun, 'sections'> {
   status: string
   completedAt?: string
   error?: { code: string; message: string }
   /** First ~120 chars of the answer, for a list row. Never the whole brief. */
   preview?: string
+  /** Which asked-for sections the answer opened, once the run is terminal. */
+  sections?: MorningBriefSectionOutcome[]
 }
 
 export interface MorningBriefStatus {
@@ -241,6 +253,7 @@ export class MorningBriefScheduler {
       sessionId,
       messageEra,
       globalMsgNum,
+      sections: resume?.sections ?? briefSections(this.config, day),
     }
     // Ledger first. A crash after this line is a resume, not a second brief.
     this.replaceRun(run)
@@ -291,21 +304,26 @@ export class MorningBriefScheduler {
     const rows = this.ledger.runs.slice(-Math.max(1, Math.min(limit, MORNING_BRIEF_LIMITS.retainedRuns))).reverse()
     const views: MorningBriefRunView[] = []
     for (const run of rows) {
+      const pending = run.sections?.length ? run.sections.map(section => ({ ...section, state: 'pending' as const })) : undefined
       if (!run.jobId) {
-        views.push({ ...run, status: run.submitError ? 'submit_failed' : 'submitting', ...(run.submitError ? { error: run.submitError } : {}) })
+        views.push({ ...run, sections: pending, status: run.submitError ? 'submit_failed' : 'submitting', ...(run.submitError ? { error: run.submitError } : {}) })
         continue
       }
       const snapshot = await this.deps.getSnapshot(run.jobId).catch(() => undefined)
       if (!snapshot) {
-        views.push({ ...run, status: run.lastKnownStatus ?? 'unknown' })
+        views.push({ ...run, sections: pending, status: run.lastKnownStatus ?? 'unknown' })
         continue
       }
       if (snapshot.status !== run.lastKnownStatus && isTerminalQueryJobStatus(snapshot.status)) {
         this.replaceRun({ ...run, lastKnownStatus: snapshot.status })
       }
       const answer = snapshot.response ?? snapshot.partialText ?? ''
+      const sections = run.sections?.length && snapshot.status === 'completed'
+        ? sectionOutcomes(run.sections, snapshot.response ?? '')
+        : pending
       views.push({
         ...run,
+        sections,
         status: snapshot.status,
         ...(snapshot.completedAt ? { completedAt: snapshot.completedAt } : {}),
         ...(snapshot.error ? { error: { code: snapshot.error.code, message: snapshot.error.message } } : {}),
@@ -315,6 +333,39 @@ export class MorningBriefScheduler {
     return views
   }
 
+  /** Per-source reach for the settings surfaces. `null` when the harness has
+   * no probes. `force` re-runs the probes instead of serving the cache. */
+  async coverage(force = false): Promise<MorningBriefCoverage | null> {
+    if (!this.deps.coverage) return null
+    try {
+      return await this.deps.coverage.describe(this.config, force)
+    } catch (error) {
+      this.log(`coverage failed: ${(error as Error).message}`)
+      return null
+    }
+  }
+
+  /**
+   * Numbers this scheduler has minted for runs that are not terminal yet: the
+   * ledger row exists BEFORE the job does, and the job's own reservation
+   * (query-job-store identities) ends the moment its terminal projection
+   * writes the exchange. Bounded to a day so a crashed row cannot pin the
+   * counter forever; the resume path reuses the same number anyway.
+   */
+  liveReservations(era: string): MessageReservation[] {
+    const floor = this.now() - 24 * 60 * 60_000
+    const out: MessageReservation[] = []
+    for (const run of this.ledger.runs) {
+      if (typeof run.globalMsgNum !== 'number' || run.submitError) continue
+      if (run.lastKnownStatus && isTerminalQueryJobStatus(run.lastKnownStatus as never)) continue
+      const fired = Date.parse(run.firedAt)
+      if (!Number.isFinite(fired) || fired < floor) continue
+      if (era !== run.messageEra) continue
+      out.push({ globalMsgNum: run.globalMsgNum, messageEra: run.messageEra, owner: `brief:${run.day}` })
+    }
+    return out
+  }
+
   async status(): Promise<MorningBriefStatus> {
     const [lastRun] = await this.listRuns(1)
     const gate: MorningBriefStatus['gate'] = !this.deps.durableJobsEnabled()

package/server/lib/provider-proof.ts

@@ -110,12 +110,23 @@ export function runBounded(
 export const CLAUDE_PROOF_MODEL = 'haiku'
 export const CLAUDE_PROOF_TIMEOUT_MS = 45_000
 
+/** No MCP servers for the proof. Claude Code 2.1.251 turns `--tools ''`
+ * into "load the whole catalog, expose none of it", and on a Mac with a
+ * large MCP fleet that catalog alone was ~244K tokens against Haiku's 200K
+ * window: "Prompt is too long", exit 1, zero API time. Six 6.43.1 update
+ * attempts rolled back on 2026-09-01/02 before a single request was made.
+ * An explicit empty config with --strict-mcp-config keeps the proof under
+ * 20K tokens and is what a readiness check should be anyway. */
+export const CLAUDE_PROOF_MCP_CONFIG = '{"mcpServers":{}}'
+
 export function claudeProofArgs(): string[] {
   return [
     '-p',
     '--model', CLAUDE_PROOF_MODEL,
     '--output-format', 'json',
     '--permission-mode', 'dontAsk',
+    '--strict-mcp-config',
+    '--mcp-config', CLAUDE_PROOF_MCP_CONFIG,
     '--tools', '',
     '--allowedTools', '',
     '--system-prompt', PROOF_PROMPT,

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

@@ -596,6 +596,12 @@ export class QueryJobCoordinator {
     }
   }
 
+  /** Message numbers held by admitted, not-yet-terminal jobs (see
+   * lib/message-reservations.ts). Sync: read straight off the store's identities. */
+  liveMessageReservations(): Array<{ jobId: string; sessionId: string; messageEra?: string; globalMsgNum: number }> {
+    return this.store.listLiveMessageReservations()
+  }
+
   getHealth(): QueryJobCoordinatorHealth {
     return {
       activeRuns: this.active.size,

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

@@ -33,6 +33,7 @@ import {
   type QueryJobSnapshot,
 } from './query-job-types.js'
 import { acquireMaintenanceWork } from './maintenance-lifecycle.js'
+import { registerMessageReservationSource } from './message-reservations.js'
 
 const TOOL_STATUS_MESSAGES: Record<string, string> = {
   WebSearch: 'Searching web...',
@@ -338,6 +339,14 @@ export const queryJobCoordinator = new QueryJobCoordinator(queryJobStore, runner
   acquireMaintenanceWork: () => acquireMaintenanceWork('durable_query', { phase: 'queued' }),
 })
 
+// A job's number is a live reservation from admission until its terminal
+// projection; the counter must see it or the phone mints it again.
+registerMessageReservationSource(() => queryJobCoordinator.liveMessageReservations().map(item => ({
+  globalMsgNum: item.globalMsgNum,
+  ...(item.messageEra ? { messageEra: item.messageEra } : {}),
+  owner: `job:${item.jobId}`,
+})))
+
 export function initQueryJobRuntime() {
   if (!durableQueryJobsEnabled()) return Promise.resolve(queryJobCoordinator.getHealth())
   return queryJobCoordinator.init()

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

@@ -69,6 +69,11 @@ interface QueryJobIdentity {
   status: QueryJobStatus
   updatedAt: string
   orphanFenceUntil?: string
+  /** The number and era the client minted for this job, carried on the
+   * always-in-memory identity so a live reservation can be enumerated without
+   * hydrating the journal. See lib/message-reservations.ts. */
+  messageEra?: string
+  globalMsgNum?: number
 }
 
 export interface QueryJobMutationResult {
@@ -541,6 +546,8 @@ export class QueryJobStore {
       status: record.status,
       updatedAt: record.persistedAt,
       ...(snapshot.orphanFenceUntil ? { orphanFenceUntil: snapshot.orphanFenceUntil } : {}),
+      ...(typeof hydrated.request.messageEra === 'string' ? { messageEra: hydrated.request.messageEra } : {}),
+      ...(typeof hydrated.request.globalMsgNum === 'number' ? { globalMsgNum: hydrated.request.globalMsgNum } : {}),
     }
     this.identitiesByJobId.set(identity.jobId, identity)
     this.identitiesByKey.set(identityKey(identity.clientJobId, identity.generation), identity)
@@ -1018,6 +1025,27 @@ export class QueryJobStore {
     return out
   }
 
+  /**
+   * Numbers held by jobs that are admitted but not yet terminal. Synchronous
+   * and in-memory on purpose: /api/message-counter answers on every phone
+   * send, and identities are never evicted (only hydrated bodies are).
+   * Before init the map is empty, so the answer is an honest nothing.
+   */
+  listLiveMessageReservations(): Array<{ jobId: string; sessionId: string; messageEra?: string; globalMsgNum: number }> {
+    const out: Array<{ jobId: string; sessionId: string; messageEra?: string; globalMsgNum: number }> = []
+    for (const identity of this.identitiesByJobId.values()) {
+      if (isTerminalQueryJobStatus(identity.status)) continue
+      if (typeof identity.globalMsgNum !== 'number') continue
+      out.push({
+        jobId: identity.jobId,
+        sessionId: identity.sessionId,
+        ...(identity.messageEra ? { messageEra: identity.messageEra } : {}),
+        globalMsgNum: identity.globalMsgNum,
+      })
+    }
+    return out
+  }
+
   async findByClientGeneration(clientJobId: string, generation: number): Promise<QueryJobSnapshot | undefined> {
     await this.ensureInitialized()
     const identity = this.identitiesByKey.get(identityKey(clientJobId.toLowerCase(), generation))

package/server/routes/message-ref.ts

@@ -26,6 +26,7 @@ import {
   exchangeBelongsToEra,
 } from '../lib/message-era.js'
 import { MessageEraResetError, resetLiveMessageEra } from '../lib/message-era-reset.js'
+import { maxReservedGlobalMsgNum } from '../lib/message-reservations.js'
 
 // v6.3.0 — read archives from the SAME persistent location the archive-mirror
 // writes to (~/.cos-glasses/data/archive via dataPath), not a package-relative
@@ -248,5 +249,9 @@ messageRefRouter.get('/message-counter', (_req, res) => {
       if (typeof ex?.globalMsgNum === 'number' && ex.globalMsgNum > liveMax) liveMax = ex.globalMsgNum
     }
   }
-  res.json({ max: Math.max(liveMax, maxGlobalMsgNumInDir(ARCHIVE_DIR, era)), era })
+  // 6.43.1 — numbers minted for jobs that are admitted but not yet projected
+  // (a running morning brief, a desk session's durable job) are part of the
+  // ceiling. Without them the phone re-minted #74 on 2026-09-01.
+  const reservedMax = maxReservedGlobalMsgNum(era)
+  res.json({ max: Math.max(liveMax, maxGlobalMsgNumInDir(ARCHIVE_DIR, era), reservedMax), era })
 })

package/server/routes/morning-brief.ts

@@ -3,7 +3,8 @@
 //   GET  /api/morning-brief          config + source catalog + status + recent runs
 //   PUT  /api/morning-brief          patch the config (validated; 400 on a bad field)
 //   POST /api/morning-brief/run      fire a brief now (202; 409 while one runs; 429 past the daily cap)
-//   GET  /api/morning-brief/runs     recent runs with live job status and message numbers
+//   GET  /api/morning-brief/runs     recent runs with live job status, message numbers, section outcomes
+//   GET  /api/morning-brief/coverage what each source can reach right now (?refresh=1 re-probes)
 //   GET  /api/morning-brief/preview  the exact prompt today's brief would send
 //
 // Authenticated by the global /api middleware like every other settings route.
@@ -24,6 +25,7 @@ export function createMorningBriefRouter(scheduler: () => MorningBriefScheduler)
       sources: describeMorningBriefSources(),
       status: await instance.status(),
       runs: await instance.listRuns(7),
+      coverage: await instance.coverage(),
     }
   }
 
@@ -72,6 +74,18 @@ export function createMorningBriefRouter(scheduler: () => MorningBriefScheduler)
     }
   })
 
+  router.get('/morning-brief/coverage', async (req, res) => {
+    const refresh = req.query.refresh === '1' || req.query.refresh === 'true'
+    try {
+      const coverage = await scheduler().coverage(refresh)
+      if (!coverage) return res.status(503).json({ error: { code: 'coverage_unavailable', message: 'This server has no coverage probes.' } })
+      res.json({ coverage })
+    } catch (error) {
+      console.error('[morning-brief] coverage failed:', error)
+      res.status(500).json({ error: { code: 'coverage_failed', message: 'Could not read source coverage.' } })
+    }
+  })
+
   router.get('/morning-brief/preview', (_req, res) => {
     res.type('text/plain').send(scheduler().previewPrompt('scheduled'))
   })