thinkpool-pair 0.7.91 → 0.7.93

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, readDurableOldestSeq } from './session-store.mjs'
 import { stampEvent, makeSeqCounter, maxSeq, seqable, capReplayEvents, chunkReplayEvents, boundEventForBroadcast, inlineImageBlocks } from './event-id.mjs'
 import { makeThrottledTrack } from './presence.mjs'
 
@@ -579,7 +579,7 @@ 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 } : {}) })),
     ],
   })
 
@@ -866,6 +866,18 @@ 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])
+    // 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
 }
@@ -901,6 +913,17 @@ 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)))
+  // 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
@@ -1337,6 +1360,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.91",
+  "version": "0.7.93",
   "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,75 @@ 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 */ }
+}
+
+// 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.
+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 */ }