thinkpool-pair 0.7.92 → 0.7.94

package/account.mjs

@@ -230,6 +230,12 @@ export async function runAccount(SUPABASE_URL, SUPABASE_ANON) {
   const childIdle = new Map()    // room -> bool (last idle report: in the quiet window)
   const childBetween = new Map() // room -> bool (between turns now — safe to restart per Contract #1)
   const childPeer = new Map()  // room -> bool (a web client is watching this room)
+  // Thinkpool Ensemble cross-ROOM router (Tier 1): the supervisor is the only process
+  // that knows every room on this machine, so it routes a child's read_session into the
+  // target room's child and relays the reply back. roomNames feeds list_sessions; pairPending
+  // maps an in-flight peek's reqId → the room that asked, so the target's reply finds its way home.
+  const roomNames = new Map()  // room -> display name (for list_sessions)
+  const pairPending = new Map() // reqId -> asking room code (for read_session reply routing)
   let applyRequested = false   // a user clicked "apply" in some room (Slice 3)
   let pendingUpdate = null     // newest published version once the poll sees it
   const warned = new Set()
@@ -384,6 +390,7 @@ export async function runAccount(SUPABASE_URL, SUPABASE_ANON) {
         continue
       }
       warned.delete(room)
+      roomNames.set(room, r.name || null)   // feed list_sessions (cross-room roster)
       process.stderr.write(`\n  ◆ serving ${room}${r.name ? ` "${r.name}"` : ''}  →  ${dir}${dirs[room] ? '' : ' (default)'}\n`)
       // Children NEVER self-update (only the supervisor restart re-resolves
       // @latest); they report idle to us over IPC so we can restart at a moment
@@ -402,8 +409,42 @@ export async function runAccount(SUPABASE_URL, SUPABASE_ANON) {
         if (!m) return
         if (m.t === 'idle') { childIdle.set(room, !!m.idle); childBetween.set(room, m.between != null ? !!m.between : !!m.idle); childPeer.set(room, !!m.webPeer) }
         else if (m.t === 'apply-update') { applyRequested = true; applyIfIdle() }   // user clicked the chip
+        // ── Thinkpool Ensemble cross-ROOM routing (Tier 1, read-only) ──────────
+        // `room` here is the room that sent the message (this closure is per-child).
+        else if (m.t === 'pair-list-req') {
+          // The asking room's OTHER sessions on this machine (same account = "your other rooms").
+          const off = process.env.TP_CROSSROOM_OFF === '1'
+          const others = off ? [] : [...children.keys()].filter((r) => r !== room).map((r) => ({ code: r, name: roomNames.get(r) || null }))
+          try { child.send({ t: 'pair-list-res', reqId: m.reqId, rooms: others, ...(off ? { error: 'Cross-session reach is turned off on this bridge.' } : {}) }) } catch { /* child gone */ }
+        }
+        else if (m.t === 'pair-peek-req') {
+          const reply = (extra) => { try { child.send({ t: 'pair-peek-res', reqId: m.reqId, ...extra }) } catch { /* child gone */ } }
+          if (process.env.TP_CROSSROOM_OFF === '1') return reply({ error: 'Cross-session reach is turned off on this bridge.' })
+          const target = String(m.targetRoom || '').toUpperCase().trim()
+          if (!target || target === room) return reply({ error: `${target || 'That'} is not another of your active sessions on this machine.` })
+          const tc = children.get(target)
+          if (!tc) return reply({ error: `Session ${target} is not running on this machine right now (only sessions this account is actively serving here are reachable).` })
+          pairPending.set(m.reqId, room)   // remember who asked so the reply routes home
+          try { tc.send({ t: 'pair-peek-local', reqId: m.reqId, fromRoom: room, terminal: m.terminal, lines: m.lines }) }
+          catch { pairPending.delete(m.reqId); reply({ error: `Could not reach session ${target}.` }) }
+        }
+        else if (m.t === 'pair-peek-res') {
+          // A target child answered — route its reply back to the room that asked.
+          const askerRoom = pairPending.get(m.reqId)
+          if (askerRoom == null) return
+          pairPending.delete(m.reqId)
+          const asker = children.get(askerRoom)
+          if (asker) { try { asker.send({ t: 'pair-peek-res', reqId: m.reqId, text: m.text, error: m.error, fromRoom: room }) } catch { /* asker gone */ } }
+        }
+      })
+      child.on('exit', () => {
+        children.delete(room); childIdle.delete(room); childBetween.delete(room); childPeer.delete(room); roomNames.delete(room)   // re-served on the next tick
+        // Fail any in-flight cross-room peeks waiting on (or asked by) this dead room.
+        for (const [reqId, askerRoom] of pairPending) {
+          if (askerRoom !== room) continue
+          pairPending.delete(reqId)
+        }
       })
-      child.on('exit', () => { children.delete(room); childIdle.delete(room); childBetween.delete(room); childPeer.delete(room) })   // re-served on the next tick
       // If an update is already pending, tell the freshly-served child immediately so
       // its room shows the "update ready" chip without waiting for the next poll.
       if (pendingUpdate) { try { child.send({ t: 'update-available', version: pendingUpdate }) } catch { /* child not ready */ } }

package/bridge.mjs

@@ -39,9 +39,9 @@ import { createClient } from '@supabase/supabase-js'
 import { createSdkMcpServer, tool } from '@anthropic-ai/claude-agent-sdk'
 import { z } from 'zod'
 import { startClaudeSession } from './claude-session.mjs'
-import { formatPeek, PEEK, siblingsOf, resolveSibling, crossPostDecision, CROSSPOST, spawnDecision } from './cross-terminal.mjs'
+import { formatPeek, PEEK, siblingsOf, resolveSibling, crossPostDecision, CROSSPOST, spawnDecision, CROSSROOM, formatPairRoster } from './cross-terminal.mjs'
 import { turnInFlight } from './update-gate.mjs'
-import { saveSession, flushSession, deleteSession, loadAll, canResume, loadPtyId, savePtyId, loadNames, saveNames, appendDurableEvents, seedDurableEvents, readDurablePage } from './session-store.mjs'
+import { saveSession, flushSession, deleteSession, loadAll, canResume, loadPtyId, savePtyId, loadNames, saveNames, appendDurableEvents, seedDurableEvents, readDurablePage, readDurableOldestSeq } from './session-store.mjs'
 import { stampEvent, makeSeqCounter, maxSeq, seqable, capReplayEvents, chunkReplayEvents, boundEventForBroadcast, inlineImageBlocks } from './event-id.mjs'
 import { makeThrottledTrack } from './presence.mjs'
 
@@ -579,10 +579,61 @@ const announce = () =>
       // the chosen label instead of defaulting to Normal / unnamed. `spawned` (set
       // when an agent Dispatched this lane via spawn_terminal) lets the client keep
       // it OUT of the top tab strip and show it only in the Ensemble menu.
-      ...[...sessions.entries()].map(([id, s]) => ({ id, cmd: s.cmd, kind: 'structured', alive: true, commands: s.commands, mode: s.mode || undefined, name: termNames[id] || undefined, ...(s.spawnedBy ? { spawned: true, spawnedBy: s.spawnedBy } : {}) })),
+      ...[...sessions.entries()].map(([id, s]) => ({ id, cmd: s.cmd, kind: 'structured', alive: true, commands: s.commands, mode: s.mode || undefined, name: termNames[id] || undefined, ...(s.archiveOldestSeq != null ? { oldestSeq: s.archiveOldestSeq } : {}), ...(s.spawnedBy ? { spawned: true, spawnedBy: s.spawnedBy } : {}) })),
     ],
   })
 
+// ── Thinkpool Ensemble — cross-ROOM reach (Tier 1: same-machine pair peek) ────
+// The in-room Ensemble (read_terminal over sibling terminals) expanded ACROSS the
+// account's OTHER rooms. The account supervisor (account.mjs) is the router: this
+// child asks it over IPC, it forwards to the target room's child, that child runs
+// formatPeek over ITS OWN registries, and the formatted text comes back. Read-only;
+// same-machine only; scoped to rooms this account serves (the supervisor only ever
+// serves rooms the account OWNS — so cross-room reach is "your other sessions", never
+// a stranger's). Cross-machine (a pair bus) + posting are later tiers.
+// Spec: docs/specs/2026-06-30-cross-room-ensemble.md
+const IS_ACCOUNT_CHILD = !!(process.send && process.env.THINKPOOL_PAIR_ACCOUNT_CHILD === '1')
+const pairWaiters = new Map()   // reqId -> { resolve, timer } for our OUTBOUND requests
+// Send a cross-room request to the supervisor and resolve with its reply ({ rooms }
+// or { text } / { error }). Fails soft (never throws into the tool handler): a
+// standalone bridge (no supervisor) or a disabled/timed-out request returns { error }.
+function pairRequest(type, payload = {}, timeoutMs = 4000) {
+  if (process.env.TP_CROSSROOM_OFF === '1') return Promise.resolve({ error: 'Cross-session reach is turned off in this room.' })
+  if (!IS_ACCOUNT_CHILD) return Promise.resolve({ error: 'Cross-session reach needs the ThinkPool account bridge running your sessions (npx thinkpool-pair). This room is running standalone, so it can only see its own terminals — use read_terminal.' })
+  const reqId = randomUUID()
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => { pairWaiters.delete(reqId); resolve({ error: 'The other session did not respond in time.' }) }, timeoutMs)
+    timer.unref?.()
+    pairWaiters.set(reqId, { resolve, timer })
+    try { process.send({ t: type, reqId, ...payload }) }
+    catch { clearTimeout(timer); pairWaiters.delete(reqId); resolve({ error: 'Could not reach the account bridge.' }) }
+  })
+}
+if (IS_ACCOUNT_CHILD) {
+  // A SECOND message listener (Node allows many) dedicated to pair traffic — leaves
+  // the account-child idle/token listener (bottom of file) untouched.
+  process.on('message', (m) => {
+    if (!m || !m.t) return
+    // Reply to one of OUR outbound cross-room requests → resolve the waiter.
+    if (m.t === 'pair-list-res' || m.t === 'pair-peek-res') {
+      const w = pairWaiters.get(m.reqId)
+      if (!w) return
+      clearTimeout(w.timer); pairWaiters.delete(m.reqId)
+      w.resolve(m)
+      return
+    }
+    // We are the TARGET of another room's read_session — run formatPeek over our own
+    // registries (selfId null: the asker is in a DIFFERENT room, so every terminal here
+    // is a sibling to show) and reply. Strictly read-only; mutates nothing.
+    if (m.t === 'pair-peek-local') {
+      let text, error
+      try { text = formatPeek({ selfId: null, sessions, terms, names: termNames, terminal: m.terminal, lines: m.lines }) }
+      catch { error = 'Could not read that session.' }
+      try { process.send({ t: 'pair-peek-res', reqId: m.reqId, text, error }) } catch { /* parent gone */ }
+    }
+  })
+}
+
 // One flush timer batches every terminal's pending bytes (~35ms cadence).
 //
 // Viewer gate (2026-06-28): pty-out is the single biggest Realtime-message
@@ -871,7 +922,13 @@ function pushLog(entry, evt) {
   // is skipped. entry.id/entry.room are stamped in openStructured; a PTY entry (no id)
   // is a no-op. This is the single place every new event passes through, so nothing is
   // missed and reloaded events (which don't ride pushLog) never double-append.
-  if (entry.id && seqable(evt)) appendDurableEvents(entry.room, entry.id, [evt])
+  if (entry.id && seqable(evt)) {
+    appendDurableEvents(entry.room, entry.id, [evt])
+    // First archived event sets the floor for a fresh lane (no seed ran). Lets the
+    // client correctly withhold "load earlier" until eviction pushes the loaded window
+    // above this floor — a new lane's first turn at seq>1 is NOT older-history.
+    if (entry.archiveOldestSeq == null) entry.archiveOldestSeq = evt.seq
+  }
   if (entry.log.length > STRUCTURED_LOG_MAX) entry.log.shift()
   return evt
 }
@@ -914,6 +971,10 @@ function openStructured({ id, model, resume, log, commands, mode, spawnedBy }) {
   entry.id = id
   entry.room = room
   seedDurableEvents(room, id, entry.log.filter((e) => seqable(e)))
+  // Archive floor — the lowest seq durably stored. Drives the client's "load earlier"
+  // offer (show only when its oldest loaded seq is BELOW this). null on a brand-new lane
+  // with no archive yet; pushLog stamps it from the first appended event.
+  entry.archiveOldestSeq = readDurableOldestSeq(room, id)
   sessions.set(id, entry)
   // Close an interrupted turn so a restored terminal comes back IDLE-with-history
   // instead of stuck "thinking" (see restoredTurnOpen). Idempotent: the closer is
@@ -965,6 +1026,43 @@ function openStructured({ id, model, resume, log, commands, mode, spawnedBy }) {
           return { content: [{ type: 'text', text }] }
         },
       ),
+      // Tier 1 cross-ROOM peek — list_sessions / read_session. Read-only reach into the
+      // account's OTHER rooms (this session's sibling SESSIONS, not just sibling terminals),
+      // routed through the account supervisor over IPC (pairRequest). Auto-allowed by the
+      // PreToolUse gate (read-only, like read_terminal). Bounded by CROSSROOM.peekPerTurnCap
+      // (reset per human turn alongside the in-room budgets) + TP_CROSSROOM_OFF kill-switch.
+      tool(
+        'list_sessions',
+        'List your OTHER ThinkPool Code sessions (rooms) open on this machine — beyond this one. Returns each room\'s code and name so you can read into one with read_session. This is Thinkpool Ensemble across SESSIONS, not just terminals: it lets you see and pick up work in your other rooms. Read-only.',
+        {},
+        async () => {
+          const okText = (t) => ({ content: [{ type: 'text', text: t }] })
+          entry.pairPeekCount = (entry.pairPeekCount || 0) + 1
+          if (entry.pairPeekCount > CROSSROOM.peekPerTurnCap) return okText(`Cross-session read limit reached for this turn (${CROSSROOM.peekPerTurnCap}). Continue with what you have.`)
+          const res = await pairRequest('pair-list-req', {})
+          return okText(formatPairRoster(res?.rooms, { thisRoom: room, error: res?.error }))
+        },
+      ),
+      tool(
+        'read_session',
+        'Read-only view INTO another of your ThinkPool Code sessions on this machine (a room code from list_sessions). Pass `session` (the room code) and optionally `terminal` (a ref/name in that room) to read its recent activity; omit `terminal` to list that room\'s terminals. It never changes the other session — reading only. Use it to check on or pick up work running in a sibling session.',
+        {
+          session: z.string().describe('the room code of the other session (from list_sessions)'),
+          terminal: z.string().optional().describe('ref, id, or name of a terminal in that room; omit to list that room\'s terminals'),
+          lines: z.number().int().positive().max(PEEK.maxLines).optional().describe(`how many recent lines to return (default ${PEEK.defaultLines})`),
+        },
+        async (args) => {
+          const okText = (t) => ({ content: [{ type: 'text', text: t }] })
+          entry.pairPeekCount = (entry.pairPeekCount || 0) + 1
+          if (entry.pairPeekCount > CROSSROOM.peekPerTurnCap) return okText(`Cross-session read limit reached for this turn (${CROSSROOM.peekPerTurnCap}). Continue with what you have.`)
+          const target = String(args?.session || '').toUpperCase().trim()
+          if (!target) return okText('Name a room code to read (call list_sessions to see them).')
+          if (target === room) return okText('That is this room — use read_terminal for terminals in your own room.')
+          const res = await pairRequest('pair-peek-req', { targetRoom: target, terminal: args?.terminal, lines: args?.lines })
+          if (res?.error) return okText(res.error)
+          return okText(res?.text || `Room ${target} returned nothing.`)
+        },
+      ),
       // Tier C — directed cross-lane action. WRITES into a sibling AGENT lane.
       // The PreToolUse gate (claude-session.mjs) already enforced: precheck passed
       // + a human approved the card. This handler routes only; it re-asserts the
@@ -1401,6 +1499,7 @@ channel
     // speaks again.
     s.peekCount = 0
     s.postCount = 0
+    s.pairPeekCount = 0   // cross-room read budget resets with the in-room ones (Tier 1)
     s.hop = 0
     const text = String(payload.text)
     // Echo the turn so BOTH readers (and late joiners, via the log) show who

package/claude-session.mjs

@@ -253,6 +253,13 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
     if (toolName === 'mcp__thinkpool__read_terminal') {
       return { continue: true, hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'allow', permissionDecisionReason: 'Auto-approved (read-only ThinkPool cross-terminal read).' } }
     }
+    // ThinkPool cross-ROOM READ (Tier 1: list_sessions / read_session) is read-only and
+    // reaches ONLY the account's own other rooms on this machine (the supervisor only
+    // serves owned rooms) — same trust class as read_terminal, so auto-allow. Posting
+    // across rooms is a later tier and will gate on a card at both ends.
+    if (toolName === 'mcp__thinkpool__list_sessions' || toolName === 'mcp__thinkpool__read_session') {
+      return { continue: true, hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'allow', permissionDecisionReason: 'Auto-approved (read-only ThinkPool cross-session read — your own rooms).' } }
+    }
     // ThinkPool cross-terminal CLOSE (Tier C+) — closes only a lane the agent itself
     // spawned (bridge-side spawnedBy check), never a sibling's work nor the host
     // terminal. Low-risk lane management → auto-allow (surfaced as a card for visibility).
@@ -413,6 +420,7 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
       'CROSS-TERMINAL AWARENESS: this room may have other terminals open alongside yours — other agents working, or shells the people are driving. You have a READ-ONLY tool, read_terminal: call it with no arguments to list the other open terminals, or with a terminal ref/id/command to read that terminal\'s recent activity. Reach for it when your work depends on what another terminal is doing (e.g. someone says "see what the other terminal hit", or you need to coordinate with a sibling agent before acting). It only ever reads — it never changes another terminal. Identify a terminal by its NAME or its ref/id from the roster, never by an on-screen number like "Terminal 2" — those positional labels renumber when a terminal is closed, so they do not reliably point at a lane.',
       'CROSS-TERMINAL HAND-OFF: you also have post_to_terminal(terminal, text) to send a message or task to ANOTHER AGENT terminal in this room (not a plain shell). Use it sparingly and only when the people clearly want the lanes to coordinate — e.g. "tell the backend terminal the API is ready", or to hand a sibling agent a concrete task. Every post requires a person in the room to approve a card before it is delivered, and an agent that was itself reached via a cross-post cannot post onward — so do not rely on it for chit-chat or loops. Prefer read_terminal to understand a sibling before you ever post to it.',
       'CROSS-TERMINAL SPAWN: when a person asks you to fan work out across multiple agents — research lanes, parallel sub-tasks, a swarm — open YOUR OWN fresh lanes with spawn_terminal(name?, task?, model?); do NOT dump the work into siblings that are already busy (a sibling is mid-task unless read_terminal shows it idle, and hijacking it derails their work). spawn_terminal opens a brand-new Claude lane and, if you pass `task`, hands it that task immediately; it appears as a new terminal in the room. A spawned lane INHERITS your current permission mode by default — so if you are in bypass, your lanes run autonomously with no per-action clicking; pass `mode` only to override. Raising a lane to bypass from a non-bypass lane asks the room to confirm once (everything else spawns without a prompt). Collect each lane\'s result later with read_terminal (a spawned lane cannot post back to you), and tidy up with close_terminal once you have what you need — you may only close lanes you spawned yourself. You are bounded: a few new lanes per turn, a per-plan dispatch ceiling on concurrent spawned lanes (Free 3 / Plus 6) that is separate from the human terminals so it never blocks them, an overall room machine cap, and a lane you were spawned/cross-posted into cannot itself spawn (so no runaway). This is how you "open the terminals yourself" instead of asking a person to.',
+      'CROSS-SESSION AWARENESS: the Ensemble reaches across your SESSIONS, not just the terminals in this room. You have two READ-ONLY tools for your OTHER ThinkPool Code rooms running on this machine: list_sessions() lists them (room code + name), and read_session(session, terminal?) reads recent activity inside one (omit `terminal` to list that room\'s terminals, or pass a ref/name from it to read that lane). Reach for them when work spans your rooms — "what\'s the other project up to", "pick up where the other session left off", or to check a long-running task in another room before you act here. They only ever read — they never change another session, and they reach ONLY your own rooms (never a stranger\'s). This works only when your sessions run under the ThinkPool account bridge; a standalone room sees just its own terminals. Posting work INTO another session is not available yet — for now, read across sessions and coordinate with the people in the room.',
       'WRITE PLANS INTO THE CHAT: whenever you form or revise a plan — because the room is in Plan mode, or because someone asked you to plan, design, or think it through first — write the actual plan out as a normal message in the room as you develop it: the approach, the concrete steps, the files you will touch, the open questions. The room does NOT surface plan files at all, and the plan-approval card does not reliably carry the plan text, so a plan that lives only in a plan file or only inside ExitPlanMode is INVISIBLE to the people you are working with — they just see "plan ready" with no content. The chat is the canonical place your plan lives; put it there so the room can read and react to it before you proceed.',
     ].join(' '),
     // Needed for live thinking-token progress (SDKThinkingTokensMessage) to

package/cross-terminal.mjs

@@ -202,3 +202,30 @@ export const spawnDecision = ({ hop = 0, spawnCount = 0, spawnedLive = 0, totalL
   if (spawnCount >= o.perTurnCap) return { ok: false, reason: `Spawn limit reached for this turn (${o.perTurnCap}).` }
   return { ok: true }
 }
+
+// ── Tier 1 cross-ROOM peek (read-only, same-machine) ─────────────────────────
+// Thinkpool Ensemble expanded from cross-TERMINAL (sibling lanes in one room) to
+// cross-SESSION (the account's OTHER rooms served by the same account supervisor).
+// This module only formats the ROSTER of other rooms; the per-room terminal read
+// reuses formatPeek as-is on the REMOTE side (the target room's bridge runs it over
+// its own registries). Cross-room is rarer + costlier than in-room peek (an IPC /
+// future-bus round-trip per call), so the per-turn cap is tighter than PEEK's.
+// Spec: docs/specs/2026-06-30-cross-room-ensemble.md
+export const CROSSROOM = {
+  peekPerTurnCap: 5,   // list_sessions + read_session calls allowed per turn (vs PEEK.perTurnCap=10 in-room)
+}
+
+// Render the list_sessions roster from the supervisor's room list. `rooms` is
+// [{ code, name }]; `thisRoom` is excluded defensively (the supervisor already
+// drops it). Mirrors formatPeek's no-arg roster shape so the agent reads one voice.
+export const formatPairRoster = (rooms, { thisRoom, error } = {}) => {
+  if (error) return String(error)
+  const seen = new Set()
+  const list = (Array.isArray(rooms) ? rooms : []).filter((r) => {
+    if (!r || !r.code || r.code === thisRoom || seen.has(r.code)) return false
+    seen.add(r.code); return true
+  })
+  if (!list.length) return 'No other sessions of yours are open on this machine right now. (Cross-session reach is limited to rooms this account is actively running here.)'
+  const rows = list.map((r) => `- ${r.code}${r.name ? ` · "${r.name}"` : ''}`)
+  return `Your other ThinkPool Code sessions on this machine (call read_session with a room code to look inside one):\n${rows.join('\n')}`
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.92",
+  "version": "0.7.94",
   "description": "Share a local coding-agent CLI (Claude Code, Codex, Gemini, Aider, …) into a ThinkPool Code room, live.",
   "type": "module",
   "bin": {

package/session-store.mjs

@@ -91,6 +91,22 @@ export function seedDurableEvents(room, id, events) {
   } catch { /* noop */ }
 }
 
+// The archive FLOOR: the lowest transcript seq durably stored for this terminal.
+// The client compares its oldest loaded seq against this — only OFFER "load earlier"
+// when there genuinely are older events in the archive (vs a fresh lane whose first
+// turn happens to land at seq > 1, or an evicted-but-unarchived gap). null = no archive.
+export function readDurableOldestSeq(room, id) {
+  try {
+    const f = eventsLog(room, id)
+    if (!fs.existsSync(f)) return null
+    for (const line of fs.readFileSync(f, 'utf8').split('\n')) {
+      if (!line) continue
+      try { const e = JSON.parse(line); if (e && e.seq != null) return e.seq } catch { /* skip torn line */ }
+    }
+    return null
+  } catch { return null }
+}
+
 // Read a backward page: events with transcript seq < beforeSeq (newest `limit` of
 // them, no-seq chrome interleaved by file order preserved). Returns { events, hasMore }.
 // beforeSeq null → the newest `limit` events (the tail). hasMore = there is older still.