thinkpool-pair 0.7.131 → 0.7.133

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
@@ -1344,7 +1370,11 @@ function openStructured({ id, model, resume, log, commands, mode, spawnedBy, rol
   // subagent-block; without cwd it runs outside its worktree; without rolePrompt it loses its
   // Flow role. blockSubagents / onLaneDone / onReviewVerdict / onSubmitPlan all derive from
   // these, so restoring them restores the whole behavior.
-  const sessionData = () => ({ sessionId: entry.session?.sessionId || resume || null, log: entry.log, commands: entry.commands, mode: entry.mode, spawnedBy: entry.spawnedBy, flowSessionId: entry.flowSessionId, flowTaskKey: entry.flowTaskKey, cwd: entry.cwd, rolePrompt: entry.rolePrompt, flowReviewTarget: entry.flowReviewTarget || null, revertTarget: entry.revertTarget || null, reviewSliceRoots: entry.reviewSliceRoots || [], openedAt: entry.openedAt || null })
+  // model: persist the terminal's active model so a /model switch SURVIVES a bridge
+  // restart. Without this, sessionData omitted it → on restart the resumed session
+  // re-launched on the host default (Opus) regardless of the last switch, and the
+  // switch looked like it "never changed the model" (Max 2026-07-02). Restored below.
+  const sessionData = () => ({ sessionId: entry.session?.sessionId || resume || null, log: entry.log, commands: entry.commands, mode: entry.mode, model: entry.model || null, spawnedBy: entry.spawnedBy, flowSessionId: entry.flowSessionId, flowTaskKey: entry.flowTaskKey, cwd: entry.cwd, rolePrompt: entry.rolePrompt, flowReviewTarget: entry.flowReviewTarget || null, revertTarget: entry.revertTarget || null, reviewSliceRoots: entry.reviewSliceRoots || [], openedAt: entry.openedAt || null })
   const persist = () => saveSession(room, id, sessionData())
   // Synchronous flush of this session's record. Used on open (so a brand-new session
   // has a file under its id BEFORE its first event — surviving a restart inside the
@@ -1625,6 +1655,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 +1759,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
@@ -2318,7 +2352,7 @@ Output:`
             // 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, model: rec.model || undefined, 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).
@@ -2355,6 +2389,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.133",
   "description": "Share a local coding-agent CLI (Claude Code, Codex, Gemini, Aider, …) into a ThinkPool Code room, live.",
   "type": "module",
   "bin": {