@gotcos/glasses-server 7.0.18 → 7.0.27

package/server/routes/session-organizer.ts

@@ -0,0 +1,149 @@
+/**
+ * Session organizer routes (Sessions chat-style layout, step 2a; S1_CONTRACT_step2a.md, A1).
+ *
+ *   GET    /api/session-folders
+ *   POST   /api/session-folders                              { name }
+ *   PATCH  /api/session-folders/:id                          { name }
+ *   DELETE /api/session-folders/:id                          (its sessions leave it; no session is deleted)
+ *   PATCH  /api/agent-sessions/:provider/:sessionId/organizer { folder_id?, cos_pinned?, title? }
+ *
+ * Behind index.ts's /api gate (API token, or a browser cookie with `x-cos-web: 1` and a same-origin Origin).
+ * The session route canonicalizes the id from the transcript it finds, so a Claude Desktop id and its CLI id are
+ * one key, and a session the server cannot find is refused (404) instead of stored.
+ * Logs carry reason codes only: never a folder name or a title.
+ */
+import { Router, type Request, type Response } from 'express'
+import {
+  agentSessionRoots,
+  findAgentSessionFile,
+  idFromCodexFilename,
+  isSafeSessionId,
+  loadClaudeDesktopAliases,
+  normalizeClaudeSessionId,
+  type AgentProvider,
+  type AgentSessionRoots,
+} from '../lib/agent-session-store.js'
+import { OrganizerError, organizerKey, sessionOrganizer, type SessionOrganizer } from '../lib/session-organizer.js'
+
+const PROVIDERS: ReadonlySet<string> = new Set(['claude', 'codex', 'cursor'])
+
+export interface SessionOrganizerRouteDeps {
+  organizer: () => SessionOrganizer
+  roots: () => AgentSessionRoots
+  /** The canonical id of a session the server can find on disk, or null. */
+  canonicalId: (provider: AgentProvider, sessionId: string, roots: AgentSessionRoots) => Promise<SessionIdentity | null>
+}
+
+/** Where a session's organizer entry lives: its canonical id, and for Claude the Desktop id it was named by when one is
+ *  known. `null`: the server cannot find the session. Throws 409 alias_conflict while Claude Desktop's records disagree
+ *  about the session's CLI id (Q1 FIX 2): an entry written then could be orphaned when they settle. */
+export interface SessionIdentity { id: string; desktopId?: string }
+
+/** The id a found transcript names: Claude's CLI uuid (a Desktop id resolves to it), Codex's rollout id, Cursor's composer. */
+export async function canonicalSessionId(provider: AgentProvider, sessionId: string, roots: AgentSessionRoots): Promise<SessionIdentity | null> {
+  if (!isSafeSessionId(sessionId)) return null
+  if (provider === 'claude') {
+    // A Desktop id may arrive as `local_<uuid>`; the alias table and transcripts use the bare uuid.
+    sessionId = normalizeClaudeSessionId(sessionId)
+    const aliases = await loadClaudeDesktopAliases(roots.claudeCodeSessions)
+    if (aliases.has(sessionId) && aliases.get(sessionId) === null) throw new OrganizerError(409, 'alias_conflict')
+    const head = aliases.get(sessionId)
+    const file = await findAgentSessionFile('claude', sessionId, roots, new Date(), aliases)
+    if (file) {
+      const id = (file.split('/').pop() || '').replace(/\.jsonl$/, '').toLowerCase()
+      if (!id) return null
+      // The Desktop id: the one asked for when it is an alias, else the single Desktop record that names this CLI id.
+      let desktopId: string | undefined = head ? sessionId : undefined
+      if (!desktopId) {
+        const named = [...aliases].filter(([, h]) => h?.cliSessionId === id).map(([d]) => d)
+        if (named.length === 1) desktopId = named[0]
+      }
+      return { id, ...(desktopId && desktopId !== id ? { desktopId } : {}) }
+    }
+    // A Desktop-only session (no CLI transcript yet): keyed by its Desktop id, which the list also shows.
+    if (head) return { id: sessionId, desktopId: sessionId }
+    return null
+  }
+  const file = await findAgentSessionFile(provider, sessionId, roots)
+  if (!file) return null
+  const parts = file.split('/')
+  const id = provider === 'codex'
+    ? idFromCodexFilename(parts[parts.length - 1] || '')
+    : (parts[parts.length - 2] || '').toLowerCase() || null
+  return id ? { id } : null
+}
+
+function fail(res: Response, error: unknown): void {
+  if (error instanceof OrganizerError) {
+    res.status(error.status).json({ error: error.reason, reason: error.reason })
+    return
+  }
+  console.error(`[session-organizer] write failed (reason=${(error as NodeJS.ErrnoException)?.code ?? 'error'})`)
+  res.status(500).json({ error: 'organizer_write_failed', reason: 'organizer_write_failed' })
+}
+
+export function createSessionOrganizerRouter(deps: SessionOrganizerRouteDeps = {
+  organizer: sessionOrganizer,
+  roots: () => agentSessionRoots(),
+  canonicalId: canonicalSessionId,
+}): Router {
+  const router = Router()
+  const noStore = (res: Response) => res.set('Cache-Control', 'private, no-store')
+
+  router.get('/session-folders', (_req: Request, res: Response) => {
+    noStore(res)
+    const o = deps.organizer()
+    if (!o.isAvailable()) return void res.status(503).json({ error: 'organizer_unavailable', reason: 'organizer_unavailable' })
+    res.json({ rev: o.rev(), folders: o.listFolders() })
+  })
+
+  router.post('/session-folders', (req: Request, res: Response) => {
+    noStore(res)
+    try {
+      const o = deps.organizer()
+      const folder = o.createFolder((req.body as { name?: unknown } | undefined)?.name)
+      res.status(201).json({ rev: o.rev(), folder })
+    } catch (error) { fail(res, error) }
+  })
+
+  router.patch('/session-folders/:id', (req: Request, res: Response) => {
+    noStore(res)
+    try {
+      const o = deps.organizer()
+      const folder = o.renameFolder(String(req.params.id), (req.body as { name?: unknown } | undefined)?.name)
+      res.json({ rev: o.rev(), folder })
+    } catch (error) { fail(res, error) }
+  })
+
+  router.delete('/session-folders/:id', (req: Request, res: Response) => {
+    noStore(res)
+    try {
+      const o = deps.organizer()
+      const released = o.deleteFolder(String(req.params.id))
+      res.json({ rev: o.rev(), released })
+    } catch (error) { fail(res, error) }
+  })
+
+  router.patch('/agent-sessions/:provider/:sessionId/organizer', async (req: Request, res: Response) => {
+    noStore(res)
+    const provider = String(req.params.provider)
+    if (!PROVIDERS.has(provider)) return void res.status(400).json({ error: 'invalid_provider', reason: 'invalid_provider' })
+    // A Claude Desktop id arrives as `local_<uuid>`; the bare uuid is the id everywhere else.
+    const sessionId = provider === 'claude' ? normalizeClaudeSessionId(String(req.params.sessionId)) : String(req.params.sessionId)
+    if (!isSafeSessionId(sessionId)) return void res.status(400).json({ error: 'invalid_session_id', reason: 'invalid_session_id' })
+    const body = req.body && typeof req.body === 'object' && !Array.isArray(req.body) ? req.body as Record<string, unknown> : {}
+    const change: { folder_id?: unknown; cos_pinned?: unknown; title?: unknown } = {}
+    for (const key of ['folder_id', 'cos_pinned', 'title'] as const) if (Object.prototype.hasOwnProperty.call(body, key)) change[key] = body[key]
+    try {
+      const o = deps.organizer()
+      if (!o.isAvailable()) throw new OrganizerError(503, 'organizer_unavailable')
+      if (Object.keys(change).length === 0) throw new OrganizerError(400, 'empty_change')
+      const identity = await deps.canonicalId(provider as AgentProvider, sessionId, deps.roots())
+      if (!identity) throw new OrganizerError(404, 'session_not_found')
+      const fields = o.updateSession(organizerKey(provider, identity.id), change, { desktopId: identity.desktopId })
+      res.json({ rev: o.rev(), session: { provider, session_id: identity.id, ...fields } })
+    } catch (error) { fail(res, error) }
+  })
+
+  return router
+}

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

@@ -21,7 +21,7 @@ import { CONTINUE_NOTE_HEADER, continueNoteAcknowledged } from '../lib/continue-
 import { nativeQueueControl, plainQueueText, type NativeQueueControl } from '../lib/codex-queue-control.js'
 import { CLIENT_TURN_ID_RE, COS_SESSION_ID_RE, DEFAULT_MAX_PROMPT_CHARS } from './agent-session-bindings.js'
 import {
-  admitToQueue, drainDecision, queueableRefusal, queuePosition,
+  admitToQueue, drainDecision, holdReasonFor, queueableRefusal, queuePosition,
   MAX_DELIVERY_ATTEMPTS, type DrainObservation, type QueuedThreadTurn,
   queueReconcileEnabled, queueResendEnabled, queuedTurnReasonCopy, sessionSteerAvailability, sessionSteerEnabled,
   steerMidturnEnabled, type SessionSteerAvailability,
@@ -153,6 +153,14 @@ export function steerAvailabilityFor(deps: Pick<ThreadTurnQueueDeps, 'steerProbe
   return sessionSteerAvailability({ provider, gateReason, continueLive, peerInbox: probe.peerInbox, waitingOnPrompt: probe.waitingOnPrompt })
 }
 
+/**
+ * When a sweep last decided each held row (epoch ms), in memory only: the row file is written when its hold
+ * reason CHANGES, not every 20 s. Bounded; a settled row is forgotten.
+ */
+const holdCheckedAt = new Map<string, number>()
+const HOLD_CHECKED_MAX = 1_000
+export function __resetHoldCheckedForTests(): void { holdCheckedAt.clear() }
+
 /** Public shape of a queued turn. No prompt echo beyond a short preview. */
 export function publicRow(turn: QueuedThreadTurn, position: number): Record<string, unknown> {
   const row: Record<string, unknown> = {
@@ -169,6 +177,12 @@ export function publicRow(turn: QueuedThreadTurn, position: number): Record<stri
     ...(turn.settledAt ? { settledAt: turn.settledAt } : {}),
     // 11/07: how many files wait with the words (never their ids or paths). Absent without files.
     ...(Array.isArray(turn.attachmentIds) && turn.attachmentIds.length > 0 ? { attachments: turn.attachmentIds.length } : {}),
+    // 2026-11-11: why a waiting row is held (a code), since when, and when a sweep last decided it. Additive.
+    ...(turn.status === 'waiting' && typeof turn.holdReason === 'string' ? {
+      waiting_reason: turn.holdReason,
+      ...(typeof turn.holdSince === 'number' ? { waiting_since: turn.holdSince } : {}),
+      ...(holdCheckedAt.has(turn.clientTurnId) ? { waiting_checked_at: holdCheckedAt.get(turn.clientTurnId) } : {}),
+    } : {}),
   }
   // 6.78.0: additive, and only while a P3 flag is on, so the row is the 6.77 bytes otherwise.
   // `resendable` is the per-row capability: present only when Send again can act on it.
@@ -242,7 +256,7 @@ function localDrainVerdict(at: number): OriginVerdict {
 }
 
 /** What one mid-turn attempt did to its row: delivered, settled some other way, or left waiting. */
-type MidTurnOutcome = 'delivered' | 'settled' | 'held'
+type MidTurnOutcome = 'delivered' | 'settled' | 'held' | 'held_files'
 
 /**
  * Steer mid-turn (COS_STEER_MIDTURN, Miles 2026-11-07): put ONE waiting row into the running turn
@@ -279,9 +293,11 @@ async function steerHeldTurn(
   deps: ThreadTurnQueueDeps,
 ): Promise<MidTurnOutcome> {
   if (turn.status !== 'waiting' || turn.attempts !== 0) return 'held'
-  if (Array.isArray(turn.attachmentIds) && turn.attachmentIds.length > 0) return 'held'
   const availability = midTurnAvailabilityFor(deps, provider, threadId, gateReason)
   if (!availability || !availability.available) return 'held'
+  // Files never go into a running turn (the peer inbox carries words only). Checked AFTER availability, so
+  // `held_files` means exactly this: the turn could have gone in now but for its files (the row's hold reason).
+  if (Array.isArray(turn.attachmentIds) && turn.attachmentIds.length > 0) return 'held_files'
   const { clientTurnId, prompt } = turn
 
   const rewrite = (apply: (row: QueuedThreadTurn) => void): QueuedThreadTurn | null => {
@@ -465,11 +481,19 @@ export async function drainThread(
       // which also means the hold is the busy GATE: the rule answers only for a refusal that
       // names a desk run (an attachable thread has no reason). Anything else holds as before.
       const cancelHeld = typeof seen.cancelHoldUntil === 'number' && Number.isFinite(seen.cancelHoldUntil) && deps.now() < seen.cancelHoldUntil
+      let reason = holdReasonFor(seen, deps.now())
       if (!midTurnOrderHeld && !cancelHeld) {
         const outcome = await steerHeldTurn(provider, threadId, turn, gate.reason, deps)
-        if (outcome === 'delivered') { delivered += 1; continue }
-        if (outcome === 'settled') { retired += 1; continue }
+        if (outcome === 'delivered') { holdCheckedAt.delete(turn.clientTurnId); delivered += 1; continue }
+        if (outcome === 'settled') { holdCheckedAt.delete(turn.clientTurnId); retired += 1; continue }
+        if (outcome === 'held_files') reason = 'files_wait_for_turn_end'
       }
+      // The hold reason: written only when it changes; the check time is kept in memory (2026-11-11).
+      const at = deps.now()
+      if (turn.holdReason !== reason) { turn.holdReason = reason; turn.holdSince = at; persist(turn) }
+      holdCheckedAt.delete(turn.clientTurnId)
+      holdCheckedAt.set(turn.clientTurnId, at)
+      while (holdCheckedAt.size > HOLD_CHECKED_MAX) holdCheckedAt.delete(holdCheckedAt.keys().next().value!)
       midTurnOrderHeld = true
       held += 1
       continue
@@ -480,6 +504,7 @@ export async function drainThread(
       turn.settledAt = deps.now()
       retired += 1; persist(turn)
       forgetIfSettled(turn)
+      holdCheckedAt.delete(turn.clientTurnId)
       continue
     }
 
@@ -488,6 +513,10 @@ export async function drainThread(
     // forever; the ceiling only bounds anything if it survives the crash it is bounding.
     turn.attempts += 1
     turn.status = 'delivering'
+    // No longer held: the reason belonged to the wait that just ended.
+    delete turn.holdReason
+    delete turn.holdSince
+    holdCheckedAt.delete(turn.clientTurnId)
     // 6.78.0: the stamp the restart reconcile reads. `journal: 1` says this build keeps an
     // attempt record for the delivery that follows; `deliveringBootId` says which boot owns
     // it, so a sweep never touches a row this process is delivering right now. Durable:

package/server/web-control/.manifest.json

@@ -2,14 +2,14 @@
   "v": 1,
   "algorithm": "sha256",
   "files": {
-    "/app.css": "0d3ebbf2ca167bc9ef6ab8efef41618f514cc4f505ae588642d36935249697af",
-    "/app.js": "3c489b154588908178de5b70b18ee8184ec9256e99f774177b9e35ceb27eb362",
+    "/app.css": "a4dbdb42ba6c9de5dc02235985fde499854693c41fca54ad3f3395587ab9834a",
+    "/app.js": "9a26933a5bd72724b620c9c61d11508d895f63ddea620df684f62bb585d761de",
     "/apple-touch-icon.png": "04ec7eca0bf6f53d89900d146ac32d4826759d6258bcdbd1ccdcc517f26f532c",
     "/control.css": "e7b287aa4acc1b3895a9ce61512fe449c555b6335a7145684fd78108ae008c75",
     "/fonts/DMSans.ttf": "8cd08d97e89c24d0aa92edd2f0f4c8ee6195eee9b7c9f154865a58b02f0c1c0d",
     "/fonts/Fraunces.ttf": "177ff6c0f14e5550a3c624247cd1189611d4eb65d000b14944c63d967958abbb",
     "/fonts/JetBrainsMono.ttf": "48715a42ec242c21e9f02692891e147d022299a52e48d5e413e1a942193ffeda",
-    "/index.html": "26ee9cd1f68829ae5f47dcc7a0c2e45a40d28c4ee65d0537f0677b13ea727267",
+    "/index.html": "736f56bbeec449f2204b815594d74042924622ef3004227202a0374df8bc82b5",
     "/mark.svg": "8e380d33d393027df192eb1afa08f15a380c2070c72d68f27311b49d9e94ca18",
     "/memories/d3.min.js": "f2094bbf6141b359722c4fe454eb6c4b0f0e42cc10cc7af921fc158fceb86539",
     "/memories/graph-explorer.css": "ec128de59811f45c71b6bededd737989309205e903951eb8211ade7664f87486",
@@ -28,17 +28,17 @@
     "/panes/questions.css": "5c5a9b32ce32386b508ce326b17d40ecacbb0f2e049df7f4fe2a0009bd3b7908",
     "/panes/questions.js": "228e8cd0a9651a290cbb380db487af677a2fc7e93a64b1e33c9411cd8b013478",
     "/panes/reader-media.js": "4cf892a855aa2d0dce6978e69296cd49b8036d8fc62f12773b3fcadc210b2ef0",
-    "/panes/sessions.css": "fa2e714e7b03459e12407f7125ab0e1eb7d12a4cc9341a2442dc73900f5a3081",
+    "/panes/sessions.css": "654e0509ab2b699b9ea92b6d9e2f7522146df1f0b6355915bef03caaf63addc4",
     "/panes/settings.js": "5c46c951fdcc2fc942486ec4b468b7e0bb0350a0a56a38d429948fc5147ab2f4",
     "/panes/speakers.css": "49e70dae4266151b14b0057f2e43de169de225b8f3ac30343c81cf532735a487",
     "/panes/speakers.js": "8132c9244fb3965de802680840d2985978571988b9b4462b347d079330251bc5",
     "/panes/threads.js": "45fd7b56480be53225e91193cfa4c41a4ee7167890f10560e439bc7d2461747f",
     "/panes/today-actions.css": "c82f95b2aaf09802b15d47b24eccdb5c974afcab38ff5f861b3a8d8630b60869",
-    "/panes/today-actions.js": "4fbc51dc624f9e4cdc85db89905f019a8a5961e4984e8733e0525c71cf0e8657",
+    "/panes/today-actions.js": "57ae8b378b1061060ae2a3f61d227d440d7806538085c1d5b310239c036e4bdc",
     "/panes/work.css": "da50355dac690f712d1f6331f70ee5eadbf5982d37508648ae7786afc99ac7b1",
-    "/panes/work.js": "0425f53fba98ca34496486d914c3b03f95de3c2a651dc0c88a2a20bc4f6407cd",
+    "/panes/work.js": "1ef872b8c7e1a57bd7bd314e11eee7ac5fa9668871da7e644a1fbf5fd9c0d9e8",
     "/shell.js": "f1cc6a52c78e01ddba89ff27c6bd0e8f8bd8f29bdfcbb5150ee4ed66a8128d9d",
-    "/theme.js": "700453683539c9efcde014ef1eb088c39478dad54f1ef53fa5e2dee9b36f0a3f",
+    "/theme.js": "360df6013cd638524543728f8fa3d35f5641d4d230da7c290de40c79216670ee",
     "/vendor/qrcode-encoder.js": "61d87cc7445cc66b862cff913de4571634746ea62bcd50d0f592be14f6d1ce46"
   }
 }

package/server/web-control/app.css

@@ -106,6 +106,15 @@ a { color: var(--accent); }
 svg.icon { width: 22px; height: 22px; flex: none; fill: none; stroke: currentColor; stroke-width: 1.6; stroke-linecap: round; stroke-linejoin: round; }
 
 /* ── Sign in ─────────────────────────────────────────────── */
+/* 7.0.19 first paint: the mark on the page's background until the sign-in card or the app shows (index.html #first-paint).
+   Fixed, so it is out of the layout and nothing shifts when it goes. Only while theme.js has run (html.fp-wait), so it
+   never shows with JavaScript off. The failsafe hides it after 25 s, longer than the 20 s sign-in check, so it ends the
+   wait only when the scripts never ran; reduced motion shortens durations, not this delay. */
+.first-paint { display: none; }
+html.fp-wait .first-paint { position: fixed; inset: 0; z-index: 70; display: grid; place-items: center; background: var(--page); color: var(--ink); pointer-events: none; animation: fp-failsafe 1ms linear 25s forwards; }
+.first-paint .mark { width: 44px; height: 44px; }
+@keyframes fp-failsafe { to { visibility: hidden; } }
+.noscript-note { margin: 0; min-height: 100dvh; display: grid; place-items: center; padding: 24px var(--gutter); font-size: 17px; color: var(--ink); text-align: center; }
 .auth-gate { min-height: 100dvh; display: grid; place-items: center; padding: calc(var(--safe-top) + 24px) var(--gutter) calc(var(--safe-bottom) + 24px); }
 .auth-card { width: 100%; max-width: 420px; }
 .auth-card .mark { width: 44px; height: 44px; margin-bottom: 22px; }