@gotcos/glasses-server 6.53.3 → 6.54.0

package/server/lib/provider-proof.ts

@@ -194,7 +194,9 @@ function safeProofError(result: ProcessResult): string {
   return 'provider returned no valid proof response'
 }
 
-const QUOTA_RE = /usage limit|hit your (?:usage |session )?limit|session limit|rate.?limit|too many requests|\b429\b|\bquota\b|resets? (?:at|in) |over capacity|overloaded|\b529\b|plan limit/i
+/** A provider's own words for a spent session, usage, rate or capacity limit. Also the lens
+ * gist's (lens-gist-engines.ts), so both read a limit the same way. */
+export const PROVIDER_QUOTA_RE = /usage[ _]limit|hit your (?:usage |session )?limit|session limit|rate.?limit|too many requests|\b429\b|\bquota\b|resets? (?:at|in) |over capacity|overloaded|\b529\b|plan limit/i
 const AUTH_RE = /not logged in|please (?:log ?in|sign in)|invalid api key|authentication|unauthori[sz]ed|\b401\b|\b403\b|login required|token (?:has )?expired|no credentials/i
 const OVERFLOW_RE = /prompt is too long|context window|too many tokens|exceeds the (?:model|context)/i
 const MISSING_RE = /ENOENT|command not found|no such file/i
@@ -209,7 +211,7 @@ export function classifyProofFailure(result: ProcessResult, answer: string, expe
   const haystack = `${result.stderr}\n${result.stdout}`.slice(0, 40_000)
   if (result.code === null && MISSING_RE.test(haystack)) return 'provider_missing'
   if (OVERFLOW_RE.test(haystack)) return 'provider_context_overflow'
-  if (QUOTA_RE.test(haystack)) return 'provider_quota'
+  if (PROVIDER_QUOTA_RE.test(haystack)) return 'provider_quota'
   if (AUTH_RE.test(haystack)) return 'provider_auth'
   if (result.code === 0) return answer === expected ? 'provider_failed' : 'provider_bad_answer'
   return 'provider_failed'

package/server/lib/session-halt.ts

@@ -38,6 +38,7 @@ import { join } from 'node:path'
 import { atomicWriteFileSync } from './atomic-fs.js'
 import { dataPath } from './data-dir.js'
 import { isValidNativeThreadId } from './native-thread-id.js'
+import { unwrapPeerMessage } from './session-stream-events.js'
 
 /**
  * How long a marker may outlive its cancel. An hour, not the plan's first 15 minutes: the
@@ -46,6 +47,14 @@ import { isValidNativeThreadId } from './native-thread-id.js'
  */
 export const HALT_MARKER_TTL_MS = 60 * 60_000
 
+/**
+ * 6.53.3 /qa: how long a re-arm waits when the hand-off was NOT verified (`maybe`: the frame
+ * may or may not have reached the session). A verified hand-off keeps the marker's hour; an
+ * unverified one that has not surfaced as a prompt within two minutes most likely never
+ * arrived, and holding it longer only widens the window for an identical desk prompt.
+ */
+export const HALT_REARM_UNVERIFIED_MS = 2 * 60_000
+
 export interface HaltMarker {
   at: number
   clientCancelId: string
@@ -121,15 +130,30 @@ export function clearHaltMarkerOnSessionEnd(sessionId: string, endedAt: number,
 // plain write would then be deleted by the very turn it was written to stop.
 //
 // So the marker is written, and when the delivered turn has not visibly started yet, it is
-// written AGAIN, once, on the first UserPromptSubmit for that session whose prompt carries
-// the delivered text. Matching the text keeps the person's own next desk prompt from ever
-// being the one that re-arms it; the window is the marker's own hour; SessionEnd drops it.
-// In memory on purpose: a restart forgets it, like every other hold here.
+// written AGAIN, once, on the first UserPromptSubmit for that session AFTER the send, if that
+// prompt IS the delivered one. The window is the marker's own hour (two minutes for an
+// unverified hand-off); SessionEnd drops it. In memory on purpose: a restart forgets it, like
+// every other hold here.
+//
+// 6.53.3 /qa (Skeptic W1): the first cut matched `prompt.includes(<first 120 characters>)`.
+// A short COS prompt ("yes") is inside most desk prompts, so the person's own next prompt
+// re-armed the marker: THEIR run was denied "Cancelled from COS", and the delivered turn's
+// own prompt, finding nothing pending, then ran the cancelled turn. Now:
+//   - EXACT: the delivered words and the prompt's words are equal once whitespace runs are
+//     collapsed and Claude Code's peer wrapper ("Another Claude session sent a message: ...",
+//     which a live Continue arrives in) is taken off. The frame carries no id of its own and
+//     its text is not changed to add one.
+//   - FIRST PROMPT DECIDES: the first prompt after the send spends the re-arm whether or not
+//     it matches. A non-match is logged (never the prompt). This gives up the cancel when
+//     the person's own prompt reaches the session first, rather than risk halting their run:
+//     a halted desk run is the worse error, and the lens already said "at its next step".
+//   - LIMIT, stated: a desk prompt with exactly the delivered words, typed after the send and
+//     taken first, is indistinguishable from the delivered turn and re-arms.
 
 interface PendingRearm {
   marker: HaltMarker
-  /** Text the delivered prompt carries (the peer-inbox acceptance marker). */
-  promptMarker: string
+  /** The delivered prompt's words, whitespace-normalised (`normalizePromptWords`). */
+  words: string
   /** Prompts submitted before this are someone else's. */
   after: number
   until: number
@@ -147,18 +171,22 @@ const MAX_PENDING_REARMS = 64
 export function haltDeliveredTurn(
   sessionId: string,
   marker: HaltMarker,
-  turn: { promptMarker: string; after: number; rearm: boolean; now?: number },
+  turn: { prompt: string; after: number; rearm: boolean; now?: number; windowMs?: number },
   dir = haltDir(),
 ): boolean {
   if (!writeHaltMarker(sessionId, marker, dir)) return false
   const id = sessionId.toLowerCase()
-  if (!turn.rearm || typeof turn.promptMarker !== 'string' || turn.promptMarker.trim().length === 0) {
+  const words = normalizePromptWords(turn.prompt)
+  if (!turn.rearm || words.length === 0) {
     pendingRearms.delete(id)
     return true
   }
   const now = turn.now ?? Date.now()
+  const windowMs = typeof turn.windowMs === 'number' && Number.isFinite(turn.windowMs) && turn.windowMs > 0
+    ? Math.min(turn.windowMs, HALT_MARKER_TTL_MS)
+    : HALT_MARKER_TTL_MS
   pendingRearms.delete(id)
-  pendingRearms.set(id, { marker, promptMarker: turn.promptMarker, after: turn.after, until: now + HALT_MARKER_TTL_MS })
+  pendingRearms.set(id, { marker, words, after: turn.after, until: now + windowMs })
   while (pendingRearms.size > MAX_PENDING_REARMS) {
     const oldest = pendingRearms.keys().next()
     if (oldest.done) break
@@ -167,10 +195,26 @@ export function haltDeliveredTurn(
   return true
 }
 
+/** Whitespace runs collapsed to one space, ends trimmed. Non-strings are empty. */
+export function normalizePromptWords(text: unknown): string {
+  return typeof text === 'string' ? text.replace(/\s+/g, ' ').trim() : ''
+}
+
+/**
+ * Is `prompt` (a UserPromptSubmit's `prompt`) the delivered prompt? Equal words, compared
+ * whole, after taking off Claude Code's peer wrapper when the prompt arrived in one.
+ */
+export function isDeliveredPrompt(prompt: unknown, delivered: string): boolean {
+  const want = normalizePromptWords(delivered)
+  if (want.length === 0 || typeof prompt !== 'string') return false
+  return normalizePromptWords(unwrapPeerMessage(prompt) ?? prompt) === want
+}
+
 /**
  * A UserPromptSubmit from the session itself (never a COS child): the hook has just deleted
- * the session's marker. When it was the delivered turn's own prompt, write the marker back.
- * One shot. True when the marker was re-armed.
+ * the session's marker. The FIRST such prompt after the send spends the pending re-arm: when
+ * it is the delivered turn's own prompt the marker is written back, otherwise the re-arm is
+ * dropped and logged. True when the marker was re-armed.
  */
 export function rearmHaltOnPrompt(sessionId: string, promptAt: number, prompt: unknown, dir = haltDir(), now = Date.now()): boolean {
   const id = typeof sessionId === 'string' ? sessionId.toLowerCase() : ''
@@ -181,8 +225,11 @@ export function rearmHaltOnPrompt(sessionId: string, promptAt: number, prompt: u
     return false
   }
   if (!Number.isFinite(promptAt) || promptAt < pending.after) return false
-  if (typeof prompt !== 'string' || !prompt.includes(pending.promptMarker)) return false
   pendingRearms.delete(id)
+  if (!isDeliveredPrompt(prompt, pending.words)) {
+    console.warn(`[session-halt] re-arm dropped: the first prompt after the hand-off was not the delivered turn session=${id.slice(0, 8)} clientCancelId=${pending.marker.clientCancelId}`)
+    return false
+  }
   return writeHaltMarker(id, pending.marker, dir)
 }
 

package/server/lib/session-hooks-runtime.ts

@@ -17,7 +17,7 @@ import { SessionHookLedger } from './session-hook-ledger.js'
 import { startSpoolIngester, type SpoolIngester, type SpoolStats } from './session-hook-spool.js'
 import { SessionSignalStore, type SessionSignal } from './session-signal-store.js'
 import { OPEN_TURN_CEILING_MS, deriveSessionState, type DerivedSessionState, type RegistryFacts, type TranscriptFacts } from './session-state-derive.js'
-import { clearHaltMarkerOnSessionEnd, dropHaltRearm, haltDeliveredTurn, rearmHaltOnPrompt, sweepHaltMarkers, type HaltMarker } from './session-halt.js'
+import { HALT_MARKER_TTL_MS, HALT_REARM_UNVERIFIED_MS, clearHaltMarkerOnSessionEnd, dropHaltRearm, haltDeliveredTurn, rearmHaltOnPrompt, sweepHaltMarkers, type HaltMarker } from './session-halt.js'
 import { cancelVoidsOpenTurn, threadCancel } from './session-cancel.js'
 import { ensureHookRuntimeFiles, ensureStableHookScript, hookSpoolDir, hookStatus, type HookStatus } from './claude-hooks-installer.js'
 
@@ -235,10 +235,17 @@ export function claudeDeskRunning(sessionId: string, now = Date.now(), dir = cla
  * hooks do not yet show the turn started (its UserPromptSubmit at or after `sentAt`), it is
  * re-armed once when that prompt's own UserPromptSubmit deletes it (`haltDeliveredTurn`).
  */
-export function haltHandedOffTurn(sessionId: string, marker: HaltMarker, turn: { promptMarker: string; sentAt: number }, now = Date.now()): boolean {
+export function haltHandedOffTurn(sessionId: string, marker: HaltMarker, turn: { prompt: string; sentAt: number; unverified?: boolean }, now = Date.now()): boolean {
   const signal = signalFor(sessionId)
   const started = !!signal && typeof signal.turnStartedAt === 'number' && signal.turnStartedAt >= turn.sentAt
-  return haltDeliveredTurn(sessionId, marker, { promptMarker: turn.promptMarker, after: turn.sentAt, rearm: !started, now })
+  return haltDeliveredTurn(sessionId, marker, {
+    prompt: turn.prompt,
+    after: turn.sentAt,
+    rearm: !started,
+    now,
+    // 6.53.3 /qa: an unverified hand-off (`maybe`) holds its re-arm two minutes, not an hour.
+    windowMs: turn.unverified === true ? HALT_REARM_UNVERIFIED_MS : HALT_MARKER_TTL_MS,
+  })
 }
 
 let ledger: SessionHookLedger | null = null

package/server/routes/agent-session-bindings.ts

@@ -96,8 +96,7 @@
 // and answer 400. They never treat an unparsed body as an empty one.
 
 import type { FenceRecord } from '../lib/thread-fence-store.js'
-import { execFileSync } from 'node:child_process'
-import { fenceLiveness, makePidStartProbe, type FenceLiveness, type FenceLivenessDeps } from '../lib/fence-liveness.js'
+import { defaultPidStartProbe, fenceLiveness, type FenceLiveness, type FenceLivenessDeps } from '../lib/fence-liveness.js'
 import { Router, type Request, type Response } from 'express'
 import { createHash, randomUUID } from 'node:crypto'
 import {
@@ -125,7 +124,7 @@ import {
 import type { RegistryCheck, RegistryRejection, RegistryResult } from '../lib/agent-session-binding-registry.js'
 import { recordCosSpawn, releaseCosSpawn } from '../lib/agent-session-ownership-store.js'
 import { isValidNativeThreadId } from '../lib/native-thread-id.js'
-import { PEER_VERIFY_TIMEOUT_MS, peerAcceptanceMarker } from '../lib/session-peer-inbox.js'
+import { PEER_VERIFY_TIMEOUT_MS } from '../lib/session-peer-inbox.js'
 import {
   CANCEL_QUEUE_HOLD_MS,
   CLIENT_CANCEL_ID_RE,
@@ -460,7 +459,7 @@ export interface CancelDeps {
    * have reached) the open session. Writes the halt marker, and re-arms it once when that
    * turn's own UserPromptSubmit deletes it (`haltHandedOffTurn`). False: not armed.
    */
-  haltHandedOffTurn?: (sessionId: string, marker: { at: number; clientCancelId: string }, turn: { promptMarker: string; sentAt: number }) => boolean
+  haltHandedOffTurn?: (sessionId: string, marker: { at: number; clientCancelId: string }, turn: { prompt: string; sentAt: number; unverified?: boolean }) => boolean
   /** Append to `data/session-cancel.jsonl`. */
   ledger?: (row: SessionCancelLedgerRow) => void
 }
@@ -1560,17 +1559,7 @@ export function createAgentSessionBindingsRouter(deps: AgentSessionBindingsDeps)
   const guard = deps.guard ?? new TargetGuard(deps.fencePersistence ?? null)
   // `ps -o lstart=` is the only start-time keyword macOS ps offers. Injectable so a
   // test drives recycled and unreadable pids without spawning real processes.
-  const livenessDeps: FenceLivenessDeps = deps.liveness ?? {
-    pidStartMs: makePidStartProbe((pid) => {
-      try {
-        return execFileSync('ps', ['-p', String(pid), '-o', 'lstart='], {
-          encoding: 'utf8', timeout: 2_000,
-        })
-      } catch {
-        return null   // not running, or ps refused the pid
-      }
-    }),
-  }
+  const livenessDeps: FenceLivenessDeps = deps.liveness ?? { pidStartMs: defaultPidStartProbe() }
   // 6.53.3 (review A4): at boot, release the fences a cancel left whose children are all
   // gone (6.53.1's false "unreaped" among them), then keep re-checking on every fence read.
   guard.adoptCancelLiveness(livenessDeps)
@@ -1691,8 +1680,11 @@ export function createAgentSessionBindingsRouter(deps: AgentSessionBindingsDeps)
       }) ?? 'unsupported'
       if (target === 'desk_run') {
         const armed = cancelProbe(() => cancelDeps.haltHandedOffTurn?.(threadId, { at: latch.at, clientCancelId: latch.clientCancelId }, {
-          promptMarker: peerAcceptanceMarker(turn.prompt),
+          // 6.53.3 /qa: the WHOLE delivered prompt (the re-arm matches it exactly), and whether
+          // the hand-off was only possibly delivered (`maybe`: a two-minute re-arm, not an hour).
+          prompt: turn.prompt,
           sentAt: turn.sentAt,
+          unverified: reached === 'maybe',
         }) === true, false)
         if (armed) {
           const settledPermissions = cancelProbe(() => cancelDeps.settlePermissions?.(threadId) ?? 0, 0)

package/server/routes/health.ts

@@ -22,6 +22,7 @@ import {
 } from '../lib/whisper-local.js'
 import { getOpenAIWhisperBudgetState } from '../lib/openai-whisper-budget.js'
 import { getMeetingSummaryBudgetState } from '../lib/meeting-summary-budget.js'
+import { lensGistPublicHealth } from '../lib/lens-gist.js'
 import { meetingSummaryLLMEnabled } from '../lib/meeting-summary.js'
 import { getKeyStatus } from '../lib/openai-key.js'
 import {
@@ -410,6 +411,8 @@ healthRouter.get('/health', async (_req, res) => {
     whisper_health,
     openai_whisper_budget,
     meeting_summary,
+    // 6.54.0: the lens gist engine (lib/lens-gist.ts); detail on /api/lens-gist/config.
+    lens_gist: lensGistPublicHealth(),
     tts_local,
     codex_models,
     cursor_models,

package/server/routes/lens-gist.ts

@@ -0,0 +1,58 @@
+import { Router } from 'express'
+import {
+  LensGistInputError,
+  getLensGist,
+  lensGistHealth,
+  listLensGistEngines,
+  normalizeLensGistInput,
+  saveLensGistConfig,
+} from '../lib/lens-gist.js'
+import { maintenanceAdmissionsOpen } from '../lib/maintenance-lifecycle.js'
+import { errMsg } from '../lib/utils.js'
+
+// Server 6.54.0. The phone asks for the three-line card behind the G2 prompt box
+// (lib/lens-gist.ts). Every answer the server gives is a 200 with a `status`, so the
+// phone never reads "the server answered no" as "the server is unreachable" (gotchas:
+// an HTTP status means the server ANSWERED). Only a malformed request is a 400.
+export const lensGistRouter = Router()
+
+lensGistRouter.post('/lens-gist', async (req, res) => {
+  let input
+  try {
+    input = normalizeLensGistInput(req.body)
+  } catch (err) {
+    res.status(err instanceof LensGistInputError ? err.status : 400).json({ error: errMsg(err) })
+    return
+  }
+  // Outside the request lease (index.ts lifecycleOwned): a drain for an update or restart
+  // closes admissions, and a gist is the first thing to give way.
+  if (!maintenanceAdmissionsOpen()) {
+    res.json({ status: 'unavailable', reason: 'maintenance' })
+    return
+  }
+  // No abort on disconnect: the phone asks ahead of the hold and may not wait, and the
+  // answer is cached for when it asks again.
+  try {
+    res.json(await getLensGist(input))
+  } catch (err) {
+    res.status(500).json({ error: errMsg(err) })
+  }
+})
+
+lensGistRouter.get('/lens-gist/config', async (_req, res) => {
+  try {
+    res.json({ ...lensGistHealth(), engines: await listLensGistEngines() })
+  } catch (err) {
+    res.status(500).json({ error: errMsg(err) })
+  }
+})
+
+lensGistRouter.put('/lens-gist/config', (req, res) => {
+  try {
+    const saved = saveLensGistConfig(req.body ?? {})
+    const overridden = !!process.env.COS_LENS_GIST_ENGINE?.trim()
+    res.json({ saved: true, effective: saved, ...(overridden ? { overriddenByEnv: 'COS_LENS_GIST_ENGINE' } : {}) })
+  } catch (err) {
+    res.status(err instanceof LensGistInputError ? err.status : 500).json({ error: errMsg(err) })
+  }
+})