@gotcos/glasses-server 6.98.1 → 6.99.16

package/server/lib/drop-when.ts

@@ -0,0 +1,265 @@
+/**
+ * Drop it P2 (plan PLAN_drop_it_2026-11-04 section 7): when a reminder fires, read from his own words.
+ *
+ * Deterministic. No model, no network, no clock of its own: `now` and the zone are inputs, so every case is a
+ * row in a table. What it reads:
+ * - days: today, tonight, tomorrow, this morning/afternoon/evening, weekdays, "next week", ISO dates, "Nov 12";
+ * - times: "3pm", "3:30 p.m.", "15:00", "at 3", noon, midnight, morning (9:00), afternoon (14:00), evening (18:00);
+ * - offsets: "in 20 minutes", "in an hour", "in 3 days", "in 2 weeks".
+ *
+ * Defaults (plan section 7):
+ * - A day alone means 9:00 (tonight means 20:00).
+ * - Today's weekday means next week ("Thursday" said on a Thursday is a week out).
+ * - A bare hour means the next one: "at 3" at 10 AM is 3 PM today; at 4 PM it is 3 AM tomorrow. On a later day,
+ *   1 to 6 read as afternoon and 7 to 11 as morning.
+ * - A time with no day is the next time the clock shows it.
+ * - Nothing found: `at` is null and COS asks once (Tomorrow 9:00, Monday 9:00, Pick a time).
+ * - An explicit day and time already past ("today 3pm" at 4 PM) is refused as `past`, never moved silently.
+ */
+import { localClock, shiftDay, taskInstant } from './morning-brief-schedule.js'
+
+export const WHEN_DEFAULTS = { dayMinutes: 9 * 60, morning: 9 * 60, afternoon: 14 * 60, evening: 18 * 60, tonight: 20 * 60, noon: 12 * 60 } as const
+/** The furthest a reminder may be set: a year out. Past that it is a typo, so COS asks. */
+export const WHEN_MAX_AHEAD_MS = 366 * 86_400_000
+
+export type WhenReason = 'none' | 'past' | 'too_far'
+export interface WhenResult {
+  /** Epoch ms of the fire, or null when COS must ask. */
+  at: number | null
+  reason?: WhenReason
+  /** What the reminder is about, with "remind me", the time words and a joining "to" taken out. */
+  about: string
+  /** The receipt's words for the time: "today 3:00 PM", "tomorrow 9:00 AM", "Thu 9:00 AM", "Nov 12 9:00 AM". */
+  label?: string
+}
+
+const MONTHS: Record<string, number> = { jan: 1, feb: 2, mar: 3, apr: 4, may: 5, jun: 6, jul: 7, aug: 8, sep: 9, oct: 10, nov: 11, dec: 12 }
+const WEEKDAYS: Record<string, number> = { sunday: 0, monday: 1, tuesday: 2, tues: 2, tue: 2, wednesday: 3, wed: 3, thursday: 4, thurs: 4, thur: 4, thu: 4, friday: 5, fri: 5, saturday: 6 }
+const SHORT_DAY = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat']
+const SHORT_MONTH = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
+
+type Span = [number, number]
+type DayPart = 'morning' | 'afternoon' | 'evening' | 'tonight'
+interface Found { span: Span }
+
+const PATTERNS = {
+  iso: /\b(\d{4})-(\d{2})-(\d{2})\b/,
+  monthDay: /\b(?:on\s+)?(jan(?:uary)?|feb(?:ruary)?|mar(?:ch)?|apr(?:il)?|may|june?|july?|aug(?:ust)?|sept?(?:ember)?|oct(?:ober)?|nov(?:ember)?|dec(?:ember)?)\.?\s+(\d{1,2})(?:st|nd|rd|th)?\b(?:,?\s+(\d{4})\b)?/,
+  offset: /\bin\s+(an?|one|two|three|\d{1,3})\s+(minutes?|mins?|hours?|hrs?|days?|weeks?)\b/,
+  relDay: /\b(today|tonight|tomorrow|tmrw|this\s+(?:morning|afternoon|evening))\b/,
+  nextWeek: /\bnext\s+week\b/,
+  weekday: /\b(?:(?:next|this|on)\s+)?(sunday|monday|tuesday|tues|tue|wednesday|wed|thursday|thurs|thur|thu|friday|fri|saturday)\b/,
+  ampm: /\b(?:at\s+)?(\d{1,2})(?::([0-5]\d))?\s*(a\.?m\.?|p\.?m\.?)(?=[^a-z]|$)/,
+  clock24: /\b(?:at\s+)?([01]?\d|2[0-3]):([0-5]\d)\b/,
+  bareHour: /\bat\s+(\d{1,2})\b(?!\s*(?:%|percent|[:.]\d))/,
+  noon: /\b(?:at\s+)?(noon|midnight)\b/,
+  part: /\b(?:in\s+the\s+)?(morning|afternoon|evening)\b/,
+} as const
+
+const NUMBER_WORDS: Record<string, number> = { a: 1, an: 1, one: 1, two: 2, three: 3 }
+
+function find(re: RegExp, text: string, taken: Span[]): (RegExpExecArray & Found) | null {
+  const global = new RegExp(re.source, 'g')
+  for (let m = global.exec(text); m; m = global.exec(text)) {
+    const span: Span = [m.index, m.index + m[0].length]
+    if (taken.some(([a, b]) => span[0] < b && a < span[1])) continue
+    return Object.assign(m, { span })
+  }
+  return null
+}
+
+function daysBetween(fromDay: string, toDay: string): number {
+  const [fy, fm, fd] = fromDay.split('-').map(Number), [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)
+}
+function validDate(y: number, m: number, d: number): boolean {
+  if (m < 1 || m > 12 || d < 1 || d > 31) return false
+  const date = new Date(Date.UTC(y, m - 1, d))
+  return date.getUTCMonth() === m - 1 && date.getUTCDate() === d
+}
+const pad = (n: number) => String(n).padStart(2, '0')
+
+/** "3:00 PM" for minutes past midnight. */
+export function clockLabel(minutes: number): string {
+  const h = Math.floor(minutes / 60), m = minutes % 60
+  return `${h % 12 === 0 ? 12 : h % 12}:${pad(m)} ${h < 12 ? 'AM' : 'PM'}`
+}
+
+/** The receipt's words for an instant, relative to now: today, tomorrow, a weekday within six days, else the date. */
+export function whenLabel(atMs: number, nowMs: number, timezone: string): string {
+  const at = localClock(atMs, timezone), now = localClock(nowMs, timezone)
+  const ahead = daysBetween(now.day, at.day)
+  const [y, mo, d] = at.day.split('-').map(Number)
+  const day = ahead === 0 ? 'today' : ahead === 1 ? 'tomorrow' : ahead > 1 && ahead < 7 ? SHORT_DAY[at.weekday]
+    : `${SHORT_DAY[at.weekday]} ${SHORT_MONTH[mo - 1]} ${d}${y !== Number(now.day.slice(0, 4)) ? `, ${y}` : ''}`
+  return `${day} ${clockLabel(at.minutes)}`
+}
+
+function about(text: string, spans: Span[]): string {
+  let out = text
+  for (const [a, b] of [...spans].sort((x, y) => y[0] - x[0])) out = out.slice(0, a) + ' ' + out.slice(b)
+  out = out.replace(/\s+/g, ' ').trim()
+  out = out.replace(/^(?:please\s+)?(?:remind\s+me|reminder|set\s+a\s+reminder|don'?t\s+let\s+me\s+forget)(?:\s*[:,-])?\s*/i, '')
+  out = out.replace(/^(?:at|on|by)\s+/i, '').replace(/^(?:to|that|about)\s+/i, '').replace(/\s+(?:at|on|by)$/i, '')
+  out = out.replace(/^[\s,.:;-]+|[\s,;:-]+$/g, '')
+  return out
+}
+
+/**
+ * Read a reminder time out of `text`. `nowMs` and `timezone` decide what "today", "Thursday" and "at 3" mean.
+ * Never throws; anything it cannot read gives `at: null` and a reason.
+ */
+/** 6.99.11 settings: the time a day alone means (Settings, Reminders, default time). */
+export interface WhenOptions { dayMinutes?: number }
+const dayMinutesOf = (o?: WhenOptions) => o?.dayMinutes !== undefined && Number.isInteger(o.dayMinutes) && o.dayMinutes >= 0 && o.dayMinutes < 1440 ? o.dayMinutes : WHEN_DEFAULTS.dayMinutes
+
+export function parseWhen(text: string, nowMs: number, timezone: string, options?: WhenOptions): WhenResult {
+  const source = typeof text === 'string' ? text.slice(0, 2_000) : ''
+  const lower = source.toLowerCase()
+  const now = localClock(nowMs, timezone)
+  const taken: Span[] = []
+  const take = (m: (RegExpExecArray & Found) | null) => { if (m) taken.push(m.span); return m }
+
+  // Times first, so "3:30" is never read as part of a date and "at 3" is not taken by the offset rule.
+  let minutes: number | null = null
+  let bareHour: number | null = null
+  const ampm = take(find(PATTERNS.ampm, lower, taken))
+  if (ampm) {
+    const h = Number(ampm[1]), m = ampm[2] ? Number(ampm[2]) : 0
+    if (h >= 1 && h <= 12) minutes = ((h % 12) + (ampm[3].startsWith('p') ? 12 : 0)) * 60 + m
+  }
+  let bareMinute = 0
+  if (minutes === null) {
+    const c = take(find(PATTERNS.clock24, lower, taken))
+    // "15:00" and "09:30" are a 24-hour clock; "3:30" with no am/pm is a bare hour like "at 3".
+    if (c && (Number(c[1]) > 12 || c[1].length === 2 && c[1].startsWith('0'))) minutes = Number(c[1]) * 60 + Number(c[2])
+    else if (c) { bareHour = Number(c[1]); bareMinute = Number(c[2]) }
+  }
+  if (minutes === null) {
+    const n = take(find(PATTERNS.noon, lower, taken))
+    if (n) minutes = n[1] === 'noon' ? WHEN_DEFAULTS.noon : 0
+  }
+  if (minutes === null && bareHour === null) {
+    const b = find(PATTERNS.bareHour, lower, taken)
+    if (b && Number(b[1]) >= 0 && Number(b[1]) <= 23) { take(b); bareHour = Number(b[1]) }
+  }
+
+  // Offsets ("in 20 minutes") are a whole answer on their own unless they name days or weeks.
+  const off = take(find(PATTERNS.offset, lower, taken))
+  if (off) {
+    const n = NUMBER_WORDS[off[1]] ?? Number(off[1]), unit = off[2]
+    if (n >= 1) {
+      if (/^(?:min|hour|hr)/.test(unit)) {
+        const at = nowMs + n * (unit.startsWith('h') ? 3_600_000 : 60_000)
+        return finish(source, taken, at, nowMs, timezone)
+      }
+      const day = shiftDay(now.day, n * (unit.startsWith('w') ? 7 : 1))
+      return resolve(day, minutes ?? (bareHour !== null ? pmBias(bareHour) + bareMinute : now.minutes))
+    }
+  }
+
+  // The day.
+  let day: string | null = null
+  let part: DayPart | null = null
+  const iso = take(find(PATTERNS.iso, lower, taken))
+  if (iso) {
+    const y = Number(iso[1]), m = Number(iso[2]), d = Number(iso[3])
+    if (validDate(y, m, d)) day = `${y}-${pad(m)}-${pad(d)}`
+  }
+  if (!day) {
+    const md = find(PATTERNS.monthDay, lower, taken)
+    if (md) {
+      const m = MONTHS[md[1].slice(0, 3)], d = Number(md[2])
+      let y = md[3] ? Number(md[3]) : Number(now.day.slice(0, 4))
+      if (validDate(y, m, d)) {
+        take(md)
+        let candidate = `${y}-${pad(m)}-${pad(d)}`
+        if (!md[3] && daysBetween(now.day, candidate) < 0) { y += 1; candidate = validDate(y, m, d) ? `${y}-${pad(m)}-${pad(d)}` : candidate }
+        day = candidate
+      }
+    }
+  }
+  if (!day) {
+    const rel = take(find(PATTERNS.relDay, lower, taken))
+    if (rel) {
+      const word = rel[1]
+      if (word === 'today') day = now.day
+      else if (word === 'tonight') { day = now.day; part = 'tonight' }
+      else if (word === 'tomorrow' || word === 'tmrw') day = shiftDay(now.day, 1)
+      else { day = now.day; part = word.replace(/^this\s+/, '') as DayPart }
+    }
+  }
+  if (!day && take(find(PATTERNS.nextWeek, lower, taken))) {
+    // Next week means its Monday (the weekly check-in's day), 9:00 unless he gave a time.
+    const toMonday = ((8 - now.weekday) % 7) || 7
+    day = shiftDay(now.day, toMonday)
+  }
+  if (!day) {
+    const wd = take(find(PATTERNS.weekday, lower, taken))
+    if (wd) {
+      const target = WEEKDAYS[wd[1]]
+      const ahead = ((target - now.weekday) + 7) % 7 || 7  // today's weekday means next week
+      day = shiftDay(now.day, ahead)
+    }
+  }
+  if (!part) {
+    const p = find(PATTERNS.part, lower, taken)
+    if (p && (day || minutes !== null || bareHour !== null)) { take(p); part = p[1] as DayPart }
+  }
+
+  if (!day && minutes === null && bareHour === null && !part) return { at: null, reason: 'none', about: about(source, taken) }
+
+  // A bare hour: the next time the clock shows it, or, on a later day, its daytime reading.
+  if (minutes === null && bareHour !== null) {
+    if (part === 'afternoon' || part === 'evening' || part === 'tonight') minutes = (bareHour % 12 + 12) * 60
+    else if (part === 'morning') minutes = (bareHour % 12) * 60
+    else if (bareHour > 12) minutes = bareHour * 60
+    else if (!day || day === now.day) {
+      const options = [bareHour % 12 * 60, (bareHour % 12 + 12) * 60].sort((a, b) => a - b)
+      const next = options.find(o => o + bareMinute > now.minutes)
+      if (next !== undefined) { minutes = next; day = day ?? now.day }
+      else if (!day) { minutes = options[0]; day = shiftDay(now.day, 1) }
+      else minutes = options[1]  // "today at 3" after 3 PM: refused as past below
+    } else minutes = pmBias(bareHour)
+    minutes += bareMinute
+  }
+  if (minutes === null) minutes = part ? WHEN_DEFAULTS[part] : dayMinutesOf(options)
+
+  // A time with no day: the next time the clock shows it.
+  if (!day) day = minutes > now.minutes ? now.day : shiftDay(now.day, 1)
+  return resolve(day, minutes)
+
+  function pmBias(h: number): number { return h >= 13 ? h * 60 : h === 12 ? 12 * 60 : h >= 7 ? h * 60 : (h + 12) * 60 }
+  function resolve(d: string, mins: number): WhenResult {
+    const at = taskInstant(d, mins, timezone)
+    // Only an explicit day can land in the past ("today 3pm" at 4 PM): it is refused, never moved silently.
+    if (at <= nowMs) return { at: null, reason: 'past', about: about(source, taken) }
+    return finish(source, taken, at, nowMs, timezone)
+  }
+}
+
+function finish(source: string, taken: Span[], at: number, nowMs: number, timezone: string): WhenResult {
+  if (at - nowMs > WHEN_MAX_AHEAD_MS) return { at: null, reason: 'too_far', about: about(source, taken) }
+  return { at, about: about(source, taken), label: whenLabel(at, nowMs, timezone) }
+}
+
+/** The three times COS offers when it could not read one (plan section 7): Tomorrow 9:00 and Monday 9:00. */
+export function whenSuggestions(nowMs: number, timezone: string, options?: WhenOptions): Array<{ id: string; label: string; at: number }> {
+  const now = localClock(nowMs, timezone)
+  const dm = dayMinutesOf(options), hm = `${Math.floor(dm / 60)}:${String(dm % 60).padStart(2, '0')}`
+  const tomorrow = taskInstant(shiftDay(now.day, 1), dm, timezone)
+  const toMonday = ((8 - now.weekday) % 7) || 7
+  const monday = taskInstant(shiftDay(now.day, toMonday), dm, timezone)
+  // The ids stay tomorrow_9 and monday_9 whatever the time: they name the choice, not the hour.
+  const out = [{ id: 'tomorrow_9', label: `Tomorrow ${hm}`, at: tomorrow }]
+  if (monday !== tomorrow) out.push({ id: 'monday_9', label: `Monday ${hm}`, at: monday })
+  return out
+}
+
+/** Snooze targets for a fired reminder: one hour from now, and tomorrow 9:00. */
+export function snoozeTargets(nowMs: number, timezone: string, options?: WhenOptions & { snoozeMs?: number }): { hour: number; tomorrow9: number } {
+  const now = localClock(nowMs, timezone)
+  const snooze = options?.snoozeMs !== undefined && options.snoozeMs > 0 ? options.snoozeMs : 3_600_000
+  return { hour: nowMs + snooze, tomorrow9: taskInstant(shiftDay(now.day, 1), dayMinutesOf(options), timezone) }
+}
+

package/server/lib/glasses-pairing.ts

@@ -425,6 +425,21 @@ export class PairingState {
     this.log(`[pairing] first authenticated request ip=${claim.ip}`)
   }
 
+  /**
+   * Whether `input` is the glasses code showing in COS Control right now. Read only: it never
+   * counts an attempt, consumes the code or creates a claim. COS Control Web asks this after a
+   * typed code fails as a web code, so it can say "that code is for the glasses app" instead of
+   * a bare "wrong code" (6.99.3; Miles typed the glasses code on the web page until locked out).
+   */
+  isLiveCode(input: unknown): boolean {
+    const at = this.now()
+    this.sweep(at)
+    const code = normalizePairingCode(input)
+    const current = this.current
+    if (!code || !current || current.status !== 'active' || at >= current.expiresAt) return false
+    return pairingCodesEqual(code, current.code)
+  }
+
   /** GET /pairing/status. */
   status(): PairingStatus {
     const at = this.now()

package/server/lib/learning-needs-you.ts

@@ -0,0 +1,111 @@
+// The Memories "To review" count for COS Control Web: the gated needs-you list from
+// `learning_events.py needs-you`, read the way Control's helper reads it (HelperSources
+// main.swift runNeedsYouCLI: 10 s timeout, the same keys, cached about 90 s).
+//
+// WHY THE SERVER RUNS IT. Server 6.45.1 strips `needs_you` from /api/context/status, and
+// Control overlays it on the Mac from this CLI. The browser has no such overlay, so the web
+// Memories page read `learning.to_review` (an object of counts) as the count and showed
+// "To review (NaN)". The bridge's status now carries this block instead, or null when the
+// CLI is unavailable, never a guess.
+
+import { execFile } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { COS_SCRIPTS_DIR } from './python-bridge.js'
+
+export const NEEDS_YOU_TIMEOUT_MS = 10_000
+/** Control: needsYouCacheTTL = 90 s (HelperSources main.swift 10969). */
+export const NEEDS_YOU_TTL_MS = 90_000
+/** Control: needsYouStaleFlagLimit = 3600 s (main.swift 10970): an older stale block loses reward_enabled. */
+export const NEEDS_YOU_STALE_FLAG_LIMIT_MS = 3_600_000
+const KEYS = ['count', 'gates', 'system_backlog', 'window_days', 'limit', 'partial', 'not_implemented', 'items', 'overflow', 'reward_enabled'] as const
+
+export type NeedsYouBlock = Partial<Record<(typeof KEYS)[number], unknown>>
+
+export interface NeedsYouDeps {
+  scriptsDir?: string | null
+  now?: () => number
+  /** Runs `file args` with a timeout; resolves { code, stdout } and never rejects. */
+  run?: (file: string, args: string[], timeoutMs: number) => Promise<{ code: number; stdout: string }>
+}
+
+/** The JSON object in the CLI's stdout: the whole of it, or the span from the first { to the last }. */
+export function parseJsonObject(output: string): Record<string, unknown> | null {
+  const text = output.trim()
+  const attempt = (s: string): Record<string, unknown> | null => {
+    try {
+      const v = JSON.parse(s)
+      return v && typeof v === 'object' && !Array.isArray(v) ? v as Record<string, unknown> : null
+    } catch { return null }
+  }
+  const whole = attempt(text)
+  if (whole) return whole
+  const start = text.indexOf('{'), end = text.lastIndexOf('}')
+  return start >= 0 && end > start ? attempt(text.slice(start, end + 1)) : null
+}
+
+/** Control's count for the rail and the To review tab: count, capped by limit when both are numbers. */
+export function needsYouCount(block: NeedsYouBlock | null): number | null {
+  if (!block) return null
+  const count = typeof block.count === 'number' ? block.count : Array.isArray(block.items) ? block.items.length : null
+  if (count === null) return null
+  return typeof block.limit === 'number' ? Math.min(count, block.limit) : count
+}
+
+function defaultRun(file: string, args: string[], timeoutMs: number): Promise<{ code: number; stdout: string }> {
+  return new Promise(resolve => {
+    execFile(file, args, { timeout: timeoutMs, maxBuffer: 4 * 1024 * 1024, env: process.env }, (err, stdout) => {
+      const code = err ? (typeof (err as { code?: unknown }).code === 'number' ? (err as { code: number }).code : 1) : 0
+      resolve({ code, stdout: String(stdout ?? '') })
+    })
+  })
+}
+
+export function createNeedsYouReader(deps: NeedsYouDeps = {}) {
+  const now = deps.now ?? (() => Date.now())
+  const run = deps.run ?? defaultRun
+  // Only a good read is kept (Control's fetchNeedsYouBlock, main.swift 10987-11001): a failed
+  // read is never cached, and falls back to the last good block, which drops reward_enabled
+  // once it is older than an hour so a stale flag cannot keep the ranking sentence alive.
+  let good: { at: number; block: NeedsYouBlock } | null = null
+  let inflight: Promise<NeedsYouBlock | null> | null = null
+
+  async function readOnce(): Promise<NeedsYouBlock | null> {
+    const dir = deps.scriptsDir !== undefined ? deps.scriptsDir : COS_SCRIPTS_DIR
+    if (!dir) return null
+    const python = join(dir, 'cos_python')
+    const script = join(dir, 'learning_events.py')
+    if (!existsSync(python) || !existsSync(script)) return null
+    const result = await run(python, [script, 'needs-you'], NEEDS_YOU_TIMEOUT_MS)
+    if (result.code !== 0) return null
+    const payload = parseJsonObject(result.stdout)
+    if (!payload || (payload.count === undefined && payload.items === undefined)) return null
+    const block: NeedsYouBlock = {}
+    for (const key of KEYS) if (payload[key] !== undefined) block[key] = payload[key]
+    return Object.keys(block).length ? block : null
+  }
+
+  function stale(): NeedsYouBlock | null {
+    if (!good) return null
+    const block: NeedsYouBlock = { ...good.block }
+    if (now() - good.at > NEEDS_YOU_STALE_FLAG_LIMIT_MS) delete block.reward_enabled
+    return block
+  }
+  /** A fresh block under NEEDS_YOU_TTL_MS old, else a new read, else the last good block; single flight; never throws. */
+  function read(): Promise<NeedsYouBlock | null> {
+    if (good && now() - good.at < NEEDS_YOU_TTL_MS) return Promise.resolve(good.block)
+    if (inflight) return inflight
+    inflight = readOnce().catch(() => null).then(block => {
+      if (block) { good = { at: now(), block }; return block }
+      return stale()
+    }).finally(() => { inflight = null })
+    return inflight
+  }
+  return { read }
+}
+
+let singleton: ReturnType<typeof createNeedsYouReader> | null = null
+export function getNeedsYouReader(): ReturnType<typeof createNeedsYouReader> {
+  if (!singleton) singleton = createNeedsYouReader()
+  return singleton
+}

package/server/lib/live-cues-v2-settings.ts

@@ -28,7 +28,8 @@ export type LiveCuesV2SettingSource = 'env' | 'setting' | 'default'
 /** COS Control's live-cue spend limits (6.79.2). Bounds are inclusive; integer fields take whole numbers only. */
 export const LIVE_CUES_V2_LIMIT_BOUNDS = {
   gate: { min: 0.5, max: 0.95, default: 0.8, integer: false, env: 'COS_LIVE_CUES_V2_GATE' },
-  maxCuesPerMeeting: { min: 1, max: 25, default: 25, integer: true, env: 'COS_LIVE_CUES_V2_MAX_PER_MEETING' },
+  // 6.99.0: the ceiling is 50 (Miles 2026-11-03, longer meetings); the default stays 25. Everything that clamps or validates this reads `.max`.
+  maxCuesPerMeeting: { min: 1, max: 50, default: 25, integer: true, env: 'COS_LIVE_CUES_V2_MAX_PER_MEETING' },
   cooldownSeconds: { min: 20, max: 900, default: 45, integer: true, env: 'COS_LIVE_CUES_V2_COOLDOWN_S' },
   dailyWriterCalls: { min: 1, max: 500, default: 150, integer: true, env: 'COS_LIVE_CUES_V2_DAILY_WRITER_CALLS' },
 } as const

package/server/lib/live-cues-v2.ts

@@ -90,8 +90,10 @@ export const LIVE_CUES_V2_LIMITS = {
   staleMs: 30_000,
   windowWords: 400,
   windowChars: 2_200,
-  /** 25 a meeting (Miles 2026-10-19: 10 ran out 10 minutes into an HC call). Writer calls stay at twice the cue cap so
-   *  discarded drafts cannot end a meeting's cues early, and the weekly default keeps the same ~15 capped meetings. */
+  /** FALLBACK DEFAULTS ONLY (nothing reads these at run time): the live cap is `resolveLiveCuesV2Limits().maxCuesPerMeeting`, which
+   *  Settings can raise to 50 (6.99.0) and env can lock. 25 a meeting (Miles 2026-10-19: 10 ran out 10 minutes into an HC call).
+   *  Writer calls stay at twice the cue cap so discarded drafts cannot end a meeting's cues early. At 25 cues the weekly default
+   *  of 750 writer calls covers ~15 capped meetings (50 calls each); at 50 cues it covers ~7 (100 calls each). */
   maxCuesPerMeeting: 25,
   maxWriterCallsPerMeeting: 50,
   defaultWeeklyWriterCalls: 750,
@@ -171,9 +173,9 @@ export function resolveLiveCuesV2Limits(env: NodeJS.ProcessEnv = process.env, se
   try { saved = settings?.limits?.() ?? {} } catch { saved = {} }
   const fromEnv: Record<LiveCuesV2LimitName, number | null> = {
     gate: envGate(env),
-    maxCuesPerMeeting: envWhole(env, LIVE_CUES_V2_LIMIT_BOUNDS.maxCuesPerMeeting.env, 1, 25),
+    maxCuesPerMeeting: envWhole(env, LIVE_CUES_V2_LIMIT_BOUNDS.maxCuesPerMeeting.env, LIVE_CUES_V2_LIMIT_BOUNDS.maxCuesPerMeeting.min, LIVE_CUES_V2_LIMIT_BOUNDS.maxCuesPerMeeting.max),
     cooldownSeconds: envCooldownSeconds(env),
-    dailyWriterCalls: envWhole(env, LIVE_CUES_V2_LIMIT_BOUNDS.dailyWriterCalls.env, 1, 500),
+    dailyWriterCalls: envWhole(env, LIVE_CUES_V2_LIMIT_BOUNDS.dailyWriterCalls.env, LIVE_CUES_V2_LIMIT_BOUNDS.dailyWriterCalls.min, LIVE_CUES_V2_LIMIT_BOUNDS.dailyWriterCalls.max),
   }
   const out = {} as LiveCuesV2Limits
   for (const name of LIVE_CUES_V2_LIMIT_NAMES) {

package/server/lib/media-store.ts

@@ -187,8 +187,18 @@ export interface MediaRecord {
    * the public attachment ref; it lets a lost finalize response or server
    * restart rediscover the one record that upload already published. */
   videoUploadId?: string
+  /** 6.99.13: the Drop it drop that holds this upload (pinForDrop). Kept apart
+   *  from runId, which an Ask's association overwrites. Never exposed. */
+  dropId?: string
 }
 
+/** A drop id (lowercase UUID v4), as lib/drop-store.ts DROP_ID. Kept local so
+ *  the media store never imports the drop store. */
+const DROP_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/
+/** The kinds a person uploads. Traffic frames and generated visuals carry
+ *  their own content TTL, so they can never be pinned to a drop. */
+const DROPPABLE_KINDS: ReadonlySet<string> = new Set(['user_photo', 'user_document', 'user_video'])
+
 interface MediaIndexFile {
   v: 1
   records: Record<string, MediaRecord>
@@ -324,6 +334,7 @@ function sanitizeRecord(raw: unknown): MediaRecord | null {
     ...(typeof r.videoUploadId === 'string' && /^vu_[0-9a-f]{24}$/.test(r.videoUploadId)
       ? { videoUploadId: r.videoUploadId }
       : {}),
+    ...(typeof r.dropId === 'string' && DROP_ID_RE.test(r.dropId) ? { dropId: r.dropId } : {}),
   }
 }
 
@@ -1212,6 +1223,75 @@ export class MediaStore {
     })
   }
 
+  /**
+   * 6.99.13 Drop it with files: bind fresh uploads to one drop so they outlive
+   * the staged TTL (4 h). An associated record has no lifecycle TTL and GC
+   * never touches it, so the bytes live as long as the drop holds them.
+   * All-or-nothing, like reserve. Refused (nothing changes):
+   *   - unknown or deleted id                        media_not_found
+   *   - expired, or its bytes already gone           media_expired
+   *   - queued with an Ask, sent with a message, held
+   *     by another drop, or not a person's upload   media_conflict
+   *   - bytes missing on disk                        media_unavailable
+   * Replaying the same drop is a no-op that answers the same refs.
+   */
+  pinForDrop(ids: string[], dropId: string): Promise<MediaAttachmentRef[]> {
+    return this.withLock(() => {
+      if (!DROP_ID_RE.test(dropId)) throw new MediaStoreError('media_conflict', 'invalid drop id')
+      const now = Date.now()
+      for (const id of ids) {
+        const rec = isValidMediaId(id) ? this.records.get(id) : undefined
+        if (!rec || rec.lifecycle === 'deleted') throw new MediaStoreError('media_not_found', `attachment ${id} not found`)
+        if (rec.lifecycle === 'associated' && rec.dropId === dropId) continue
+        if (rec.lifecycle === 'expired' || rec.contentRemoved || this.isContentExpired(rec, now)) {
+          throw new MediaStoreError('media_expired', `attachment ${id} expired`)
+        }
+        if (!DROPPABLE_KINDS.has(rec.ref.kind)) throw new MediaStoreError('media_conflict', `attachment ${id} is not an upload`)
+        if (rec.lifecycle !== 'staged') throw new MediaStoreError('media_conflict', `attachment ${id} is already in use`)
+        if (!existsSync(this.absPath(rec.storagePath))) throw new MediaStoreError('media_unavailable', `attachment ${id} content unavailable`)
+      }
+      let dirty = false
+      const refs: MediaAttachmentRef[] = []
+      for (const id of ids) {
+        const rec = this.records.get(id)!
+        refs.push(rec.ref)
+        if (rec.lifecycle === 'associated' && rec.dropId === dropId) continue
+        rec.lifecycle = 'associated'
+        rec.dropId = dropId
+        rec.associatedAtMs = now
+        rec.updatedAtMs = now
+        dirty = true
+      }
+      if (dirty) this.saveIndex()
+      return refs
+    })
+  }
+
+  /**
+   * 6.99.13: Undo of a drop with files. Removes the bytes of the uploads this
+   * drop pinned, and only those: a record another drop holds, or one an Ask
+   * since bound to a message (globalMsgNum), is left alone. Safe to replay.
+   * Answers how many were removed.
+   */
+  unpinDrop(ids: string[], dropId: string): Promise<number> {
+    return this.withLock(() => {
+      if (!DROP_ID_RE.test(dropId)) return 0
+      const now = Date.now()
+      let removed = 0
+      for (const id of ids) {
+        const rec = isValidMediaId(id) ? this.records.get(id) : undefined
+        if (!rec || rec.lifecycle !== 'associated' || rec.dropId !== dropId || rec.globalMsgNum != null) continue
+        this.removeAssetFiles(rec)
+        rec.lifecycle = 'deleted'
+        rec.contentRemoved = true
+        rec.updatedAtMs = now
+        removed++
+      }
+      if (removed) this.saveIndex()
+      return removed
+    })
+  }
+
   /** Hard delete — permitted only while unassociated (staged/reserved).
    *  Associated records follow conversation retention instead. */
   deleteUnassociated(id: string): Promise<boolean> {

package/server/lib/meeting-batch-transcribe.ts

@@ -471,11 +471,24 @@ export interface HqJobPlan {
   strictPrimary?: true
 }
 
+/**
+ * An iPhone recording's saved transcript. Parakeet stays the strict primary. Parakeet takes
+ * no prompt, so the dictionary's vocabulary reaches it only through a second opinion: when
+ * one is on, it is Whisper Large-v3 (prompted with the vocabulary) and the resolver keeps
+ * the user's choice, so its vocabulary rescue can write a dictionary term Parakeet missed.
+ * Off stays off. Before this, a phone plan forced both off and the dictionary never applied
+ * to iPhone recordings beyond the fixed corrections (Miles, 2026-11-05).
+ */
+export function phoneHqPlan(selected: Pick<HqJobPlan, 'secondOpinion' | 'resolver' | 'frontEnd'>): HqJobPlan {
+  const secondOpinion = selected.secondOpinion === 'off' ? 'off' : 'large-v3'
+  return { engine: 'parakeet-ultra', secondOpinion, resolver: secondOpinion !== 'off' && selected.resolver, frontEnd: selected.frontEnd, strictPrimary: true }
+}
+
 export function currentHqJobPlan(sessionId?: string): HqJobPlan {
   const selected = readSttSettings()
   if (sessionId && PHONE_CAPTURE_ID.test(sessionId)) {
     requirePhoneRecording(sessionId)
-    return { engine: 'parakeet-ultra', secondOpinion: 'off', resolver: false, frontEnd: selected.frontEnd, strictPrimary: true }
+    return phoneHqPlan(selected)
   }
   if (sessionId && MAC_CAPTURE_ID.test(sessionId) && selected.hq === 'parakeet-ultra') {
     return { engine: selected.hq, secondOpinion: selected.secondOpinion, resolver: selected.resolver, frontEnd: selected.frontEnd, strictPrimary: true }
@@ -827,7 +840,7 @@ export async function transcribeSegments(
   plan: HqJobPlan,
   deps: HqDecodeDeps = defaultHqDeps,
 ): Promise<BatchResult[]> {
-  if (expectedSessionId?.startsWith('phone_')) { requirePhoneRecording(expectedSessionId); plan = { ...plan, engine: 'parakeet-ultra', secondOpinion: 'off', resolver: false, strictPrimary: true } }
+  if (expectedSessionId?.startsWith('phone_')) { requirePhoneRecording(expectedSessionId); plan = phoneHqPlan(plan) }
   if (expectedSessionId && MAC_CAPTURE_ID.test(expectedSessionId) && plan.engine === 'parakeet-ultra') plan = { ...plan, strictPrimary: true }
   const results: BatchResult[] = []
   const meetingId = basename(audioDir)