@gotcos/glasses-server 6.27.7 → 6.27.9

package/CHANGELOG.md

@@ -1,5 +1,49 @@
 ## Unreleased
 
+## 6.27.9
+- **Large sessions open instead of 413ing.** `GET /api/agent-sessions/:provider/:id`
+  answered `413 Session too large to open` for any transcript over 32 MiB, so the
+  biggest sessions — the ones most worth reviewing before a follow-up — returned
+  nothing at all. A 67 MB transcript is not exotic; this repo's own 2026-08-13 session
+  is 70 MB. Oversized files are now read as a bounded **head (256 KiB) + tail
+  (768 KiB)**. That 70 MB session parses in **7 ms** and yields a 1,286-char digest
+  with both the opening ask and the most recent turns.
+- Slicing at an arbitrary byte offset is safe because `parseJsonLine` returns null for
+  the fragmentary first line of the tail window and the loop skips it.
+- **`truncated` is reported, and the counts stop pretending.** On a partial read the
+  message counts are counts of what was READ. The digest therefore prints
+  `… middle of a large session not read …` instead of a turn number it cannot know —
+  a confidently wrong "… 12 earlier turns …" on a 4,000-turn session is the same
+  dishonesty as a silent cap.
+- **Slash-command scaffolding no longer eats the two best slots.** `collectTurn` now
+  applies the existing `isWrapperPrompt` filter and `<user_query>` stripping, so a
+  digest opens with the real ask rather than `<command-message>…`.
+- Window sizes are injectable. With production defaults any quick-to-build fixture is
+  smaller than head+tail combined, so a test would read the whole file and pass
+  identically with windowing REMOVED — it did, until a mutation caught it. The test
+  now pins the read count and fails when windowing is dropped.
+
+## 6.27.8
+- **Session bodies get a real digest.** `GET /api/agent-sessions/:provider/:id` adds
+  `discussion_digest`: up to **2000 chars** of what actually happened — the opening
+  ask, the most recent user turns in order, and where the assistant left off.
+- **The list row is untouched at 180.** Miles: "it should be in the body not the
+  title, the row should be no more than the 180 characters." `discussion_summary`
+  keeps its 180-char budget for the single-line row; the digest is a separate field
+  the detail page reads. One shared field could not serve both — a 2000-char gist
+  appended to a row destroys it.
+- **No LLM, no extra reads.** `parseAgentSession` already streams every line of the
+  transcript to count turns; it was discarding the middle. The digest is assembled
+  from turns it is already parsing, so it costs no tokens and no additional I/O.
+- **Elision is stated, never silent.** The store keeps the opening turns plus a
+  60-turn recent window so a 900-turn session cannot balloon memory, and passes the
+  TRUE turn count so the `… N earlier turns …` line reports what was really dropped
+  rather than what the buffer happened to hold.
+- Opening turns are reserved BEFORE recency. Filling from the end first starved the
+  original ask out of a 40-turn session entirely — caught by its own test.
+- Older clients ignore the field; older servers omit it and the glasses fall back to
+  the 180-char summary.
+
 ## 6.27.7
 - **`GET /api/agent-sessions` ships in the public package.** Claude Code, Codex,
   and Cursor transcripts from this Mac, last 7 days of writes. Glasses 6.8.360

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotcos/glasses-server",
-  "version": "6.27.7",
+  "version": "6.27.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/lib/agent-session-store.ts

@@ -148,6 +148,102 @@ export function composeDiscussionSummary(input: {
   return joined.length <= max ? joined : `${joined.slice(0, max - 1)}…`
 }
 
+/** Deep digest budget. The glasses detail page paginates at 200 chars, so 2000 is
+ *  ~10 swipes — long by G2 standards, and deliberately so: this exists to be READ
+ *  before deciding whether to follow up on a session, the one moment depth beats
+ *  brevity. The LIST row keeps the short `discussion_summary`; a 2000-char gist
+ *  appended to a single row would destroy it. Two fields, two jobs. */
+export const DISCUSSION_DIGEST_MAX = 2000
+
+/** Per-turn cap, so one enormous paste cannot eat the whole budget. */
+const DIGEST_TURN_MAX = 220
+
+/** Turns kept from the START. The opening ask frames everything after it. */
+const DIGEST_HEAD_TURNS = 2
+
+/** Recent turns retained while streaming. Comfortably more than 2000 chars can
+ *  render (~20-25 at typical length), so the budget and not the buffer decides
+ *  what appears. */
+const DIGEST_RECENT_WINDOW = 60
+
+/**
+ * A readable account of what actually happened in a session.
+ *
+ * `composeDiscussionSummary` is the opening prompt plus the last assistant snippet at
+ * 180 chars — it says where a session started and where it stopped, and nothing about
+ * the turns between, which is exactly what you need to decide whether to reopen it.
+ *
+ * Shape: the opening ask, then the MOST RECENT user turns in chronological order, then
+ * where the assistant left off. Recency is weighted because a follow-up continues from
+ * the end, not the beginning.
+ *
+ * NO LLM, by design — assembled from turns `parseAgentSession` already streams, so a
+ * digest costs no tokens and no extra file reads.
+ *
+ * Elision is STATED, never silent: dropping 40 turns and rendering the rest as clean
+ * prose reads like the whole story. `… N earlier turns …` says otherwise.
+ */
+export function composeDiscussionDigest(input: {
+  userTurns: string[]
+  latestAssistant?: string
+  max?: number
+  /** True number of user turns in the session, when `userTurns` is a bounded sample.
+   *  The caller keeps only head + a recent window so a 900-turn session cannot balloon
+   *  memory, and without this the elision line would report only the turns it can see
+   *  and quietly under-count the rest — a silent cap wearing an honest label. */
+  totalTurns?: number
+  /** The transcript was read as head+tail, so the middle was never seen and the true
+   *  turn count is unknown. Print elision WITHOUT a number rather than a wrong one. */
+  truncated?: boolean
+}): string {
+  const max = input.max ?? DISCUSSION_DIGEST_MAX
+  const clean = (s: string): string => s.replace(/\s+/g, ' ').trim()
+  const cap = (s: string): string => (s.length <= DIGEST_TURN_MAX ? s : `${s.slice(0, DIGEST_TURN_MAX - 1)}…`)
+
+  const turns = input.userTurns.map(clean).filter(Boolean).map(cap)
+  const latest = clean(input.latestAssistant ?? '')
+  if (turns.length === 0 && !latest) return ''
+  const total = Math.max(input.totalTurns ?? turns.length, turns.length)
+
+  // Reserve room for the closing state before spending budget on asks.
+  const tail = latest ? `\n\nLatest: ${cap(latest)}` : ''
+  let budget = max - tail.length
+
+  const head = turns.slice(0, DIGEST_HEAD_TURNS)
+  const rest = turns.slice(DIGEST_HEAD_TURNS)
+
+  // HEAD FIRST. Claiming the opening ask "frames everything after it" and then
+  // spending the budget from the end left no room for it — a 40-turn session rendered
+  // as "… 22 earlier turns …" with the original request nowhere on the page. Reserve
+  // the framing, then spend what is left on recency. Caught by its own test.
+  const headKept: string[] = []
+  for (const turn of head) {
+    const cost = turn.length + 3
+    if (cost > budget) break
+    headKept.push(turn)
+    budget -= cost
+  }
+
+  // Then fill from the END backwards — the turns nearest a follow-up.
+  const kept: string[] = []
+  for (let i = rest.length - 1; i >= 0; i--) {
+    const cost = rest[i].length + 3
+    if (cost > budget) break
+    kept.unshift(rest[i])
+    budget -= cost
+  }
+
+  const dropped = total - headKept.length - kept.length
+  const lines: string[] = []
+  for (const t of headKept) lines.push(`• ${t}`)
+  if (input.truncated) lines.push('… middle of a large session not read …')
+  else if (dropped > 0) lines.push(`… ${dropped} earlier turn${dropped === 1 ? '' : 's'} …`)
+  for (const t of kept) lines.push(`• ${t}`)
+
+  const body = lines.join('\n') + tail
+  return body.length <= max ? body : `${body.slice(0, max - 1)}…`
+}
+
 export function assistantProseFromRecord(obj: Record<string, unknown>): string | null {
   if (obj.type === 'assistant') {
     const message = obj.message && typeof obj.message === 'object' ? obj.message as Record<string, unknown> : null
@@ -931,6 +1027,54 @@ export async function findAgentSessionFile(
   return best?.file ?? null
 }
 
+/** Bytes read from the START of an oversized transcript — enough for the opening ask
+ *  and the session_meta record that carries cwd/branch. */
+export const PARTIAL_HEAD_BYTES = 256 * 1024
+/** Bytes read from the END. Larger than the head because the recent turns are what a
+ *  follow-up continues from. */
+export const PARTIAL_TAIL_BYTES = 768 * 1024
+
+/**
+ * Lines of a transcript, reading the WHOLE file when it fits and head+tail when it
+ * does not.
+ *
+ * WHY. `GET /api/agent-sessions/:provider/:id` used to answer 413 "Session too large
+ * to open" for anything over 32 MiB, so the biggest sessions — the ones most worth
+ * summarizing before a follow-up — returned nothing at all. A 67 MB transcript is
+ * real; today's own session is one. Refusing was never necessary: the detail page
+ * needs the opening turns, the recent turns, and the counts, and two bounded windows
+ * carry all three without loading 67 MB into memory.
+ *
+ * The first line of the tail window is almost always a fragment of a JSON record.
+ * `parseJsonLine` returns null for it and the caller's loop skips it, which is why
+ * this can slice at an arbitrary byte offset and stay correct.
+ */
+export async function* agentSessionLines(
+  path: string,
+  size: number,
+  maxBytes: number,
+  // Window sizes are injectable so a test can prove ELISION without writing a
+  // multi-megabyte fixture. With the production 256 KiB + 768 KiB defaults, any
+  // fixture small enough to build quickly is fully covered by the two windows — so
+  // the test would read the whole file, see every turn, and pass identically with
+  // windowing removed. It did exactly that until a mutation caught it.
+  headBytes = PARTIAL_HEAD_BYTES,
+  tailBytes = PARTIAL_TAIL_BYTES,
+): AsyncGenerator<string> {
+  if (size <= maxBytes) {
+    yield* createInterface({ input: createReadStream(path), crlfDelay: Infinity })
+    return
+  }
+  yield* createInterface({
+    input: createReadStream(path, { start: 0, end: headBytes - 1 }),
+    crlfDelay: Infinity,
+  })
+  yield* createInterface({
+    input: createReadStream(path, { start: Math.max(headBytes, size - tailBytes) }),
+    crlfDelay: Infinity,
+  })
+}
+
 export interface AgentSessionDetail {
   session_id: string
   provider: AgentProvider
@@ -939,14 +1083,27 @@ export interface AgentSessionDetail {
   git_branch: string
   first_prompt: string
   discussion_summary: string
+  /** Deep, paginated body text for the detail page — up to 2000 chars. The list row
+   *  keeps `discussion_summary` at 180. Older clients ignore this field. */
+  discussion_digest: string
   user_message_count: number
   assistant_message_count: number
   omitted_tools: number
   file_size_bytes: number
+  /** True when the transcript exceeded the read ceiling and only head+tail were
+   *  parsed. The message counts are then counts of what was READ, not of the
+   *  session — the client must not present them as exact. */
+  truncated: boolean
 }
 
-export async function parseAgentSession(provider: AgentProvider, path: string): Promise<AgentSessionDetail> {
+export async function parseAgentSession(
+  provider: AgentProvider,
+  path: string,
+  opts: { maxBytes?: number; headBytes?: number; tailBytes?: number } = {},
+): Promise<AgentSessionDetail> {
   const st = await stat(path)
+  const maxBytes = opts.maxBytes ?? AGENT_SESSION_MAX_FILE_BYTES
+  const truncated = st.size > maxBytes
   let title = ''
   let project = ''
   let gitBranch = ''
@@ -954,11 +1111,38 @@ export async function parseAgentSession(provider: AgentProvider, path: string):
   let firstPrompt = ''
   let latestAssistant = ''
   let userCount = 0
+  // Bounded sample for the deep digest: the opening turns plus a recent window.
+  // The composer only ever renders head + as many recent as fit 2000 chars, so
+  // retaining the whole conversation would be memory held for nothing — a 900-turn
+  // session is real. `userCount` still carries the TRUE total so the elision line
+  // reports what was actually dropped rather than what this buffer happens to hold.
+  const digestHead: string[] = []
+  const digestRecent: string[] = []
+  const collectTurn = (text: string): void => {
+    // Reuse the wrapper filter the rest of this module already trusts. Without it the
+    // opening turns of a slash-command session render as
+    // "<command-message>cos-glasses</command-message>…" — scaffolding, not the ask,
+    // and it lands in the two most valuable slots in the digest.
+    const raw = (text ?? '').trim()
+    if (!raw || isWrapperPrompt(raw)) return
+    // Same tag-stripping firstLineTitle does, so an inline <user_query> wrapper does
+    // not leak angle brackets into the body.
+    const unwrapped = (() => {
+      const start = raw.indexOf('<user_query>')
+      const end = raw.indexOf('</user_query>')
+      const inner = start >= 0 && end > start ? raw.slice(start + '<user_query>'.length, end) : raw
+      return inner.replace(/<[^>]+>/g, ' ')
+    })()
+    const line = unwrapped.replace(/\s+/g, ' ').trim()
+    if (!line) return
+    if (digestHead.length < DIGEST_HEAD_TURNS) { digestHead.push(line.slice(0, DIGEST_TURN_MAX)); return }
+    digestRecent.push(line.slice(0, DIGEST_TURN_MAX))
+    if (digestRecent.length > DIGEST_RECENT_WINDOW) digestRecent.shift()
+  }
   let assistantCount = 0
   let omittedTools = 0
 
-  const rl = createInterface({ input: createReadStream(path), crlfDelay: Infinity })
-  for await (const line of rl) {
+  for await (const line of agentSessionLines(path, st.size, maxBytes, opts.headBytes, opts.tailBytes)) {
     const obj = parseJsonLine(line)
     if (!obj) continue
     if (provider === 'claude') {
@@ -980,6 +1164,7 @@ export async function parseAgentSession(provider: AgentProvider, path: string):
       }
       if (obj.type === 'user') {
         userCount += 1
+        collectTurn(text)
         if (!firstPrompt) firstPrompt = firstLineTitle(text)
         if (!title) title = firstLineTitle(text)
       } else {
@@ -1012,6 +1197,7 @@ export async function parseAgentSession(provider: AgentProvider, path: string):
         if (snippet) latestAssistant = snippet
       } else {
         userCount += 1
+        collectTurn(text)
         if (!firstPrompt) firstPrompt = firstLineTitle(text)
         if (!title) title = firstLineTitle(text)
       }
@@ -1026,6 +1212,7 @@ export async function parseAgentSession(provider: AgentProvider, path: string):
       if (obj.role === 'user') {
         userCount += 1
         const query = cursorUserTitle(text, true) ?? cursorUserTitle(text, false)
+        collectTurn(query ?? text)
         if (query) {
           title = query
           if (!firstPrompt) firstPrompt = query
@@ -1057,9 +1244,19 @@ export async function parseAgentSession(provider: AgentProvider, path: string):
       firstPrompt: firstPrompt || title,
       latestAssistant,
     }),
+    discussion_digest: composeDiscussionDigest({
+      userTurns: [...digestHead, ...digestRecent],
+      latestAssistant,
+      // On a truncated read `userCount` counts only the sampled windows, so passing
+      // it as the total would print a confidently WRONG "… 12 earlier turns …" for a
+      // session with hundreds. The digest drops the number instead of inventing one.
+      totalTurns: truncated ? undefined : userCount,
+      truncated,
+    }),
     user_message_count: userCount,
     assistant_message_count: assistantCount,
     omitted_tools: omittedTools,
     file_size_bytes: st.size,
+    truncated,
   }
 }

package/server/routes/agent-sessions.ts

@@ -19,7 +19,6 @@ import { stat } from 'node:fs/promises'
 import {
   AGENT_SESSION_LIST_LIMIT,
   AGENT_SESSION_LIST_MAX,
-  AGENT_SESSION_MAX_FILE_BYTES,
   AGENT_SESSION_WINDOW_HOURS,
   agentSessionRoots,
   findAgentSessionFile,
@@ -156,10 +155,17 @@ agentSessionsRouter.get('/agent-sessions/:provider/:sessionId', async (req, res)
       return
     }
     const st = await stat(found)
-    if (st.size > AGENT_SESSION_MAX_FILE_BYTES) {
-      res.status(413).json({ error: 'Session too large to open', reason: 'session_too_large' })
-      return
-    }
+    // Oversized transcripts are READ IN PART, not refused.
+    //
+    // This used to answer 413 "Session too large to open" above 32 MiB, which made the
+    // biggest sessions — the ones most worth reviewing before a follow-up — completely
+    // unopenable on the glasses. A 67 MB transcript is not exotic; this repo's own
+    // 2026-08-13 session is one. The detail page needs the opening turns, the recent
+    // turns, and stats, and a bounded head+tail carries all three.
+    //
+    // `parsed.truncated` says so out loud, and the counts are then counts of what was
+    // READ. Presenting a partial count as the session total would be the same
+    // dishonesty as a silent cap, so the digest omits the number entirely instead.
     const parsed = await parseAgentSession(provider, found)
     if (provider === 'cursor') {
       const names = await loadCursorComposerNames(agentSessionRoots().cursorComposerDb)
@@ -175,6 +181,11 @@ agentSessionsRouter.get('/agent-sessions/:provider/:sessionId', async (req, res)
       display_label: parsed.display_label,
       first_prompt: parsed.first_prompt,
       discussion_summary: parsed.discussion_summary || '',
+      // Detail only. The list row (line 73) deliberately stays on the 180-char
+      // summary — Miles: "it should be in the body not the title, the row should
+      // be no more than the 180 characters."
+      discussion_digest: parsed.discussion_digest || '',
+      truncated: parsed.truncated,
       project: parsed.project,
       created: modified,
       modified,