thinkpool-pair 0.7.12 → 0.7.14

package/bridge.mjs

@@ -36,7 +36,7 @@ import { spawn } from 'node:child_process'
 import { randomUUID } from 'node:crypto'
 import { createClient } from '@supabase/supabase-js'
 import { startClaudeSession } from './claude-session.mjs'
-import { saveSession, flushSession, loadLatest, canResume, loadPtyId, savePtyId } from './session-store.mjs'
+import { saveSession, flushSession, loadAll, canResume, loadPtyId, savePtyId } from './session-store.mjs'
 
 // Public client creds (the same anon values the web app ships — safe to embed).
 // Override with TP_SUPABASE_URL / TP_SUPABASE_ANON if you ever need to.
@@ -776,11 +776,15 @@ channel
       const startCmd = attachedCmd || autoAgent   // autoAgent: account-mode auto-open (headless)
       if (startCmd && !terms.size && !sessions.size) {
         // Claude + structured mode → Agent SDK session; everything else → PTY.
-        // On restart, restore the latest saved structured session for this room:
-        // replay its transcript + resume the live SDK context if recent enough.
+        // On restart, restore EVERY saved structured session for this room (not
+        // just the latest) — replay each transcript + resume its live SDK context
+        // when recent enough. Without this, backgrounded terminals died on a
+        // bridge restart even though their state was on disk. Bounded by KEEP=8;
+        // only runs on a fresh start (guard above), so a network re-subscribe
+        // with live sessions won't re-spawn them.
         if (wantStructured(startCmd)) {
-          const prev = loadLatest(room)
-          if (prev && (prev.log?.length || prev.sessionId)) openStructured({ id: prev.id, resume: canResume(prev) ? prev.sessionId : undefined, log: prev.log, commands: prev.commands, mode: prev.mode })
+          const all = loadAll(room).filter((r) => r.log?.length || r.sessionId)
+          if (all.length) for (const rec of all) openStructured({ id: rec.id, resume: canResume(rec) ? rec.sessionId : undefined, log: rec.log, commands: rec.commands, mode: rec.mode })
           else openStructured({ id: randomUUID() })
         }
         else {

package/claude-session.mjs

@@ -127,6 +127,15 @@ export function startClaudeSession({ cwd, model, resume, mode: initialMode = 'de
   const alwaysAllow = new Set()  // tool:risk signatures the user chose "don't ask again" for
   const toolStart = new Map()     // tool_use id → start time, for the duration badge
   let effort = null               // active reasoning effort for the turn (from the hook input)
+  // Live token count for the thinking indicator — mirrors Claude Code's
+  // "↓ N tokens": the turn's billed OUTPUT tokens (thinking is billed as
+  // output, so this is the full count, not just the reasoning estimate). A
+  // tool-using turn emits several assistant messages; message_delta carries
+  // the running output_tokens for the CURRENT message, so we fold finished
+  // messages into turnBaseOut and add the live message's count on top. Reset
+  // per turn on `result`.
+  let turnBaseOut = 0             // output tokens from completed messages this turn
+  let curMsgOut = 0               // latest output_tokens for the in-flight message
 
   const emit = (evt) => { try { onEvent?.(evt) } catch { /* never let a consumer throw into the loop */ } }
 
@@ -286,7 +295,11 @@ export function startClaudeSession({ cwd, model, resume, mode: initialMode = 'de
             // model reasons, surfaced as the indicator's ↓ N tokens. Coarse,
             // emitted during extended thinking; not a per-token stream.
             if (m.subtype === 'thinking_tokens') {
-              emit({ kind: 'thinking_tokens', tokens: m.estimated_tokens, delta: m.estimated_tokens_delta })
+              // The reasoning-phase estimate (smooth, but approximate). Only
+              // surface it BEFORE real output streams — once message_delta gives
+              // us authoritative output_tokens (which already include thinking),
+              // that supersedes the estimate so the count never jumps backwards.
+              if (turnBaseOut + curMsgOut === 0) emit({ kind: 'thinking_tokens', tokens: m.estimated_tokens, delta: m.estimated_tokens_delta })
               break
             }
             if (m.session_id) sessionId = m.session_id
@@ -312,8 +325,25 @@ export function startClaudeSession({ cwd, model, resume, mode: initialMode = 'de
               }
             }
             break
+          case 'stream_event': {
+            // Live output-token progress for the thinking indicator. message_delta
+            // carries the running output_tokens for the current assistant message;
+            // message_start opens a new one (fold the finished message into the
+            // turn base first). Authoritative + monotonic within a turn.
+            const ev = m.event
+            if (ev?.type === 'message_start') {
+              turnBaseOut += curMsgOut
+              curMsgOut = ev.message?.usage?.output_tokens || 0
+              emit({ kind: 'thinking_tokens', tokens: turnBaseOut + curMsgOut })
+            } else if (ev?.type === 'message_delta' && ev.usage) {
+              curMsgOut = ev.usage.output_tokens ?? curMsgOut
+              emit({ kind: 'thinking_tokens', tokens: turnBaseOut + curMsgOut })
+            }
+            break
+          }
           case 'result':
             if (m.session_id) sessionId = m.session_id
+            turnBaseOut = 0; curMsgOut = 0   // reset the live token count for the next turn
             emit({ kind: 'result', subtype: m.subtype, sessionId, costUsd: m.total_cost_usd, usage: m.usage, numTurns: m.num_turns })
             // Surface a usage/context meter (chrome, not a transcript line). The
             // context window % comes from the control request; cost is cumulative.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.12",
+  "version": "0.7.14",
   "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

@@ -56,6 +56,14 @@ export function canResume(rec) {
   return !!(rec && rec.sessionId && rec.savedAt && (Date.now() - rec.savedAt) < RESUME_MAX_AGE_MS)
 }
 
+// EVERY saved session for the room, oldest→newest (so tabs reappear in order).
+// Drives resume-ALL on a bridge restart — without this only the latest session
+// came back and every backgrounded terminal died on restart despite its state
+// sitting on disk. Bounded by KEEP (prune keeps the newest 8).
+export function loadAll(room) {
+  return listRecs(room).sort((a, b) => (a.savedAt || 0) - (b.savedAt || 0))
+}
+
 // Last PTY terminal id auto-opened for an attached command. A reconnecting
 // bridge reuses it so it re-attaches to the SAME terminal tab instead of
 // minting a fresh UUID and breeding a new dormant "Terminal N" each restart.