@gotcos/glasses-server 6.59.0 → 6.61.0

package/.env.example

@@ -159,6 +159,14 @@ BIND_HOST=0.0.0.0
 # changing committed transcription or meeting audio.
 # COS_WHISPER_PREVIEW_MODEL=auto    # auto | small.en | turbo | off
 
+# Who spoke when (6.61.0). Nemotron 3 Diarization separates the voices in each
+# chunk and at save; the voiceprint names them. It needs FluidAudio's
+# fluidaudiocli and its models ON THIS MAC: the server always passes --models
+# and never lets the CLI download. Missing either, labels stay on the voiceprint.
+# COS_DIARIZER=nemotron            # nemotron | embedding (voiceprint only, the 6.60 labels)
+# COS_NEMOTRON_CLI=~/.cos-glasses/bin/fluidaudiocli
+# COS_NEMOTRON_MODELS=~/.cos-glasses/models/nemotron-3-diarization   # holds Nemotron3Diarizer_fast32.mlmodelc + learnable_sil_emb.bin
+
 # Spoken reply playback defaults to local Kokoro on Apple silicon Macs. The
 # first run creates a private venv and downloads the model. Local mode fails
 # closed: it never sends text to OpenAI. Set openai_primary only when cloud TTS

package/CHANGELOG.md

@@ -1,3 +1,69 @@
+## 6.61.0
+
+### Nemotron is the default diarizer, for real: it splits two-voice chunks on the HUD during the call and in the final transcript, and the voiceprint names each voice
+
+- Miles, 2026-10-02 07:10: "I want nemotron to become the default as it's more accurate. We should see it labeling in the HUD (During the call) and in the final transcript." This folds in the unpublished 6.60.1, which made `COS_DIARIZER` default to `nemotron` but never ran Nemotron: every live chunk was still labelled by the whole-chunk voiceprint, and its `[diarizer] tracks=nemotron` log line was false. That line is gone; every `[diarizer]` line now says what ran.
+- **What it does, and what it does not claim.** Nemotron separates the voices inside a chunk and across a meeting; it names nobody. The voiceprint still decides every name, with its thresholds unchanged. What changes is that a chunk holding two voices is no longer given one label, and a stretch the voiceprint could not name can take the name of the voice Nemotron heard there. This release does not claim the labels are more accurate: the replay below measures how rarely Nemotron disagrees with labels the voiceprint was already sure of, which is stability, not accuracy (see the disclosure there).
+- The evidence it builds on is the read-only canary of 2026-10-01 (`operations/personal/wk40_2026/nemotron3_canary/`): FluidAudio v0.17.4, preset `fast32`, about 155x realtime warm; on chunks the voiceprint is sure of, Nemotron's dominant channel maps back to the same name in 29 of 29 conclusive meetings (mean 0.959); 45.6% of chunks hold two voices the voiceprint labels as one. The canary's alignment rules are reused as written: chunkEntries joined to `chunk_NNNN.wav` by chunkIndex with `audioSha256` checked, each WAV at its real `elapsed` with only the overlapping tail trimmed, the raw 10 ms probabilities scored at 0.5, 8 channels.
+- **Live, on the HUD.** Each chunk runs `fluidaudiocli nemotron3-diarize` on the chunk WAV the server has just written, started before the voiceprint and Whisper so it runs in their shadow, on the Neural Engine (`--compute-units ane`, so the GPU stays Whisper's; its probabilities matched `all` frame for frame at 0.5 on real chunks) at a lower CPU priority. A channel active for at least 0.5 s is a track. Whisper's word clocks place the words on the tracks when the ASR gives them (the iPhone path); the live whisper-server path returns compact JSON without clocks (its verbose JSON can crash the native server), so there the text is laid over the frames where Nemotron hears speech in proportion to word length, a turn change moves to the nearest phrase end within two words, and a one-word flicker inside another voice's turn is absorbed. The voiceprint names each track: one track takes the chunk's voiceprint; with two or more, a track with at least 2 s of its own audio (the same floor as a whole chunk) is named by `identifySpeaker` on that audio, its calibration rows tagged `nemotron-track`; a shorter one takes the chunk's voiceprint when it is the dominant voice, otherwise the client's label when that is a real name different from the dominant one, otherwise `Ext`. A name is never invented.
+- **The chunk response (the contract with COS Glasses 6.9.567).** `speaker` stays and is now the dominant voice's name (by voiced time among the tracks that carry the words; two channels can carry one person, and a louder voice with no words in the chunk is not who said it), `text` is unchanged, and an optional `segments: [{ speaker, text, startSec, endSec, similarity }]` lists the turns in time order; their texts joined with one space equal `text`. A replayed upload of a canonical chunk returns the same segments, and the `transcript_chunk` display event carries them. The segments are stored on the chunk, with `diarizer: { engine, tracks, timing, ms }` and, when the dominant name differs from the whole-chunk voiceprint, `voiceprintSpeaker` and `voiceprintSimilarity`. The saved sidecar's `speakers` counts segment speakers too. The whole-chunk voiceprint still runs first and still banks the chunk embedding, auto-enrols and saves training and Ext audio exactly as before. When boot recovery strips a hallucination from a stored chunk, its turns are refitted to the new text, or dropped when the words no longer line up, so they always join to the text.
+- **The fallback-experience rule.** Live never stalls or loses a chunk; every fallback keeps today's voiceprint label and gives no `segments`.
+  - The model is warmed in the background at server start (a silent second; the first Neural Engine compile took 15 to 35 s); until then chunks are `warming`. A warm-up tries three times (5 s and 30 s apart); a temp directory it cannot make is a failed attempt with a reason, never a warm-up stuck on `warming`.
+  - Each run has a 1.5 s budget and is killed with SIGKILL at the deadline. At most two run at once; a chunk that finds both busy is `busy`, never queued.
+  - **The breaker.** Three failed runs in a row (budget kills or crashes) stop spawning: every chunk takes the voiceprint at once, with no 1.5 s wait, and the server logs `[diarizer] breaker open: ...`. After a rest of 2 minutes one fresh warm-up decides; each further trip doubles the rest (2, 4, 8, 16, 32, then 60 minutes at most), and a clean chunk resets it. A warm-up that gives up rests on the same schedule; a missing CLI or missing models are re-checked every 2 minutes without spawning anything.
+  - A missing CLI or missing models (any install without FluidAudio) is logged once at warm-up, and chunks carry no per-chunk `diarizer` stamp. Run failures (timeout, crash, unreadable output, busy) are logged per chunk with their reason; state reasons (`warming`, `cooling`, `warmup_failed`) are counted per chunk and logged once per change of state.
+- **The final transcript.** When a meeting is saved, the finalization job runs one Nemotron pass over the whole meeting after the HQ batch is persisted, while the raw chunk audio still exists, and before the job reaches the ops handoff. One run over the timeline keeps the channels consistent for the whole call. A channel takes a name only from chunks the voiceprint was sure of (similarity at least 0.65, the review panel's own floor, a real name, one-sided by Even Hub, or by Nemotron itself when a chunk has no Even Hub histogram), with at least 3 such chunks and 80% of them agreeing; several channels may map to one person, and a channel two people share stays unmapped. Following the canary's retro plan, a room with more than four identities or all eight channels in use (a channel counts with half a second of speech, not a blip) gets no meeting-wide map. Every word then takes its channel's name, or keeps its per-chunk name (the live Nemotron turn it sat in, else its existing label). The timeline is built asynchronously in steps, so a long meeting does not freeze live uploads; a timeline far longer than the audio it holds (more than 1.5 times, plus 10 minutes) is a bad clock and the pass is skipped as `too_long` before anything is allocated.
+- **Only labels change.** The saved transcript is relabelled in place, word by word, against the relabelled speaker words (a 12-word window, then a three-word anchor past anything cleaning removed). A line splits where its speaker changes and is never merged with its neighbour, so a pass that changes no label reproduces the transcript byte for byte, writes nothing and moves no revision (`no_change`). Nothing is written unless the result has exactly the same words in the same order. Each changed batch word keeps `originalSpeaker`, a changed streaming chunk keeps `originalSpeaker` and gains `finalSegments`, and the sidecar keeps the whole pre-relabel transcript under `diarization.originalTranscript` with the channel map and its evidence. If the markdown write fails the sidecar is put back byte for byte; if even that fails the pass reports `sidecar_restore_failed` and says so in the log.
+- **A person's edit always wins.** A meeting with a human correction (`correctionRevision` above 0) is never relabelled. The pass re-reads both files just before writing; if a relabel, a deattribution or a summary landed during its CLI run, it stands down (`changed_during_pass`) and writes nothing. Relabel and deattribute answer 409 `meeting_finalizing` (retryable) while a finalization job exists for the meeting, as held naming already did. A second pass over an applied meeting is a no-op. If the pass fails in any way the meeting stays exactly as saved, and the job goes on.
+- **Voice profiles stay safe.** Since a chunk's label can now be its dominant turn's name, naming a voice no longer enrols a chunk whose own whole-chunk voiceprint named a third person, or a chunk Nemotron split into more than one turn; the response says how many it refused (`otherVoiceSkipped`, present only when it happened). A wrong existing label is still how a new person first appears (the Milo case).
+- **When COS sync sees it.** The relabel completes before the meeting is visible as final: the job is still in `batch_pending` when it runs, and `sync_meetings.py --g2-only --g2-import-file` runs from the ops handoff only after it returns. Sync reads speakers from the markdown transcript and, for a batch meeting, from `batchSegments[].speakerWords`, both already relabelled; `batchTranscript` is kept equal to the canonical text. No sync change is needed. With early sync on, the claim made at save is marked HQ pending and the final import replaces its transcript, as it already did for HQ.
+- **Offline by construction.** The server always passes `--models <dir>`; that path in FluidAudio has no network call, while the CLI run without it downloads from Hugging Face and deletes a cache whose weights marker it does not recognise. The directory is `COS_NEMOTRON_MODELS`, else `~/.cos-glasses/models/nemotron-3-diarization`, which the warm-up links to FluidAudio's own cache (`~/Library/Application Support/FluidAudio/Models/nemotron-3-diarization`, bundle `monolithic/v2`). An incomplete explicit directory is never replaced by another copy. With no complete local copy the CLI is never run. Probed 2026-10-02 under `sandbox-exec` with all network denied: the CLI ran from the linked directory and from the cache. The CLI has no version command, so the warm-up logs its sha256 once and whether it is the verified v0.17.4 build (`readiness.diarizer.cliKnown`).
+- **The CLI gets nothing it does not need.** It runs with PATH, HOME, TMPDIR, USER, LOGNAME and the locale only: no API token, provider key or OpenAI key reaches it (verified warm with only those on 2026-10-02).
+- **Nothing outlives the server.** Runs and temp directories in flight are tracked. `gracefulShutdown` and the process exit hook kill every CLI run and delete every temp directory (the final pass's holds the whole meeting's audio). The next start sweeps `cos-nemotron-*` directories older than a minute and kills CLI runs of ours that were orphaned.
+- **Honest health, codes only.** `/api/health` is public (no token) and the server listens on the LAN, so `readiness.diarizer` carries codes and counts only: never a speaker name, a path, a meeting title or raw error text (QA blocker; the channel map and raw errors now stay in `server.log`). It reports `requested`; `active`, which is `nemotron` only while the model is warm, the breaker is closed and most of the last five chunks really were labelled by Nemotron (otherwise `warming` or `embedding`), with the `fallback` reason; `recent`; `breaker` (open, trips, next retry); the preset, budget and lane; the warm-up; `cliKnown`; the per-chunk outcome counts by reason and the last chunk; and the final passes as `{ status, reasonCode, mode, crowded, channels, mappedChannels, wordsRelabeled, wordsTotal, excludedChunks, ms, at }` with counts keyed by status and code from a fixed set. A Nemotron fallback never degrades `readiness.status`. Every final pass logs what it applied or why it left the meeting alone, with any chunks left off the timeline (missing, hash mismatch, unreadable); a pass the save path declines because the batch sidecar was not written is counted and logged too (`metadata_not_persisted`).
+- **Settings.** `COS_DIARIZER` (default `nemotron`; `embedding`, `eres2net` or `voiceprint` turns Nemotron off entirely: no warm-up, no run, the 6.60 labels), `COS_NEMOTRON_CLI` (default `~/.cos-glasses/bin/fluidaudiocli`) and `COS_NEMOTRON_MODELS`, all in `managed-runtime-contract.json` and `.env.example`. To turn it off, put `COS_DIARIZER=embedding` in `~/.cos-glasses/.env`.
+- **After updating.** No Install hooks and no COS Control change. The first start compiles the model for the Neural Engine in the background (about 30 s on the M3 Ultra); chunks use the voiceprint until `readiness.diarizer.active` reads `nemotron`. No LLM is called anywhere in transcription.
+- **Real-data replay (read-only, 2026-10-02).** Clones of three meetings from the canary list, `COS_DATA_DIR` pointed at a scratch copy so not even the calibration log touched the store, the live path chunk by chunk exactly as the route runs it (Nemotron started first, the whole-chunk voiceprint, Whisper large-v3 through a private whisper-server with the live server's arguments, then the track names), then the final pass on a sidecar carrying those live turns. The live replay ran on `dacd8be`-era code, with the mutation gate alongside part of it, so the times are a busy-Mac upper bound.
+  - **Disclosure: what the agreement numbers measure.** They measure how rarely Nemotron disagrees with a label the voiceprint was already sure of, not whether a label is right. The live path gives a one-track chunk the stored voiceprint label by construction, so its agreement is high by design on those chunks; the final pass maps channels from the very chunks it is then scored on. Nobody listened to the changed turns. The independent check available here is the last number in each final line: final word labels against the per-track voiceprint names of the live turns.
+  - Silas and Miles, Thu 10:01 (505 chunks with text): Nemotron labelled 502 (3 `no_speech`); 114 chunks (22.7%) gained a second speaker, 1.31 segments per chunk; on 270 high-confidence chunks the dominant name matched the stored label 270 times. Final: channels {0: Silas, 1: MU}, 2,201 of 8,484 words relabelled (988 Ext to Silas, 455 Ext to MU, 609 turn splits); majority agreement 1.000 on 132 one-sided and 241 high-confidence chunks; final words against the voiceprint-named live tracks 0.983 (4,589 words).
+  - Ryan and Miles, Thu 16:03 (853): 852 labelled (1 `no_speech`); 289 (33.9%) gained a second speaker, 1.49 segments per chunk; dominant agreement 0.995 on 659. Final: {0: Ryan, 1: MU, 2: Ryan}, 4,432 of 19,140 words relabelled; majority agreement 0.993 one-sided (274), 0.974 high-confidence (650); against live tracks 0.974 (12,969 words).
+  - Five people, Wed 07:31 (753): 747 labelled (6 `no_speech`); 175 (23.4%) gained a second speaker, 1.32 per chunk; dominant agreement 0.995 on 365. Final: crowded (5 identities), so no meeting-wide map; the live turns relabelled 2,977 of 12,226 words; majority agreement 0.995 one-sided (183), 0.980 high-confidence (346); against live tracks 0.999.
+  - Latency with Whisper load, all 2,111 chunks: Nemotron's own run p50 140 to 141 ms, p95 149 to 157 ms, max 196, 302 and 680 ms; what the chunk waited beyond Whisper (the end of Nemotron plus naming the tracks) p50 0 ms, p95 89 to 114 ms, max 129, 142 and 213 ms; no chunk timed out or found the lane busy. The final pass took 19 s, 30 s and 28 s for 52, 86 and 80 minutes of audio.
+  - The final pass re-run on the QA-fixed code, on the stored sidecars without live turns: 10:01 applied ({0: Silas, 1: MU}, 1,935 of 8,484 words, one-sided 1.000, high-confidence 0.996); 16:03 applied ({0: Ryan, 1: MU, 2: Ryan}, 4,234 of 19,140, 0.993 and 0.974); 07:31 crowded with no live turns to apply, so `no_change`: nothing written.
+  - The rule that the chunk `speaker` is the voice carrying the words came after the replay; it changes none of the 2,101 replayed chunks' names (every replayed `speaker` carried words).
+  - The replay found a real bug before release: the first final pass regenerated the transcript from the relabelled words and cleaned it again, which changed which URL-only lines cleaning dropped, so the word check refused every batch meeting. Fixed by relabelling in place.
+- **QA round 1** (the Skeptic and the Ghost Hunter, on `dacd8be`). Fixed: the public health leak (blocker); the final pass overwriting a correction or summary made during its run; rename enrolment able to take a chunk the voiceprint gave to someone else; the CLI inheriting the server's tokens; health reading `nemotron` while every chunk fell back; no breaker on repeated budget kills; `no_change` that almost never fired because lines were merged; no cap on a timeline stretched by a bad `elapsed`; temp audio and CLI runs left behind by an exit; a warm-up that could stick on `warming`; recovery leaving turns that no longer joined to the text; untestable guards (a seam for the writer and the relabeller now makes the word check reachable); missing telemetry; constants defined twice. 28 of the new regression tests fail on `dacd8be` and pass here.
+- Tests: the backend choice and the models directory (offline, linking, an incomplete override); the CLI run (the arguments, the minimal environment, the frame check both ways, exit codes, SIGKILL at the budget, a missing binary, children and temp dirs killed and removed, the startup sweep); word-to-track mapping with clocks and estimated, phrase snapping, flickers, tracks, exclusive audio; naming (one track, two long tracks, a short dominant and a short other with the client label, a repeated or unknown client label, an unnamed track, word clocks over estimates, the voice that carries the words, punctuation-only tokens and merged turns joining to the text exactly, turns refitted after recovery); the runtime (a cold model, busy under a 300-chunk backlog, the breaker and its backoff, the real defaults pinned, health while chunks fall back, a warm-up whose temp dir cannot be made, the warm-up failure and identity lines, outcomes counted and logged, a missing CLI never stamped); the route (segments in the response and the HUD event with every legacy field intact, stored on the chunk, replayed, a fallback answering like 6.60, the voiceprint by choice leaving the record as 6.60 wrote it; recovery refitting turns); the final pass (consistent tracks with original labels and line breaks kept, a crashed or timed-out CLI changing no byte, words cleaning changed or removed kept exactly with labels in step, a relabel or summary during the run surviving, `no_change` writing nothing, `too_long`, a failed markdown write restoring the sidecar and a failed restore reported, the word check reached through the seam, the log lines, the timeout formula pinned, blips not crowding a room, an exit mid-pass leaving no temp audio, a human correction, the voiceprint by choice, a streaming meeting, a crowded room, the timeline's hash check, trim and refusal of a non-regular file, the map's floors, a declined pass counted); the save path (the pass runs on the saved files while the audio exists and before the job leaves `batch_pending`; a failed or throwing pass leaves the meeting byte-identical; relabel and deattribute refused while finalizing and taken after); rename enrolment refusing another voice or a two-voice chunk; unauthenticated `/api/health` after a final pass carrying no name, path or raw error; `readiness.diarizer`; the runtime contract keys. The suite runs with `COS_DIARIZER=embedding` so no test can spawn the real CLI.
+- `node server/scripts/nemotron-mutation-gate.mjs` (repository only, not in the package) runs from a green baseline, matches each target exactly once, and each mutant must fail the test named for it: baseline 160 tests in 11 files, 96 of 96 killed. In QA round 1 it caught a mutant that dropped unmatched words and hid behind a line the pass left whole; the test now inserts a word into a line the pass splits. `server/scripts/nemotron-replay.ts` is the replay above (repository only).
+
+## 6.60.0
+
+### A question that starts while you are away waits up to 10 minutes for the glasses you are wearing
+
+- 2026-09-30: a Claude question reached the glasses at 07:28:34 with 109 s left; the ring double tap did not work (a glasses bug, fixed in 6.9.563), so Miles answered on the phone at 07:29:30. More generally a question that starts while he is away was answerable from the glasses only for the broker's 110 s, and when no glasses or phone was polling at that moment it went straight to the Mac's dialog (`no_client`) and the glasses never saw it. His words: questions that begin while the user is away should have a second option to be reclaimed from the glasses if possible; else the user does not know the Mac is waiting on answers. He approved this at 18:40 CDT ("Yes, up to 10 min"), set the rule at 19:54 ("Hold only if the glasses or phone were connected in the last 30 min. A Claude Remote Control session with no glasses gets its question right away, as before."), and approved the QA round 1 fix pass at 21:04.
+- **The away hold.** While the desk is idle past the existing threshold (`COS_PERMISSION_BROKER_DESK_IDLE_S`, default 90 s, the one the gate already uses), a question or approval is held for up to 10 minutes from when its hook started, but only when all of these hold: the hold is on; the installed hook waits longer than 6.59.0 could ever hold (after Install hooks); and the glasses or phone that show held questions reported you present within 30 minutes. Held that way, it stays answerable while nothing is polling, so glasses or a phone that come back can still answer it.
+- **The contract shared with COS Glasses 6.9.563.** The questions poll becomes `GET /api/session-questions?client=glasses|phone&hold=1&presenceAgeMs=<int>`. `hold=1` says this client can show held questions (6.9.563 and later). `presenceAgeMs` is the ms since the latest real wearer evidence (glasses: a ring or temple input, or a device status with wearing true; phone: a foreground touch), a whole number from 0 to 24 h, left out when there is none since the app started. Only a poll with `hold=1` and a valid `presenceAgeMs` counts toward the hold. The server keeps the newest such presence in memory, forward-only, on the monotonic and the wall clock, and reads its age as the larger of the two, so a Mac that slept never makes it look newer. Recent means within `COS_PERMISSION_BROKER_AWAY_RECENT_CLIENT_S` (default 1800, clamped to 0 through 86400; under 30 it means the 30 s live window). After a restart nothing is recent until such a poll.
+- **Older clients keep 6.59.0.** A poll without `hold=1` (6.9.538, 6.9.561, 6.9.562, any phone build before 6.9.563) keeps the 6.59.0 liveness exactly (live for 30 s, a 110 s hold, handed back when it goes quiet) and never enables the away hold, even with `presenceAgeMs`. A `hold=1` poll without presence (a connected lens nobody wears, QA round 1 Skeptic W1) makes no client live and holds nothing: `{}` at once. A `hold=1` client counts as live only while its wearer's presence is recent.
+- **Re-checked every desk poll (Skeptic W2).** Once no client is live and the wearer's latest presence is older than the window, a held question goes to the Mac's dialog (`no_client`) within 1.5 s, so one glance never holds a question 10 minutes. Touching the Mac still hands it back within 1.5 s, and a request that arrives while you are at the desk still goes straight to the dialog.
+- **Before Install hooks the away hold is off (User W6).** While the hook waits no longer than 6.59.0 could hold (its 120 s clamp), away semantics are off entirely: no presence hold, quiet clients hand back, 110 s. One 6.60.0 rule still applies: a `hold=1` client (6.9.563 and later) counts as live only while its wearer's presence is 30 minutes old or less (next item).
+- **A lens nobody has touched for 30 minutes gets no question card (QA round 2, W-A).** With 6.9.563 or later, the glasses count as live only while a ring or temple input, a worn report or a phone touch is 30 minutes old or less. That holds in every setting: before Install hooks, and with the away hold off. The wearing flag reads false almost all the time, so in a long meeting or a drive with no ring input a question goes straight to the Mac's dialog (`no_client`) instead of the lens. On 6.59.0 the same lens showed it for 110 s first. This is the QA round 1 Skeptic W1 decision: a connected lens nobody wears no longer delays the Mac's dialog.
+- `COS_PERMISSION_BROKER_AWAY_HOLD_S` sets the hold: default 600, clamped to 30 through 600, never shorter than the base 110 s; `0`, `off` or `false` turns the away hold off (the 6.59.0 broker, except that a `hold=1` lens still needs recent presence to count as live). Junk is the default. Both settings are in `managed-runtime-contract.json`; COS Control's environment allowlist needs them in a Control build, until then set them in `~/.cos-glasses/.env`.
+- **What it changes for a session driven from elsewhere.** While the desk is idle and you wore the glasses or touched the phone (with 6.9.563 or later) in the last 30 minutes, a permission prompt from a session you drive from another surface (Claude Remote Control, say) waits up to 10 minutes for the glasses before the Mac's dialog shows, unless you answer it from the glasses or phone, leave it for the Mac, touch the Mac, or your presence lapses. With no recent presence it shows at once, as before. `COS_PERMISSION_BROKER_AWAY_RECENT_CLIENT_S` narrows the window; `COS_PERMISSION_BROKER_AWAY_HOLD_S=0` turns the hold off.
+- **Never past the hook's own wait.** The hold is clamped by the hook that is actually installed: the PermissionRequest `timeout` in `~/.claude/settings.json` (read through the 5 s hook-status cache) and the wait the hook stamped on this request, the lesser, minus 10 s (5 s for the script's curl to give up before Claude Code stops the hook, 5 s more so the server's `{}` lands first: the 130, 125, 120 chain every release since 6.52.0 kept). If the settings file cannot be read, the stamp alone bounds it (Skeptic N4). A request with no stamp (the earlier script, or an earlier hook block) waited 130 s with a 125 s curl, so it is never held past 120 s.
+- **The hook.** `--hooks install` writes the PermissionRequest block with `timeout: 630` and passes 630 to the script as its second argument (an argument, never an environment variable, so it can only come from that block). The script gives up its curl 5 s before that wait (it was a fixed 125 s) and stamps it on the request as `hookWaitS`; an invocation with no usable argument keeps the earlier 130 and 125 and sends no stamp. Only a whole number from 20 to 3,600 with no leading zero counts. The curl now runs as a tracked child, and the script stops it when the script itself is stopped (TERM, INT, HUP), so the server sees the hook leave (`hook_gone`) at once and never accepts an answer the session can no longer receive (Skeptic W7).
+- **After updating.** Neither Update Server (`cos-control-helper update`) nor a server boot rewrites the Claude settings file or replaces an installed hook script, so until Install hooks runs once the broker is 6.59.0. `--hooks status` and `/api/session-hooks/status` read `drift` with `priorWaitOnly: true` and `permissionHookTimeoutS: 130`; COS Control shows its "Reinstall hooks" banner. Cancel from the lens keeps working meanwhile: `hookHaltReady` accepts that one drift on this package's script or a halt-capable earlier one, and the script 6.53.3 through 6.59.0 shipped (`df54677f...`) joins the halt-capable list, pinned against its bytes. Any other drift is still not halt-ready. Canary C below found that a running Claude session picked up a changed hook timeout.
+- **Rolling back to 6.59.0 (Completionist W5, Skeptic N7).** After Install hooks, 6.59.0 reads the 630 block as `drift` and is not halt-ready, so cancel from the lens stays off for desk runs until Install hooks is run again under 6.59.0 (it writes the 130 block back). Questions stay safe meanwhile: the 6.60.0 hook script under a 6.59.0 server stamps a wait the old server ignores, and 6.59.0 holds at most 120 s, well inside the 630 s hook.
+- **What the clients see.** Additive, every earlier field and meaning unchanged. Each pending item gains `answerable` (true while listed), `awayHold` and `waitingAtMac` (false while listed); `deadlineAt` is the latest it stays answerable, sooner if the wearer's presence lapses with no client polling. `GET /api/session-questions` gains `awayHoldMs` (how long a request that starts now is held at most with recent presence; 0 when off or before Install hooks), `awayRecentClientMs` (the window; 0 when off), `settled` (recently settled items, newest first, codes and times only: every one the Mac still waits on, and the newest others up to 32), `waitingAtMac` (how many), `serverStartedAt` (this process's start) and `waitingAtMacForgottenBefore`. `/api/models` `capabilities.sessionQuestions.awayHoldMs` and `awayRecentClientMs` carry the same numbers. `/api/health` `sessionHooks` gains `permissionHookTimeoutS` and `priorWaitOnly`.
+- **Waiting at the Mac.** An item is `waitingAtMac` when the server wrote `{}` to its listening hook (back at the desk, expired, no client, drained), so the Mac's own dialog is up, and that request has not been finished since: its own tool has not finished or been denied (matched by its own fingerprint only, never by a denial of another dialog of the same tool, Skeptic N3), its turn has not ended, and its session row does not read ended (cleared at once, Skeptic N2). A `{}` that could not be written, an answer, a hook that left, or a retraction is never waiting. No hook marks the moment a dialog is approved, so an approved tool that is still running reads as waiting: the safe direction, never "not waiting" while a dialog may be up. Kept an hour, or up to a day while the session's own row still waits on that very request.
+- **Forgot vs moved past (Ghost Hunter W1).** `waitingAtMacForgottenBefore` starts at the server's start and moves only when the server drops an item the Mac may still wait on. An entry a client saw waiting that is missing from `settled` moved past if it settled after that time; at or before it, or from a server with another `serverStartedAt`, the server forgot it and the Mac may still be waiting.
+- **Telemetry (Completionist N9, Ghost Hunter W5).** Every request answered `{}` logs one line: `fast path <reason>`, and for `no_client` and `desk_active` `not_away=hold_off|ceiling_at_base|no_hold_client|stale_presence|desk_active`, with `presenceAgeMs`, `windowMs` and `clientLive`. Each held request logs once the numbers its deadline came from: `hold={"installedHookTimeoutS","hookWaitS","awayHoldS","ceilingS","effectiveDeadlineS","deskIdleMs","clientLive","presenceAgeMs","recentWindowS","notAwayReason"}`. Never text. The broker's authenticated counters gain `awayHeld` and `parkedWithoutClient`.
+- **Canaries (Claude Code 2.1.286, 2026-09-30, throwaway `claude -p` sessions in temporary projects with `--setting-sources project`, an empty `--strict-mcp-config`, `--no-session-persistence` and haiku, so no user hook and no COS spool saw them, cleaned up after).** The claim the hold rests on: Claude Code waits on a PermissionRequest command hook for its configured timeout when that is above 130 s, and applies its decision. A630, timeout 630 and a hook that slept 610 s then allowed: the hook ran 21:06:28 to 21:16:38 and the tool ran the same second; not killed. A, timeout 300 and a 200 s sleep: the same, 19:12:11 to 19:15:31. B, the control, timeout 150: stopped at 150 s, the tool denied. C, a session started at 150 whose first request rewrote its own setting to 300: the second request's hook ran the full 200 s.
+- Smoke, the real 6.60.0 script with `630` against a scratch server (the real routes and liveness module, wired as `index.ts`): a 6.9.563 poll with `presenceAgeMs=0`, then 35 s quiet (presence recent, no client live): held with a 600 s deadline, answered at 140 s, past the earlier curl's 125 s, and the script printed the allow and exited 0. No poll at all: `{}` in 120 ms, `no_client`, `not_away=no_hold_client`. A poll with `hold=1` and no `presenceAgeMs` (a lens nobody wears): `{}` in 118 ms, the same.
+- The existing mutation gate's cases on the code this release reshaped (the no-client gate, the desk gate, the retraction rule, the quiet-client tick, the poll stamps, `hookHaltReady`) are retargeted to the new lines with the same mutations.
+- **Exactly once, against the real registry (Ghost Hunter W7).** The glasses' saved-turn drain re-sends a turn under one `clientTurnId`; new tests run it against the real `AgentSessionBindingRegistry`: sequential (replays), two concurrent POSTs while the first is in flight (one delivery; the other `native_turn_in_progress`, not delivered; a later retry replays), across a binding retired and re-created on the same thread (replays), and a thread busy with the first send (a new attach `native_target_busy`, the same id `native_turn_in_progress`, then a replay through a new binding). No gap was found.
+- Docs: the README's session questions section (the contract, the rule, the clamp, the fields, forgot vs moved past), the settings list and the `no_client` troubleshooting line.
+- Tests: the contract parse and the liveness module (hold and legacy polls apart, presence only with `hold=1`, out-of-range ages, forward-only on both clocks, the sleep case, a reset); a lens polling with no presence, an older client, presence 10 minutes, exactly 30 minutes, 30 minutes and 1 ms, 31 minutes, a window of 0; the tick re-check at 30:00 and a wearer who came back; a worn lens as a live client until its presence lapses; the ceiling at base; never shorter than the base; unreadable settings with and without a stamp; no client ever (also over the real route under 100 ms) and a restart; every fast path logged; the real defaults wired as `index.ts`; desk return within one 1.5 s production poll; `no_client` and `drained` leave the dialog up; fingerprint-only and ended-row clearing; the listing keeps every waiting item past the cap; forgot vs moved past and the day-long keep; the hook script's stamp, its curl limit and a TERM that leaves no curl and a `hook_gone`; the installer's 630 block, the prior-wait drift and halt readiness; the runtime contract keys. `node server/scripts/away-hold-mutation-gate.mjs` (repository only, not in the package) runs its mutants from a green baseline, each target matched exactly once, and each must fail the test named for it: 68 of 68 killed, including the Ghost Hunter's two survivors (`no_client` and `drained` dropped from the dialog-up set, the never-below-base guard removed). The existing gate's 13 retargeted cases: 13 of 13 killed.
+
 ## 6.59.0
 
 ### Work on the glasses: progress, everything open, and a request inbox COS Control works through

package/README.md

@@ -246,7 +246,8 @@ The client contract (also at `/api/models` `capabilities.sessionQuestions`):
 - Poll `GET /api/session-questions?client=glasses` (or `client=phone`) with X-Cos-Token
   every `pollIntervalMs` (10,000). Only those two `client` values count as a live
   answerer; a poll without `client`, or with any other value, is answered but never
-  counts. A client quiet for `liveWindowMs` (30,000) hands every held request back.
+  counts. A client quiet for `liveWindowMs` (30,000) hands every held request back,
+  except one the away hold holds (6.60.0, below).
 - The response carries `enabled`, `mode`, `protocolVersion` (1), `pollIntervalMs`,
   `liveWindowMs`, `pending` and `items` (a question's `questions`, or an approval's
   `approval`: `{tool, summary, detail}`, the command, path or URL exactly as it will run,
@@ -259,7 +260,69 @@ The client contract (also at `/api/models` `capabilities.sessionQuestions`):
   404 `not_found` after a server restart or once a settled item is pruned (10 minutes);
   503 during a maintenance drain, when every held item has already gone back to the Mac.
 
-Touching the Mac hands a held request back to its dialog at once; the deadline is 110 s.
+Touching the Mac hands a held request back to its dialog at once; the deadline is 110 s,
+or the away hold's.
+
+**The away hold (6.60.0).** A request that starts while you are away (the desk idle 90 s,
+the same threshold as above) is held for up to 10 minutes, but only when the glasses or the
+phone that show held questions report that you wore or touched them in the last 30 minutes.
+The client contract (COS Glasses 6.9.563 and later):
+
+- Poll `GET /api/session-questions?client=glasses|phone&hold=1&presenceAgeMs=<int>`.
+  `hold=1` says this client shows held questions. `presenceAgeMs` is the milliseconds since
+  the latest real wearer evidence (glasses: a ring or temple input, or a device status with
+  wearing true; phone: a foreground touch), a whole number from 0 to 86,400,000, and is left
+  out when there is none since the app started.
+- Only a poll with `hold=1` AND a valid `presenceAgeMs` counts toward the hold. The server
+  keeps the newest such presence in memory, on the monotonic clock and the wall clock, and
+  reads its age as the larger of the two (so a Mac that slept never makes it look newer).
+  Recent means within `COS_PERMISSION_BROKER_AWAY_RECENT_CLIENT_S` (default 1800, clamped to 0
+  through 86400; under 30 it means the 30 s live window). After a server restart nothing is
+  recent until such a poll.
+- A `hold=1` poll without presence (a connected lens nobody wears) makes no client live and
+  holds nothing. A poll without `hold=1` (COS Glasses 6.9.562 and earlier, every older phone
+  build) keeps the 6.59.0 meaning exactly: live for 30 s, a 110 s hold, and never the away
+  hold.
+
+Held that way, a request stays answerable while no client is polling, so glasses or a phone
+that come back can still answer it. It is re-checked every 1.5 s: once no client is live and
+your latest presence is older than the window, it goes to the Mac's dialog. Touching the Mac
+still hands it back within 1.5 s, and a request that arrives while you are at the desk still
+goes straight to the dialog. With no recent presence (a Claude Remote Control session with
+no glasses, say) nothing changes from 6.59.0: `{}` at once and the Mac's dialog.
+
+It is never held past the hook's own wait: the PermissionRequest `timeout` in
+`~/.claude/settings.json` (630 s after Install hooks; 130 s on an install from before 6.60.0)
+and the wait the hook stamps on the request, the lesser, minus 10 s. Until Install hooks has
+run, the hook waits no longer than 6.59.0 could hold, so the away hold is off entirely and the
+broker is 6.59.0. After updating, `--hooks status` reads `drift` with `priorWaitOnly: true`
+until Install hooks (COS Control) or `npx --yes @gotcos/glasses-server@latest --hooks install`
+is run once; cancel from the lens keeps working meanwhile. `COS_PERMISSION_BROKER_AWAY_HOLD_S`
+sets the hold (default 600, clamped to 30 through 600; `0` turns the away hold off; a `hold=1` lens still needs recent presence to count as live).
+Additive fields, every earlier one unchanged:
+
+- each item: `answerable` (true while listed), `awayHold` (held by the away hold) and
+  `waitingAtMac` (false while listed). `deadlineAt` is the latest it stays answerable; it goes
+  sooner when your presence lapses with no client polling.
+- the response: `awayHoldMs` (how long a request that starts now is held at most with recent
+  presence; 0 when off or before Install hooks), `awayRecentClientMs` (the presence window,
+  0 when the hold is off), `settled` (recently settled items, newest first: every one the Mac
+  still waits on, and the newest others up to 32; `id`, `sessionId`, `provider`, `kind`,
+  `tool`, `createdAt`, `deadlineAt`, `settledAt`, `resolution`, `answerable: false`,
+  `awayHold`, `waitingAtMac`; never the questions, the card or the answer), `waitingAtMac`
+  (how many of them the Mac's own dialog still waits on), `serverStartedAt` (when this server
+  process started) and `waitingAtMacForgottenBefore`.
+- `waitingAtMac` is true when the server handed the request to the Mac's dialog (back at the
+  desk, expired, no client, drained) and that request has not been finished since: its own
+  tool has not finished or been denied, its turn has not ended, and its session row does not
+  read ended. No hook marks the moment a dialog is approved, so an approved tool that is
+  still running reads as waiting. It is kept an hour, or up to a day while the session's own
+  row still waits on that request.
+- Forgot vs moved past: an entry you saw waiting that is no longer in `settled` was moved past
+  if its `settledAt` is after `waitingAtMacForgottenBefore`; at or before it (or from a server
+  with another `serverStartedAt`), the server forgot it, and the Mac may still be waiting.
+- `/api/models` `capabilities.sessionQuestions.awayHoldMs` and `awayRecentClientMs`, the same numbers.
+
 Allow once or deny only: no permission rule is ever written. Rows carry
 `pending_question_id` or `pending_permission_id` while a request is held, and a question
 row reads `waiting_kind: question` whatever the switch says; `/api/health` reports
@@ -402,8 +465,16 @@ machine-wide rollback for build 204+ server-owned query recovery),
 `COS_MESSAGES_TRAIL=0` (6.52.0: no Messages trail; every job stream and snapshot is the
 6.51.0 one), `COS_PERMISSION_BROKER` (6.52.0: `0` answers every permission request with
 the Mac's own dialog, `questions` holds questions but not tool approvals; unset holds
-both), `COS_PERMISSION_BROKER_DESK_IDLE_S` (default 90, never below 30) and
+both), `COS_PERMISSION_BROKER_DESK_IDLE_S` (default 90, never below 30),
 `COS_PERMISSION_BROKER_TIMEOUT_S` (default 110, clamped to 5 through 120),
+`COS_PERMISSION_BROKER_AWAY_HOLD_S` (6.60.0: default 600, clamped to 30 through 600, never
+past the installed hook's wait; `0` turns the away hold off),
+`COS_PERMISSION_BROKER_AWAY_RECENT_CLIENT_S` (6.60.0: default 1800; the away hold applies
+only when a `hold=1` client reported its wearer present within it; under 30 means the 30 s
+live window),
+`COS_DIARIZER` (6.61.0: default `nemotron`; `embedding` keeps the voiceprint only),
+`COS_NEMOTRON_CLI` and `COS_NEMOTRON_MODELS` (6.61.0: the FluidAudio CLI and its
+local model directory; see Speaker diarization),
 `COS_MEDIA_ROOT` (optional image/video store location; default
 `~/.cos-glasses/data/media`), and `COS_VIDEO_UPLOAD_V2=1` (private 6.27.3+
 resumable-video canary, managed by COS Control 0.5.20). The V2 canary retains
@@ -510,6 +581,66 @@ report `enrolled: false`. Set `owner_speaker_label` to `MU` to keep the existing
 voiceprints rather than re-enrolling, which would split the same voice across two
 profiles.
 
+### Who spoke when: Nemotron (6.61.0, the default)
+
+The voiceprint names a person but gives a chunk one label, and about 45% of
+meeting chunks hold two voices. Since 6.61.0 the server separates the voices
+with [Nemotron 3 Diarization](https://huggingface.co/FluidInference/nemotron-3-diarization-coreml)
+(FluidAudio's `fluidaudiocli`, preset `fast32`, Neural Engine) and lets the
+voiceprint name each one. Nemotron never names anyone itself, and the
+voiceprint's thresholds are unchanged: what changes is that a two-voice chunk
+is split into turns instead of carrying one label.
+
+- **Live, on the HUD.** Each chunk runs Nemotron in parallel with Whisper, inside
+  a 1.5 s budget, at most two at once. The chunk response keeps `speaker` (now
+  the dominant voice's name) and `text`, and adds
+  `segments: [{ speaker, text, startSec, endSec, similarity }]` in time order;
+  their texts joined with one space equal `text`. A track with at least 2 s of
+  its own audio is named by the voiceprint on that audio; a shorter one takes the
+  chunk's voiceprint when it is the dominant voice, otherwise the client's label
+  (when that is a real name different from the dominant one) or `Ext`. The
+  segments are stored on the chunk, so the saved meeting keeps them.
+- **The final transcript.** When a meeting is saved, one Nemotron pass over the
+  whole meeting maps each channel to a name from the chunks the voiceprint was
+  sure of (similarity 0.65 or more, one-sided), and relabels the transcript word
+  by word before the meeting reaches COS sync. A channel two people share stays
+  unmapped and keeps the per-chunk names. Only labels change: lines split where
+  the speaker changes and are never merged, nothing is written unless every
+  word survives in order, changed words keep `originalSpeaker`, and the sidecar
+  keeps the pre-relabel transcript under `diarization.originalTranscript`. A
+  meeting with a human speaker correction is never relabelled; an edit made
+  while the pass runs makes it stand down, and relabel or deattribute answer
+  409 `meeting_finalizing` until the meeting has finished finalizing.
+- **Never in the way.** Until the model is warm (the first Neural Engine compile
+  takes 15 to 35 s, started in the background at server start), and on any
+  timeout, crash, busy lane, missing CLI or missing model, a chunk keeps the
+  voiceprint label exactly as before, and the server logs the reason. Three
+  failed runs in a row open a breaker: no CLI is spawned and every chunk takes
+  the voiceprint at once, for 2 minutes, doubling per trip up to an hour, then
+  one fresh warm-up decides. A failed final pass leaves the meeting exactly as
+  saved. The CLI runs with a minimal environment (no tokens or keys), and no run
+  or temp file outlives the server. No model call is ever made.
+
+**Offline.** The server always passes `--models <dir>` to the CLI, a directory
+holding `Nemotron3Diarizer_fast32.mlmodelc` and `learnable_sil_emb.bin`, and that
+path in FluidAudio never downloads. Without `--models` the CLI fetches from
+Hugging Face, so the server never runs it that way. The directory is
+`COS_NEMOTRON_MODELS`, else `~/.cos-glasses/models/nemotron-3-diarization`, which
+the server links to FluidAudio's own cache
+(`~/Library/Application Support/FluidAudio/Models/nemotron-3-diarization`, left
+there by running the CLI once by hand). The CLI is `COS_NEMOTRON_CLI`, else
+`~/.cos-glasses/bin/fluidaudiocli`. Missing either, the server stays on the
+voiceprint and says so.
+
+`COS_DIARIZER=embedding` (or `voiceprint`, `eres2net`) turns Nemotron off: no
+warm-up, no run, the 6.60 labels. `/api/health` `readiness.diarizer` reports
+`active` (`nemotron` only while warm, the breaker is closed and most recent
+chunks really were labelled by Nemotron; otherwise `warming` or `embedding`),
+the `fallback` reason, the recent outcomes, the breaker, the per-chunk counts,
+the warm-up and the final passes. `/api/health` is public, so this carries codes
+and counts only, never a speaker name, path or error text; those stay in
+`server.log`. A Nemotron fallback never degrades `readiness.status`.
+
 ## HQ dictation
 
 Prompt dictation defaults to HQ. The phone owns the preference: **Fast mode
@@ -726,13 +857,17 @@ BIND_HOST=0.0.0.0 npm run start:server
   back, set `COS_DURABLE_QUERY_JOBS=0`; accepted jobs still drain while new prompts use legacy streaming.
 - *Session questions never reach the glasses?* The server holds one only when every
   gate passes. `/api/health` `permissionBroker.lastFastPath` names the last reason a
-  request went straight to the Mac's dialog: `no_client` (no poll with
-  `client=glasses|phone` in the last 30 s: the app build has no question cards, or its
-  timers are frozen), `desk_active` (the Mac saw input), `approvals_off`
+  request went straight to the Mac's dialog: `no_client` (no client could answer: no poll
+  with `client=glasses|phone` and without `hold=1` in the last 30 s, no `hold=1` poll in the
+  last 30 s whose wearer was present within the window, and (6.60.0) no away hold: the app
+  build has no question cards, its timers are frozen, nobody wore the glasses or touched the
+  phone recently, or Install hooks has not run; the server log line `fast path no_client
+  not_away=...` names which), `desk_active` (the Mac saw input), `approvals_off`
   (`COS_PERMISSION_BROKER=questions`), `broker_off`, `cursor`, `unsupported_tool`
   (ExitPlanMode is never held). `lastQuestionsPollAt` says when a client last counted.
   `--hooks status` must read `installed` (right after updating to 6.53.4 it reads
-  `script_outdated` until Install hooks is run once; its `advice` line says so). To turn it off with no reinstall, set
+  `script_outdated` until Install hooks is run once, and right after updating to 6.60.0
+  `drift` with `priorWaitOnly: true`; its `advice` line says so). To turn it off with no reinstall, set
   `COS_PERMISSION_BROKER=0` in `~/.cos-glasses/.env` and restart. For the Messages
   trail, `/api/health` `messages_trail.readerErrors` counts lines a reader could not map.
 - *Offline meeting recovery unavailable?* — build 209+ requires server 6.11.0+.

package/bin/hooks/cos-session-hook

@@ -1,5 +1,5 @@
 #!/bin/sh
-# COS session hook (glasses-server 6.48.0; Cursor Stop follow-up 6.51.0; halt check 6.53.0; single entry 6.53.3). Installed into ~/.claude/settings.json by
+# COS session hook (glasses-server 6.48.0; Cursor Stop follow-up 6.51.0; halt check 6.53.0; single entry 6.53.3; away hold wait 6.60.0). Installed into ~/.claude/settings.json by
 # `--hooks install`; Claude Code runs it with the hook event name as $1 and the event
 # payload on stdin. It spools one JSON file per event into the hook spool and exits 0
 # on every path. Only PermissionRequest ever talks to the server, and only when the
@@ -115,7 +115,17 @@ else
   { head -c 1048576 > "$T.in"; cat >/dev/null; }
 fi
 case "$(head -c 1 "$T.in")" in '{') ;; *) EVENT=rejected ;; esac
-{ printf '{"ts":%s,"ppid":%s,"event":"%s","payload":' "$TS" "$PPID" "$EVENT"; cat "$T.in"; printf '}\n'; } > "$T"
+# 6.60.0: the installer passes the PermissionRequest block's own timeout as $2. Claude Code
+# stops this hook at that many seconds, so curl below gives up 5 s before it, and the
+# request carries it (`hookWaitS`) so the server never holds it longer. No usable $2 (an
+# earlier block) is the earlier wait, 130, with no stamp.
+WAIT=130; STAMP_WAIT=''
+if [ "$EVENT" = PermissionRequest ]; then
+  case "${2:-}" in ''|0*|*[!0-9]*) ;; *)
+    if [ ${#2} -le 4 ] && [ "$2" -ge 20 ] && [ "$2" -le 3600 ]; then WAIT=$2; STAMP_WAIT=",\"hookWaitS\":$2"; fi ;;
+  esac
+fi
+{ printf '{"ts":%s,"ppid":%s,"event":"%s"%s,"payload":' "$TS" "$PPID" "$EVENT" "$STAMP_WAIT"; cat "$T.in"; printf '}\n'; } > "$T"
 rm -f "$T.in"
 # 6.51.0, CURSOR ONLY. Cursor runs this hook from ~/.claude/settings.json for its own
 # composers, and submits a Stop hook's {"followup_message":...} as that composer's next
@@ -153,8 +163,18 @@ DESK_S=$(cat "$GH/hook-desk-idle-s" 2>/dev/null || echo 90)
 { [ -n "$IDLE_NS" ] && [ "$(( ${IDLE_NS%.*} / 1000000000 ))" -ge "$DESK_S" ]; } || { cleanup; exit 0; }
 TOK=$(cat "$GH/hook-token" 2>/dev/null); [ -n "$TOK" ] || { cleanup; exit 0; }   # no token, no request
 PORT=$(cat "$GH/hook-port" 2>/dev/null || echo 3141)
-OUT=$(curl -s --connect-timeout 2 --max-time 125 -H "X-Cos-Hook-Token: $TOK" -H 'content-type: application/json' \
-  --data-binary @"$T.req" "http://127.0.0.1:$PORT/api/permission-requests/ask") || { cleanup; exit 0; }
+# 6.60.0 (QA round 1, W7): curl runs as a tracked child, not only inside $(...), and this
+# script stops it when it is stopped itself (Claude Code's timeout, an interrupt). The
+# broker then sees the socket close at once (`hook_gone`) and never accepts an answer the
+# session can no longer receive.
+rm -f "$T.out"
+curl -s --connect-timeout 2 --max-time $((WAIT - 5)) -H "X-Cos-Hook-Token: $TOK" -H 'content-type: application/json' \
+  -o "$T.out" --data-binary @"$T.req" "http://127.0.0.1:$PORT/api/permission-requests/ask" &
+CURL=$!
+trap 'kill "$CURL" 2>/dev/null; rm -f "$T.req" "$T.out"; exit 0' TERM INT HUP
+wait "$CURL" || { trap - TERM INT HUP; cleanup; rm -f "$T.out"; exit 0; }
+trap - TERM INT HUP
+OUT=$(cat "$T.out" 2>/dev/null); rm -f "$T.out"
 cleanup
 case "$OUT" in '{"hookSpecificOutput"'*) printf '%s' "$OUT" ;; esac
 exit 0

package/managed-runtime-contract.json

@@ -35,9 +35,14 @@
     "COS_PERMISSION_BROKER",
     "COS_PERMISSION_BROKER_DESK_IDLE_S",
     "COS_PERMISSION_BROKER_TIMEOUT_S",
+    "COS_PERMISSION_BROKER_AWAY_HOLD_S",
+    "COS_PERMISSION_BROKER_AWAY_RECENT_CLIENT_S",
     "COS_LENS_GIST_ENGINE",
     "COS_LENS_GIST_MODEL",
-    "COS_LENS_GIST_DAILY_CAP"
+    "COS_LENS_GIST_DAILY_CAP",
+    "COS_DIARIZER",
+    "COS_NEMOTRON_CLI",
+    "COS_NEMOTRON_MODELS"
   ],
   "maintenance": {
     "scope": "cross_boot",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotcos/glasses-server",
-  "version": "6.59.0",
+  "version": "6.61.0",
   "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,9 @@
     "!server/scripts/work-review-mutation-gate.mjs",
     "!server/scripts/work-intake-mutation-gate.mjs",
     "!server/scripts/work-progress-mutation-gate.mjs",
+    "!server/scripts/away-hold-mutation-gate.mjs",
+    "!server/scripts/nemotron-mutation-gate.mjs",
+    "!server/scripts/nemotron-replay.ts",
     "!server/scripts/mutation-gate.mjs",
     "!server/lib/meeting-engine/__fixtures__/**",
     "!server/lib/__fixtures__/**",

package/server/index.ts

@@ -24,13 +24,15 @@ import { agentSessionStreamRouter } from './routes/agent-session-stream.js'
 import { createAttachedTurnStream } from './lib/session-stream-producer.js'
 import { claudeSessionsRouter } from './routes/claude-sessions.js'
 import { createSessionHooksRouter } from './routes/session-hooks.js'
-import { cachedHookStatus, claudeDeskRunning, deskIdleSeconds, deskTurnEndedAt, haltHandedOffTurn, registerDrainKickStats, registryIdleAfterStop, sessionHooksEnabled, sessionSignalStore, signalFor, startSessionHooksRuntime } from './lib/session-hooks-runtime.js'
+import { cachedHookStatus, claudeDeskRunning, onSessionRowEnded, deskIdleSeconds, deskTurnEndedAt, haltHandedOffTurn, registerDrainKickStats, registryIdleAfterStop, sessionHooksEnabled, sessionSignalStore, signalFor, startSessionHooksRuntime } from './lib/session-hooks-runtime.js'
 import { writeHaltMarker } from './lib/session-halt.js'
 import { appendSessionCancelLedger, cancelHoldUntil as cancelHoldUntilFor, noteThreadCancelled, threadCancel } from './lib/session-cancel.js'
 import { makeQueueTurnEvidence } from './lib/queue-turn-evidence.js'
 import {
   PermissionBroker,
   brokerSignalSink,
+  permissionBrokerAwayHoldMs,
+  permissionBrokerAwayRecentClientMs,
   permissionBrokerMode,
   permissionBrokerTimeoutMs,
   readHidIdleSeconds,
@@ -38,7 +40,7 @@ import {
   wirePermissionBrokerToSignals,
 } from './lib/permission-broker.js'
 import { createPermissionBrokerHookRouter, createSessionQuestionsRouter } from './routes/permission-broker.js'
-import { lastQuestionsPollAt } from './lib/client-liveness.js'
+import { lastHoldQuestionsPollAt, lastLegacyQuestionsPollAt, lastQuestionsPollAt, presenceAgeMs } from './lib/client-liveness.js'
 import {
   createAgentSessionBindingsRouter,
   TargetGuard,
@@ -114,6 +116,8 @@ import { startLocalTtsServer, stopLocalTtsServer } from './lib/tts-local.js'
 import { initSileroVAD } from './lib/vad-silero.js'
 import { initSessionCache } from './lib/session-cache-writer.js'
 import { initSpeakerEmbeddings } from './lib/speaker-embeddings.js'
+import { startNemotronWarmup } from './lib/nemotron-live.js'
+import { killNemotronChildren } from './lib/nemotron-cli.js'
 import { logActiveSessionsOnShutdown, startAutoSnapshot } from './lib/conversation.js'
 import { getMediaStore } from './lib/media-store.js'
 import { listenRequiredServers, type RequiredListener } from './lib/listener-startup.js'
@@ -241,6 +245,13 @@ app.use(cors({
 // (lib/permission-broker.ts). An app without the question UI never polls, so for it every
 // request is `{}`. `COS_PERMISSION_BROKER=0` is the switch, read per request, and every
 // request outside the gate is answered `{}` at once.
+// 6.60.0: the away hold. While the desk is idle, and only when glasses or a phone that send
+// `hold=1` reported wearer presence within `COS_PERMISSION_BROKER_AWAY_RECENT_CLIENT_S`
+// (default 1800; in memory, the larger of the monotonic and wall-clock age), a request is held
+// up to `COS_PERMISSION_BROKER_AWAY_HOLD_S` (default 600, `0` is the 6.59.0 broker) whether or
+// not a client is polling right now, never past the PermissionRequest timeout the Claude
+// settings file carries (read through the 5 s hook-status cache) and the hook's own stamp.
+// Older clients (no `hold=1`) keep the 6.59.0 liveness and never enable it.
 const permissionBroker = new PermissionBroker({
   now: () => Date.now(),
   mode: () => permissionBrokerMode(process.env, sessionHooksEnabled()),
@@ -249,10 +260,22 @@ const permissionBroker = new PermissionBroker({
   readDeskIdleSeconds: readHidIdleSeconds,
   deskIdleSeconds,
   timeoutMs: () => permissionBrokerTimeoutMs(process.env),
+  awayHoldMs: () => permissionBrokerAwayHoldMs(process.env),
+  installedHookTimeoutS: () => cachedHookStatus().permissionHookTimeoutS,
+  lastLegacyPollAt: lastLegacyQuestionsPollAt,
+  lastHoldPollAt: lastHoldQuestionsPollAt,
+  presenceAgeMs: () => presenceAgeMs(),
+  awayRecentClientMs: () => permissionBrokerAwayRecentClientMs(process.env),
+  stillWaitingAtMac: (sessionId, fingerprint) => {
+    const signal = sessionSignalStore.get(sessionId)
+    return !!signal && !signal.ended && signal.waiting?.fingerprint === fingerprint
+  },
   signals: brokerSignalSink(sessionSignalStore),
 })
 registerPermissionBroker(permissionBroker)
 wirePermissionBrokerToSignals(permissionBroker, sessionSignalStore)
+// 6.60.0 (QA round 1, N2): a row that reads ended clears "waiting at the Mac" at once.
+onSessionRowEnded(sessionId => { permissionBroker.sessionRowEnded(sessionId) })
 
 // THE TWO HOOK-TOKEN DOORS, deliberately BEFORE the /api gate and the global body parser.
 // Each checks the per-install hook token (never the pairing token) in constant time before
@@ -979,6 +1002,12 @@ async function gracefulShutdown(): Promise<void> {
     console.error('[live-cues] shutdown termination failed:', error)
   }
   try { logActiveSessionsOnShutdown() } catch { /* best-effort flush */ }
+  // 6.61.0: no Nemotron run may outlive the server, and no temp directory may
+  // keep a meeting's audio (the module's exit hook repeats this for any exit).
+  try {
+    const nemotron = killNemotronChildren()
+    if (nemotron.killed || nemotron.removed) console.log(`[diarizer] shutdown: killed ${nemotron.killed} Nemotron run(s), removed ${nemotron.removed} temp dir(s)`)
+  } catch { /* best effort */ }
   stopCodexModelCatalogRefresh()
   stopWhisperServer()
   await stopWhisperPreviewServer({ final: true })
@@ -1141,6 +1170,9 @@ listenRequiredServers(listeners).then(() => {
     // Initialize Silero VAD (silence trimming before Whisper) — fails soft if model absent
     const vadOk = initSileroVAD()
     console.log(`[startup] Silero VAD: ${vadOk ? 'active' : 'disabled (model not found)'}`)
+    // 6.61.0: warm Nemotron in the background (the first Neural Engine compile
+    // takes 15-30 s). Chunks use the voiceprint until it is warm; never awaited.
+    startNemotronWarmup()
   }
 
   // Durable recovery starts with the admitted runtime by default. A literal