@gotcos/glasses-server 6.91.0 → 6.91.1

package/CHANGELOG.md

@@ -1,3 +1,29 @@
+## 6.91.1 - The meaning guard reads clock times, so a time format you asked for is not refused
+
+2026-10-25: canary C5 on the pair that ships (Sonnet, v4, instructions and the learned style) found the 6.91.0 guard
+refusing answers that followed the person's own instruction "write times in the form 10:30 am": "at ten" written
+"10:00 am" counted "am" and "00" as added numbers, and the unpolished text went out. 6.90.0 pasted that formatting, so
+this was a step backward for any Sonnet user with a time-format instruction. Fixed before npm latest moves. Zero
+`claude -p` calls.
+
+- **Clock times** (`server/lib/dictation-meaning-guard.ts`): every time, spoken or written, in the dictation and in the
+  answer, is read as minutes since midnight: "ten", "ten thirty", "half past ten", "quarter to five", "ten o'clock",
+  "ten oh five", 10, 10:00, 10:30, am, pm, a.m., p.m., "22:30" and "twenty two thirty". Without am or pm an hour from
+  1 to 12 reads both ways, so "ten thirty pm" written "22:30" and "ten thirty" written "22:30" are kept. am, pm and a
+  trailing ":00" are format only and never count as added numbers: "at ten" written "at 10:00 am", "ten thirty
+  Central" written "10:30 am Central" and "meet at 9" written "meet at 9:00" are kept. A real change still trips:
+  "ten thirty" written "11:30", "7 am" written "7 pm", "3:00 pm" written "3", and a time the speaker never said. A year
+  that reads like a time ("nineteen fifty" as "1950") still matches its plain form.
+- **C5 re-checked offline:** the 30 stored C5 answers (synthetic) run through the 6.91.1 guard: 0 of 15 stacked and 0
+  of 14 plain refused (6.91.0 refused b02 and b09), so what would go out is 11/11 backtracks on both arms. Every other
+  stored synthetic output: still 0 false trips in 356. Route test: on Sonnet v4 with the time-format instruction saved,
+  b02 and b09 go out polished, and a changed time is still refused.
+- **Eval:** `STACKED_INSTRUCTIONS` is 985 characters (it was 1,033, over the 1,000 cap, so the reader refused it and
+  the 6.91.0 Haiku stacked arm ran without instructions), and the eval now stops if the reader would refuse the set.
+- **Known limit, kept:** the largest possible stack (985-character instructions and all 13 learned-style rules) costs
+  Sonnet v4 +4.3% at p50 and **+46.7% at p90** (9,260 vs 6,311 ms, C5 2026-10-25, n=15). No user has that today: the
+  learned style starts empty and grows a rule at a time. Prompts are unchanged for it.
+
 ## 6.91.0 - Dictation that learns your voice: prompt v4 on Sonnet, Your style, the meaning guard, an opt-in literal register
 
 2026-10-24 22:45: extend AI polish into "a Grammarly but further for voice dictation", remove ungrammatical spoken
@@ -133,8 +159,14 @@ builds the capture, the classifier and Your style.
   (+3.2%); Sonnet p50 3,024 vs 2,949 (+2.5%), p90 4,460 vs 3,997 (+11.6%). Stacked arm (Haiku, v4 + 1,033-character
   instructions + the largest learned style, 767 characters): p50 3,147 vs 2,794 (+12.6%), p90 3,646 vs 3,520 (+3.6%),
   backtracks 11/11. C4 cold, Sonnet: v4 p50 4,346 vs v3 4,713. The absolute Haiku bar is measured after install.
-  **Pending before npm latest:** the stacked arm on the pair that ships, Sonnet with v4, instructions and the learned
-  style (about 15 calls). The stacked number above is Haiku, which does not get v4 or the style.
+  **Pending before npm latest, run 2026-10-25: DISPROVEN (p90).** The stacked arm on the pair that ships, Sonnet with
+  v4, 985-character instructions and the largest learned style (13 rules, 767 characters), against plain Sonnet v4, on
+  the 15-case backtrack and new-preserve slice, interleaved, warm (29 of 30 warm; 30 calls, 1 plain call timed out at
+  20 s): p50 4,968 vs 4,762 ms (+4.3%), p90 9,260 vs 6,311 ms (+46.7%, over the +25% bar; 4 of 15 stacked calls took
+  7.9 to 18.0 s, 1 of 14 plain). Backtracks 11/11 in the model's answers on both arms; new preserve 4/4 stacked, 3/3
+  plain. What would go out: 9/11 stacked, because the meaning guard refused two answers that followed the instruction
+  "write times in the form 10:30 am" ("at ten" as "10:00 am" adds "am" and "00"). The Haiku stacked number above ran
+  without its instructions: that set is 1,033 characters, over the 1,000 cap, so the reader refused it.
 - **C6: PROVEN** (route and golden tests). Every new route is 401 without the token; an old client body works; a skip
   path sends no `polishOutcome`; a port of the 0.5.343 helper and `choose` logs a guarded answer as
   `fillers_only:failed` or `skipped:failed`, never applied; all four switches off, and Haiku outside a terminal, give the

package/README.md

@@ -875,7 +875,10 @@ built-in polish rules, which keep precedence.
   `polishOutcome: "guarded"`, `guard: "<kind>"` and `polishSkipped: "failed"`.
   A self-correction may drop what it replaced. "2 million", "25th",
   "dont", "half past ten" and a numbered list you asked for read as what you
-  said. The log line carries counts only. `COS_DICTATION_MEANING_GUARD=0` turns
+  said. 6.91.1: clock times compare as minutes since midnight, so "at ten"
+  written "10:00 am" and "ten thirty pm" written "22:30" are kept (am, pm and
+  ":00" are format only), while "ten thirty" written "11:30" trips. The log
+  line carries counts only. `COS_DICTATION_MEANING_GUARD=0` turns
   it off.
 - **Finalize answers** add, all optional: `polishOutcome` (`polished`,
   `unchanged` or `guarded`, about the model step; an empty model answer is a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotcos/glasses-server",
-  "version": "6.91.0",
+  "version": "6.91.1",
   "description": "COS Glasses: 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/dictation-meaning-guard.ts

@@ -11,9 +11,16 @@
  *   "cant"), all one NEG token; never, no, none, nothing, nobody, neither, nor, without, unless,
  *   except;
  * - number: digits, number words, ordinals ("twenty fifth" is 25, like "25th"), %, $, a digit with a
- *   scale word ("2 million" is two million, like "two million"), clock times ("half past ten" is
- *   10:30, "quarter to five" 4:45) and am/pm. A decimal point splits a number on both sides ("one
- *   point five" and "1.5" are both 1 then 5);
+ *   scale word ("2 million" is two million, like "two million"), and clock times. A decimal point
+ *   splits a number on both sides ("one point five" and "1.5" are both 1 then 5);
+ * - times (6.91.1): every clock time, spoken or written, in the dictation and in the answer, is read
+ *   as minutes since midnight: "ten thirty", "half past ten", "quarter to five", "ten o'clock",
+ *   "10:30", "10:30 am", "ten thirty pm", "22:30", "twenty two thirty". Without am or pm an hour
+ *   from 1 to 12 reads both ways, so "ten thirty pm" written "22:30" is kept and "ten thirty" written
+ *   "11:30" is a changed number. am, pm and a trailing ":00" are format only: "at ten" written
+ *   "at 10:00 am" is kept. A time is kept when the answer has the same time, when it is on the hour
+ *   and the answer says just that hour (and the dictation said no am or pm), or when every part of
+ *   it survives as a plain number ("nineteen fifty" written "1950");
  * - date: a weekday or a month;
  * - name: a mid-sentence capital, a dictionary term or a speaker name. A sentence-initial word and
  *   "I" are not names unless they are dictionary terms. Skipped for a dictation that is not English.
@@ -52,8 +59,10 @@ export function meaningGuardEnabled(env: NodeJS.ProcessEnv = process.env): boole
   return !(raw === '0' || raw === 'false' || raw === 'off')
 }
 
-interface Tok { raw: string; low: string; sentenceStart: boolean; pause: boolean; listMarker: boolean }
-interface Item { kind: MeaningGuardKind; key: string; pos: number; list?: boolean }
+interface Tok { raw: string; low: string; sentenceStart: boolean; pause: boolean; listMarker: boolean; colonNext: boolean }
+interface Item { kind: MeaningGuardKind; key: string; pos: number; list?: boolean; inTime?: boolean; time?: TimeSpan }
+/** A clock time: the tokens it covers, its minutes since midnight (two readings without am/pm), its parts. */
+interface TimeSpan { start: number; end: number; times: number[]; explicit: boolean; parts: string[] }
 
 const ONES = new Map(['zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten', 'eleven', 'twelve',
   'thirteen', 'fourteen', 'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen'].map((w, i) => [w, i]))
@@ -148,7 +157,8 @@ function tokenize(text: string): Tok[] {
     const sentenceStart = before.length === 0 || /[.!?:\n•]$/.test(before) || /\n\s*(?:[-*•]|\d+[.)])?\s*$/.test(text.slice(0, m.index))
     // "1." or "2)" at the start of a line: a list number.
     const listMarker = /^\d+$/.test(m[0]) && /(?:^|\n)[ \t]*$/.test(text.slice(0, m.index)) && /^[.)]/.test(text.slice(m.index + m[0].length))
-    out.push({ raw: m[0], low: m[0].toLowerCase(), sentenceStart, pause: /[,;.!?—–()]/.test(gap), listMarker })
+    const colonNext = /^:\d/.test(text.slice(m.index + m[0].length))
+    out.push({ raw: m[0], low: m[0].toLowerCase(), sentenceStart, pause: /[,;.!?—–()]/.test(gap), listMarker, colonNext })
     last = m.index + m[0].length
   }
   return out
@@ -230,6 +240,74 @@ function numberRun(tokens: Tok[], i: number): { value: number; end: number } | n
   return { value: total + group, end: j - 1 }
 }
 
+const MERIDIEM = new Set(['am', 'pm'])
+
+/** Minutes since midnight: one reading with am/pm or a 24-hour hour, both readings for 1 to 12 without. */
+function clockMinutes(hour: number, minute: number, meridiem: string | undefined): { times: number[]; explicit: boolean } {
+  if (meridiem && hour >= 1 && hour <= 12) return { times: [((hour % 12) + (meridiem === 'pm' ? 12 : 0)) * 60 + minute], explicit: true }
+  if (hour >= 1 && hour <= 12) return { times: [(hour % 12) * 60 + minute, ((hour % 12) + 12) * 60 + minute], explicit: false }
+  return { times: [hour * 60 + minute], explicit: true }
+}
+
+/** The readings of a bare hour ("ten" or "10") as a time on the hour. */
+function hourReadings(n: number): number[] {
+  if (n >= 1 && n <= 12) return [(n % 12) * 60, ((n % 12) + 12) * 60]
+  return n === 0 || (n >= 13 && n <= 23) ? [n * 60] : []
+}
+
+/** A spoken hour: one to nineteen, twenty, twenty one to twenty three. */
+function spokenHour(tokens: Tok[], i: number): { value: number; end: number } | null {
+  const w = tokens[i]?.low ?? ''
+  const v = ONES.get(w)
+  if (v !== undefined) return v >= 1 ? { value: v, end: i } : null
+  if (w !== 'twenty') return null
+  const ones = ONES.get(tokens[i + 1]?.low ?? '')
+  return ones !== undefined && ones >= 1 && ones <= 3 ? { value: 20 + ones, end: i + 1 } : { value: 20, end: i }
+}
+
+/** Spoken minutes after an hour: "oh five", ten to nineteen, twenty to fifty nine. */
+function spokenMinutes(tokens: Tok[], i: number): { value: number; end: number } | null {
+  const w = tokens[i]?.low ?? ''
+  const next = ONES.get(tokens[i + 1]?.low ?? '')
+  if (w === 'oh' || w === 'o') return next !== undefined && next >= 1 && next <= 9 ? { value: next, end: i + 1 } : null
+  const v = ONES.get(w)
+  if (v !== undefined) return v >= 10 ? { value: v, end: i } : null
+  const tens = TENS.get(w)
+  if (tens === undefined || tens > 50) return null
+  return next !== undefined && next >= 1 && next <= 9 ? { value: tens + next, end: i + 1 } : { value: tens, end: i }
+}
+
+/** One clock time starting at token i, or null. An hour alone is not a time; it needs minutes or am/pm. */
+function timeAt(tokens: Tok[], i: number): Omit<TimeSpan, 'parts'> | null {
+  const t = tokens[i]
+  let hour: number, end: number
+  if (/^\d{1,2}$/.test(t.low)) { hour = Number.parseInt(t.low, 10); end = i }
+  else { const h = spokenHour(tokens, i); if (!h) return null; hour = h.value; end = h.end }
+  let minute = 0, hasMinutes = false
+  const next = tokens[end + 1]?.low ?? ''
+  if (tokens[end].colonNext && /^\d{2}$/.test(next)) { minute = Number.parseInt(next, 10); end++; hasMinutes = true }
+  else if (!/^\d/.test(t.low)) { const m = spokenMinutes(tokens, end + 1); if (m) { minute = m.value; end = m.end; hasMinutes = true } }
+  const meridiem = MERIDIEM.has(tokens[end + 1]?.low ?? '') ? tokens[end + 1].low : undefined
+  if (!hasMinutes && !meridiem) return null
+  if (meridiem) end++
+  if (hour > 23 || minute > 59) return null
+  const { times, explicit } = clockMinutes(hour, minute, meridiem)
+  return { start: i, end, times, explicit }
+}
+
+/** Every clock time in the text, as time items; the number items inside one become its parts. */
+function addTimes(tokens: Tok[], items: Item[]): void {
+  for (let i = 0; i < tokens.length; i++) {
+    const found = timeAt(tokens, i)
+    if (!found) continue
+    const parts = items.filter(it => it.kind === 'number' && it.pos >= found.start && it.pos <= found.end)
+    parts.forEach(it => { it.inTime = true })
+    const time: TimeSpan = { ...found, parts: parts.map(it => it.key) }
+    items.push({ kind: 'number', key: `time:${time.times.join('/')}`, pos: found.start, time })
+    i = found.end
+  }
+}
+
 interface Extract { items: Item[]; tokens: Tok[] }
 
 function extract(text: string, knownPhrases: string[][], withNames: boolean): Extract {
@@ -281,6 +359,7 @@ function extract(text: string, knownPhrases: string[][], withNames: boolean): Ex
       if (!t.sentenceStart || midCapital.has(fold(t.low))) items.push({ kind: 'name', key: fold(t.low), pos: i })
     }
   }
+  addTimes(tokens, items)
   // Dictionary terms and speaker names, in any case and position, as whole phrases.
   if (withNames) {
     for (const phrase of knownPhrases) {
@@ -390,13 +469,35 @@ export function meaningGuardProblem(cleaned: string, answer: string, known: stri
     return respelled
   }
 
+  // 6.91.1: clock times, compared as minutes since midnight (see the header).
+  const inTimes = input.items.filter(i => i.time).map(i => i.time!)
+  const outTimes = output.items.filter(i => i.time).map(i => i.time!)
+  const bareHours = (items: Item[]) => items.filter(i => i.kind === 'number' && !i.time && !i.inTime && /^\d+$/.test(i.key)).map(i => Number(i.key))
+  const inBare = bareHours(input.items)
+  const outBare = bareHours(output.items)
+  const sameTime = (a: TimeSpan, b: TimeSpan) => a.times.some(t => b.times.includes(t))
+  // A bare hour matches a time only on that hour: its readings are all on the hour.
+  const onTheHour = (time: TimeSpan, n: number) => hourReadings(n).some(t => time.times.includes(t))
+  const numberKept = (key: string) => outKeys.get('number')!.has(key) || keptByJoin.has(key)
+  const timeKept = (time: TimeSpan) => outTimes.some(o => sameTime(time, o))
+    || (!time.explicit && outBare.some(n => onTheHour(time, n)))
+    || time.parts.every(numberKept)
+  // A time in the answer is not new when the dictation had it, had its hour ("at ten" as "10:00 am"),
+  // or had its parts as numbers. am, pm and ":00" are format only.
+  const timeAccounted = (time: TimeSpan) => inTimes.some(i => sameTime(i, time))
+    || inBare.some(n => onTheHour(time, n))
+    || time.parts.filter(p => !MERIDIEM.has(p) && p !== '0').every(p => inKeys.get('number')!.has(p))
+  const kept = (item: Item): boolean => item.kind === 'name' ? nameKept(item.key)
+    : item.time ? timeKept(item.time)
+    : item.kind === 'number' ? numberKept(item.key) || (/^\d+$/.test(item.key) && outTimes.some(o => onTheHour(o, Number(item.key))))
+    : outKeys.get(item.kind)!.has(item.key)
+
   // A dropped token with a correction marker after it and a same-kind replacement the answer kept.
   const exempt = (item: Item): boolean => {
     if (item.kind === 'negation') return false
     for (const { start, end, reach } of spans) {
       if (start <= item.pos || start - item.pos > DROP_TO_MARKER) continue
-      const replaced = input.items.some(r => r.kind === item.kind && r.key !== item.key && r.pos > end && r.pos - end <= reach
-        && (r.kind === 'name' ? nameKept(r.key) : outKeys.get(r.kind)!.has(r.key)))
+      const replaced = input.items.some(r => r.kind === item.kind && r.key !== item.key && r.pos > end && r.pos - end <= reach && kept(r))
       if (replaced) return true
     }
     return false
@@ -414,9 +515,9 @@ export function meaningGuardProblem(cleaned: string, answer: string, known: stri
     const id = `${item.kind}:${item.key}`
     if (seen.has(id)) continue
     if (item.kind === 'negation' && countNegations) continue
-    const kept = item.kind === 'name' ? nameKept(item.key)
-      : outKeys.get(item.kind)!.has(item.key) || (item.kind === 'number' && keptByJoin.has(item.key))
-    if (kept) { seen.add(id); continue }
+    // A number inside a clock time is judged with its time.
+    if (item.inTime) continue
+    if (kept(item)) { seen.add(id); continue }
     // Every occurrence must be exempt for a drop to be excused.
     const occurrences = input.items.filter(i => i.kind === item.kind && i.key === item.key)
     seen.add(id)
@@ -437,7 +538,9 @@ export function meaningGuardProblem(cleaned: string, answer: string, known: stri
     const outNumberItems = output.items.filter(i => i.kind === 'number')
     for (const key of outNumbers) if (outNumberItems.filter(i => i.key === key).every(i => i.list)) listOnly.add(key)
   }
-  for (const key of outNumbers) if (!inKeys.get('number')!.has(key) && !joinedOut.has(key) && !listOnly.has(key)) added.number++
+  const plainOut = new Set(output.items.filter(i => i.kind === 'number' && !i.time && !i.inTime).map(i => i.key))
+  for (const key of plainOut) if (!inKeys.get('number')!.has(key) && !joinedOut.has(key) && !listOnly.has(key)) added.number++
+  for (const time of outTimes) if (!timeAccounted(time)) added.number++
 
   const kind = MEANING_GUARD_KINDS.find(k => dropped[k] > 0 || added[k] > 0)
   return kind ? { kind, dropped, added, namesSkipped: !withNames } : null