@gotcos/glasses-server 6.36.7 → 6.36.9

package/CHANGELOG.md

@@ -1,5 +1,48 @@
 ## Unreleased
 
+## 6.36.9
+- **The queue gate can now see COS's own bindings, which closes a 30-minute lockout.**
+  `threadOccupancy` sees FOREIGN holders only — `OccupancyReason` has no
+  `native_target_busy`, because that refusal comes from the binding registry. So when a
+  live COS binding held a thread, Continue refused `native_target_busy`, the client
+  armed the queue, and this gate answered `409 thread_free` ("Pick Continue again"),
+  which refused identically. A closed loop for the whole binding TTL, while the refusal
+  copy said "detach that one first" — an action with no endpoint.
+- The same gap burnt the delivery ceiling: the drainer saw `attachable`, ATTEMPTED, and
+  the attach route refused. Five of those retired a turn in about two minutes. With the
+  binding visible, `drainDecision` returns `hold` and spends nothing — one change closes
+  both the loop and the burn.
+- **A gate refusal no longer spends an attempt.** Classified by REASON, never by status:
+  every refusal that is not `invalid_request` (400) or a capability gap (503) comes back
+  409, so a status rule would have retried `native_target_fenced` — "an earlier turn may
+  or may not have been delivered" — up to 1,080 times. Reuses `queueableRefusal`, and
+  fails CLOSED on an unrecognised reason.
+- The attempt is still written and fsynced BEFORE the call, then REFUNDED once the
+  outcome is known. Deferring the increment would have reopened the crash-safety hole
+  the comment there describes, and a test reads `attempts` off disk mid-delivery to
+  prove it.
+- **The refusal reason is no longer discarded.** `deliver` read `body.error`; the attach
+  route emits `reason` and has never emitted `error`, so every stored reason in the
+  field was the literal `attach_409` and the whole feature was reason-blind. Also
+  carries the turn route's own `retryable` verdict, which outranks our inference.
+
+
+## 6.36.8
+- **The queue now covers the refusal that actually fires.** Device diagnostics, once the
+  path was finally instrumented, recorded `native_target_busy` on every Continue that
+  reached the server — never `native_thread_working`, which is what 6.36.7 was built
+  around. Selecting Continue SUCCEEDS and mints a binding; if the dictation is not
+  completed the binding lingers to its TTL, and every Continue inside that window
+  refuses. Twelve such bindings had stacked up on one thread over an evening.
+- `native_target_busy` and `native_turn_in_progress` are now queueable. Both are
+  transient by construction — a clock clears them — and both are COS's OWN bookkeeping
+  rather than a foreign process holding the thread. Delivery still re-runs the full
+  gate, so nothing about the safety model changes.
+- `native_target_fenced` is deliberately NOT queueable: "may or may not have been
+  delivered" cannot be resolved by waiting, and queueing it risks a duplicate turn in a
+  real conversation.
+
+
 ## 6.36.7
 - **A turn spoken at a busy thread is now queued instead of refused.** Miles: "if
   there's a session that's still running, that would just put it into the queue the same

package/package.json

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

package/server/index.ts

@@ -517,10 +517,33 @@ app.use('/api', claudeSessionsRouter)
 // buys the guarantee that the queue CANNOT weaken the gate even by accident.
 if (threadAttachEnabled()) {
   const queueDeps = {
+    // TWO GATES, ONE ANSWER. `threadOccupancy` sees FOREIGN holders -- another app on
+    // the Mac writing the transcript. It does not, and cannot, see COS's OWN bindings:
+    // `OccupancyReason` has no `native_target_busy` member, because that refusal is
+    // produced only by the binding registry inside `bindings.create`.
+    //
+    // That gap is what trapped Miles on 2026-08-18. Continue refused
+    // `native_target_busy` (a live COS binding held the thread), the client armed the
+    // queue, he dictated -- and this gate, asking occupancy alone, answered
+    // `attachable: true`, so the route replied `409 thread_free` ("Pick Continue again
+    // to send it"). Continue refused identically. A closed loop for the 30-minute
+    // binding TTL, with the refusal copy telling him to "detach that one first" -- an
+    // action with no endpoint.
+    //
+    // It also burnt the delivery ceiling: the drainer saw `attachable` and ATTEMPTED,
+    // the attach route refused, and five of those retired the turn in ~2 minutes. With
+    // the binding visible here, `drainDecision` returns 'hold' instead and no attempt
+    // is spent -- so this single change closes the loop AND the attempt burn.
     occupancy: (provider: string, threadId: string) => {
       try {
         const v = threadOccupancy(provider, threadId, occupancyProbes, occupancyDirs)
-        return { attachable: v.attachable === true, reason: v.reason ?? null }
+        if (v.attachable !== true) return { attachable: false, reason: v.reason ?? null }
+        // Occupancy is happy; ask the registry the question it cannot answer.
+        // `getByThread` returns the binding ONLY when it actually blocks the target
+        // (`blocksTarget`), so an expired or terminal one correctly reads as free.
+        const holder = agentSessionBindingRegistry.getByThread(provider, threadId, Date.now())
+        if (holder !== null) return { attachable: false, reason: 'native_target_busy' }
+        return { attachable: true, reason: null }
       } catch {
         // A throwing probe is not an open door.
         return { attachable: false, reason: 'probe_failed' }

package/server/lib/thread-turn-queue-deliver.ts

@@ -75,7 +75,7 @@ export async function deliverQueuedTurnOverLoopback(
   turn: QueuedThreadTurn,
   port: number,
   token: string,
-): Promise<{ ok: boolean; reason?: string }> {
+): Promise<{ ok: boolean; reason?: string; serverRetryable?: boolean }> {
   try {
     const attach = await post(
       port, token,
@@ -83,8 +83,17 @@ export async function deliverQueuedTurnOverLoopback(
       { cosSessionId: turn.cosSessionId },
     )
     if (attach.status !== 200 && attach.status !== 201) {
-      // The gate said no at drain time. Not an error -- the queue holds and tries again.
-      return { ok: false, reason: String(attach.body.error ?? `attach_${attach.status}`) }
+      // THE KEY IS `reason`, NOT `error`. `refuseAttach` emits
+      // `{ attached: false, reason, reasonCopy }` and has never emitted an `error`
+      // key, so reading `body.error` always fell through to the status fallback and
+      // every stored reason in the field was the literal string `attach_409`.
+      //
+      // That made the whole feature reason-blind: 409 is the DEFAULT status for every
+      // refusal that is not `invalid_request` (400) or a capability gap (503), so
+      // `attach_409` covered transient `native_target_busy` and permanent
+      // `native_target_fenced` alike. Any retry policy keyed on the status would have
+      // treated "an earlier turn may or may not have been delivered" as retryable.
+      return { ok: false, reason: String(attach.body.reason ?? attach.body.error ?? `attach_${attach.status}`) }
     }
     const bindingId = typeof attach.body.bindingId === 'string' ? attach.body.bindingId : ''
     if (!bindingId) return { ok: false, reason: 'attach_no_binding' }
@@ -99,7 +108,14 @@ export async function deliverQueuedTurnOverLoopback(
     )
     // 202 is the success shape: admitted, delivered in the background, poll the ledger.
     if (sent.status === 202 || sent.status === 200) return { ok: true }
-    return { ok: false, reason: String(sent.body.error ?? `turn_${sent.status}`) }
+    // Same defect on the turn leg: `refuseTurn` emits `reason`/`reasonCopy`/`retryable`
+    // and no `error`. `retryable` is the server's OWN judgement about this refusal --
+    // carried through rather than re-derived, so the two layers cannot disagree.
+    return {
+      ok: false,
+      reason: String(sent.body.reason ?? sent.body.error ?? `turn_${sent.status}`),
+      serverRetryable: typeof sent.body.retryable === 'boolean' ? sent.body.retryable : undefined,
+    }
   } catch (error) {
     return { ok: false, reason: error instanceof Error ? error.message : 'deliver_failed' }
   }

package/server/lib/thread-turn-queue.ts

@@ -120,6 +120,19 @@ export const MAX_DELIVERY_ATTEMPTS = 5
  */
 const QUEUEABLE_REFUSALS: ReadonlySet<string> = new Set([
   'native_thread_working',
+  // COS'S OWN LEFTOVER BINDING, and the reason this feature did not work for a day.
+  // Proven from device diagnostics 2026-08-17: every Continue that reached the server
+  // was refused `native_target_busy` ("already attached to another COS chat"), never
+  // `native_thread_working`. Selecting Continue SUCCEEDS and mints a binding; if the
+  // dictation is not completed the binding lingers to its TTL, and every Continue in
+  // that window refuses. Twelve such bindings had stacked up on one thread.
+  //
+  // It belongs here because it is transient BY CONSTRUCTION -- the binding expires on
+  // a clock -- and because it is COS's own bookkeeping, not a foreign process holding
+  // the thread. Queueing waits it out, and delivery re-runs the whole gate as always.
+  'native_target_busy',
+  // Same shape: a COS turn is mid-flight on this thread and will finish.
+  'native_turn_in_progress',
   'live_desktop_process',
   'thread_busy',
   'binding_conflict',

package/server/routes/thread-turn-queue.ts

@@ -36,7 +36,12 @@ export interface ThreadTurnQueueDeps {
    * ambiguous must resolve `ok: false` with a reason: an unknown delivery that is
    * retried puts the same sentence into a real conversation twice.
    */
-  deliver: (turn: QueuedThreadTurn) => Promise<{ ok: boolean; reason?: string }>
+  deliver: (turn: QueuedThreadTurn) => Promise<{
+    ok: boolean
+    reason?: string
+    /** The turn route's OWN `retryable` judgement, when it sent one. Authoritative. */
+    serverRetryable?: boolean
+  }>
   now: () => number
 }
 
@@ -54,6 +59,31 @@ function publicRow(turn: QueuedThreadTurn, position: number): Record<string, unk
   }
 }
 
+/**
+ * Is this failed delivery a "not yet" rather than a "no"?
+ *
+ * CLASSIFIED BY REASON, NEVER BY STATUS. Every attach refusal that is not
+ * `invalid_request` (400) or a capability gap (503) comes back 409 -- transient
+ * `native_target_busy` and permanent `native_target_fenced` alike -- so a status-based
+ * rule would retry a turn whose copy reads "an earlier turn on this thread may or may
+ * not have been delivered" up to 1,080 times inside the TTL. That is the one refusal
+ * that needs a human.
+ *
+ * `queueableRefusal` is reused rather than a second list being written: it already
+ * encodes "can this condition ever pass", it is tested, and a turn should be retried
+ * for exactly the reasons it was allowed to queue for.
+ *
+ * FAILS CLOSED. An unrecognised reason, an absent reason, or a thrown deliver all
+ * return false and spend an attempt. A new refusal added upstream is therefore bounded
+ * by default rather than silently retried forever.
+ */
+function isRetryableDelivery(outcome: { reason?: string; serverRetryable?: boolean }): boolean {
+  // The turn route publishes its own verdict; it outranks our inference either way.
+  if (outcome.serverRetryable === false) return false
+  if (outcome.serverRetryable === true) return true
+  return queueableRefusal(outcome.reason)
+}
+
 /**
  * One drain pass over one thread.
  *
@@ -103,7 +133,7 @@ export async function drainThread(
     writeQueue(provider, threadId, queue)
     dirty = true
 
-    let outcome: { ok: boolean; reason?: string }
+    let outcome: { ok: boolean; reason?: string; serverRetryable?: boolean }
     try {
       outcome = await deps.deliver(turn)
     } catch (error) {
@@ -114,6 +144,20 @@ export async function drainThread(
       turn.status = 'delivered'
       turn.settledAt = deps.now()
       delivered += 1
+    } else if (isRetryableDelivery(outcome)) {
+      // A GATE REFUSAL IS NOT A FAILED DELIVERY, so it must not spend the ceiling --
+      // measured cost of getting this wrong: three of Miles's turns retired in about
+      // two minutes each, never delivered, while the 6h TTL never got to matter.
+      //
+      // REFUNDED, not deferred. The increment and its fsync stay BEFORE the call
+      // (routes:101-103) because that is what survives a crash mid-delivery -- the
+      // ceiling only bounds anything if it outlives the crash it is bounding, and a
+      // test reads `attempts` off disk from inside the deliver callback to prove it.
+      // So the attempt is spent first and given back here, where the outcome is known.
+      turn.attempts = Math.max(0, turn.attempts - 1)
+      turn.status = 'waiting'
+      turn.reason = outcome.reason
+      held += 1
     } else if (turn.attempts >= MAX_DELIVERY_ATTEMPTS) {
       turn.status = 'refused'
       turn.reason = outcome.reason ?? 'delivery_failed'