@gotcos/glasses-server 6.27.3 → 6.27.5

package/CHANGELOG.md

@@ -1,3 +1,57 @@
+## 6.27.5
+- **Chunk uploads now leave a server-side trace.** On 2026-08-12 a phone upload
+  stalled on both media transports and the server was a complete blind spot: nothing
+  recorded that a chunk request had arrived, so "the client never got the ack" could
+  not be separated from "the server never sent one" without reading a staging file's
+  mtime and running `netstat` by hand.
+- `[media-chunk]` now logs one line per REQUEST (never per data event - a 237-chunk
+  upload logging per `data` would bury the log): `body-read` when the body finishes
+  arriving, `responded` with status when the response is fully flushed to the socket,
+  `abandoned` when the client goes away mid-body, and `closed-unanswered` when the
+  socket closes with no response written. Each carries bytes received and elapsed ms.
+- `closed-unanswered` is the only case where blaming the server is correct, and it is
+  now stated explicitly rather than inferred from absence of evidence. It gates on
+  **`res` 'close', not `req` 'close'**: since Node 16 `IncomingMessage` emits 'close'
+  when the REQUEST completes rather than when the socket does, so on an async handler
+  (`putOriginal` and `putFrame` both are) it lands while `res.writableEnded` is still
+  false. Gated on `req` it false-fired on EVERY successful V2 chunk — 237 bogus alarms
+  per upload on the single most diagnostic line in the file. Caught by adversarial QA
+  before release and pinned by a test that fails if the gate moves back.
+- The two early refusals (`chunk_bytes_required` 400 and declared-Content-Length 413)
+  returned BEFORE the tracer existed, so a chunk the server actively rejected logged
+  nothing — the same silence as a request that never arrived. The tracer is now
+  declared above them and every refusal logs.
+- Diagnosis only. No behaviour change to any upload path.
+
+## 6.27.4
+
+### Fuzzy name corrections reach phone dictation
+
+- `applyFuzzyCorrections` is now called inside `cleanOutboundDictation`, so text
+  arriving at `POST /dictation/finalize` gets the same Levenshtein pass the
+  server-transcription route has always had. It previously had exactly ONE call site
+  (`transcribe-audio.ts:252`), which meant phone Moonshine dictation — which sends
+  text, never audio — never received it. Verified by call-site enumeration, not by
+  reading a single file.
+- Runs BEFORE the autoclean LLM, so the model sees corrected proper nouns instead of
+  being asked to guess at them, and it still helps on every path where autoclean is
+  off, over the character cap, or breaker-open.
+- Same target construction (`getAllSpeakerNames()` + `getVocabulary()`) and the same
+  non-fatal posture as the existing call site: a correction pass is quality
+  enhancement, never a durability dependency.
+
+**Measured reach, so callers do not assume more than it delivers.** The distance
+budget is 1 edit for 5-8 character words, so it catches single-edit misses
+(`Austen` → Austin, `Nyala` → Niala) but NOT `Miyala` → Niala (2 edits) or
+`Yukoma` → Ukaoma (3). Wiring it does **not** remove the need for explicit
+`whisper_corrections` entries on multi-edit misses; the new test asserts both
+directions so that is not re-derived later.
+
+`Austin` deliberately untouched — `correctAustinJustin()` already owns that pair.
+
+Pairs with app 6.8.346, which breadcrumbs the finalize call so a missing correction
+can be told apart from a finalize step that never ran.
+
 ## 6.27.3
 
 ### Durable, resumable video transport (private canary)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotcos/glasses-server",
-  "version": "6.27.3",
+  "version": "6.27.5",
   "description": "COS Glasses \u2014 self-hosted AI heads-up-display server for Even G2 smart glasses, powered by Claude Code, Codex, or Cursor Agent CLI",
   "type": "module",
   "bin": {

package/server/routes/media.ts

@@ -255,7 +255,42 @@ export function createMediaChunkBodyParser(options: MediaChunkParserOptions = {}
       return
     }
 
+    // Chunk-upload lifecycle trace.
+    //
+    // WHY. On 2026-08-12 a phone upload stalled on BOTH transports and the server side
+    // was a complete blind spot: nothing recorded that a chunk request had even
+    // arrived, so "the client never got the ack" could not be separated from "the
+    // server never sent one" without reading a staging file's mtime and running
+    // netstat by hand.
+    //
+    // SAMPLED like the client's breadcrumbs, and for the same reason. One line per
+    // REQUEST is still 2 rows x 248 chunks per video (~500), and at the advertised
+    // 2 GB ceiling ~16,400 rows and ~1.5 MB of log for ONE upload, into a LaunchAgent
+    // stdout with no rotation. Routine progress is sampled; the DIAGNOSTIC events —
+    // abandoned, closed-unanswered, too-large, and any non-2xx — are never sampled
+    // away, because those are the rows an investigation actually needs.
+    //
+    // Declared ABOVE the early refusals below: those used to return before this
+    // existed, so a chunk the server actively refused logged nothing at all — the
+    // same silence as a request that never arrived.
+    const openedAt = Date.now()
+    // `?? ''` is load-bearing: a request with neither field (the direct-parser test
+    // harness, and any non-Express caller) made `path.slice` throw and took the whole
+    // parser down. A tracer must never be able to break the thing it observes.
+    const path = req.originalUrl?.split('?')[0] ?? req.url ?? ''
+    const traceTarget = `${req.method} ${path}`
+    // Trailing segment is the chunk index on both routes
+    // (`/media/upload/:id/:index` and `/media/video-upload/:id/original/:index`).
+    const chunkIndex = Number(path.slice(path.lastIndexOf('/') + 1))
+    const sampled = !Number.isFinite(chunkIndex) || chunkIndex === 0 || chunkIndex % 32 === 0
+    let received = 0
+    const logLifecycle = (event: string, extra = '', always = false): void => {
+      if (!always && !sampled) return
+      console.log(`[media-chunk] ${event} ${traceTarget} bytes=${received} +${Date.now() - openedAt}ms${extra}`)
+    }
+
     const refuse = (status: number, body: Record<string, unknown>): void => {
+      logLifecycle('refused', ` status=${status} error=${String(body.error ?? '')}`, true)
       res.status(status).json(body)
       res.once('finish', () => req.destroy())
     }
@@ -279,7 +314,6 @@ export function createMediaChunkBodyParser(options: MediaChunkParserOptions = {}
     }
 
     const parts: Buffer[] = []
-    let received = 0
     let settled = false
 
     req.on('data', (chunk: Buffer) => {
@@ -288,6 +322,7 @@ export function createMediaChunkBodyParser(options: MediaChunkParserOptions = {}
       if (received > maxChunkBytes) {
         settled = true
         parts.length = 0
+        logLifecycle('too-large', ` max=${maxChunkBytes}`)
         refuse(413, { error: 'attachment_too_large', maxBytes: maxChunkBytes })
         return
       }
@@ -297,12 +332,33 @@ export function createMediaChunkBodyParser(options: MediaChunkParserOptions = {}
       if (settled) return
       settled = true
       parts.length = 0
+      // The client went away mid-body. Distinguishes a phone that stopped sending
+      // from a server that stopped answering — opposite diagnoses, same silence.
+      logLifecycle('abandoned')
     }
     req.once('aborted', abandon)
     req.once('error', abandon)
+    // Fires when the response is fully flushed to the socket. Paired with 'body-read'
+    // this is the proof that the server answered, and how fast.
+    res.once('finish', () => {
+      logLifecycle('responded', ` status=${res.statusCode}`)
+    })
+    // `res` 'close', NOT `req` 'close'. Since Node 16 `IncomingMessage` emits 'close'
+    // when the REQUEST completes, not when the socket does — so on any async handler
+    // it fires while `res.writableEnded` is still false. `putOriginal`/`putFrame` are
+    // both async, so gating on `req` made this false-fire on EVERY successful V2
+    // chunk: 237 bogus rows per upload, on the single line the changelog calls "the
+    // only case where blaming the server is correct". A watcher that cries wolf on the
+    // happy path is worse than no watcher. `res` 'close' fires after the response is
+    // finished or genuinely aborted, so the guard means what it says.
+    res.once('close', () => {
+      if (res.writableEnded) return
+      logLifecycle('closed-unanswered', '', true)
+    })
     req.once('end', () => {
       if (settled) return
       settled = true
+      logLifecycle('body-read')
       chunkBodies.set(req, Buffer.concat(parts))
       next()
     })

package/server/routes/prompt-drafts.ts

@@ -35,6 +35,8 @@ import {
   applyNegativeRules,
 } from '../lib/hallucination-filter.js'
 import { applyCorrections } from '../lib/whisper-local.js'
+import { applyFuzzyCorrections } from '../lib/fuzzy-correct.js'
+import { getAllSpeakerNames } from '../lib/speaker-embeddings.js'
 import { transcribeWhisperPreview } from '../lib/whisper-preview.js'
 import { autoCleanDictation, AUTOCLEAN_MAX_CHARS } from '../lib/dictation-clean.js'
 import { getVocabulary } from '../lib/profile.js'
@@ -104,6 +106,27 @@ function routeAutoClean(req: { body?: any; query?: any }): AutoCleanRequest {
 
 async function cleanOutboundDictation(text: string, opts: AutoCleanRequest & { signal?: AbortSignal }): Promise<string> {
   let cleaned = applyNegativeRules(applyCorrections(text)).replace(/\s+/g, ' ').trim() || text
+  // applyCorrections above is an EXACT string map, so it only fixes misspellings someone
+  // already hand-authored. A novel miss ("Miyala" for Niala, "Yukoma" for Ukaoma) sails
+  // through it. The Levenshtein pass is what catches those, and until now it had exactly
+  // ONE call site — transcribe-audio.ts:252, the server-transcription route — so phone
+  // Moonshine dictation, which arrives here as text, never got it. Same construction and
+  // same non-fatal posture as that site, deliberately: targets are speaker names plus
+  // vocabulary, and a throw must never cost the user their transcript.
+  //
+  // Runs BEFORE the autoclean LLM so the model sees corrected proper nouns rather than
+  // being asked to guess at them, and it still helps on every path where autoclean is
+  // off, over the char cap, or breaker-open.
+  try {
+    const fuzzyTargets = [...getAllSpeakerNames(), ...getVocabulary()]
+    const { text: corrected, replacements } = applyFuzzyCorrections(cleaned, fuzzyTargets)
+    if (replacements > 0) {
+      console.log(`[prompt-draft] Fuzzy corrected ${replacements} word(s)`)
+      cleaned = corrected
+    }
+  } catch (fuzzyErr: any) {
+    console.warn(`[prompt-draft] Fuzzy correction failed (non-fatal): ${fuzzyErr?.message ?? fuzzyErr}`)
+  }
   if (!(opts.enabled ?? autoCleanDefaultEnabled())) return cleaned
   if (cleaned.length > AUTOCLEAN_MAX_CHARS || autoCleanBreaker.isOpen() || autoCleanCountToday() >= autoCleanDailyCap()) return cleaned
   const startedAt = Date.now()