thinkpool-pair 0.7.30 → 0.7.31

package/bridge.mjs

@@ -39,7 +39,7 @@ import { createClient } from '@supabase/supabase-js'
 import { startClaudeSession } from './claude-session.mjs'
 import { turnInFlight } from './update-gate.mjs'
 import { saveSession, flushSession, deleteSession, loadAll, canResume, loadPtyId, savePtyId, loadNames, saveNames } from './session-store.mjs'
-import { stampEvent } from './event-id.mjs'
+import { stampEvent, makeSeqCounter, maxSeq, seqable } from './event-id.mjs'
 
 // Public client creds (the same anon values the web app ships — safe to embed).
 // Override with TP_SUPABASE_URL / TP_SUPABASE_ANON if you ever need to.
@@ -615,6 +615,20 @@ function printLocal(evt) {
   }
 }
 
+// Single stamp+append point for a structured session's replayed log. Assigns the
+// per-term contiguous seq (C1), appends, and caps at STRUCTURED_LOG_MAX (oldest
+// first). EVERY event that joins entry.log must go through here so the client's
+// "drop ≤ seqHi" cursor stays correct (a logged event with no seq would break it).
+function pushLog(entry, evt) {
+  // Only TRANSCRIPT events consume a seq (seqable) — replay-chrome kinds the web
+  // filters out (system/thinking_tokens/effort) ride the log seq-less so they don't
+  // 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)
+  if (entry.log.length > STRUCTURED_LOG_MAX) entry.log.shift()
+  return evt
+}
+
 // The Phase-2 path: instead of a PTY, run Claude Code through the Agent SDK and
 // relay STRUCTURED events. onEvent → broadcast `code-event` + print locally +
 // persist to the host file; tool calls round-trip through the perm card; the
@@ -622,6 +636,11 @@ function printLocal(evt) {
 function openStructured({ id, model, resume, log, commands, mode }) {
   if (sessions.has(id)) return
   const entry = { cmd: 'claude', kind: 'structured', log: Array.isArray(log) ? log.slice(-STRUCTURED_LOG_MAX) : [], pending: new Map(), session: null, recovered: false, commands: Array.isArray(commands) ? commands : undefined, mode }
+  // C1 (RT-2): per-term contiguous seq counter. Seeded from the restored log's max
+  // so a bridge restart resumes ABOVE every persisted seq — fresh events never reuse
+  // 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))
   sessions.set(id, entry)
   // This session's private mockup outbox — render.sh writes manifests here (via
   // TP_MOCKUP_OUTBOX below) and the watcher attributes every card to THIS id, so
@@ -671,10 +690,7 @@ function openStructured({ id, model, resume, log, commands, mode }) {
         entry.compacting = false
         bcast('code-event', { term: id, evt: { kind: 'compact', status: 'done', ts: Date.now() } })
       }
-      if (!chrome) {
-        entry.log.push(evt)
-        if (entry.log.length > STRUCTURED_LOG_MAX) entry.log.shift()
-      }
+      if (!chrome) pushLog(entry, evt)
       bcast('code-event', { term: id, evt })
       printLocal(evt)
       if (!chrome) persist()
@@ -831,9 +847,17 @@ channel
       })
     }
     // Structured sessions replay their event log (reader rebuilds from it).
+    // C1 (RT-2): send only the tail past the client's per-term cursor (seqHi) when
+    // it supplies one — the authoritative replay-from-cursor that supersedes
+    // re-sending + re-merging the whole log on every reconnect. Events with no seq
+    // (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
-      bcast('code-replay', { to: payload?.to ?? null, term: id, events: s.log })
+      const from = Number(payload?.cursors?.[id]) || 0
+      const events = from > 0 ? s.log.filter((e) => e.seq == null || e.seq > from) : s.log
+      bcast('code-replay', { to: payload?.to ?? null, term: id, events })
     }
     // Re-send any still-pending permission/question cards. They ride a one-shot
     // code-perm-req broadcast (NOT the replayed event log), so a reconnect/refresh
@@ -881,7 +905,7 @@ channel
     const echoYou = () => {
       if (payload.silent) return
       const evt = { kind: 'you', text, cid: payload.cid, by: payload.by }
-      s.log.push(evt); if (s.log.length > STRUCTURED_LOG_MAX) s.log.shift()
+      pushLog(s, evt)
       bcast('code-event', { term: payload.term, evt })
     }
     // Session controls (/model, /clear) are NOT agent turns — they change the
@@ -891,7 +915,7 @@ channel
     // slash still flow through as a real, self-terminating turn.
     const ctlLine = (ctlText) => {
       const evt = { kind: 'control', text: ctlText, by: payload.by, cid: payload.cid }
-      s.log.push(evt); if (s.log.length > STRUCTURED_LOG_MAX) s.log.shift()
+      pushLog(s, evt)
       bcast('code-event', { term: payload.term, evt })
     }
     const mm = text.match(/^\/model\b\s*(\S+)?/)
@@ -902,7 +926,7 @@ channel
     }
     if (/^\/clear\s*$/.test(text)) {
       s.session.sendTurn(text)
-      s.log = []; bcast('code-event', { term: payload.term, evt: { kind: 'clear' } })
+      s.log = []; s.seq = makeSeqCounter(0); bcast('code-event', { term: payload.term, evt: { kind: 'clear' } })
       flushSession(room, payload.term, { sessionId: s.session?.sessionId || null, log: [] })
       ctlLine('context cleared. You can continue with these answers in mind.')
       return

package/event-id.mjs

@@ -27,3 +27,43 @@ export function stampEvent(evt, gen = randomUUID) {
   if (!evt.cid) evt.cid = gen()
   return evt
 }
+
+/* C1 (RT-2): a per-term monotonic, CONTIGUOUS sequence counter. Every event that
+   enters a session's replayed log gets `seq = counter.next()`, so the web room can
+   replay-from-cursor and dedup by "drop ≤ seqHi" instead of re-merging the whole
+   log by cid on every reconnect (see src/pages/code/seqDedup.js).
+
+   THE restart property (what makes Slice 3's between-turns restart dup-free): when a
+   bridge restart restores a persisted log, seed the counter from maxSeq(log) so the
+   NEXT seq is strictly above every restored seq. Reusing an old seq would make the
+   client drop the fresh event as a duplicate. */
+export function makeSeqCounter(startAfter = 0) {
+  let n = Number.isFinite(startAfter) ? startAfter : 0
+  return {
+    next: () => ++n,
+    bumpTo: (m) => { if (Number.isFinite(m) && m > n) n = m },
+    current: () => n,
+  }
+}
+
+// Kinds the bridge logs for the live transcript but that the WEB treats as
+// replay-chrome (src/pages/code/code-constants.js REPLAY_CHROME): filtered out of
+// the replay + handled as transient state, never applied as a transcript line. They
+// must NOT consume a per-term seq — the client advances its cursor (seqHi) ONLY over
+// transcript events, so a seq on one of these would leave a hole in the applied
+// sequence → the client sees a false gap → spurious resync storms. So the counter
+// skips them and they ride the log seq-less (the client cid-handles/ignores them).
+// MUST stay a subset of REPLAY_CHROME ∩ {kinds the bridge logs} — guarded by
+// bridge/test-seq.mjs S6. (mode/usage/clear/compact/stalled are bridge-chrome and
+// never logged at all, so they never reach the counter.)
+export const NO_SEQ_KINDS = new Set(['system', 'thinking_tokens', 'effort'])
+export const seqable = (evt) => !!evt && typeof evt === 'object' && !NO_SEQ_KINDS.has(evt.kind)
+
+// Highest numeric `seq` across a log of events (0 when none) — the floor a restored
+// session's counter resumes above.
+export function maxSeq(events) {
+  if (!Array.isArray(events)) return 0
+  let m = 0
+  for (const e of events) if (e && typeof e.seq === 'number' && e.seq > m) m = e.seq
+  return m
+}

package/package.json

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