thinkpool-pair 0.7.130 → 0.7.131

package/bridge.mjs

@@ -1222,7 +1222,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
@@ -1627,6 +1627,9 @@ function openStructured({ id, model, resume, log, commands, mode, spawnedBy, rol
     : null
   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
@@ -2309,13 +2312,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.
@@ -2794,6 +2801,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,12 @@ 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>` }]) } },
     // 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.131",
   "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 [] }
 }