@gotcos/glasses-server 6.73.3 → 6.73.14

package/CHANGELOG.md

@@ -1,3 +1,77 @@
+## 6.73.14 — Saved Mac recordings appear in Meetings; Work chat keeps a plan with a stray item (local candidate)
+
+- A saved Mac recording now lists in Meetings on a Mac whose COS pipeline files G2 recordings (Miles 2026-10-15: the 10:39 PM recording saved but Control said "Saved meeting not found yet" forever). Mac captures never reach the pipeline (routes/meeting.ts, MAC_CAPTURE_ID), and that layout listed only the operations tree. The store's Mac rows now join it (`withMacStoreRows`, standalone identity, an operations copy wins by session), are filtered before the store's 200-row cap, count in the calendar's day dots (`macStoreDayCounts`), and a month holding only Mac recordings reaches the pager. G2 store rows stay the pipeline's.
+- QA before release: the store matches a Mac session from the sidecar's 4 KB head before it opens any markdown, so a list of Mac rows no longer reads the store's G2 recordings (617 files, about 16 MB, on every Control poll, including `?day=` every 3 s during a hand-off); a `day` with no `month` reads only that month's folder. Store rows carry their start `time` ("HH:MM", from the Time line, else the Date line, else the filename), so a Mac recording sorts by its time among the same day's operations rows instead of at 00:00, where the 20-row list could cut it. A Mac recording whose session an operations row or a merged scribe already holds is left out of the day dots as it is of the rows, so an operations copy counts once.
+- Not changed: Mac recordings still skip the operations pipeline (search, vector and graph index, Work intake). That is a product decision, not this fix.
+- Work chat cleans the planner's `contextItemIDs` instead of refusing the plan: unknown ids drop, repeats keep once, anything that is not a list of strings sends every item, and so does a list none of whose ids Control supplied; an empty list sends the fixed three. The count of unknown ids is logged (`[work-chat]`), never the ids. One stray id used to discard a whole high-effort plan (QA 2026-10-15).
+- Pair with Control 0.5.313. Transcription-candidate and cue flags stay disabled. No public publication is implied.
+
+## 6.73.13 — Work chat picks each assignment's context (local candidate)
+
+- Work chat input accepts optional `items` ({id, kind, label, estTokens}; ids and estimates only, never contents; at most 40; your request, the task and COS instructions required). The planner returns `contextItemIDs` per assignment, a subset of the supplied ids; the fixed three are always added and Control's order is kept; omitted means every item. GET `/api/work/chat` advertises `contextItems: true` and `maxContextItems: 40`. The planner is asked for the smallest set each assignment needs.
+- Work chat's output budget rises from 4,086 to 4,946 tokens so three full selections fit (derived in lib/work-chat.ts).
+- Pair with Control 0.5.312 (Work Context Meter, Plan and send). Transcription-candidate and cue flags stay disabled. No public publication is implied.
+
+## 6.73.12 — Atomic dictionary edits and Work chat planner effort (local candidate)
+
+- Work chat plans at a chosen effort: `low`, `medium` or `high` (default `high`, Miles 2026-10-15). GET `/api/work/chat` advertises `efforts`; the answer reports the effort used. Anything else is a 400 before any model call. Higher effort raises cost per plan; still one call per Plan click.
+- Work chat now thinks at medium and high (6,000 and 16,000 thinking tokens) with an output budget derived from its largest valid plan (4,086 tokens) and a 180-second deadline. Before, every plan ran with thinking off and a 1,400-token cap that could cut a full plan into a 503. Lens gist and Meeting Ask keep exactly their old settings (1,400 / 0 / 45 s, low).
+
+- Add `POST /api/transcription-glossary/vocabulary/add` `{term}`, `/vocabulary/remove` `{term}` and `/correction/remove` `{heard}`. Each changes one item inside the same write chain as PUT and learn, so COS Control's Dictionary pane no longer reads the whole dictionary and writes it back (a Fix a word landing in between could be lost). Same limits as learn: 500 terms, 100 UTF-16 units, no URL, email or path in the vocabulary. Hand edits are not logged for undo.
+- Pair with Control 0.5.310. Older servers keep reading and adding corrections from Control; single-word edits, Fix a word and Undo need 6.73.12. Transcription-candidate and cue flags stay disabled. No public publication is implied.
+
+## 6.73.11 — Fix a word: the dictionary learns (local candidate)
+
+- Add `POST /api/transcription-glossary/correction` `{heard, written, source}`: learns ONE correction and adds the spelling to the vocabulary in one write, serialized with PUT. A case variant of an existing key is replaced, not duplicated. Same limits as PUT: 500 terms, 100 characters, no URL, email or path spellings (they would join the decoder prompt). `source` is `dictation`, `meeting`, `g2` or `manual`.
+- Add `GET /api/transcription-glossary/recent`: what COS learned, newest first, with source and time. The log lives in the data dir (`transcription-corrections.json`, last 200, atomic, 0600); the dictionary stays in `.cos-profile.json`.
+- Add `POST /api/transcription-glossary/correction/undo` `{id}`: reverts exactly that entry, puts back a replaced case variant, and removes the spelling only if no remaining correction writes it. Refuses with 409 when a newer entry owns the word or it was edited since.
+- Live, meeting and dictation transcription pick a learned word up on the next sentence (decoder and vocab-echo caches are cleared). Pair with Control 0.5.309. 6.73.10 is the Work chat candidate on its own branch. Transcription-candidate and cue flags stay disabled. No public publication is implied.
+
+## 6.73.10 — Choose the Work chat planner (local candidate)
+
+- Accept an optional `planner` (`sonnet` or `opus`) on `POST /api/work/chat` and run that Claude model, still tools-off. Anything else is a 400 before any model call. Clients that send none keep Sonnet. `GET /api/work/chat` now advertises `planners: ["sonnet","opus"]` and keeps `planner: "sonnet"` as the default; the answer's `model` names what ran. The choice selects the model only and never reaches the prompt.
+- Cost: still one model call per user action, serialized by the existing busy lock (a second request gets 409). Opus costs more per call than Sonnet; nothing new runs on a schedule.
+- Planning still never dispatches. Ships with Control 0.5.309, which reviews every planned assignment before anything is sent. Transcription-candidate and cue flags stay disabled. No public publication is implied.
+
+## 6.73.9 — Keep stalled Mac captures recoverable (local candidate)
+
+- Never auto-save or expire a Mac capture (`mac_<uuid>`). COS Control keeps every chunk on the Mac and delivers or recovers it. The 4 h stranded sweep posted the save without the server pin a Mac save requires, read the 400 as final and closed the session; boot recovery closed any session idle past 4 h the same way. A capture stalled at 51 of 1,200 chunks (2026-10-15) would have lost its server-side recovery at 20:12. Both paths now leave Mac captures open (`restoresAtBoot`, sweep guard).
+- Note for 6.73.6 to 6.73.8: the decision provider switch (Jev or SubQ) for Work search, session suggestions and completion checks, with authenticated `/api/decision-provider` and `/api/subq-key` routes, a private 0600 SubQ key file, and `COS_SUBQ_DAILY_TOKENS` (default 1M) capping each workflow's daily usage separately. SubQ sends the decision prompt to SubQ's API. Meeting intake (`work_intake.py`) stays on Jev.
+- Known limitation: in a saved Mac meeting's full-quality Parakeet pass, a window with no words over detected speech still abandons that pass; the meeting saves with its live transcript.
+- Pair with Control 0.5.307. Transcription-candidate and cue flags stay disabled. No public publication is implied.
+
+## 6.73.8 — Live Ask on Mac recordings (local candidate)
+
+- Accept Mac capture ids (`mac_<uuid>`, the id the Mac recording route issues) in live COS Ask, Ask history, files and orientation, and Work intake Ask evidence. Every Ask on a Mac recording failed with `invalid_session_id`; found in a live meeting 2026-10-15. One shared pattern in `lib/ask-session-id.ts`; traversal-shaped and upper-case ids stay refused.
+- Record Parakeet's no-words answer over detected speech on a Mac chunk as an empty chunk with a `[mac-asr]` warning, instead of a retryable 503. Replays of the same audio failed forever and froze every later chunk of a live meeting (2026-10-15, chunk 51). Real Parakeet failures stay retryable with no Whisper fallback; the saved meeting still re-transcribes the full audio with strict Parakeet.
+- Pair with Control 0.5.306. Transcription-candidate and cue flags stay disabled. No public publication is implied.
+
+## 6.73.7 — Strict local desktop dictation (local candidate)
+
+- Advertise the desktop dictation capability before microphone audio is transferred.
+- Honor an explicit Parakeet Ultra requirement through the existing COS dictionary and vocabulary pipeline; return a retryable error rather than substituting Whisper or cloud transcription.
+- Bound streamed desktop audio to two minutes of canonical PCM16 WAV data. Preserve legacy transcription behavior for callers without the engine requirement.
+- Pair with Control 0.5.303 for microphone dictation and shared Mac live meeting views. Retain the recording/onboarding/SubQ changes from 6.73.6 and keep transcription-candidate/cue flags disabled. No public publication is implied.
+
+## 6.73.6 — Manual Mac recording transport (local candidate)
+
+- Register selected-app Mac system-audio capture with immutable source identity and high-confidence speaker policy before admitting audio.
+- Persist canonical PCM chunk receipts, exact timing and capture provenance through retry, save and meeting context. Reject missing chunks, conflicting retries and source substitution.
+- Keep Mac playback out of automatic G2/Fireflies merges and voice training. Glasses are optional for the matched Control 0.5.301 pilot.
+- Preserve transcription settings and disabled transcription-candidate/cue flags. Signed-host capture and permission acceptance remain local installation gates; this entry does not indicate public availability.
+
+## 6.73.5 — Tasks from saved meetings (local candidate)
+
+- Add authenticated, bounded creation of a task and its exact source meeting in one canonical locked write.
+- Preserve source files through the existing meeting context store, reuse matching linked tasks on retry, and explicitly report collisions with unrelated or closed work.
+- Return a renamed task's stable Work identity so matched Control 0.5.295/build 348 opens the saved card.
+- Keep existing transcription choices and experimental cue/transcription flags unchanged.
+
+## 6.73.4 (local candidate)
+
+- Add tools-off Sonnet planning and result synthesis for task-level Work chat. Actual delivery uses existing native-session continuation.
+- Preserve independent session status and user ownership of shared task completion.
+
 ## 6.73.3 — Speaker identity policy and exact Codex child sessions
 
 - Preserve the original child Codex session when reading completed job details. Control can open the actual result without substituting the parent conversation or starting another model turn.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotcos/glasses-server",
-  "version": "6.73.3",
+  "version": "6.73.14",
   "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": {
@@ -45,6 +45,7 @@
     "!server/scripts/hq-contention-canary.ts",
     "!server/scripts/live-cos-ask-canary.ts",
     "!server/scripts/work-review-candidate.ts",
+    "!server/scripts/work-chat-canary.ts",
     "!server/scripts/work-session-identity-canary.ts",
     "!server/scripts/work-hardening-fixture.ts",
     "!server/scripts/work-review-mutation-gate.mjs",

package/server/index.ts

@@ -148,7 +148,10 @@ import { createWorkReviewsRouter } from './routes/work-reviews.js'
 import { createWorkBoardRouter } from './routes/work-board.js'
 import { createWorkIntakeRouter } from './routes/work-intake.js'
 import { createWorkHandoffRequestsRouter } from './routes/work-handoff-requests.js'
+import { createSubqKeyRouter } from './routes/subq-key.js'
+import { createDecisionProviderRouter } from './routes/decision-provider.js'
 import { createJevRouter } from './routes/jev.js'
+import { createWorkChatRouter } from './routes/work-chat.js'
 import { createWorkSearchRouter } from './routes/work-search.js'
 import { isReadOnlyApiPost } from './lib/work-search.js'
 import { dataPath } from './lib/data-dir.js'
@@ -383,6 +386,7 @@ app.use('/api', (req, res, next) => {
     || req.path === '/diagnostics/provider-proof'
     || req.path === '/transcribe'
     || req.path.startsWith('/transcribe-stream')
+    || req.path.startsWith('/mac-recording/')
     || req.path === '/meeting/save'
     // The import run answers 202 and keeps working. It takes its own
     // maintenance lease per page and checks admissions itself, so the global
@@ -797,7 +801,10 @@ app.use('/api', createWorkIntakeRouter({ store: workIntakeStore }))
 // (6.57.1), and the Work completion check (6.58.0).
 app.use('/api', createJevRouter(workReviewRuntime ? { review: async id => workReviewRuntime.peek(id) } : {}))
 // Work search by meaning (6.65.0, Control 0.5.259): one Jev Choice over the board's cards, with its own cap, switch and breaker.
+app.use('/api', createDecisionProviderRouter())
+app.use('/api', createSubqKeyRouter())
 app.use('/api', createWorkSearchRouter())
+app.use('/api', createWorkChatRouter())
 app.use('/api', queryRouter)
 // The scheduled start-of-day brief: settings, status, run-now. Same auth as
 // every other settings route; the brief itself is an ordinary durable job.

package/server/lib/ask-session-id.ts

@@ -0,0 +1,5 @@
+// Which recordings may open live Ask, its history and Work evidence. 6.73.8: a Mac capture
+// (mac_<uuid>, lib/mac-recording.ts MAC_CAPTURE_ID) uses the same Ask as a G2 meeting; before this
+// every Mac request and saved-question read failed with invalid_session_id.
+export const MAC_ASK_SESSION = /^mac_[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/
+export const ASK_SESSION = /^(?:meeting_[A-Za-z0-9_-]{1,89}|mac_[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/

package/server/lib/decision-provider.ts

@@ -0,0 +1,163 @@
+/** Explicit classifier routing. No retry or cross-provider fallback; generative engines do not use this seam. */
+import { lstatSync, mkdirSync, readFileSync } from 'node:fs'
+import { dirname } from 'node:path'
+import { JevClient, JevError, type JevAnswers } from './jev.js'
+import { dataPath } from './data-dir.js'
+import { durableAtomicWriteFileSync } from './atomic-fs.js'
+import { redactSecretText } from './activity-preview.js'
+import { secureExistingPrivateFile } from './secure-user-config.js'
+
+import { resolveSubqKey, SUBQ_MODEL } from './subq-key.js'
+export { SUBQ_MODEL } from './subq-key.js'
+import { resolveDecisionSelection, type DecisionProvider, type DecisionUseCase } from './decision-settings.js'
+export type { DecisionProvider, DecisionUseCase } from './decision-settings.js'
+export interface DecisionImage { mediaType: 'image/png' | 'image/jpeg' | 'image/webp'; base64: string }
+export interface DecisionOptions { signal?: AbortSignal; images?: DecisionImage[] }
+export interface DecisionClient { readonly provider?: DecisionProvider; snapshot?: () => DecisionClient; ask(state: unknown, questions: Record<string, unknown>, estimate: number, options?: DecisionOptions): Promise<JevAnswers> }
+export class DecisionProviderError extends Error {
+  constructor(readonly code: 'decision_invalid_provider' | 'decision_not_configured' | 'decision_cap_reached' | 'decision_breaker_open' |
+    'decision_key_rejected' | 'decision_credits_required' | 'decision_rate_limited' | 'decision_request_rejected' | 'decision_unavailable' |
+    'decision_bad_answer' | 'decision_cancelled' | 'decision_images_unsupported' | 'decision_usage_unavailable') { super(code) }
+}
+export const SUBQ_ENDPOINT = 'https://api.subq.ai/v1/systemone'
+export const SUBQ_LIMITS = { timeoutMs: 20_000, dailyTokens: 1_000_000, breakerFailures: 3, breakerMs: 3_600_000, maxBodyBytes: 13 * 1024 * 1024 } as const
+
+/** No key probing, and no unknown value silently treated as Jev. Per-use-case settings override the global switch. */
+export function selectedDecisionProvider(useCase: DecisionUseCase, env: NodeJS.ProcessEnv = process.env): DecisionProvider {
+  try { return resolveDecisionSelection(useCase, env).provider } catch { throw new DecisionProviderError('decision_invalid_provider') }
+}
+const isRecord = (v: unknown): v is Record<string, unknown> => !!v && typeof v === 'object' && !Array.isArray(v)
+const probability = (v: unknown): v is number => typeof v === 'number' && Number.isFinite(v) && v >= 0 && v <= 1
+function clean(value: unknown): unknown {
+  if (typeof value === 'string') return redactSecretText(value).replace(/[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/gi, '[email]')
+    .replace(/\b\d{3}[-. ]\d{3}[-. ]\d{4}\b/g, '[phone]')
+  if (Array.isArray(value)) return value.map(clean)
+  if (isRecord(value)) return Object.fromEntries(Object.entries(value).map(([key, v]) => [String(clean(key)), clean(v)]))
+  return value
+}
+/** Validate locally. Image bytes are never logged, persisted, fetched by URL, or inferred from a user's screen. */
+function requestBody(state: unknown, questions: Record<string, unknown>, images: DecisionImage[] = []): string {
+  const entries = Object.entries(questions)
+  if (!entries.length || entries.length > 16 || entries.some(([k, q]) => !k || k.length > 100 || !isRecord(q) || typeof q.instructions !== 'string' ||
+    !['noul', 'choice', 'score'].includes(String(q.type)) || (q.type === 'choice' && (!isRecord(q.criteria) || Object.keys(q.criteria).length < 2 || Object.keys(q.criteria).length > 255)) ||
+    (q.type === 'score' && (!Array.isArray(q.criteria) || q.criteria.length < 2 || q.criteria.length > 10)))) throw new DecisionProviderError('decision_request_rejected')
+  let total = 0
+  if (images.length > 4) throw new DecisionProviderError('decision_request_rejected')
+  for (const image of images) {
+    if (!['image/png', 'image/jpeg', 'image/webp'].includes(image.mediaType) || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(image.base64)) throw new DecisionProviderError('decision_request_rejected')
+    const bytes = Buffer.from(image.base64, 'base64'); total += bytes.length
+    const valid = image.mediaType === 'image/png' ? bytes.subarray(0, 8).equals(Buffer.from('89504e470d0a1a0a', 'hex')) :
+      image.mediaType === 'image/jpeg' ? bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255 : bytes.toString('ascii', 0, 4) === 'RIFF' && bytes.toString('ascii', 8, 12) === 'WEBP'
+    if (!valid || bytes.length > 4 * 1024 * 1024 || total > 8 * 1024 * 1024) throw new DecisionProviderError('decision_request_rejected')
+  }
+  const body = JSON.stringify({ model: SUBQ_MODEL, state: clean(state), questions: clean(questions), ...(images.length ? { images } : {}) })
+  if (Buffer.byteLength(body) > SUBQ_LIMITS.maxBodyBytes) throw new DecisionProviderError('decision_request_rejected')
+  return body
+}
+
+/** Strict schema at the provider boundary, before any workflow threshold can turn it into advice. */
+export function validateDecisionAnswers(raw: unknown, questions: Record<string, unknown>): JevAnswers['answers'] {
+  if (!isRecord(raw) || Object.keys(raw).length !== Object.keys(questions).length) throw new DecisionProviderError('decision_bad_answer')
+  for (const [name, spec] of Object.entries(questions)) {
+    const q = spec as Record<string, unknown>, a = raw[name]
+    if (!isRecord(a) || a.type !== q.type) throw new DecisionProviderError('decision_bad_answer')
+    if (q.type === 'noul') { if (!probability(a.noul)) throw new DecisionProviderError('decision_bad_answer'); continue }
+    const criteria = q.criteria as Record<string, unknown> | unknown[]
+    const labels = Object.keys(criteria), probs = a.probabilities
+    if (!isRecord(probs) || Object.keys(probs).length !== labels.length || labels.some(k => !probability(probs[k])) ||
+      Math.abs(Object.values(probs).reduce<number>((sum, p) => sum + Number(p), 0) - 1) > 0.02 || !probability(a.confidence)) throw new DecisionProviderError('decision_bad_answer')
+    if (q.type === 'choice' && (typeof a.choice !== 'string' || !labels.includes(a.choice))) throw new DecisionProviderError('decision_bad_answer')
+    if (q.type === 'score' && (typeof a.score !== 'number' || !Number.isFinite(a.score) || a.score < 0 || a.score > labels.length - 1 || !isRecord(a.legend) || labels.some(k => !(k in (a.legend as Record<string, unknown>))))) throw new DecisionProviderError('decision_bad_answer')
+  }
+  return raw as JevAnswers['answers']
+}
+
+export class SubqDecisionClient implements DecisionClient {
+  readonly provider = 'subq' as const
+  private failures = 0
+  private breakerUntil = 0
+  private reserved = 0
+  constructor(private readonly fetchImpl: typeof fetch = fetch, private readonly now: () => Date = () => new Date(),
+    private readonly usageFile = dataPath('subq-decisions-usage.json'), private readonly key = () => resolveSubqKey()?.key,
+    private readonly cap = () => { const n = Number(process.env.COS_SUBQ_DAILY_TOKENS); return Number.isFinite(n) && n > 0 ? Math.floor(n) : SUBQ_LIMITS.dailyTokens },
+    private readonly timeoutMs: number = SUBQ_LIMITS.timeoutMs) {}
+  resetForNewKey(): void { this.failures = 0; this.breakerUntil = 0 }
+  private ledger(): Record<string, number> {
+    try {
+      const stat = lstatSync(this.usageFile)
+      if (stat.isSymbolicLink() || !stat.isFile()) throw new Error('unsafe')
+    } catch (e) {
+      if (e && typeof e === 'object' && 'code' in e && e.code === 'ENOENT') return {}
+      throw new DecisionProviderError('decision_usage_unavailable')
+    }
+    try {
+      secureExistingPrivateFile(this.usageFile)
+      const value: unknown = JSON.parse(readFileSync(this.usageFile, 'utf8'))
+      if (!isRecord(value) || Object.entries(value).some(([day, count]) => !/^\d{4}-\d{2}-\d{2}$/.test(day) || typeof count !== 'number' || !Number.isFinite(count) || count < 0 || count > Number.MAX_SAFE_INTEGER)) throw new Error('invalid')
+      return value as Record<string, number>
+    } catch { throw new DecisionProviderError('decision_usage_unavailable') }
+  }
+  private day(): string { return this.now().toISOString().slice(0, 10) }
+  private record(tokens: number): void {
+    try {
+      const ledger = this.ledger(); ledger[this.day()] = (ledger[this.day()] ?? 0) + tokens
+      mkdirSync(dirname(this.usageFile), { recursive: true, mode: 0o700 })
+      durableAtomicWriteFileSync(this.usageFile, JSON.stringify(ledger) + '\n', { mode: 0o600 })
+    } catch { throw new DecisionProviderError('decision_usage_unavailable') }
+  }
+  private fail(code: DecisionProviderError['code'], breaker = false): never {
+    if (breaker && ++this.failures >= SUBQ_LIMITS.breakerFailures) { this.breakerUntil = this.now().getTime() + SUBQ_LIMITS.breakerMs; this.failures = 0 }
+    throw new DecisionProviderError(code)
+  }
+  async ask(state: unknown, questions: Record<string, unknown>, _estimate: number, options: DecisionOptions = {}): Promise<JevAnswers> {
+    if (options.signal?.aborted) return this.fail('decision_cancelled')
+    const key = this.key(); if (!key) return this.fail('decision_not_configured')
+    if (this.breakerUntil > this.now().getTime()) return this.fail('decision_breaker_open')
+    const body = requestBody(state, questions, options.images)
+    // Reserve a conservative byte-based estimate, including encoded images, before concurrent requests can enter.
+    const estimate = Buffer.byteLength(body) + 1
+    if ((Number(this.ledger()[this.day()]) || 0) + this.reserved + estimate > this.cap()) return this.fail('decision_cap_reached')
+    this.reserved += estimate
+    try {
+      let res: Response
+      try { res = await this.fetchImpl(SUBQ_ENDPOINT, { method: 'POST', redirect: 'error', headers: { Authorization: `Bearer ${key}`, 'Content-Type': 'application/json' },
+        body, signal: AbortSignal.any([AbortSignal.timeout(this.timeoutMs), ...(options.signal ? [options.signal] : [])]) }) }
+      catch { this.record(estimate); return this.fail(options.signal?.aborted ? 'decision_cancelled' : 'decision_unavailable', !options.signal?.aborted) }
+      if (res.status === 401 || res.status === 403) return this.fail('decision_key_rejected')
+      if (res.status === 402) return this.fail('decision_credits_required')
+      if (res.status === 429) return this.fail('decision_rate_limited')
+      if ([400, 413, 422].includes(res.status)) return this.fail('decision_request_rejected')
+      if (!res.ok) return this.fail('decision_unavailable', true)
+      // Count conservative usage even when a successful response is unreadable. No raw provider error is echoed.
+      let raw: unknown
+      try { raw = await res.json() } catch { this.record(estimate); return this.fail('decision_bad_answer', true) }
+      const used = isRecord(raw) && isRecord(raw.usage) && typeof raw.usage.input_tokens === 'number' && Number.isFinite(raw.usage.input_tokens) && raw.usage.input_tokens > 0 ? raw.usage.input_tokens : estimate
+      this.record(used)
+      if (!isRecord(raw) || raw.model !== SUBQ_MODEL) return this.fail('decision_bad_answer', true)
+      let answers: JevAnswers['answers']
+      try { answers = validateDecisionAnswers(raw.answers, questions) } catch { return this.fail('decision_bad_answer', true) }
+      this.failures = 0
+      return { provider: 'subq', answers, model: SUBQ_MODEL, inputTokens: used }
+    } finally { this.reserved -= estimate }
+  }
+}
+
+const configuredSubqClients = new Set<SubqDecisionClient>()
+export function resetSubqDecisionClients(): void { configuredSubqClients.forEach(client => client.resetForNewKey()) }
+/** Snapshot selection per workflow request. Separate clients and cache identities prevent stale cross-provider answers. */
+export function createDecisionClient(useCase: DecisionUseCase, jev: Pick<JevClient, 'ask'> = new JevClient(), env: NodeJS.ProcessEnv = process.env): DecisionClient {
+  const clients: Partial<Record<DecisionProvider, DecisionClient>> = {}
+  const snapshot = (): DecisionClient => {
+    const selected = selectedDecisionProvider(useCase, env)
+    if (!clients[selected]) clients[selected] = selected === 'subq' ? new SubqDecisionClient(fetch, () => new Date(), dataPath(`subq-${useCase}-usage.json`)) : {
+      provider: 'jev', async ask(state, questions, estimate, options) {
+        if (options?.images?.length) throw new DecisionProviderError('decision_images_unsupported')
+        return { ...await jev.ask(state, questions, estimate, options), provider: 'jev' }
+      },
+    }
+    if (selected === 'subq') configuredSubqClients.add(clients[selected] as SubqDecisionClient)
+    return clients[selected]!
+  }
+  return { snapshot, ask: (state, questions, estimate, options) => snapshot().ask(state, questions, estimate, options) }
+}
+export function isDecisionFailure(error: unknown): error is JevError | DecisionProviderError { return error instanceof JevError || error instanceof DecisionProviderError }

package/server/lib/decision-settings.ts

@@ -0,0 +1,72 @@
+/** Private, durable classifier selection. No key storage or account/network changes. */
+import { createHash } from 'node:crypto'
+import { lstatSync, readFileSync } from 'node:fs'
+import { dirname } from 'node:path'
+import { dataPath } from './data-dir.js'
+import { durableAtomicWriteFileSync } from './atomic-fs.js'
+import { secureExistingPrivateFile, securePrivateDirectory } from './secure-user-config.js'
+
+export type DecisionProvider = 'jev' | 'subq'
+export const DECISION_WORKFLOWS = ['session', 'completion', 'search'] as const
+export type DecisionUseCase = typeof DECISION_WORKFLOWS[number]
+export interface DecisionSettings { schema: 1; provider?: DecisionProvider; overrides: Partial<Record<DecisionUseCase, DecisionProvider>> }
+export class DecisionSettingsError extends Error {
+  constructor(readonly code: 'invalid_decision_settings' | 'decision_settings_unavailable' | 'decision_invalid_provider' | 'decision_settings_conflict') { super(code) }
+}
+const record = (v: unknown): v is Record<string, unknown> => !!v && typeof v === 'object' && !Array.isArray(v)
+const provider = (v: unknown): v is DecisionProvider => v === 'jev' || v === 'subq'
+const settingsFile = () => dataPath('decision-provider.json')
+export function readDecisionSettings(file = settingsFile()): DecisionSettings {
+  // Only an absent directory entry means defaults. A dangling symlink or a file
+  // disappearing after this check must not silently change the selected provider.
+  try {
+    const stat = lstatSync(file)
+    if (stat.isSymbolicLink() || !stat.isFile()) throw new Error('unsafe')
+  } catch (e) {
+    if (e && typeof e === 'object' && 'code' in e && e.code === 'ENOENT') return { schema: 1, overrides: {} }
+    throw new DecisionSettingsError('decision_settings_unavailable')
+  }
+  try {
+    secureExistingPrivateFile(file)
+    const value = JSON.parse(readFileSync(file, 'utf8'))
+    if (!record(value) || value.schema !== 1 || !record(value.overrides) || Object.keys(value).some(k => !['schema','provider','overrides'].includes(k)) ||
+      (value.provider !== undefined && !provider(value.provider)) || Object.entries(value.overrides).some(([key,v]) => !DECISION_WORKFLOWS.includes(key as DecisionUseCase) || !provider(v))) throw new Error('invalid')
+    return value as unknown as DecisionSettings
+  } catch {
+    throw new DecisionSettingsError('decision_settings_unavailable')
+  }
+}
+export function decisionSettingsRevision(settings: DecisionSettings): string {
+  return createHash('sha256').update(JSON.stringify([settings.provider ?? null, ...DECISION_WORKFLOWS.map(w => settings.overrides[w] ?? null)])).digest('hex')
+}
+export function patchDecisionSettings(current: DecisionSettings, raw: unknown): DecisionSettings {
+  if (!record(raw) || !Object.keys(raw).length || Object.keys(raw).some(k => !['provider','overrides','expectedRevision'].includes(k)) || typeof raw.expectedRevision !== 'string' || !/^[a-f0-9]{64}$/.test(raw.expectedRevision) || (!('provider' in raw) && !('overrides' in raw)) ||
+    ('provider' in raw && raw.provider !== null && !provider(raw.provider)) ||
+    ('overrides' in raw && (!record(raw.overrides) || !Object.keys(raw.overrides).length || Object.entries(raw.overrides).some(([k,v]) => !DECISION_WORKFLOWS.includes(k as DecisionUseCase) || (v !== null && !provider(v)))))) {
+    throw new DecisionSettingsError('invalid_decision_settings')
+  }
+  if (raw.expectedRevision !== decisionSettingsRevision(current)) throw new DecisionSettingsError('decision_settings_conflict')
+  const next: DecisionSettings = { ...current, overrides: { ...current.overrides } }
+  if ('provider' in raw) { if (raw.provider === null) delete next.provider; else next.provider = raw.provider as DecisionProvider }
+  if (record(raw.overrides)) for (const [key,value] of Object.entries(raw.overrides)) {
+    if (value === null) delete next.overrides[key as DecisionUseCase]; else next.overrides[key as DecisionUseCase] = value as DecisionProvider
+  }
+  return next
+}
+export function writeDecisionSettings(next: DecisionSettings, file = settingsFile()): void {
+  securePrivateDirectory(dirname(file)); secureExistingPrivateFile(file)
+  durableAtomicWriteFileSync(file, JSON.stringify(next) + '\n', { mode: 0o600 })
+}
+export function resolveDecisionSelection(useCase: DecisionUseCase, env: NodeJS.ProcessEnv = process.env, settings = readDecisionSettings()): { provider: DecisionProvider; source: 'config' | 'env' | 'default' } {
+  const workflowEnv = env[`COS_DECISION_PROVIDER_${useCase.toUpperCase()}`]
+  const choice = settings.overrides[useCase] ?? workflowEnv ?? settings.provider ?? env.COS_DECISION_PROVIDER ?? 'jev'
+  const selected = choice.trim().toLowerCase()
+  if (!provider(selected)) throw new DecisionSettingsError('decision_invalid_provider')
+  return { provider: selected, source: settings.overrides[useCase] !== undefined ? 'config' : workflowEnv !== undefined ? 'env' : settings.provider !== undefined ? 'config' : env.COS_DECISION_PROVIDER !== undefined ? 'env' : 'default' }
+}
+export function decisionSettingsView(settings: DecisionSettings, configured: Record<DecisionProvider, boolean>, env: NodeJS.ProcessEnv = process.env) {
+  const global = resolveDecisionSelection('session', { COS_DECISION_PROVIDER: env.COS_DECISION_PROVIDER }, { schema: 1, provider: settings.provider, overrides: {} })
+  const selections = Object.fromEntries(DECISION_WORKFLOWS.map(w => [w, resolveDecisionSelection(w, env, settings)])) as Record<DecisionUseCase, ReturnType<typeof resolveDecisionSelection>>
+  return { schema: 1 as const, revision: decisionSettingsRevision(settings), provider: global.provider, overrides: settings.overrides, effective: Object.fromEntries(DECISION_WORKFLOWS.map(w => [w,selections[w].provider])),
+    sources: Object.fromEntries(DECISION_WORKFLOWS.map(w => [w,selections[w].source])), configured, saved: { provider: settings.provider ?? null, overrides: settings.overrides } }
+}

package/server/lib/glossary-learn.ts

@@ -0,0 +1,221 @@
+// One-word dictionary learning (6.73.11). "Fix a word" in COS Control, and any
+// other surface, teaches ONE correction at a time: heard → written joins the
+// corrections map and `written` joins the vocabulary, in one write. Every learn
+// is logged (bounded, newest first) so the person can see what COS learned, from
+// where, and undo exactly that one entry.
+//
+// Pure: no IO. The route in routes/glossary.ts reads the profile and the log,
+// calls these, and writes both back inside the glossary write chain.
+
+export const MAX_TERMS = 500
+export const MAX_TERM_LEN = 100
+export const MAX_LOG = 200
+export const CORRECTION_SOURCES = ['dictation', 'meeting', 'g2', 'manual'] as const
+export type CorrectionSource = typeof CORRECTION_SOURCES[number]
+
+export interface GlossaryWords {
+  vocabulary: string[]
+  corrections: Record<string, string>
+}
+
+export interface CorrectionLogEntry {
+  id: string
+  heard: string
+  written: string
+  source: CorrectionSource
+  at: string
+  /** The existing key this entry replaced (a case variant of `heard`, or `heard` itself), or null. */
+  replacedKey: string | null
+  /** What `replacedKey` mapped to before this entry, or null. */
+  previous: string | null
+  /** True when this entry put `written` into the vocabulary. */
+  addedVocabulary: boolean
+}
+
+export type LearnResult =
+  | { ok: true; unchanged: true }
+  | { ok: true; unchanged: false; words: GlossaryWords; entry: CorrectionLogEntry }
+  | { ok: false; status: number; error: string }
+
+export type UndoResult =
+  | { ok: true; words: GlossaryWords; log: CorrectionLogEntry[]; entry: CorrectionLogEntry }
+  | { ok: false; status: number; error: string }
+
+// Positive vocab is injected into the Whisper decoder prompt; URLs/emails/paths
+// there induce ".com"/handle hallucinations on quiet audio, so they are refused.
+export function looksLikeUrlEmailPath(s: string): boolean {
+  return /(?:https?:\/\/|www\.)/i.test(s)
+    || /@[\w.-]+\.\w/.test(s)
+    || /\.(?:com|net|org|io|ai|co|gov|edu|app|dev)\b/i.test(s)
+    || /[/\\]/.test(s)
+}
+
+const CONTROL = /[\u0000-\u001f\u007f]/
+const same = (a: string, b: string) => a.trim().toLowerCase() === b.trim().toLowerCase()
+
+export function isCorrectionSource(value: unknown): value is CorrectionSource {
+  return typeof value === 'string' && (CORRECTION_SOURCES as readonly string[]).includes(value)
+}
+
+export function learnCorrection(
+  words: GlossaryWords,
+  input: { heard: unknown; written: unknown; source: unknown },
+  stamp: { id: string; at: string },
+): LearnResult {
+  if (typeof input.heard !== 'string' || typeof input.written !== 'string') {
+    return { ok: false, status: 400, error: 'heard and written must be strings' }
+  }
+  if (!isCorrectionSource(input.source)) {
+    return { ok: false, status: 400, error: `source must be one of ${CORRECTION_SOURCES.join(', ')}` }
+  }
+  const heard = input.heard.trim()
+  const written = input.written.trim()
+  if (!heard || !written) return { ok: false, status: 400, error: 'heard and written must not be empty' }
+  if (heard.length > MAX_TERM_LEN || written.length > MAX_TERM_LEN) {
+    return { ok: false, status: 400, error: `a correction is at most ${MAX_TERM_LEN} characters` }
+  }
+  if (CONTROL.test(heard) || CONTROL.test(written)) {
+    return { ok: false, status: 400, error: 'a correction cannot contain line breaks or control characters' }
+  }
+  if (heard === written) return { ok: false, status: 400, error: 'the written spelling is the same as what was heard' }
+  if (looksLikeUrlEmailPath(written)) {
+    return { ok: false, status: 400, error: 'the written spelling cannot be a URL, email or path; it would join the decoder prompt' }
+  }
+
+  const existingKey = Object.keys(words.corrections).find(key => same(key, heard)) ?? null
+  const correctionChanged = existingKey !== heard || words.corrections[heard] !== written
+  const inVocabulary = words.vocabulary.some(term => same(term, written))
+  if (!correctionChanged && inVocabulary) return { ok: true, unchanged: true }
+
+  if (existingKey === null && Object.keys(words.corrections).length >= MAX_TERMS) {
+    return { ok: false, status: 409, error: `the dictionary already holds ${MAX_TERMS} corrections; remove one first` }
+  }
+  if (!inVocabulary && words.vocabulary.length >= MAX_TERMS) {
+    return { ok: false, status: 409, error: `the vocabulary already holds ${MAX_TERMS} terms; remove one first` }
+  }
+
+  const corrections = { ...words.corrections }
+  if (existingKey !== null && existingKey !== heard) delete corrections[existingKey]
+  corrections[heard] = written
+  const vocabulary = inVocabulary ? [...words.vocabulary] : [...words.vocabulary, written]
+  const entry: CorrectionLogEntry = {
+    id: stamp.id,
+    heard,
+    written,
+    source: input.source,
+    at: stamp.at,
+    replacedKey: existingKey,
+    previous: existingKey === null ? null : words.corrections[existingKey],
+    addedVocabulary: !inVocabulary,
+  }
+  return { ok: true, unchanged: false, words: { vocabulary, corrections }, entry }
+}
+
+/** Newest first, bounded. */
+export function appendLog(log: CorrectionLogEntry[], entry: CorrectionLogEntry): CorrectionLogEntry[] {
+  return [entry, ...log].slice(0, MAX_LOG)
+}
+
+/**
+ * Revert exactly one logged entry, and only while the dictionary still says
+ * what that entry wrote. A later entry for the same word, or a hand edit since,
+ * makes the undo refuse rather than clobber the newer choice.
+ */
+export function undoCorrection(words: GlossaryWords, log: CorrectionLogEntry[], id: unknown): UndoResult {
+  if (typeof id !== 'string' || !id) return { ok: false, status: 400, error: 'id is required' }
+  const index = log.findIndex(entry => entry.id === id)
+  if (index < 0) return { ok: false, status: 404, error: 'that correction is no longer in the recent list' }
+  const entry = log[index]
+  if (log.slice(0, index).some(newer => same(newer.heard, entry.heard))) {
+    return { ok: false, status: 409, error: `a newer correction changed "${entry.heard}"; undo that one first` }
+  }
+  if (words.corrections[entry.heard] !== entry.written) {
+    return { ok: false, status: 409, error: `"${entry.heard}" was changed since; edit it in the dictionary instead` }
+  }
+  const corrections = { ...words.corrections }
+  delete corrections[entry.heard]
+  if (entry.replacedKey !== null && entry.previous !== null) {
+    const collision = Object.keys(corrections).some(key => same(key, entry.replacedKey!))
+    if (collision) return { ok: false, status: 409, error: `"${entry.replacedKey}" was changed since; edit it in the dictionary instead` }
+    corrections[entry.replacedKey] = entry.previous
+  }
+  let vocabulary = [...words.vocabulary]
+  // The spelling stays while any remaining correction still writes it.
+  if (entry.addedVocabulary && !Object.values(corrections).some(value => same(value, entry.written))) {
+    vocabulary = vocabulary.filter(term => !same(term, entry.written))
+  }
+  return { ok: true, words: { vocabulary, corrections }, log: log.filter((_, i) => i !== index), entry }
+}
+
+/** Tolerant reader: a missing or corrupt log is an empty one; malformed rows are dropped. */
+export function parseLog(raw: unknown): CorrectionLogEntry[] {
+  const entries = raw && typeof raw === 'object' && Array.isArray((raw as { entries?: unknown }).entries)
+    ? (raw as { entries: unknown[] }).entries : []
+  const out: CorrectionLogEntry[] = []
+  for (const value of entries) {
+    if (!value || typeof value !== 'object') continue
+    const e = value as Record<string, unknown>
+    if (typeof e.id !== 'string' || typeof e.heard !== 'string' || typeof e.written !== 'string'
+      || !isCorrectionSource(e.source) || typeof e.at !== 'string' || typeof e.addedVocabulary !== 'boolean') continue
+    const replacedKey = typeof e.replacedKey === 'string' ? e.replacedKey : null
+    const previous = typeof e.previous === 'string' ? e.previous : null
+    out.push({ id: e.id, heard: e.heard, written: e.written, source: e.source, at: e.at, replacedKey, previous, addedVocabulary: e.addedVocabulary })
+    if (out.length >= MAX_LOG) break
+  }
+  return out
+}
+
+// ── Single-item edits (6.73.12) ──────────────────────────────────────────────
+// COS Control's Dictionary pane adds or removes ONE word or correction. Each is a
+// pure step over the stored words, run inside the glossary write chain, so a
+// concurrent learn can never be lost the way a client read-then-PUT could lose it.
+// These are hand edits; they are not logged for undo.
+
+export type EditResult =
+  | { ok: true; unchanged: true }
+  | { ok: true; unchanged: false; words: GlossaryWords }
+  | { ok: false; status: number; error: string }
+
+function validTerm(raw: unknown, what: string): { ok: true; value: string } | { ok: false; status: number; error: string } {
+  if (typeof raw !== 'string') return { ok: false, status: 400, error: `${what} must be a string` }
+  const value = raw.trim()
+  if (!value) return { ok: false, status: 400, error: `${what} must not be empty` }
+  if (value.length > MAX_TERM_LEN) return { ok: false, status: 400, error: `${what} is at most ${MAX_TERM_LEN} characters` }
+  if (CONTROL.test(value)) return { ok: false, status: 400, error: `${what} cannot contain line breaks or control characters` }
+  return { ok: true, value }
+}
+
+export function addVocabulary(words: GlossaryWords, raw: unknown): EditResult {
+  const term = validTerm(raw, 'term')
+  if (!term.ok) return term
+  if (looksLikeUrlEmailPath(term.value)) {
+    return { ok: false, status: 400, error: 'a vocabulary word cannot be a URL, email or path; it would join the decoder prompt' }
+  }
+  if (words.vocabulary.some(existing => same(existing, term.value))) return { ok: true, unchanged: true }
+  if (words.vocabulary.length >= MAX_TERMS) {
+    return { ok: false, status: 409, error: `the vocabulary already holds ${MAX_TERMS} terms; remove one first` }
+  }
+  return { ok: true, unchanged: false, words: { vocabulary: [...words.vocabulary, term.value], corrections: { ...words.corrections } } }
+}
+
+/** Removes the exact word; a word that is not there is not an error. */
+export function removeVocabulary(words: GlossaryWords, raw: unknown): EditResult {
+  const term = validTerm(raw, 'term')
+  if (!term.ok) return term
+  const vocabulary = words.vocabulary.filter(existing => existing.trim() !== term.value)
+  if (vocabulary.length === words.vocabulary.length) return { ok: true, unchanged: true }
+  return { ok: true, unchanged: false, words: { vocabulary, corrections: { ...words.corrections } } }
+}
+
+/** Removes the correction for `heard` (its exact key, else its one case variant). */
+export function removeCorrection(words: GlossaryWords, raw: unknown): EditResult {
+  const heard = validTerm(raw, 'heard')
+  if (!heard.ok) return heard
+  const key = heard.value in words.corrections
+    ? heard.value
+    : Object.keys(words.corrections).find(existing => same(existing, heard.value))
+  if (key === undefined) return { ok: true, unchanged: true }
+  const corrections = { ...words.corrections }
+  delete corrections[key]
+  return { ok: true, unchanged: false, words: { vocabulary: [...words.vocabulary], corrections } }
+}