thinkpool-pair 0.7.290 → 0.7.291

package/bridge.mjs

@@ -120,6 +120,7 @@ import { supersedeDispatchLease } from './dispatch-lease.mjs'
 import { turnInFlight } from './update-gate.mjs'
 import { saveSession, flushSession, deleteSession, loadAll, canResume, loadPtyId, savePtyId, loadNames, saveNames, appendDurableEvents, seedDurableEvents, readDurablePage, readDurableOldestSeq, hasDurableArchive, servesHistoryPage } from './session-store.mjs'
 import { stampEvent, makeSeqCounter, maxSeq, seqable, capReplayEvents, chunkReplayEvents, boundEventForBroadcast, inlineImageBlocks, ImageEventQueue, imageQueueConfig, uploadCodeImage as uploadCodeImageRequest, usageReportLine, codexUsageReportLine, buildRecapFromLog, RECAP_CAP, trimmedBeforeSeq, firstSeq } from './event-id.mjs'
+import { createLatestReplayPump, requestedReplayIds } from './replay-transport.mjs'
 import { classifyCodeEvent, unknownCodeEventNotice } from './code-event-contract.mjs'
 import { fetchPairControlDeliveryAuthority } from './pair-control-authority.mjs'
 import { SIDE_HANDOFF_PROMPT, SIDE_ROLE_PROMPT, appendSideContext, assistantTextSince, sideContextBlock, sideSnapshot } from './side-lane.mjs'
@@ -574,6 +575,7 @@ if (process.stdin.isTTY && !headless && process.env.THINKPOOL_PAIR_AUTOUPDATE !=
 }
 const name = process.env.TP_NAME || os.userInfo().username || 'host'
 const BRIDGE_ID = (randomUUID?.().slice(0,8)) || 'bridgexx'
+const BRIDGE_STARTED_AT = Date.now()
 // host: this machine's short label — os.hostname() with any DNS/domain suffix
 // stripped and capped ~24 chars. A /code room can be served by different bridges
 // over time (Max's Mac vs Conrad's Linux box); the client uses this to show WHICH
@@ -957,6 +959,13 @@ function beginStructuredTurn(entry, now = Date.now()) {
   return true
 }
 
+function advanceStructuredTurn(entry, now = Date.now()) {
+  entry._turnRev = (Number(entry._turnRev) || 0) + 1
+  entry._turnStart = now
+  entry._busyAnn = true
+  return true
+}
+
 function stampStructuredTurn(entry, event) {
   if (event && event.turnRev == null && Number(entry?._turnRev) > 0) event.turnRev = entry._turnRev
   return event
@@ -1064,17 +1073,21 @@ const defendFrame = (event, payload) => {
   return p
 }
 
-const bcast = (event, payload, ch = channel) => {
+const bcastAwait = async (event, payload, ch = channel) => {
   if (event === 'pty-out' || event === 'code-event') lastActivity = Date.now()
   payload = defendFrame(event, payload)
   try {
     if (ch.channelAdapter?.canPush?.() ?? true) {
-      ch.send({ type: 'broadcast', event, payload })
+      return await ch.send({ type: 'broadcast', event, payload })
     } else {
-      ch.httpSend(event, payload).catch(() => { /* offline — replay covers it */ })
+      return await ch.httpSend(event, payload)
     }
-  } catch { /* noop */ }
+  } catch { return null /* offline — replay covers it */ }
 }
+const bcast = (event, payload, ch = channel) => { void bcastAwait(event, payload, ch) }
+const replayPump = createLatestReplayPump({
+  send: ({ event, payload }) => bcastAwait(event, payload),
+})
 
 // Per-room terminal display names (id -> label), set by the web's `term-rename`.
 // Persisted on the host so a rename is cross-device + survives a bridge restart;
@@ -1093,7 +1106,7 @@ const announce = () => {
   const provNames = providerNameMap()
   const rev = ++announceRev
   return bcast('bridge', {
-    v: 2, name, bridge_id: BRIDGE_ID, rev, repo: repoLabel, branch: readBranch(),
+    v: 2, name, bridge_id: BRIDGE_ID, started_at: BRIDGE_STARTED_AT, rev, repo: repoLabel, branch: readBranch(),
     // sdkWarn: the auto-pulled agent SDK failed its boot compatibility smoke test —
     // surfaced so the room can show a banner (turns may misbehave; pin a good SDK).
     ...(sdkStatus.ok === false ? { sdkWarn: `${sdkStatus.version}: ${sdkStatus.reason}` } : {}),
@@ -2876,6 +2889,20 @@ function openStructured({ id, runtime = 'claude', model, models, effort, resume,
     // per-machine default (provider.mjs/applyProviderEnv). null for built-in/unknown → the
     // default Claude env is left exactly as-is (unchanged path).
     env: { ...process.env, ...buildConductorEnv({ flowSessionId, mode }), ...(resolveProviderEnv(provider) || {}), TP_MOCKUP_OUTBOX: mockupOutbox },
+    onTurnStart: (options = {}) => {
+      // Hermes promotes /queue items internally, without a second code-turn.
+      // Advance the lifecycle before its first output and publish the deferred
+      // human line under the new turn revision, keeping all viewers converged.
+      if (entry._busyAnn === true) advanceStructuredTurn(entry)
+      else beginStructuredTurn(entry)
+      const queuedEcho = options._thinkpoolQueuedEcho
+      if (queuedEcho) {
+        const evt = { kind: 'you', ...queuedEcho }
+        pushLog(entry, evt)
+        bcast('code-event', { term: id, evt })
+      }
+      announce()
+    },
     onEvent: (evt) => {
       if (!classifyCodeEvent(evt).known) {
         // Never archive or replay an unknown provider payload as a known fact. Do
@@ -2933,7 +2960,9 @@ function openStructured({ id, runtime = 'claude', model, models, effort, resume,
       // replay-union dedupes ONLY by cid, and SDK events carry none — without an
       // id, an event that arrives both live AND in a reconnect replay renders
       // twice (the 2026-06-19 duplicate-message bug). See event-id.mjs.
-      const busyChanged = syncStructuredTurn(entry)
+      const continuesQueued = runtime === 'hermes' && (evt.kind === 'result' || evt.kind === 'error') && (entry.session?.queuedDepth || 0) > 0
+      if (continuesQueued) evt.continuesQueued = true
+      const busyChanged = continuesQueued ? false : syncStructuredTurn(entry)
       stampStructuredTurn(entry, evt)
       stampEvent(evt)
       const stalledChanged = evt.kind === 'stalled' ? !entry.stalled : !!entry.stalled
@@ -3651,14 +3680,17 @@ channel
     // Flush pending bytes first so the replay is complete up to "now"; both
     // ride the same ordered socket, so the client sees replay-then-live.
     flushAll()
-    for (const [id, t] of terms) {
+    const to = payload?.to ?? null
+    const requestId = String(payload?.requestId || randomUUID?.() || `${Date.now()}`)
+    const frames = []
+    for (const [id, t] of requestedReplayIds(terms, payload?.terms, payload?.priority)) {
       if (!t.scrollback) continue
       // Cap scrollback too — a huge PTY buffer would blow the same frame limit.
       const sb = t.scrollback.length > 100000 ? t.scrollback.slice(-100000) : t.scrollback
-      bcast('pty-replay', {
-        to: payload?.to ?? null, term: id,
+      frames.push({ event: 'pty-replay', payload: {
+        to, term: id, requestId,
         b64: Buffer.from(sb, 'utf8').toString('base64'),
-      })
+      } })
     }
     // 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
@@ -3669,14 +3701,13 @@ channel
     // cursor) still gets the full log.
     // 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)
+    const replaySessions = requestedReplayIds(sessions, payload?.terms, payload?.priority)
     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 })
+        frames.push({ event: 'code-replay', payload: { to, term: id, requestId, chunkIndex: 0, chunkCount: 1, events: [], empty: true } })
         continue
       }
       const from = Number(payload?.cursors?.[id]) || 0
@@ -3716,10 +3747,14 @@ channel
       // trimmedBefore rides the FIRST (oldest) chunk only — the later chunks are contiguous
       // with it, so a stamp there would read as a second, phantom gap. Same rule as
       // lastUsage above and hasMore on history-page below.
-      let firstChunk = true
-      for (const events of chunks) {
-        bcast('code-replay', { to: payload?.to ?? null, term: id, events, ...(ahead ? { reset: true } : {}), ...(firstChunk && trimmedBefore != null ? { trimmedBefore } : {}), ...(firstChunk && s.lastUsage?.ctx ? { lastUsage: s.lastUsage } : {}) })
-        firstChunk = false
+      for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex++) {
+        const events = chunks[chunkIndex]
+        frames.push({ event: 'code-replay', payload: {
+          to, term: id, requestId, chunkIndex, chunkCount: chunks.length, events,
+          ...(ahead ? { reset: true } : {}),
+          ...(chunkIndex === 0 && trimmedBefore != null ? { trimmedBefore } : {}),
+          ...(chunkIndex === 0 && s.lastUsage?.ctx ? { lastUsage: s.lastUsage } : {}),
+        } })
       }
     }
     // Re-send any still-pending permission/question cards. They ride a one-shot
@@ -3728,10 +3763,15 @@ channel
     // (unanswered) tool row — the AskUserQuestion "vanished on reconnect" bug. Only
     // truly-unresolved cards remain in `pending` (resolved ones are deleted), and
     // the client dedupes code-perm-req by id, so this can't resurrect an answered one.
-    for (const [, s] of sessions) {
-      for (const [, p] of s.pending) bcast('code-perm-req', p.payload)
-    }
-    announce()
+    // One awaited frame per event-loop turn. A newer request from this viewer
+    // replaces every unsent frame from the older one, so visibility/online races
+    // cannot multiply a cold replay into several concurrent megabyte bursts.
+    replayPump.enqueue(to || '*', frames, async () => {
+      for (const [, s] of sessions) {
+        for (const [, p] of s.pending) await bcastAwait('code-perm-req', p.payload)
+      }
+      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
@@ -3750,11 +3790,12 @@ channel
     if (!servesHistoryPage({ payloadHost: payload?.host, bridgeName: name, hasSession: sessions.has(id), hasArchive: hasDurableArchive(room, 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 requestId = String(payload?.requestId || randomUUID?.() || `${Date.now()}`)
+    if (!events.length) { bcast('history-page', { to, term: id, requestId, chunkIndex: 0, chunkCount: 1, 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 }))
+    chunks.forEach((evs, i) => bcast('history-page', { to, term: id, requestId, chunkIndex: i, chunkCount: chunks.length, events: evs, hasMore: i === 0 ? hasMore : true }))
   })
   .on('broadcast', { event: 'file-put' }, ({ payload }) => {
     if (!payload?.id || !payload?.url) return
@@ -4030,13 +4071,24 @@ channel
     const nativeImages = s.runtime === 'codex' || s.runtime === 'hermes'
       ? await waitForNativeImages(payload.files, { updir: UPDIR })
       : []
+    const deferHermesQueueEcho = s.runtime === 'hermes' && s.session.turnActive && /^\s*\/queue\s+/i.test(text)
+    const turnOptions = {
+      ...(nativeImages.length ? { images: nativeImages } : {}),
+      ...(deferHermesQueueEcho && !payload.silent ? { _thinkpoolQueuedEcho: {
+        text: payload.body != null ? String(payload.body) : text,
+        cid: payload.cid,
+        by: payload.by,
+        ...(Array.isArray(payload.files) && payload.files.length ? { files: payload.files } : {}),
+        ...(Array.isArray(payload.pastes) && payload.pastes.length ? { pastes: payload.pastes } : {}),
+      } } : {}),
+    }
     // Sample the runtime before dispatch so a missed prior falling edge cannot
     // make this genuinely new turn inherit the previous turn's revision.
     syncStructuredTurn(s)
-    const accepted = s.session.sendTurn(sendText, nativeImages.length ? { images: nativeImages } : undefined)
+    const accepted = s.session.sendTurn(sendText, Object.keys(turnOptions).length ? turnOptions : undefined)
     if (accepted === false) syncStructuredTurn(s)
     else beginStructuredTurn(s)
-    echoYou()
+    if (!deferHermesQueueEcho || accepted === false) echoYou()
     if (accepted === false) {
       // A runtime that did not accept a turn must still close the optimistic
       // user-line lifecycle. Without this boundary the client truthfully shows
@@ -4312,7 +4364,7 @@ channel
   .subscribe(async status => {
     if (status === 'SUBSCRIBED') {
       realtimeHealthy = true; brokenSince = 0
-      trackPresence({ name, role: 'bridge', bridge_id: BRIDGE_ID })
+      trackPresence({ name, role: 'bridge', bridge_id: BRIDGE_ID, started_at: BRIDGE_STARTED_AT })
       const startCmd = attachedCmd || autoAgent   // autoAgent: account-mode auto-open (headless)
       if (startCmd && !terms.size && !sessions.size) {
         // Claude + structured mode → Agent SDK session; everything else → PTY.

package/hermes-session.mjs

@@ -68,7 +68,7 @@ export function startHermesSession({
   command = HERMES_COMMAND, args = ['acp'], clientFactory = createAcpClient,
   mcpHttpFactory = startCodexMcpHttp, lazy = false, hermesRole = null,
   crossPostGate = null, didSpawnTarget = null, crossRoomPostGate = null, effort = 'high',
-  admitStart = null,
+  admitStart = null, onTurnStart = null,
 } = {}) {
   let activeCwd = cwd
   const requestedModel = model || null
@@ -503,6 +503,7 @@ export function startHermesSession({
         const next = queuedTurns.shift()
         const turnId = ++activeTurnId
         turnActive = true
+        try { onTurnStart?.(next.options || {}) } catch { /* observer cannot break the FIFO */ }
         try { await runPrompt(next.text, next.options, { steering: false, turnId, promptIndex: next.promptIndex, forceFull: next.forceFull }) }
         catch (error) { turnActive = false; emit({ kind: 'error', message: `Hermes queued turn failed: ${error?.message || error}`, recoverable: true }) }
       }
@@ -514,6 +515,7 @@ export function startHermesSession({
   return {
     get sessionId() { return sessionId },
     get turnActive() { return turnActive },
+    get queuedDepth() { return queuedTurns.length },
     get canSteer() { return !!client?.alive },
     get started() { return started },
     get models() { return [] },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.290",
+  "version": "0.7.291",
   "description": "Share a local coding-agent CLI (Claude Code, Codex, Gemini, Aider, …) into a ThinkPool Code room, live.",
   "type": "module",
   "bin": {
@@ -49,6 +49,7 @@
     "pair-control-authority.mjs",
     "event-id.mjs",
     "event-bounds.mjs",
+    "replay-transport.mjs",
     "plan-meters.mjs",
     "recap.mjs",
     "transcript-sanitize.mjs",

package/replay-transport.mjs

@@ -0,0 +1,64 @@
+// Replay transport policy. Reconnects are allowed to supersede older work for
+// the same viewer, and frames are deliberately paced so live events and Stop /
+// permission traffic are not trapped behind a multi-megabyte replay burst.
+
+export function requestedReplayIds(entries, terms, priority) {
+  const requested = Array.isArray(terms) ? new Set(terms.filter(Boolean)) : null
+  return [...entries]
+    .filter(([id]) => !requested || requested.has(id))
+    .sort(([a], [b]) => a === priority ? -1 : b === priority ? 1 : 0)
+}
+
+const defaultYield = () => new Promise((resolve) => setTimeout(resolve, 0))
+
+export function createLatestReplayPump({ send, yieldTurn = defaultYield } = {}) {
+  if (typeof send !== 'function') throw new TypeError('replay pump requires send(frame)')
+  const viewers = new Map()
+
+  const run = async (viewer, state) => {
+    if (state.running) return
+    state.running = true
+    try {
+      while (state.frames.length) {
+        const generation = state.generation
+        const frame = state.frames.shift()
+        await send(frame)
+        await yieldTurn()
+        // enqueue() replaces the remaining frames. The send already in flight is
+        // allowed to finish; nothing older can start after the replacement.
+        if (generation !== state.generation) continue
+      }
+      const done = state.onDone
+      state.onDone = null
+      if (done) await done()
+    } finally {
+      state.running = false
+      if (state.frames.length) void run(viewer, state)
+      else if (viewers.get(viewer) === state) viewers.delete(viewer)
+    }
+  }
+
+  return {
+    enqueue(viewer, frames, onDone = null) {
+      const key = String(viewer || '*')
+      const state = viewers.get(key) || { generation: 0, frames: [], onDone: null, running: false }
+      state.generation += 1
+      state.frames = Array.isArray(frames) ? [...frames] : []
+      state.onDone = typeof onDone === 'function' ? onDone : null
+      viewers.set(key, state)
+      void run(key, state)
+      return state.generation
+    },
+    cancel(viewer) {
+      const state = viewers.get(String(viewer || '*'))
+      if (!state) return false
+      state.generation += 1
+      state.frames = []
+      state.onDone = null
+      return true
+    },
+    pending(viewer) {
+      return viewers.get(String(viewer || '*'))?.frames.length || 0
+    },
+  }
+}