thinkpool-pair 0.7.130 → 0.7.132

package/bridge.mjs

@@ -656,6 +656,32 @@ const sessions = new Map()
 let attachedId = null
 let shuttingDown = false
 
+// Background warmer (2026-07-02): after a restart, proactively cold-boot the lazily-
+// restored IDLE terminals — ready-gated to ≤WARM_CONCURRENCY at once so there's no
+// boot-storm (the contention that made restore take minutes) — so they're warm BEFORE
+// the user clicks them, erasing the lazy-boot first-turn penalty. A user turn to a
+// still-cold terminal boots it on demand as the fallback. warmComplete frees a slot when
+// a terminal's init `system` event proves it live (called from onEvent).
+const warmQueue = []
+let warmingCount = 0
+const WARM_CONCURRENCY = 3
+function pumpWarm() {
+  while (warmingCount < WARM_CONCURRENCY && warmQueue.length) {
+    const e = warmQueue.shift()
+    if (!e || e.warmed || e.warming || !e.session || e.session.started) continue
+    e.warming = true; warmingCount++
+    try { e.session.warm?.() } catch { e.warming = false; warmingCount--; continue }
+    // Free the slot if a warm never signals ready (stuck boot) so the queue still drains.
+    e.warmTimer = setTimeout(() => { if (e.warming) { e.warming = false; warmingCount = Math.max(0, warmingCount - 1); pumpWarm() } }, 100000)
+  }
+}
+const warmComplete = (e) => {
+  if (!e || !e.warming) return
+  e.warming = false; e.warmed = true; warmingCount = Math.max(0, warmingCount - 1)
+  try { clearTimeout(e.warmTimer) } catch { /* noop */ }
+  pumpWarm()
+}
+
 // One send door for every broadcast. supabase-js ≥2.10x deprecation-warns
 // (console.warn) whenever send() silently falls back to REST because the
 // socket can't push — at the flush timer's 28×/s that's a wall of warnings
@@ -1222,7 +1248,7 @@ function restoredTurnOpen(log) {
 // relay STRUCTURED events. onEvent → broadcast `code-event` + print locally +
 // persist to the host file; tool calls round-trip through the perm card; the
 // rolling log replays to joiners and survives bridge restarts (session-store).
-function openStructured({ id, model, resume, log, commands, mode, spawnedBy, rolePrompt, flowSessionId, flowTaskKey, cwd, reviewSliceRoots, openedAt }) {
+function openStructured({ id, model, resume, log, commands, mode, spawnedBy, rolePrompt, flowSessionId, flowTaskKey, cwd, reviewSliceRoots, openedAt, defer }) {
   if (sessions.has(id)) return
   // spawnedBy: set when this lane was Dispatched (spawn_terminal). Restored from the
   // session store so the Ensemble flag survives a bridge restart (else a respin
@@ -1625,8 +1651,12 @@ function openStructured({ id, model, resume, log, commands, mode, spawnedBy, rol
         return { allow: true, reason: 'no reviewed slice targeted' }
       }
     : null
+  entry.deferred = !!defer   // a lazily-booted idle terminal — the background warmer will boot it
   entry.session = startClaudeSession({
     cwd: cwd || process.cwd(), model, resume, mode, rolePrompt,
+    // defer: a restored-idle terminal cold-boots its query only on first use — restore is
+    // then instant for display, and only used terminals pay the ~50s MCP boot (Max, 2026-07-02).
+    lazy: !!defer,
     reviewGate,
     // A Flow CONDUCTOR (flowSessionId set, no flowTaskKey) must DECOMPOSE, not explore via
     // a fan-out of Task/Explore subagents, and must not build. Hard-block Task/Bash/Write for
@@ -1725,6 +1755,9 @@ function openStructured({ id, model, resume, log, commands, mode, spawnedBy, rol
         try { entry.session?.sendTurn('continue') } catch { /* not resumable — stays idle, user can continue manually */ }
         process.stderr.write(`\n  ◆ auto-resumed interrupted turn (${id.slice(0, 8)}) — sent continue.\n`)
       }
+      // A background-warmed terminal is now live — free its warmer slot so the next queued
+      // idle terminal starts booting.
+      if (evt.kind === 'system' && entry.warming) warmComplete(entry)
       // Chrome events (mode / usage / clear / compact) are transient state, not
       // transcript — broadcast + print them but keep out of the persisted/replayed log.
       // 'stalled' is transient turn-liveness state (would replay as a stale frozen
@@ -2309,13 +2342,17 @@ Output:`
           // Restore in stable creation order (openedAt) so the tab strip comes back in the
           // SAME order across a bridge restart — NOT readdir/filesystem order, which reshuffled
           // the tabs (Max, 2026-07-02). Legacy recs fall back to their first event ts / savedAt.
-          const okey = (r) => r.openedAt || (Array.isArray(r.log) ? (r.log.find((e) => e?.ts)?.ts || 0) : 0) || r.savedAt || 0
+          const okey = (r) => r._bt || r.openedAt || r.savedAt || 0
           all.sort((a, b) => okey(a) - okey(b))
           if (all.length) for (const rec of all) {
             // FL-M6 — restore the flow context (id/role/cwd) so an in-flight flow survives a
             // bridge restart: the conductor keeps its subagent-block + plan interception, and
             // lanes keep their worktree cwd + the ability to mark done.
-            openStructured({ id: rec.id, resume: canResume(rec) ? rec.sessionId : undefined, log: rec.log, commands: rec.commands, mode: rec.mode, spawnedBy: rec.spawnedBy, flowSessionId: rec.flowSessionId, flowTaskKey: rec.flowTaskKey, cwd: rec.cwd, rolePrompt: rec.rolePrompt, reviewSliceRoots: rec.reviewSliceRoots, openedAt: rec.openedAt })
+            openStructured({ id: rec.id, resume: canResume(rec) ? rec.sessionId : undefined, log: rec.log, commands: rec.commands, mode: rec.mode, spawnedBy: rec.spawnedBy, flowSessionId: rec.flowSessionId, flowTaskKey: rec.flowTaskKey, cwd: rec.cwd, rolePrompt: rec.rolePrompt, reviewSliceRoots: rec.reviewSliceRoots, openedAt: rec.openedAt,
+              // Lazy-boot restored terminals that were IDLE + not part of a flow: their transcript
+              // shows immediately; the query boots on first turn. Mid-turn + flow terminals boot now
+              // (mid-turn needs auto-resume; flow needs its lane live).
+              defer: !rec.flowSessionId && !restoredTurnOpen(rec.log || []) })
             const re = sessions.get(rec.id)
             if (re && rec.flowReviewTarget) re.flowReviewTarget = rec.flowReviewTarget
             // S4 — a resumed re-dispatch lane keeps its surviving revert target across a bridge restart.
@@ -2348,6 +2385,13 @@ Output:`
           // saved-session restore above still runs unconditionally, so a bridge
           // restart resumes backgrounded sessions regardless of this guard.
           else if (attachedCmd) openStructured({ id: randomUUID() })
+          // Background-warm the lazily-restored idle terminals shortly after restore, so
+          // they're ready before the user clicks them (no first-turn penalty). Delayed so the
+          // eagerly-booted (mid-turn / auto-resumed) sessions get the machine to themselves first.
+          setTimeout(() => {
+            for (const [, e] of sessions) if (e.deferred && !e.warmed && !e.warming && !e.session?.started) warmQueue.push(e)
+            if (warmQueue.length) { process.stderr.write(`\n  ◆ background-warming ${warmQueue.length} idle terminal(s) (≤${WARM_CONCURRENCY} at a time)…\n`); pumpWarm() }
+          }, 6000)
         }
         else {
           // Reuse the prior auto-opened PTY id across restarts so a reconnecting
@@ -2794,6 +2838,13 @@ process.on('SIGTERM', () => shutdown(0))
 // Route both through shutdown() so children are reaped + presence left, then the
 // supervisor / launchd / systemd respawns a clean process.
 process.on('uncaughtException', (err) => {
+  // Benign write-to-closed-pipe/socket (a broadcast or a child stream that closed
+  // mid-restore) must NOT kill the bridge — that respawn triggered a SECOND full
+  // restore, doubling an already-slow restore (Max, 2026-07-02). Log + keep running.
+  if (err && (err.code === 'EPIPE' || err.code === 'ECONNRESET' || err.code === 'ERR_STREAM_WRITE_AFTER_END' || err.code === 'ERR_STREAM_DESTROYED')) {
+    try { process.stderr.write(`\n  ⚠ ignored benign ${err.code} (not fatal): ${err?.message || ''}\n`) } catch { /* noop */ }
+    return
+  }
   try { process.stderr.write(`\n  ⚠ uncaughtException: ${err?.stack || err}\n  ◆ shutting down cleanly for a fresh respawn.\n`) } catch { /* noop */ }
   shutdown(1)
 })

package/claude-session.mjs

@@ -181,11 +181,17 @@ export async function oneShotSummary({ prompt, env, cwd, timeoutMs = 25000 }) {
   return null
 }
 
-export function startClaudeSession({ cwd, model, resume, env, mode: initialMode = 'default', onEvent, requestPermission, mcpServers, crossPostGate, crossRoomPostGate, rolePrompt, blockSubagents = false, onSubmitPlan = null, onLaneDone = null, onReviewVerdict = null, reviewGate = null }) {
+export function startClaudeSession({ cwd, model, resume, env, mode: initialMode = 'default', onEvent, requestPermission, mcpServers, crossPostGate, crossRoomPostGate, rolePrompt, blockSubagents = false, onSubmitPlan = null, onLaneDone = null, onReviewVerdict = null, reviewGate = null, lazy = false }) {
   const ac = new AbortController()
   let input = makeInputStream()   // `let`: auto-restart swaps in a fresh stream
   let sessionId = resume || null
   let closed = false
+  // Lazy boot (2026-07-02): a RESTORED-IDLE terminal returns a full session object but
+  // defers the expensive query() cold-start (MCP + settingSources, ~50s each) until its
+  // FIRST turn — so a bridge restart restores every tab's transcript instantly and only
+  // the terminals a person actually uses pay the boot. Mid-turn terminals boot eagerly
+  // (lazy:false) so auto-resume still works.
+  let started = false
   // Cold-start measurement (2026-06-21, spec 2026-06-21-code-session-deploy-stability):
   // stamp when the open begins so we can log spawn→ready (the SDK's first `init`
   // system message — when the terminal becomes usable). New room terminals "take a
@@ -676,6 +682,7 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
   }
 
   const runQuery = async () => {
+    started = true
     try {
       q = query({ prompt: input.stream, options: { ...opts, ...(sessionId ? { resume: sessionId } : {}) } })
       for await (const m of q) {
@@ -848,10 +855,16 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
       turnActive = false
     }
   }
-  runQuery()
+  if (!lazy) runQuery()
 
   return {
-    sendTurn(text) { if (!closed) { turnActive = true; sawSuggestion = false; if (sugTimer) { clearTimeout(sugTimer); sugTimer = null } lastEvtTs = Date.now(); stalledSent = false; input.push([{ type: 'text', text: String(text) }, { type: 'text', text: `<system-reminder>\n${TP_ROOM_REMINDER}\n</system-reminder>` }]) } },
+    // A lazy (restored-idle) session cold-boots the query on its first turn. input.push
+    // is queue-backed, so the pushed turn buffers and runs once the query is ready.
+    sendTurn(text) { if (!closed) { if (!started) runQuery(); turnActive = true; sawSuggestion = false; if (sugTimer) { clearTimeout(sugTimer); sugTimer = null } lastEvtTs = Date.now(); stalledSent = false; input.push([{ type: 'text', text: String(text) }, { type: 'text', text: `<system-reminder>\n${TP_ROOM_REMINDER}\n</system-reminder>` }]) } },
+    // Cold-boot the query WITHOUT sending a turn — the background warmer calls this on
+    // lazily-restored idle terminals so they're ready before the user clicks them.
+    warm() { if (!started && !closed) runQuery() },
+    get started() { return started },
     // Set the permission mode — Claude Code's ⇧⇥ cycle. setPermissionMode is a
     // streaming control request (drives plan-mode behaviour SDK-side); the local
     // `mode` drives our PreToolUse auto-approve policy. Echo so the room syncs.

package/package.json

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

@@ -42,7 +42,18 @@ function archive(room, file) {
 function listRecs(room) {
   try {
     return fs.readdirSync(dir(room)).filter((f) => f.endsWith('.json'))
-      .map((f) => { try { return JSON.parse(fs.readFileSync(path.join(dir(room), f), 'utf8')) } catch { return null } })
+      .map((f) => {
+        const p = path.join(dir(room), f)
+        try {
+          const r = JSON.parse(fs.readFileSync(p, 'utf8'))
+          // _bt: the rec FILE's creation time — a reliable, monotonic proxy for when the
+          // terminal was first opened (overwrites on save don't change it). Used to restore
+          // tabs in stable creation order; the persisted openedAt is unreliable because a
+          // truncated log's first event ts drifts far from real creation. Load-time only.
+          try { const s = fs.statSync(p); r._bt = s.birthtimeMs || s.mtimeMs || 0 } catch { r._bt = 0 }
+          return r
+        } catch { return null }
+      })
       .filter(Boolean)
   } catch { return [] }
 }