thinkpool-pair 0.7.131 → 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
@@ -1625,6 +1651,7 @@ 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
@@ -1728,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
@@ -2355,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

package/claude-session.mjs

@@ -861,6 +861,10 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
     // 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.131",
+  "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": {