@gotcos/glasses-server 6.75.0 → 6.77.0

package/server/lib/transcript-cleanup-state.ts

@@ -0,0 +1,201 @@
+// Transcript cleanup (6.77.0): how it is switched on, which model it uses, and how it stops.
+//
+// SWITCH. Its own flag, nothing shared:
+//   1. env COS_TRANSCRIPT_CLEANUP=1 forces it on, =0 forces it off (source 'env'); a
+//      request to change it then answers 409 env_forced.
+//   2. the saved setting (transcript-cleanup/settings.json, atomic), which COS Control's
+//      toggle writes through POST /api/transcript-cleanup/settings (source 'setting').
+//   3. off (source 'default'). Miles turns it on.
+// An unreadable settings file reads as no setting: it fails toward off, never toward spending.
+//
+// MODEL. Haiku unless the setting or env COS_TRANSCRIPT_CLEANUP_MODEL says sonnet. Always a
+// pinned model id, never the CLI default (a bare `claude -p` can resolve to Opus).
+//
+// STOPS (each one a recorded skip, correction_skipped style):
+//   switch_off       nothing runs at all: no fuzzy pass, no file, no trace
+//   api_key_in_env   ANTHROPIC_API_KEY is set and COS_ALLOW_API_FALLBACK is not 1: the CLI
+//                    would bill the API key, not the plan
+//   claude_not_found no Claude CLI
+//   daily_calls      COS_TRANSCRIPT_CLEANUP_DAILY calls today (default 30), charged BEFORE
+//                    the call and never refunded
+//   daily_tokens     COS_TRANSCRIPT_CLEANUP_DAILY_TOKENS today (default 400k in plus out)
+//   breaker_open     3 failures in a row, or one provider limit, open it for 30 minutes
+//                    (60 after a limit); the first meeting after that is one trial call
+// Per meeting: one call, at most COS_TRANSCRIPT_CLEANUP_MAX_SPANS spans (default 40, hard
+// 80), a 24k-character prompt and a 1,500-token answer. The day is the local calendar day.
+// An unreadable or impossible state file reads as a spent day, so a corrupt ledger can
+// stop spending but never start it.
+
+import { existsSync, mkdirSync, readFileSync } from 'node:fs'
+import { dirname } from 'node:path'
+import { durableAtomicWriteFileSync } from './atomic-fs.js'
+import { cleanupDir } from './transcript-cleanup-screen.js'
+import { CLEANUP_MODEL_IDS, type CleanupModelChoice } from './transcript-cleanup-model.js'
+import { SPAN_LIMITS } from './transcript-cleanup-spans.js'
+
+export type CleanupSettingSource = 'env' | 'setting' | 'default'
+export interface StoredCleanupSettings { enabled: boolean | null; model: CleanupModelChoice | null }
+
+export class TranscriptCleanupSettings {
+  private cache: StoredCleanupSettings | null = null
+  constructor(readonly file: string = cleanupDir('settings.json')) {}
+
+  stored(): StoredCleanupSettings {
+    if (this.cache) return this.cache
+    let value: StoredCleanupSettings = { enabled: null, model: null }
+    try {
+      if (existsSync(this.file)) {
+        const raw = JSON.parse(readFileSync(this.file, 'utf8')) as Record<string, unknown>
+        if (raw && typeof raw === 'object' && !Array.isArray(raw)) {
+          value = {
+            enabled: typeof raw.enabled === 'boolean' ? raw.enabled : null,
+            model: raw.model === 'haiku' || raw.model === 'sonnet' ? raw.model : null,
+          }
+        }
+      }
+    } catch { value = { enabled: null, model: null } }
+    this.cache = value
+    return value
+  }
+
+  /** Atomic and durable; the cached value changes only after the write. */
+  save(patch: Partial<{ enabled: boolean; model: CleanupModelChoice }>, now: Date = new Date()): StoredCleanupSettings {
+    const current = this.stored()
+    const next: StoredCleanupSettings = {
+      enabled: patch.enabled ?? current.enabled,
+      model: patch.model ?? current.model,
+    }
+    mkdirSync(dirname(this.file), { recursive: true, mode: 0o700 })
+    durableAtomicWriteFileSync(this.file, JSON.stringify({ schema: 1, ...next, updatedAt: now.toISOString() }) + '\n', { mode: 0o600 })
+    this.cache = next
+    return next
+  }
+}
+
+export function resolveCleanupSwitch(env: NodeJS.ProcessEnv, settings: TranscriptCleanupSettings | null): { enabled: boolean; source: CleanupSettingSource } {
+  if (env.COS_TRANSCRIPT_CLEANUP === '1') return { enabled: true, source: 'env' }
+  if (env.COS_TRANSCRIPT_CLEANUP === '0') return { enabled: false, source: 'env' }
+  let stored: boolean | null = null
+  try { stored = settings ? settings.stored().enabled : null } catch { stored = null }
+  if (stored !== null) return { enabled: stored, source: 'setting' }
+  return { enabled: false, source: 'default' }
+}
+
+export function resolveCleanupModel(env: NodeJS.ProcessEnv, settings: TranscriptCleanupSettings | null): { choice: CleanupModelChoice; id: string; source: CleanupSettingSource } {
+  const raw = (env.COS_TRANSCRIPT_CLEANUP_MODEL ?? '').trim().toLowerCase()
+  if (raw === 'haiku' || raw === 'sonnet') return { choice: raw, id: CLEANUP_MODEL_IDS[raw], source: 'env' }
+  let stored: CleanupModelChoice | null = null
+  try { stored = settings ? settings.stored().model : null } catch { stored = null }
+  if (stored) return { choice: stored, id: CLEANUP_MODEL_IDS[stored], source: 'setting' }
+  return { choice: 'haiku', id: CLEANUP_MODEL_IDS.haiku, source: 'default' }
+}
+
+function intEnv(env: NodeJS.ProcessEnv, name: string, fallback: number, max: number): number {
+  const raw = Number(env[name])
+  return Number.isFinite(raw) && raw >= 0 ? Math.min(Math.floor(raw), max) : fallback
+}
+
+export interface CleanupLimits { dailyCalls: number; dailyTokens: number; maxSpans: number; breakerFailures: number; breakerCooldownMs: number; limitCooldownMs: number }
+export function cleanupLimits(env: NodeJS.ProcessEnv = process.env): CleanupLimits {
+  return {
+    dailyCalls: intEnv(env, 'COS_TRANSCRIPT_CLEANUP_DAILY', 30, 500),
+    dailyTokens: intEnv(env, 'COS_TRANSCRIPT_CLEANUP_DAILY_TOKENS', 400_000, 10_000_000),
+    maxSpans: Math.max(1, intEnv(env, 'COS_TRANSCRIPT_CLEANUP_MAX_SPANS', SPAN_LIMITS.defaultMaxSpans, SPAN_LIMITS.hardMaxSpans)),
+    breakerFailures: 3,
+    breakerCooldownMs: 30 * 60_000,
+    limitCooldownMs: 60 * 60_000,
+  }
+}
+
+export interface BudgetState {
+  day: string
+  calls: number
+  tokens: number
+  consecutiveFailures: number
+  breakerOpenUntil: number | null
+}
+
+export function localDay(now: Date): string {
+  return now.toLocaleDateString('en-CA')
+}
+
+/** The day's spend and the breaker. One small JSON file, rewritten atomically on every change. */
+export class TranscriptCleanupBudget {
+  constructor(readonly file: string = cleanupDir('state.json'), private readonly now: () => Date = () => new Date()) {}
+
+  read(): BudgetState {
+    const day = localDay(this.now())
+    const spent: BudgetState = { day, calls: Number.MAX_SAFE_INTEGER, tokens: Number.MAX_SAFE_INTEGER, consecutiveFailures: 0, breakerOpenUntil: null }
+    try {
+      if (!existsSync(this.file)) return { day, calls: 0, tokens: 0, consecutiveFailures: 0, breakerOpenUntil: null }
+      const raw = JSON.parse(readFileSync(this.file, 'utf8')) as Partial<BudgetState>
+      if (!raw || typeof raw !== 'object' || typeof raw.day !== 'string') return spent
+      const failures = Number(raw.consecutiveFailures ?? 0)
+      const openUntil = raw.breakerOpenUntil === null || raw.breakerOpenUntil === undefined ? null : Number(raw.breakerOpenUntil)
+      const breaker = { consecutiveFailures: Number.isFinite(failures) && failures >= 0 ? failures : 0, breakerOpenUntil: openUntil !== null && Number.isFinite(openUntil) ? openUntil : null }
+      // A future day key or a negative count fails toward NOT spending.
+      if (raw.day > day) return { ...spent, ...breaker }
+      if (raw.day < day) return { day, calls: 0, tokens: 0, ...breaker }
+      const calls = Number(raw.calls), tokens = Number(raw.tokens)
+      if (!(calls >= 0) || !(tokens >= 0)) return { ...spent, ...breaker }
+      return { day, calls, tokens, ...breaker }
+    } catch {
+      return spent
+    }
+  }
+
+  private write(state: BudgetState): void {
+    mkdirSync(dirname(this.file), { recursive: true, mode: 0o700 })
+    durableAtomicWriteFileSync(this.file, JSON.stringify(state) + '\n', { mode: 0o600 })
+  }
+
+  /** Why a call may not run now, or null. Read-only. */
+  gate(limits: CleanupLimits): 'daily_calls' | 'daily_tokens' | 'breaker_open' | null {
+    const s = this.read()
+    if (s.breakerOpenUntil !== null && this.now().getTime() < s.breakerOpenUntil) return 'breaker_open'
+    if (s.calls >= limits.dailyCalls) return 'daily_calls'
+    if (s.tokens >= limits.dailyTokens) return 'daily_tokens'
+    return null
+  }
+
+  /** Charge one call BEFORE it runs. False when the day is spent. */
+  charge(limits: CleanupLimits): boolean {
+    const s = this.read()
+    if (s.calls >= limits.dailyCalls || s.tokens >= limits.dailyTokens) return false
+    this.write({ ...s, calls: s.calls + 1 })
+    return true
+  }
+
+  recordUsage(tokens: number): void {
+    const s = this.read()
+    if (s.tokens === Number.MAX_SAFE_INTEGER) return
+    this.write({ ...s, tokens: s.tokens + Math.max(0, Math.round(tokens)) })
+  }
+
+  recordSuccess(): void {
+    const s = this.read()
+    if (s.consecutiveFailures === 0 && s.breakerOpenUntil === null) return
+    this.write({ ...s, consecutiveFailures: 0, breakerOpenUntil: null })
+  }
+
+  /** Returns true when this failure opened the breaker. */
+  recordFailure(limits: CleanupLimits, providerLimit: boolean): boolean {
+    const s = this.read()
+    const failures = s.consecutiveFailures + 1
+    const open = providerLimit || failures >= limits.breakerFailures
+    const until = open ? this.now().getTime() + (providerLimit ? limits.limitCooldownMs : limits.breakerCooldownMs) : s.breakerOpenUntil
+    this.write({ ...s, consecutiveFailures: failures, breakerOpenUntil: until })
+    return open
+  }
+}
+
+let settingsSingleton: TranscriptCleanupSettings | null = null
+let budgetSingleton: TranscriptCleanupBudget | null = null
+export function transcriptCleanupSettings(): TranscriptCleanupSettings {
+  if (!settingsSingleton) settingsSingleton = new TranscriptCleanupSettings()
+  return settingsSingleton
+}
+export function transcriptCleanupBudget(): TranscriptCleanupBudget {
+  if (!budgetSingleton) budgetSingleton = new TranscriptCleanupBudget()
+  return budgetSingleton
+}

package/server/lib/transcript-cleanup-suggestions.ts

@@ -0,0 +1,126 @@
+// Dictionary suggestions from transcript cleanup (6.77.0).
+//
+// When a cleanup edit is accepted and what it wrote is a term this meeting's CONTEXT
+// supplied (a screen line, a dropped file, the owner card, COS people, a notes hit) and
+// the dictionary does not already hold it, COS records a SUGGESTION: the written form,
+// the heard forms, and where the evidence came from. Never an automatic addition. A
+// person accepts it (the word joins the profile vocabulary through the glossary's own
+// writer, optionally with its heard form as a logged, undoable correction) or dismisses
+// it (that written form is never suggested again).
+//
+// One file, `transcript-cleanup/suggestions.json`, rewritten atomically. Deduped by the
+// written form, case-insensitive. Bounded: 200 suggestions, 5 heard forms and 5 evidence
+// rows each; accepted and dismissed ones are evicted before pending ones. Evidence rows
+// carry ids, a file or app name and a time, never transcript or screen text.
+
+import { existsSync, mkdirSync, readFileSync } from 'node:fs'
+import { dirname } from 'node:path'
+import { randomBytes } from 'node:crypto'
+import { durableAtomicWriteFileSync } from './atomic-fs.js'
+import { cleanupDir } from './transcript-cleanup-screen.js'
+import type { EvidenceSource } from './transcript-cleanup-context.js'
+
+export const SUGGESTION_LIMITS = { suggestions: 200, heard: 5, evidence: 5 } as const
+export const SUGGESTION_ID = /^sug_[0-9a-f]{16}$/
+
+export interface SuggestionEvidence {
+  source: EvidenceSource
+  sessionId: string
+  heard: string
+  at: string
+  detail: string | null
+}
+
+export interface DictionarySuggestion {
+  id: string
+  written: string
+  heard: string[]
+  status: 'pending' | 'accepted' | 'dismissed'
+  count: number
+  createdAt: string
+  updatedAt: string
+  evidence: SuggestionEvidence[]
+}
+
+const same = (a: string, b: string) => a.trim().toLowerCase() === b.trim().toLowerCase()
+
+export class SuggestionStore {
+  constructor(readonly file: string = cleanupDir('suggestions.json')) {}
+
+  list(): DictionarySuggestion[] {
+    try {
+      if (!existsSync(this.file)) return []
+      const raw = JSON.parse(readFileSync(this.file, 'utf8')) as { suggestions?: unknown }
+      if (!raw || !Array.isArray(raw.suggestions)) return []
+      return raw.suggestions.filter((s): s is DictionarySuggestion => !!s && typeof s === 'object'
+        && typeof (s as DictionarySuggestion).id === 'string' && typeof (s as DictionarySuggestion).written === 'string'
+        && ['pending', 'accepted', 'dismissed'].includes((s as DictionarySuggestion).status)
+        && Array.isArray((s as DictionarySuggestion).heard) && Array.isArray((s as DictionarySuggestion).evidence))
+    } catch {
+      return []
+    }
+  }
+
+  private write(list: DictionarySuggestion[]): void {
+    mkdirSync(dirname(this.file), { recursive: true, mode: 0o700 })
+    durableAtomicWriteFileSync(this.file, JSON.stringify({ schema: 1, suggestions: list }, null, 2) + '\n', { mode: 0o600 })
+  }
+
+  get(id: string): DictionarySuggestion | null {
+    return this.list().find(s => s.id === id) ?? null
+  }
+
+  /**
+   * Record one piece of evidence for a written form. Returns the suggestion, or null when
+   * nothing was recorded: no evidence, the form is already in the dictionary, or it was
+   * dismissed before.
+   */
+  record(input: { written: string; heard: string; evidence: Array<{ source: EvidenceSource; detail: string | null }>; sessionId: string; at: string; inDictionary: (written: string) => boolean }): DictionarySuggestion | null {
+    const written = input.written.replace(/\s+/g, ' ').trim()
+    if (!written || written.length > 100 || !input.evidence.length) return null
+    if (input.inDictionary(written)) return null
+    const list = this.list()
+    const existing = list.find(s => same(s.written, written))
+    if (existing && existing.status !== 'pending') return null
+    const rows: SuggestionEvidence[] = input.evidence.map(e => ({ source: e.source, sessionId: input.sessionId, heard: input.heard.slice(0, 100), at: input.at, detail: e.detail }))
+    let out: DictionarySuggestion
+    if (existing) {
+      if (!existing.heard.some(h => same(h, input.heard)) && existing.heard.length < SUGGESTION_LIMITS.heard) existing.heard.push(input.heard.slice(0, 100))
+      for (const row of rows) {
+        const dup = existing.evidence.some(e => e.source === row.source && e.sessionId === row.sessionId && same(e.heard, row.heard))
+        if (!dup && existing.evidence.length < SUGGESTION_LIMITS.evidence) existing.evidence.push(row)
+      }
+      existing.count += 1
+      existing.updatedAt = input.at
+      out = existing
+    } else {
+      out = { id: `sug_${randomBytes(8).toString('hex')}`, written, heard: [input.heard.slice(0, 100)], status: 'pending', count: 1, createdAt: input.at, updatedAt: input.at, evidence: rows.slice(0, SUGGESTION_LIMITS.evidence) }
+      list.push(out)
+    }
+    this.write(evict(list))
+    return out
+  }
+
+  setStatus(id: string, status: 'accepted' | 'dismissed', at: string): DictionarySuggestion | null {
+    const list = this.list()
+    const s = list.find(x => x.id === id)
+    if (!s) return null
+    s.status = status
+    s.updatedAt = at
+    this.write(list)
+    return s
+  }
+}
+
+function evict(list: DictionarySuggestion[]): DictionarySuggestion[] {
+  if (list.length <= SUGGESTION_LIMITS.suggestions) return list
+  const ordered = [...list].sort((a, b) => (a.status === 'pending' ? 1 : 0) - (b.status === 'pending' ? 1 : 0) || a.updatedAt.localeCompare(b.updatedAt))
+  const drop = new Set(ordered.slice(0, list.length - SUGGESTION_LIMITS.suggestions).map(s => s.id))
+  return list.filter(s => !drop.has(s.id))
+}
+
+let singleton: SuggestionStore | null = null
+export function suggestionStore(): SuggestionStore {
+  if (!singleton) singleton = new SuggestionStore()
+  return singleton
+}

package/server/lib/transcript-cleanup-text.ts

@@ -0,0 +1,200 @@
+// Transcript cleanup (6.77.0): the text model every other cleanup module shares.
+//
+// A saved meeting's `## Transcript` section is lines of `[Label]: words`. Cleanup only
+// ever edits the WORDS of a line, never its label, never a line it cannot parse, and
+// never across a line break: a speaker turn is the largest unit an edit can touch.
+//
+// Tokens are whitespace runs inside a line's text. Each carries its `core`: the token
+// without leading and trailing punctuation, which is what is compared, flagged and
+// replaced, so "Ukoma," becomes "Ukaoma," and the comma stays exactly where it was.
+//
+// No IO and no model here.
+
+import { levenshtein } from './fuzzy-correct.js'
+
+export interface TranscriptLine {
+  index: number
+  /** `[Label]: ` including the trailing space, or '' for a line without a label. */
+  prefix: string
+  label: string | null
+  text: string
+  /** False for blank lines and anything that is not a speaker turn. Never edited. */
+  editable: boolean
+}
+
+export interface Token {
+  /** Position in the flat token list. */
+  i: number
+  line: number
+  /** Offsets of the core inside `line.text`. */
+  start: number
+  end: number
+  raw: string
+  core: string
+  key: string
+  /** First token of its line, or after a sentence end. */
+  sentenceStart: boolean
+  probability?: number
+  /** Epoch ms of the word, when the batch words could be aligned. */
+  atMs?: number
+  engine?: string
+}
+
+const LINE = /^\[([^\]\n]{1,80})\]: ?(.*)$/
+
+export function parseTranscriptLines(section: string): TranscriptLine[] {
+  return section.split('\n').map((raw, index) => {
+    const m = LINE.exec(raw)
+    if (!m) return { index, prefix: '', label: null, text: raw, editable: false }
+    const prefix = raw.slice(0, raw.length - m[2].length)
+    return { index, prefix, label: m[1], text: m[2], editable: m[2].trim().length > 0 }
+  })
+}
+
+export function joinTranscriptLines(lines: readonly TranscriptLine[]): string {
+  return lines.map(line => line.prefix + line.text).join('\n')
+}
+
+/** Letters and digits only, accents folded, lowercase. The comparison form of a word. */
+export function fold(word: string): string {
+  return word.normalize('NFKD').replace(/\p{M}/gu, '').toLowerCase().replace(/[^\p{L}\p{N}]/gu, '')
+}
+
+const EDGE = /^[^\p{L}\p{N}]+|[^\p{L}\p{N}]+$/gu
+
+export function tokenize(lines: readonly TranscriptLine[]): Token[] {
+  const out: Token[] = []
+  for (const line of lines) {
+    if (!line.editable) continue
+    let sentenceStart = true
+    for (const m of line.text.matchAll(/\S+/g)) {
+      const raw = m[0]
+      const at = m.index ?? 0
+      const lead = /^[^\p{L}\p{N}]*/u.exec(raw)![0].length
+      const core = raw.replace(EDGE, '')
+      const start = at + lead
+      out.push({ i: out.length, line: line.index, start, end: start + core.length, raw, core, key: fold(core), sentenceStart })
+      sentenceStart = /[.!?]["')\]]*$/.test(raw)
+    }
+  }
+  return out
+}
+
+/** One spoken word from the batch decode, placed on the meeting clock. */
+export interface WordInfo {
+  word: string
+  probability?: number
+  atMs?: number
+  engine?: string
+}
+
+/**
+ * The batch words of a saved meeting, in transcript order, from its `.g2-chunks.json`
+ * sidecar. A segment's word times are seconds from that window's start; the window
+ * starts at `startElapsed` on the meeting clock (the same convention
+ * mapWordsToSpeakers uses), and the meeting started at `startTime` (epoch ms).
+ */
+export function wordInfoFromSidecar(sidecar: Record<string, unknown>): WordInfo[] {
+  const segments = Array.isArray(sidecar.batchSegments) ? sidecar.batchSegments : []
+  const startTime = typeof sidecar.startTime === 'number' && Number.isFinite(sidecar.startTime) ? sidecar.startTime : null
+  const out: WordInfo[] = []
+  for (const raw of segments) {
+    if (!raw || typeof raw !== 'object') continue
+    const segment = raw as { words?: unknown; startElapsed?: unknown; stt?: { engine?: unknown } }
+    const words = Array.isArray(segment.words) ? segment.words : []
+    const startElapsed = typeof segment.startElapsed === 'number' && Number.isFinite(segment.startElapsed) ? segment.startElapsed : null
+    const engine = typeof segment.stt?.engine === 'string' ? segment.stt.engine : undefined
+    for (const w of words) {
+      if (!w || typeof w !== 'object') continue
+      const word = typeof (w as { word?: unknown }).word === 'string' ? (w as { word: string }).word.trim() : ''
+      if (!word) continue
+      const p = (w as { probability?: unknown }).probability
+      const s = (w as { start?: unknown }).start
+      const atMs = startTime !== null && startElapsed !== null && typeof s === 'number' && Number.isFinite(s)
+        ? Math.round(startTime + startElapsed + s * 1000) : undefined
+      out.push({
+        word,
+        ...(typeof p === 'number' && Number.isFinite(p) ? { probability: p } : {}),
+        ...(atMs !== undefined ? { atMs } : {}),
+        ...(engine ? { engine } : {}),
+      })
+    }
+  }
+  return out
+}
+
+/** How far ahead the aligner looks for a transcript token among the batch words. */
+export const ALIGN_LOOKAHEAD = 40
+
+/**
+ * Attach probability, time and engine to the tokens the batch words produced.
+ *
+ * The saved transcript IS those words (selectBatchTranscriptForPersistence joins
+ * them; the hallucination line filter may drop a line; Nemotron only relabels), so
+ * a greedy forward match finds them in order. A token with no match within the
+ * lookahead stays unaligned: it simply carries no confidence, which can only make
+ * cleanup look at it less, never more.
+ */
+export function alignWordInfo(tokens: Token[], words: readonly WordInfo[]): number {
+  let j = 0
+  let aligned = 0
+  for (const token of tokens) {
+    const limit = Math.min(words.length, j + ALIGN_LOOKAHEAD)
+    let hit = -1
+    for (let k = j; k < limit; k++) {
+      if (words[k].word === token.raw || fold(words[k].word) === token.key) { hit = k; break }
+    }
+    if (hit < 0) continue
+    const w = words[hit]
+    if (w.probability !== undefined) token.probability = w.probability
+    if (w.atMs !== undefined) token.atMs = w.atMs
+    if (w.engine) token.engine = w.engine
+    aligned++
+    j = hit + 1
+  }
+  return aligned
+}
+
+/**
+ * A consonant skeleton: how a word sounds with its vowels unsure. Ukaoma, Yukoma,
+ * eucoma and "U coma" all read "km". Only ever used together with an onset check and
+ * a length bound, because a two-letter skeleton alone matches far too much.
+ */
+export function skeleton(word: string): string {
+  let s = fold(word).replace(/[0-9]/g, '')
+  s = s.replace(/ph/g, 'f').replace(/ck/g, 'k').replace(/c(?=[eiy])/g, 's').replace(/c/g, 'k').replace(/q/g, 'k')
+    .replace(/x/g, 'ks').replace(/z/g, 's').replace(/dg/g, 'j')
+  s = s.replace(/[aeiouy]/g, '')
+  return s.replace(/(.)\1+/g, '$1')
+}
+
+/** Vowel onset, counting a leading y before a vowel ("Yukoma") as a vowel. */
+export function vowelOnset(word: string): boolean {
+  const f = fold(word)
+  return /^[aeiou]/.test(f) || /^y[aeiou]/.test(f)
+}
+
+export function maxFuzzyDistance(length: number): number {
+  return length <= 8 ? 1 : length <= 11 ? 2 : 3
+}
+
+/** True when two folded words sound alike under the skeleton rule. */
+export function soundsAlike(a: string, b: string): boolean {
+  const fa = fold(a), fb = fold(b)
+  if (!fa || !fb || Math.abs(fa.length - fb.length) > 2) return false
+  const sa = skeleton(fa), sb = skeleton(fb)
+  if (sa.length < 2 || sa !== sb) return false
+  if (vowelOnset(fa) !== vowelOnset(fb)) return false
+  const d = levenshtein(fa, fb)
+  return d <= Math.max(maxFuzzyDistance(Math.max(fa.length, fb.length)) + 2, Math.ceil(Math.max(fa.length, fb.length) * 0.5))
+}
+
+/** Edit distance small enough that two words are plausibly one word misheard. */
+export function closeSpelling(a: string, b: string): boolean {
+  const fa = fold(a), fb = fold(b)
+  if (!fa || !fb) return false
+  if (fa === fb) return true
+  const longest = Math.max(fa.length, fb.length)
+  return levenshtein(fa, fb) <= Math.max(1, Math.floor(longest / 3))
+}
+