thinkpool-pair 0.7.200 → 0.7.202

package/bridge.mjs

@@ -98,6 +98,7 @@ const flowRedispatch = new Map()
 // broadcasts; without persistent state the cap can never bite.
 const flowBudgets = new Map()
 import { formatPeek, PEEK, siblingsOf, resolveSibling, crossPostDecision, CROSSPOST, spawnDecision, SPAWN, CROSSROOM, formatPairRoster, crossRoomPostDecision, formatRoomNow, formatClosableHint } from './cross-terminal.mjs'
+import { armInterruptedResume, sendInterruptedContinue, supersedeInterruptedResume } from './interrupted-resume.mjs'
 import { turnInFlight } from './update-gate.mjs'
 import { saveSession, flushSession, deleteSession, loadAll, canResume, loadPtyId, savePtyId, loadNames, saveNames, appendDurableEvents, seedDurableEvents, readDurablePage, readDurableOldestSeq, hasDurableArchive, servesHistoryPage } from './session-store.mjs'
 import { stampEvent, makeSeqCounter, maxSeq, seqable, capReplayEvents, chunkReplayEvents, boundEventForBroadcast, inlineImageBlocks, usageReportLine, buildRecapFromLog, RECAP_CAP, trimmedBeforeSeq, firstSeq } from './event-id.mjs'
@@ -844,15 +845,16 @@ 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).
+// Background warming is OPT-IN. Even a per-room cap multiplies under the account
+// supervisor: four rooms at concurrency 3 launched twelve Claude SDK cold boots at once,
+// stretching measured readiness from ~15s to 40–66s and leaving every idle process
+// resident. Restored transcripts already paint immediately and sendTurn boots a cold lane
+// on demand, so the safe default is zero speculative runtimes. TP_BACKGROUND_WARM=1 keeps
+// the old behaviour available for a deliberately single-room host.
 const warmQueue = []
 let warmingCount = 0
 const WARM_CONCURRENCY = 3
+const BACKGROUND_WARM_ENABLED = process.env.TP_BACKGROUND_WARM === '1'
 function pumpWarm() {
   while (warmingCount < WARM_CONCURRENCY && warmQueue.length) {
     const e = warmQueue.shift()
@@ -2270,9 +2272,7 @@ function openStructured({ id, runtime = 'claude', model, effort, resume, log, co
       // resume gets its single "continue" HERE — not on a blind timer that raced the ~40s
       // resume and dropped the turn into a dead input stream. Fires exactly once.
       if (evt.kind === 'system' && entry.pendingAutoResume) {
-        entry.pendingAutoResume = false
-        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`)
+        if (sendInterruptedContinue(entry)) process.stderr.write(`\n  ◆ auto-resumed interrupted turn (${id.slice(0, 8)}) — sent continue.\n`)
       }
       // Context-carry (2026-07-08): a lane re-opened WITHOUT an SDK resume (provider switch,
       // non-resumable restart) starts blank. Fire the text-layer recap as its first turn the
@@ -2693,7 +2693,10 @@ channel
       // through to the SDK default when absent. Stamped on the entry so the announce
       // carries it at open (chip shows the model immediately, not the branch).
       const runtime = structuredRuntime(payload.cmd)
-      openStructured({ id: payload.id, runtime, mode: payload.mode, model: payload.model || undefined, provider: runtime === 'codex' ? undefined : payload.provider || undefined })
+      // Opening a tab is not work. Paint and announce it immediately, then cold-boot the
+      // expensive Claude/Codex runtime on its first real turn. This keeps a fresh terminal
+      // instant and prevents abandoned tabs from becoming permanent resident processes.
+      openStructured({ id: payload.id, runtime, mode: payload.mode, model: payload.model || undefined, provider: runtime === 'codex' ? undefined : payload.provider || undefined, defer: true })
       process.stderr.write(`\n  ◆ web opened a structured "${payload.cmd}" session (${payload.mode || 'default'}${payload.model ? `, model ${payload.model}` : ''}).\n`)
       return
     }
@@ -2829,7 +2832,7 @@ channel
   // ── structured-session control (Phase 2) ──
   .on('broadcast', { event: 'code-open' }, ({ payload }) => {
     if (payload?.host && payload.host !== name) return
-    openStructured({ id: payload?.id || randomUUID(), runtime: payload?.runtime, model: payload?.model, provider: payload?.runtime === 'codex' ? undefined : payload?.provider, resume: payload?.resume, mode: payload?.mode })
+    openStructured({ id: payload?.id || randomUUID(), runtime: payload?.runtime, model: payload?.model, provider: payload?.runtime === 'codex' ? undefined : payload?.provider, resume: payload?.resume, mode: payload?.mode, defer: true })
   })
   .on('broadcast', { event: 'code-turn' }, async ({ payload }) => {
     const s = payload?.term && sessions.get(payload.term)
@@ -2847,6 +2850,11 @@ channel
     s.hop = 0
     s.roomHop = 0   // a human turn is room-hop 0 — clears any injected cross-room hop depth
     const text = String(payload.text)
+    // A human turn supersedes a restart's still-pending auto-continue. Without this,
+    // their message starts the cold runtime; its init event then queues a second stale
+    // `continue` behind the request. Codex normally resumes immediately at restore, while
+    // Claude holds this flag only until its input stream is live.
+    supersedeInterruptedResume(s)
     // Echo the turn so BOTH readers (and late joiners, via the log) show who
     // said what — UNLESS silent (an @pool fire, which renders its own line).
     const echoYou = () => {
@@ -3199,7 +3207,8 @@ channel
             // instant it's live. openStructured already closed the interrupted turn idle, so a
             // continue that can't be delivered just leaves it idle (recoverable) — never a hang.
             if (re && !rec.flowSessionId && canResume(rec) && restoredTurnOpen(rec.log || [])) {
-              re.pendingAutoResume = true
+              const recovery = armInterruptedResume(re)
+              if (recovery === 'sent') process.stderr.write(`\n  ◆ auto-resumed interrupted Codex turn (${rec.id.slice(0, 8)}) — sent continue.\n`)
             }
             // Context-carry (2026-07-08): the SAME mid-turn case but the SDK context CANNOT
             // resume (canResume false — a stale/expired session). A bare "continue" would land
@@ -3220,10 +3229,9 @@ channel
           // saved-session restore above still runs unconditionally, so a bridge
           // restart resumes backgrounded sessions regardless of this guard.
           else if (attachedCmd) openStructured({ id: randomUUID(), runtime: structuredRuntime(attachedCmd) })
-          // 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(() => {
+          // Optional compatibility lever for deliberately single-room hosts. Account-mode
+          // and normal standalone launches leave restored idle lanes truly lazy by default.
+          if (BACKGROUND_WARM_ENABLED) 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)

package/claude-session.mjs

@@ -239,7 +239,9 @@ export function startClaudeSession({ cwd, model, effort: initialEffort = 'high',
   // long time"; settingSources:['user','project','local'] boots every host MCP
   // server + SessionStart hook + plugin before init. This is the A-side baseline;
   // open a terminal with TP_MCP_STRICT=1 (below) for the B-side to isolate MCP's share.
-  const spawnT0 = Date.now()
+  // A lazy lane may sit unopened for hours. Start the latency clock when query() really
+  // launches, not when the lightweight tab/session wrapper is created.
+  let spawnT0 = null
   let readyLogged = false
   let modelsSent = false   // one-shot: emit the SDK's supported-model list on first init
   let sdkToolsChecked = false   // one-shot: run the AskUserQuestion regression guard on the first init carrying tools[]
@@ -804,6 +806,7 @@ export function startClaudeSession({ cwd, model, effort: initialEffort = 'high',
   }
 
   const runQuery = async () => {
+    if (spawnT0 == null) spawnT0 = Date.now()
     started = true
     // Per-query AbortController (child of the session `ac`): lets a model switch kill
     // just this query. Resolve the previous qDone in case it's still pending.

package/interrupted-resume.mjs

@@ -0,0 +1,29 @@
+// Runtime-specific bridge-restart recovery.
+//
+// Claude owns a long-lived input stream: its continue must wait for the init system
+// event proving that stream is consumed. Codex is one process per turn and has no idle
+// init event: sending the prompt IS what launches the resumed process.
+
+export function sendInterruptedContinue(entry) {
+  if (!entry) return false
+  entry.pendingAutoResume = false
+  try { return entry.session?.sendTurn?.('continue') !== false }
+  catch { return false }
+}
+
+export function armInterruptedResume(entry) {
+  if (!entry?.session) return 'unavailable'
+  if (entry.runtime === 'codex') return sendInterruptedContinue(entry) ? 'sent' : 'unavailable'
+  entry.pendingAutoResume = true
+  return 'armed'
+}
+
+// A real person speaking always wins the race. Otherwise a human turn that starts a
+// cold Claude/Codex runtime can trigger its init event and enqueue a stale second
+// `continue` behind the person's actual request.
+export function supersedeInterruptedResume(entry) {
+  if (!entry?.pendingAutoResume) return false
+  entry.pendingAutoResume = false
+  return true
+}
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.200",
+  "version": "0.7.202",
   "description": "Share a local coding-agent CLI (Claude Code, Codex, Gemini, Aider, …) into a ThinkPool Code room, live.",
   "type": "module",
   "bin": {
@@ -27,6 +27,7 @@
     "transcript-sanitize.mjs",
     "session-store.mjs",
     "cross-terminal.mjs",
+    "interrupted-resume.mjs",
     "flow-conductor.mjs",
     "flow-worktree.mjs",
     "flow-task-graph.mjs",