thinkpool-pair 0.7.202 → 0.7.204

package/bridge.mjs

@@ -1044,7 +1044,7 @@ const announce = () => {
       // turnActive). Authoritative — the bridge owns the turn — so the /code
       // dashboard reads "N agents working" off the roster instead of sniffing
       // the live code-event stream (which a passive dashboard channel misses).
-      ...[...sessions.entries()].map(([id, s]) => ({ id, cmd: s.cmd, kind: 'structured', runtime: s.runtime || 'claude', alive: true, busy: s.session?.turnActive ?? false, commands: s.commands, mode: s.mode || undefined, effort: s.effort || undefined, name: termNames[id] || undefined, model: s.model || undefined, ...(s.runtime === 'codex' ? { approvalPolicy: codexConfigForMode(s.mode).approvalPolicy, models: s.models || [] } : {}), ...(s.archiveOldestSeq != null ? { oldestSeq: s.archiveOldestSeq } : {}), ...(s.spawnedBy ? { spawned: true, spawnedBy: s.spawnedBy } : {}), ...(s.flowSessionId ? { flowId: s.flowSessionId, flowRole: s.flowTaskKey ? 'lane' : 'conductor' } : {}),
+      ...[...sessions.entries()].map(([id, s]) => ({ id, cmd: s.cmd, kind: 'structured', runtime: s.runtime || 'claude', alive: true, busy: s.session?.turnActive ?? false, hasTranscript: s.log.length > 0, commands: s.commands, mode: s.mode || undefined, effort: s.effort || undefined, name: termNames[id] || undefined, model: s.model || undefined, ...(s.runtime === 'codex' ? { approvalPolicy: codexConfigForMode(s.mode).approvalPolicy, models: s.models || [] } : {}), ...(s.archiveOldestSeq != null ? { oldestSeq: s.archiveOldestSeq } : {}), ...(s.spawnedBy ? { spawned: true, spawnedBy: s.spawnedBy } : {}), ...(s.flowSessionId ? { flowId: s.flowSessionId, flowRole: s.flowTaskKey ? 'lane' : 'conductor' } : {}),
         // provider: the registered LLM-provider this lane runs on, NAME-ONLY {id,name}
         // (NEVER the key or baseUrl). Additive; older clients ignore it. Omitted for the
         // built-in/default Claude path (no badge). Makes the lane's provider badge +
@@ -2239,7 +2239,10 @@ function openStructured({ id, runtime = 'claude', model, effort, resume, log, co
       { const onBuiltin = !entry.provider || entry.provider === 'anthropic'
         const m = onBuiltin ? (evt.model || evt.ctx?.model) : null
         if (m && m !== entry.model) { entry.model = m; announce() }
-        if (evt.kind === 'models' && Array.isArray(evt.models) && evt.models.length) { roomModels = evt.models; announce() } }
+        // A custom Anthropic-compatible endpoint may expose its own catalog through the
+        // same SDK method. Never publish that as the ROOM's Claude catalog: its models
+        // already render in the provider group and otherwise leak under ANTHROPIC.
+        if (onBuiltin && evt.kind === 'models' && Array.isArray(evt.models) && evt.models.length) { roomModels = evt.models; announce() } }
       // Cache the last usage/ctx meter on the entry (persisted + replayed — see
       // openStructured). Chrome events bypass pushLog/persist in emitTail below, so
       // usage needs an explicit persist() here to survive a bridge restart.
@@ -2730,8 +2733,18 @@ channel
     // (legacy/pre-C1 logs) ride along always; the client cid-dedups those and
     // additionally drops ≤ seqHi, so an over-send is harmless. A fresh joiner (no
     // cursor) still gets the full log.
-    for (const [id, s] of sessions) {
-      if (!s.log.length) continue
+    // Hydrate the viewed lane first. Other terminals still warm in the background,
+    // but cannot queue ahead of the transcript the person is waiting to see.
+    const replaySessions = [...sessions.entries()].sort(([a], [b]) =>
+      a === payload?.priority ? -1 : b === payload?.priority ? 1 : 0)
+    for (const [id, s] of replaySessions) {
+      // An explicit empty replay is an acknowledgement, not data. It lets mixed
+      // clients clear their loading cover even if they missed the announce's
+      // hasTranscript:false state.
+      if (!s.log.length) {
+        bcast('code-replay', { to: payload?.to ?? null, term: id, events: [], empty: true })
+        continue
+      }
       const from = Number(payload?.cursors?.[id]) || 0
       const mx = maxSeq(s.log)
       // Cursor-sanity (B-safety): if the client's cursor is AHEAD of our highest seq, the

package/event-bounds.mjs

@@ -0,0 +1,96 @@
+/* Browser-safe structured-event bounding shared by the bridge broadcast path and
+   the web client's persisted reload snapshot. Large Codex/Claude tool payloads
+   must remain recognisable (tool name + a useful preview), but must never turn a
+   replay frame or tx: seed row into a multi-megabyte hydration dependency. */
+
+export const STRUCTURED_EVENT_CAP = 80000
+
+const sizeOf = (value) => {
+  try { return JSON.stringify(value).length } catch { return Infinity }
+}
+
+const clipString = (value, limit) => {
+  if (value.length <= limit) return value
+  return `${value.slice(0, limit)}\n…[truncated ${value.length - limit} bytes]`
+}
+
+function compactValue(value, budget, depth = 0) {
+  if (sizeOf(value) <= budget) return value
+  if (typeof value === 'string') return clipString(value, Math.max(80, budget - 80))
+  if (value == null || typeof value !== 'object') return value
+  if (depth >= 4) return '[nested value omitted — too large]'
+
+  if (Array.isArray(value)) {
+    const out = []
+    const limit = Math.min(value.length, 8)
+    const per = Math.max(240, Math.floor((budget - 180) / Math.max(1, limit)))
+    for (let i = 0; i < limit; i++) out.push(compactValue(value[i], per, depth + 1))
+    if (value.length > limit) out.push(`…[${value.length - limit} more items omitted]`)
+    return out
+  }
+
+  const entries = Object.entries(value)
+  const out = {}
+  const limit = Math.min(entries.length, 16)
+  const per = Math.max(240, Math.floor((budget - 180) / Math.max(1, limit)))
+  for (let i = 0; i < limit; i++) {
+    const [key, nested] = entries[i]
+    out[key] = compactValue(nested, per, depth + 1)
+  }
+  if (entries.length > limit) out._omitted = `${entries.length - limit} more fields`
+  return out
+}
+
+function compactBlock(block, budget) {
+  if (!block || typeof block !== 'object') return compactValue(block, budget)
+  if (sizeOf(block) <= budget) return block
+  if (block.type === 'image') {
+    return { type: 'text', text: '[image omitted from replay — open the live session to view]' }
+  }
+  const out = {}
+  for (const key of ['type', 'id', 'name', 'tool_use_id']) if (block[key] != null) out[key] = block[key]
+  // A replay needs the tool identity and a useful preview, not a second full copy
+  // of a giant patch/result that already lives in the durable archive.
+  const payloadBudget = Math.min(block.type === 'tool_use' ? 12000 : 20000, Math.max(500, budget - 600))
+  if (typeof block.text === 'string') out.text = clipString(block.text, payloadBudget)
+  if (block.input != null) out.input = compactValue(block.input, payloadBudget, 1)
+  if (block.content != null) out.content = compactValue(block.content, payloadBudget, 1)
+  if (!('text' in out) && !('input' in out) && !('content' in out)) out.text = `[${block.type || 'content'} omitted — too large]`
+  return out
+}
+
+export function boundStructuredEvent(event, cap = STRUCTURED_EVENT_CAP) {
+  if (!event || typeof event !== 'object' || sizeOf(event) <= cap) return event
+
+  const out = { ...event, _bounded: true }
+  const stringBudget = Math.min(12000, Math.max(1000, Math.floor(cap / 4)))
+  for (const key of ['text', 'output', 'stdout', 'stderr', 'input']) {
+    if (typeof out[key] === 'string') out[key] = clipString(out[key], stringBudget)
+  }
+  if (typeof out.content === 'string') out.content = clipString(out.content, stringBudget)
+  else if (Array.isArray(out.content)) {
+    const per = Math.max(900, Math.floor((cap - 2000) / Math.max(1, Math.min(out.content.length, 8))))
+    out.content = out.content.slice(0, 8).map(block => compactBlock(block, per))
+    if (event.content.length > 8) out.content.push({ type: 'text', text: `…[${event.content.length - 8} more blocks omitted]` })
+  }
+  if (Array.isArray(out.blocks)) {
+    const per = Math.max(900, Math.floor((cap - 2000) / Math.max(1, Math.min(out.blocks.length, 8))))
+    out.blocks = out.blocks.slice(0, 8).map(block => compactBlock(block, per))
+    if (event.blocks.length > 8) out.blocks.push({ type: 'text', text: `…[${event.blocks.length - 8} more blocks omitted]` })
+  }
+
+  if (sizeOf(out) <= cap) return out
+
+  // Hard fallback: retain ordering/dedup identity and recognisable tool blocks.
+  const identity = {}
+  for (const key of ['kind', 'seq', 'cid', 'ts', 'term', 'toolUseId', 'isError']) {
+    if (out[key] != null) identity[key] = out[key]
+  }
+  if (Array.isArray(out.blocks)) identity.blocks = out.blocks.slice(0, 4).map(block => compactBlock(block, 6000))
+  else if (Array.isArray(out.content)) identity.content = out.content.slice(0, 4).map(block => compactBlock(block, 6000))
+  else if (typeof out.content === 'string') identity.content = clipString(out.content, 12000)
+  else if (typeof out.text === 'string') identity.text = clipString(out.text, 12000)
+  identity._bounded = true
+  identity._notice = 'Large tool payload truncated for fast transcript hydration'
+  return identity
+}

package/event-id.mjs

@@ -1,4 +1,5 @@
 import { randomUUID } from 'node:crypto'
+import { boundStructuredEvent, STRUCTURED_EVENT_CAP } from './event-bounds.mjs'
 
 /* event-id.mjs — stamp a structured event with a stable identity + timestamp
    BEFORE it is logged + broadcast.
@@ -180,29 +181,9 @@ export function firstSeq(events) {
 // so dedup, ordering, seqHi, and turn structure stay intact. Returns the event UNCHANGED
 // (no clone) when it's already small; clones before mutating so the persisted log is never
 // touched. (Proper fix for inline images = upload to storage + broadcast a URL — separate.)
-export const PER_EVENT_CAP = 180000
-const truncStr = (s) => s.slice(0, 20000) + `\n…[truncated ${s.length - 20000} bytes — too large to broadcast]`
+export const PER_EVENT_CAP = STRUCTURED_EVENT_CAP
 export function boundEventForBroadcast(evt, cap = PER_EVENT_CAP) {
-  if (!evt || typeof evt !== 'object') return evt
-  let json
-  try { json = JSON.stringify(evt) } catch { return evt }
-  if (json.length <= cap) return evt
-  const out = { ...evt }
-  for (const k of ['text', 'output', 'stdout', 'stderr', 'input']) {
-    if (typeof out[k] === 'string' && out[k].length > 20000) out[k] = truncStr(out[k])
-  }
-  if (typeof out.content === 'string' && out.content.length > 20000) out.content = truncStr(out.content)
-  else if (Array.isArray(out.content)) {
-    out.content = out.content.map((b) => {
-      if (!b || typeof b !== 'object') return b
-      if (JSON.stringify(b).length <= 20000) return b
-      if (b.type === 'image') return { type: 'text', text: '[image omitted from replay — too large to broadcast; open the live session to view]' }
-      if (typeof b.text === 'string') return { ...b, text: truncStr(b.text) }
-      return { type: 'text', text: `[${b.type || 'content'} omitted — too large to broadcast]` }
-    })
-  }
-  out._bounded = true
-  return out
+  return boundStructuredEvent(evt, cap)
 }
 
 // Detect inline base64 IMAGE blocks on a tool_result event (a screenshot the agent

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.202",
+  "version": "0.7.204",
   "description": "Share a local coding-agent CLI (Claude Code, Codex, Gemini, Aider, …) into a ThinkPool Code room, live.",
   "type": "module",
   "bin": {
@@ -22,6 +22,7 @@
     "agent-notify.mjs",
     "agent-detect.mjs",
     "event-id.mjs",
+    "event-bounds.mjs",
     "plan-meters.mjs",
     "recap.mjs",
     "transcript-sanitize.mjs",