thinkpool-pair 0.7.129 → 0.7.131

package/bridge.mjs

@@ -1222,12 +1222,16 @@ 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 }) {
+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
   // stripped it and the lane reverted to a plain tab — the t6 "no chip" bug).
-  const entry = { cmd: 'claude', kind: 'structured', log: Array.isArray(log) ? log.slice(-STRUCTURED_LOG_MAX) : [], pending: new Map(), session: null, recovered: false, commands: Array.isArray(commands) ? commands : undefined, mode, model: model || null, spawnedBy: spawnedBy || undefined, flowSessionId: flowSessionId || null, flowTaskKey: flowTaskKey || null, cwd: cwd || null }
+  const entry = { cmd: 'claude', kind: 'structured', log: Array.isArray(log) ? log.slice(-STRUCTURED_LOG_MAX) : [], pending: new Map(), session: null, recovered: false, commands: Array.isArray(commands) ? commands : undefined, mode, model: model || null, spawnedBy: spawnedBy || undefined, flowSessionId: flowSessionId || null, flowTaskKey: flowTaskKey || null, cwd: cwd || null,
+    // Stable creation order — persisted so a bridge restart restores tabs in the SAME
+    // order (not readdir/filesystem order). Legacy recs (no openedAt) derive it from the
+    // first transcript event ts, so even the first post-fix restart is ordered right.
+    openedAt: openedAt || (Array.isArray(log) ? (log.find((e) => e?.ts)?.ts || 0) : 0) || Date.now() }
   // C1 (RT-2): per-term contiguous seq counter. Seeded from the restored log's max
   // so a bridge restart resumes ABOVE every persisted seq — fresh events never reuse
   // an old seq, which is what keeps the between-turns restart dup-free (see
@@ -1340,7 +1344,7 @@ 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 || [] })
+  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 })
   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
@@ -1623,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
@@ -2302,11 +2309,20 @@ Output:`
           // Closed sessions are unlinked by deleteSession, so a file existing on disk ==
           // a session that was live at shutdown (never an explicitly closed one).
           const all = loadAll(room)
+          // 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._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 })
+            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.
@@ -2785,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.129",
+  "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 [] }
 }