thinkpool-pair 0.7.90 → 0.7.92

package/bridge.mjs

@@ -41,7 +41,7 @@ import { z } from 'zod'
 import { startClaudeSession } from './claude-session.mjs'
 import { formatPeek, PEEK, siblingsOf, resolveSibling, crossPostDecision, CROSSPOST, spawnDecision } from './cross-terminal.mjs'
 import { turnInFlight } from './update-gate.mjs'
-import { saveSession, flushSession, deleteSession, loadAll, canResume, loadPtyId, savePtyId, loadNames, saveNames } from './session-store.mjs'
+import { saveSession, flushSession, deleteSession, loadAll, canResume, loadPtyId, savePtyId, loadNames, saveNames, appendDurableEvents, seedDurableEvents, readDurablePage } from './session-store.mjs'
 import { stampEvent, makeSeqCounter, maxSeq, seqable, capReplayEvents, chunkReplayEvents, boundEventForBroadcast, inlineImageBlocks } from './event-id.mjs'
 import { makeThrottledTrack } from './presence.mjs'
 
@@ -866,6 +866,12 @@ function pushLog(entry, evt) {
   // hole the client's applied sequence. See event-id.mjs NO_SEQ_KINDS.
   if (entry.seq && seqable(evt)) evt.seq = entry.seq.next()
   entry.log.push(evt)
+  // Durable, UNBOUNDED archive (powers "load earlier history"): append the transcript
+  // event before the in-memory cap evicts it. Only seqable kinds — chrome/thinking noise
+  // 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.log.length > STRUCTURED_LOG_MAX) entry.log.shift()
   return evt
 }
@@ -901,6 +907,13 @@ function openStructured({ id, model, resume, log, commands, mode, spawnedBy }) {
   // an old seq, which is what keeps the between-turns restart dup-free (see
   // event-id.mjs + src/pages/code/seqDedup.js). pushLog() is the single stamp point.
   entry.seq = makeSeqCounter(maxSeq(entry.log))
+  // Identity for the durable archive — pushLog appends every new transcript event to
+  // <room>/<id>.events.jsonl keyed off these. Seed the archive once from the restored
+  // (≤2000) log so the retained window is immediately pageable; no-op if it already
+  // exists, so this never double-writes across restarts.
+  entry.id = id
+  entry.room = room
+  seedDurableEvents(room, id, entry.log.filter((e) => seqable(e)))
   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
@@ -1337,6 +1350,22 @@ channel
     }
     announce()
   })
+  // "Load earlier history": serve an OLDER page from the durable JSONL archive (the
+  // events the in-memory 2000-cap evicted). beforeSeq anchors the page at the client's
+  // lowest loaded transcript seq; we return the slice just before it, chunked under the
+  // same byte budget as replay. This is the backward cursor — it never touches seqHi
+  // (the forward live/replay cursor); the client cid-dedups + reorders on the prepend.
+  .on('broadcast', { event: 'history-page-request' }, ({ payload }) => {
+    const id = payload?.term
+    if (!id) return
+    const { events, hasMore } = readDurablePage(room, id, Number(payload?.beforeSeq) || null, 200)
+    const to = payload?.to ?? null
+    if (!events.length) { bcast('history-page', { to, term: id, events: [], hasMore: false }); return }
+    const chunks = chunkReplayEvents(events.map((e) => boundEventForBroadcast(e)))
+    // hasMore rides only the FIRST (oldest) chunk so the client sets the floor flag once
+    // from the true page boundary; later chunks are just more of the same page.
+    chunks.forEach((evs, i) => bcast('history-page', { to, term: id, events: evs, hasMore: i === 0 ? hasMore : true }))
+  })
   .on('broadcast', { event: 'file-put' }, ({ payload }) => {
     if (!payload?.id || !payload?.url) return
     // Multi-bridge rooms: targeted like term-open; untargeted = solo case.

package/event-id.mjs

@@ -98,10 +98,20 @@ export function capReplayEvents(events, budget = REPLAY_BYTE_BUDGET) {
 // no event in the recent window is lost (capReplayEvents truncates; this doesn't). Each
 // returned chunk is broadcast as its own `code-replay` — seqDedup.classifyReplay applies
 // them in order (each chunk is contiguous and seq > seqHi), so the client rebuilds the
-// whole window across frames. We keep the MOST RECENT `maxChunks * budget` bytes (older
-// history is the DB transcript snapshot's job) so a giant log doesn't fan out 30+ frames.
+// whole window across frames. We keep the MOST RECENT `maxChunks * budget` bytes.
+//
+// 6 → 14 (2026-06-29): 6 chunks = 900KB, but a real session's full log routinely
+// exceeds that (measured: a forge thread = 1.0MB / 7 chunks, a maxed 2000-event
+// lane = 1.7MB / 12 chunks), so the OLDEST turns — incl. the user's first prompt —
+// were dropped on replay and never reached the client ("not seeing full history of
+// terminal N", Max 2026-06-29). The DB transcript snapshot can't cover the gap: it's
+// capped at 200 tx events AND the client can only persist what it received, so the
+// head only ever lived in this in-memory log. The bridge already hard-caps the log at
+// STRUCTURED_LOG_MAX (2000) events ≈ 2.1MB worst case, so 14 chunks (2.1MB) sends the
+// WHOLE retained log on a fresh (cursor-0) replay — chunkReplayEvents still only emits
+// as many chunks as the log needs, so small sessions are unaffected.
 // Returns an array of event-arrays, oldest chunk first; [] when there's nothing to send.
-export const REPLAY_MAX_CHUNKS = 6
+export const REPLAY_MAX_CHUNKS = 14
 export function chunkReplayEvents(events, budget = REPLAY_BYTE_BUDGET, maxChunks = REPLAY_MAX_CHUNKS) {
   if (!Array.isArray(events) || events.length === 0) return []
   // Walk newest→oldest accumulating into the current chunk; start a new chunk when the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.90",
+  "version": "0.7.92",
   "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

@@ -60,6 +60,59 @@ function prune(room) {
   } catch { /* noop */ }
 }
 
+// ── Durable append-only event log (unbounded history; the <id>.json snapshot is
+// still capped at STRUCTURED_LOG_MAX for fast restart, this is the full archive). ──
+// One JSONL per terminal: every transcript event appended once, O(1), never rewritten.
+// Powers "load earlier history" paging without holding the whole log in memory.
+const eventsLog = (room, id) => path.join(dir(room), `${id}.events.jsonl`)
+
+// Append events to the durable log. Caller passes only the events it wants kept
+// (transcript kinds) — chrome/thinking noise is filtered upstream. Sync append keeps
+// strict on-disk order; writes are tiny so the blocking cost is negligible.
+export function appendDurableEvents(room, id, events) {
+  if (!room || !id || !Array.isArray(events) || !events.length) return
+  try {
+    ensureDir(room)
+    fs.appendFileSync(eventsLog(room, id), events.map((e) => JSON.stringify(e)).join('\n') + '\n')
+  } catch { /* noop */ }
+}
+
+// One-time seed: if the durable log doesn't exist yet (a terminal that predates this
+// feature, or a fresh restart before any new event), write the loaded snapshot as the
+// base so the retained window is immediately pageable. No-op once the file exists, so
+// reloaded events never double-append (only genuinely-new events ride pushLog → append).
+export function seedDurableEvents(room, id, events) {
+  if (!room || !id || !Array.isArray(events) || !events.length) return
+  try {
+    ensureDir(room)
+    const f = eventsLog(room, id)
+    if (fs.existsSync(f)) return
+    fs.writeFileSync(f, events.map((e) => JSON.stringify(e)).join('\n') + '\n')
+  } catch { /* noop */ }
+}
+
+// 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.
+export function readDurablePage(room, id, beforeSeq, limit = 200) {
+  try {
+    const f = eventsLog(room, id)
+    if (!fs.existsSync(f)) return { events: [], hasMore: false }
+    const all = []
+    for (const line of fs.readFileSync(f, 'utf8').split('\n')) {
+      if (!line) continue
+      try { all.push(JSON.parse(line)) } catch { /* skip a torn line */ }
+    }
+    let bound = all.length
+    if (beforeSeq != null) {
+      const i = all.findIndex((e) => e && e.seq != null && e.seq >= beforeSeq)
+      if (i >= 0) bound = i
+    }
+    const start = Math.max(0, bound - limit)
+    return { events: all.slice(start, bound), hasMore: start > 0 }
+  } catch { return { events: [], hasMore: false } }
+}
+
 const timers = new Map()
 function write(room, id, data) {
   try { ensureDir(room); fs.writeFileSync(path.join(dir(room), `${id}.json`), JSON.stringify({ ...data, id, savedAt: Date.now() })); prune(room) } catch { /* noop */ }