@gotcos/glasses-server 6.59.0 → 6.60.0

package/CHANGELOG.md

@@ -1,3 +1,31 @@
+## 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,13 @@ 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_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
@@ -726,13 +794,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,6 +35,8 @@
     "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"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotcos/glasses-server",
-  "version": "6.59.0",
+  "version": "6.60.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,7 @@
     "!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/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,
@@ -241,6 +243,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 +258,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

package/server/lib/claude-hooks-installer.ts

@@ -36,8 +36,24 @@ export interface HookSubscription {
   matcher?: string
   async: boolean
   timeout: number
+  /**
+   * 6.60.0: the command passes the block's own `timeout` to the script as its second
+   * argument. The script stops waiting 5 s before it and stamps it on the request it posts
+   * (`hookWaitS`), so the broker knows the wait of THIS invocation. The command and the
+   * timeout sit in one block, so whether or not a running Claude session re-reads its hook
+   * settings, the stamp it sends and the timeout it enforces come from the same block.
+   */
+  passTimeout?: boolean
 }
 
+/**
+ * 6.60.0: Claude Code's wait on the PermissionRequest hook: the away hold (default 600 s)
+ * plus slack. The script's curl stops at 625 and the broker answers by 620 at the latest.
+ */
+export const PERMISSION_HOOK_TIMEOUT_S = 630
+/** What every install before 6.60.0 carries for PermissionRequest, with no wait argument. */
+export const LEGACY_PERMISSION_HOOK_TIMEOUT_S = 130
+
 /**
  * Every event the reducer understands, with the timing each one needs. SessionStart,
  * UserPromptSubmit, Stop and SessionEnd are synchronous: measured 2026-09-15, an async
@@ -55,6 +71,10 @@ export interface HookSubscription {
  * because the merge keeps exactly one of ours per event and status requires it: the script
  * spools only AskUserQuestion and ExitPlanMode, which is what the old async matcher block
  * did. Changing this row makes every existing install read `drift` until Install hooks.
+ *
+ * 6.60.0: PermissionRequest waits 630 s (was 130) and passes that number to the script, for
+ * the away hold. An install that differs ONLY by still carrying the earlier block (130 s, no
+ * argument) reads `drift` with `priorWaitOnly`, and stays halt-ready (`hookHaltReady`).
  */
 export const HOOK_SUBSCRIPTIONS: readonly HookSubscription[] = [
   { event: 'SessionStart', async: false, timeout: 5 },
@@ -62,7 +82,7 @@ export const HOOK_SUBSCRIPTIONS: readonly HookSubscription[] = [
   { event: 'UserPromptSubmit', async: false, timeout: 5 },
   { event: 'Stop', async: false, timeout: 5 },
   { event: 'StopFailure', async: true, timeout: 10 },
-  { event: 'PermissionRequest', async: false, timeout: 130 },
+  { event: 'PermissionRequest', async: false, timeout: PERMISSION_HOOK_TIMEOUT_S, passTimeout: true },
   { event: 'PermissionDenied', async: true, timeout: 10 },
   { event: 'PreToolUse', async: false, timeout: 5 },
   { event: 'PostToolUse', async: true, timeout: 10 },
@@ -117,9 +137,13 @@ export function shellQuote(value: string): string {
 /**
  * The installed command carries the two paths the script needs as environment, so the
  * server and the script can never disagree about where the spool or the token is.
+ * 6.60.0: `waitS`, for a subscription with `passTimeout`, follows the event name as the
+ * script's second argument (an argument, never an environment variable: a variable could
+ * be inherited from the shell that started Claude, an argument only comes from this block).
  */
-export function hookCommand(scriptPath: string, event: string, paths: HookPaths = currentHookPaths()): string {
-  return `COS_GLASSES_HOME=${shellQuote(paths.home)} COS_HOOK_SPOOL=${shellQuote(paths.spoolDir)} ${shellQuote(scriptPath)} ${event}`
+export function hookCommand(scriptPath: string, event: string, paths: HookPaths = currentHookPaths(), waitS?: number): string {
+  const base = `COS_GLASSES_HOME=${shellQuote(paths.home)} COS_HOOK_SPOOL=${shellQuote(paths.spoolDir)} ${shellQuote(scriptPath)} ${event}`
+  return waitS === undefined ? base : `${base} ${Math.trunc(waitS)}`
 }
 
 export interface HookPaths {
@@ -133,20 +157,57 @@ export function currentHookPaths(): HookPaths {
 
 type HookBlock = { matcher?: unknown; hooks?: unknown }
 
+function hookIsOurs(h: unknown): boolean {
+  return !!h && typeof h === 'object' && typeof (h as { command?: unknown }).command === 'string'
+    && ((h as { command: string }).command.includes(HOOK_SCRIPT_MARKER) || (h as { command: string }).command.includes(HOOK_SCRIPT_NAME + ' '))
+}
+
 function blockIsOurs(block: unknown): boolean {
   if (!block || typeof block !== 'object') return false
   const hooks = (block as HookBlock).hooks
   if (!Array.isArray(hooks)) return false
-  return hooks.some(h => h && typeof h === 'object' && typeof (h as { command?: unknown }).command === 'string'
-    && ((h as { command: string }).command.includes(HOOK_SCRIPT_MARKER) || (h as { command: string }).command.includes(HOOK_SCRIPT_NAME + ' ')))
+  return hooks.some(hookIsOurs)
 }
 
 function canonicalBlock(scriptPath: string, sub: HookSubscription, paths: HookPaths): Record<string, unknown> {
-  const hook: Record<string, unknown> = { type: 'command', command: hookCommand(scriptPath, sub.event, paths), timeout: sub.timeout }
+  const command = hookCommand(scriptPath, sub.event, paths, sub.passTimeout ? sub.timeout : undefined)
+  const hook: Record<string, unknown> = { type: 'command', command, timeout: sub.timeout }
   if (sub.async) hook.async = true
   return sub.matcher ? { matcher: sub.matcher, hooks: [hook] } : { hooks: [hook] }
 }
 
+/**
+ * 6.60.0: the block an install before 6.60.0 wrote for this event, when this release changed
+ * it only by the wait: PermissionRequest at 130 s with no wait argument. Null for any other.
+ */
+function priorWaitBlock(scriptPath: string, sub: HookSubscription, paths: HookPaths): Record<string, unknown> | null {
+  if (sub.event !== 'PermissionRequest') return null
+  return canonicalBlock(scriptPath, { event: sub.event, async: sub.async, timeout: LEGACY_PERMISSION_HOOK_TIMEOUT_S }, paths)
+}
+
+/**
+ * 6.60.0: how long Claude Code waits on OUR PermissionRequest hook, read from a settings
+ * object: the smallest `timeout` among our entries (Claude runs each, so the first to give up
+ * bounds the wait). Null when none of ours is there, or one of ours has no usable number:
+ * the broker then keeps the old safe clamp (`lib/permission-broker.ts` `holdCeilingS`).
+ */
+export function permissionHookTimeoutS(settings: unknown): number | null {
+  const hooks = settings && typeof settings === 'object' ? (settings as Record<string, unknown>).hooks : null
+  const blocks = hooks && typeof hooks === 'object' ? (hooks as Record<string, unknown>).PermissionRequest : null
+  if (!Array.isArray(blocks)) return null
+  let least: number | null = null
+  for (const block of blocks) {
+    if (!blockIsOurs(block)) continue
+    for (const h of (block as HookBlock).hooks as unknown[]) {
+      if (!hookIsOurs(h)) continue
+      const timeout = (h as { timeout?: unknown }).timeout
+      if (typeof timeout !== 'number' || !Number.isFinite(timeout) || timeout <= 0) return null
+      least = least === null ? timeout : Math.min(least, timeout)
+    }
+  }
+  return least
+}
+
 export type MergeResult =
   | { ok: true; settings: Record<string, unknown>; changed: boolean }
   /** The file holds a `hooks` shape this merge would have to destroy to proceed. */
@@ -190,22 +251,29 @@ export function stripHookSettings(current: unknown): MergeResult {
   return { ok: true, settings, changed: JSON.stringify(settings) !== before }
 }
 
-/** Which of our events a settings object carries, by exact canonical command. */
-export function subscribedEvents(current: unknown, scriptPath: string, paths: HookPaths = currentHookPaths()): { subscribed: string[]; missing: string[]; drifted: string[] } {
+/**
+ * Which of our events a settings object carries, by exact canonical command. `priorWait`
+ * (6.60.0) names the drifted events whose one block of ours is exactly the block an earlier
+ * release wrote, differing only by the wait (`priorWaitBlock`).
+ */
+export function subscribedEvents(current: unknown, scriptPath: string, paths: HookPaths = currentHookPaths()): { subscribed: string[]; missing: string[]; drifted: string[]; priorWait: string[] } {
   const hooks = current && typeof current === 'object' && (current as Record<string, unknown>).hooks
   const table = hooks && typeof hooks === 'object' ? hooks as Record<string, unknown> : {}
   const subscribed: string[] = []
   const missing: string[] = []
   const drifted: string[] = []
+  const priorWait: string[] = []
   for (const sub of HOOK_SUBSCRIPTIONS) {
     const blocks = Array.isArray(table[sub.event]) ? table[sub.event] as unknown[] : []
     const ours = blocks.filter(blockIsOurs)
     if (ours.length === 0) { missing.push(sub.event); continue }
     const canonical = JSON.stringify(canonicalBlock(scriptPath, sub, paths))
-    if (ours.length === 1 && JSON.stringify(ours[0]) === canonical) subscribed.push(sub.event)
-    else drifted.push(sub.event)
+    if (ours.length === 1 && JSON.stringify(ours[0]) === canonical) { subscribed.push(sub.event); continue }
+    drifted.push(sub.event)
+    const prior = priorWaitBlock(scriptPath, sub, paths)
+    if (prior && ours.length === 1 && JSON.stringify(ours[0]) === JSON.stringify(prior)) priorWait.push(sub.event)
   }
-  return { subscribed, missing, drifted }
+  return { subscribed, missing, drifted, priorWait }
 }
 
 export type HookInstallState =
@@ -231,6 +299,16 @@ export interface HookStatus {
   subscribed: string[]
   missing: string[]
   drifted: string[]
+  /** 6.60.0: drifted events whose block is exactly an earlier release's, but for the wait. */
+  priorWait: string[]
+  /**
+   * 6.60.0: `drift`, and the ONLY difference is that the settings still carry the earlier
+   * PermissionRequest block (130 s, no wait argument): an install from before 6.60.0 that
+   * has not run Install hooks since. Questions are then held at most 120 s, as before.
+   */
+  priorWaitOnly: boolean
+  /** 6.60.0: our PermissionRequest hook's `timeout` in the settings file, or null (`permissionHookTimeoutS`). */
+  permissionHookTimeoutS: number | null
   tokenPresent: boolean
 }
 
@@ -272,16 +350,19 @@ export function hookStatus(paths: { settingsPath?: string; scriptPath?: string;
   const tokenPresent = existsSync(hookTokenPath())
   const read = readSettings(settingsPath)
   if (!read.ok) {
-    return { state: read.reason, installed: false, settingsPath, scriptPath, scriptSha, packageScriptSha, subscribed: [], missing: HOOK_SUBSCRIPTIONS.map(s => s.event), drifted: [], tokenPresent }
+    return { state: read.reason, installed: false, settingsPath, scriptPath, scriptSha, packageScriptSha, subscribed: [], missing: HOOK_SUBSCRIPTIONS.map(s => s.event), drifted: [], priorWait: [], priorWaitOnly: false, permissionHookTimeoutS: null, tokenPresent }
   }
   const events = subscribedEvents(read.settings, scriptPath, hookPaths)
+  const permissionWaitS = permissionHookTimeoutS(read.settings)
   let state: HookInstallState
   if (hooksDisabled(read.settings)) state = 'disabled_by_settings'
   else if (events.subscribed.length === 0 && events.drifted.length === 0) state = 'missing'
   else if (events.missing.length > 0 || events.drifted.length > 0) state = 'drift'
   else if (!scriptSha || (packageScriptSha && scriptSha !== packageScriptSha)) state = 'script_outdated'
   else state = 'installed'
-  return { state, installed: state === 'installed', settingsPath, scriptPath, scriptSha, packageScriptSha, ...events, tokenPresent }
+  const priorWaitOnly = state === 'drift' && events.missing.length === 0 && events.drifted.length > 0
+    && events.drifted.every(event => events.priorWait.includes(event))
+  return { state, installed: state === 'installed', settingsPath, scriptPath, scriptSha, packageScriptSha, ...events, priorWaitOnly, permissionHookTimeoutS: permissionWaitS, tokenPresent }
 }
 
 /**
@@ -295,22 +376,35 @@ export function hookStatus(paths: { settingsPath?: string; scriptPath?: string;
  *   - c0b41bf8...: the 6.53.3 script as first built, before its /qa round made every event
  *     drain stdin. Never published, but installable from a local build of that commit
  *     (7433b7f), and it carries the same halt check.
+ *   - df54677f...: the script 6.53.3 through 6.59.0 shipped. 6.60.0 changed it only for the
+ *     away hold (the PermissionRequest wait); its halt check is the same.
  * Each is pinned against its bytes in `server/lib/__fixtures__/`.
  */
 export const HALT_CAPABLE_PRIOR_SCRIPT_SHAS: readonly string[] = [
   '1158bb06297550128f01fc47caa68806a5287d6da2d05b0d1c812e8ae20764e7',
   'c0b41bf8581cfea498e1e1ac5220fe4e148bd97448d13b60a88879ee5992cc51',
+  'df54677f79908893509ee87608cfe3f4a53ced03f88f337f16a63741d6b3d547',
 ]
 
 /**
  * 6.53.3: can the hooks on this Mac stop a desk Claude run now? `installed`, or the only
  * difference is a halt-capable earlier script (above). What the cancel route's
  * `hooksReady` and `/api/health` `features.sessionCancel.deskClaude` read.
+ *
+ * 6.60.0: or `drift` with `priorWaitOnly` (the settings still carry the earlier
+ * PermissionRequest wait, every other block is current) on this package's script or a
+ * halt-capable earlier one. The wait changes how long a question is held, not the halt
+ * check, so updating the server never turns cancel from the lens off. Any other drift
+ * still is not halt-ready.
  */
-export function hookHaltReady(status: Pick<HookStatus, 'installed' | 'state' | 'scriptSha'>): boolean {
+export function hookHaltReady(status: Pick<HookStatus, 'installed' | 'state' | 'scriptSha'> & Partial<Pick<HookStatus, 'priorWaitOnly' | 'packageScriptSha'>>): boolean {
   if (status.installed === true) return true
-  return status.state === 'script_outdated' && typeof status.scriptSha === 'string'
-    && HALT_CAPABLE_PRIOR_SCRIPT_SHAS.includes(status.scriptSha)
+  const priorScript = typeof status.scriptSha === 'string' && HALT_CAPABLE_PRIOR_SCRIPT_SHAS.includes(status.scriptSha)
+  if (status.state === 'script_outdated') return priorScript
+  if (status.state === 'drift' && status.priorWaitOnly === true) {
+    return priorScript || (typeof status.scriptSha === 'string' && status.scriptSha === status.packageScriptSha)
+  }
+  return false
 }
 
 const INSTALL_COMMAND = 'npx --yes @gotcos/glasses-server@latest --hooks install'
@@ -319,8 +413,17 @@ const INSTALL_COMMAND = 'npx --yes @gotcos/glasses-server@latest --hooks install
  * 6.53.3: one plain sentence for `--hooks status` saying what the state means and what fixes
  * it. Null when installed. Carries no path: the status JSON beside it already names them.
  */
-export function hookStatusAdvice(status: Pick<HookStatus, 'installed' | 'state' | 'scriptSha' | 'packageScriptSha'>): string | null {
+export function hookStatusAdvice(status: Pick<HookStatus, 'installed' | 'state' | 'scriptSha' | 'packageScriptSha'> & Partial<Pick<HookStatus, 'priorWaitOnly'>>): string | null {
   const short = (sha: string | null): string => (sha ? sha.slice(0, 12) : 'none')
+  // 6.60.0: the one drift an update itself causes. Say what it costs and that nothing broke.
+  if (status.state === 'drift' && status.priorWaitOnly === true) {
+    return 'The Claude settings file still carries the earlier permission hook wait (130 s), so a question that starts while you are away '
+      + 'is held for the glasses for at most 2 minutes instead of 10. '
+      + `Run \`${INSTALL_COMMAND}\`, or press Install hooks in COS Control. `
+      + (hookHaltReady(status)
+        ? 'Cancel from the lens still stops desk runs meanwhile.'
+        : 'Until then a desk run cannot be cancelled from the lens.')
+  }
   switch (status.state) {
     case 'installed':
       return null