thinkpool-pair 0.7.116 → 0.7.118

package/bridge.mjs

@@ -680,10 +680,18 @@ const bcast = (event, payload, ch = channel) => {
 // Persisted on the host so a rename is cross-device + survives a bridge restart;
 // every announce carries them so a late-joining or second device sees them too.
 const termNames = loadNames(room)
+// The SDK's supported-model LIST (value/displayName/description), captured from
+// any session's `models` event. Announced room-level so EVERY device gets it on
+// connect — not just the one that saw the one-shot event (the picker fell back to
+// a hardcoded shorthand set on other devices / after reload). Max 2026-07-02.
+let roomModels = null
 
 const announce = () =>
   bcast('bridge', {
     v: 2, name, repo: repoLabel, branch: readBranch(),
+    // models: the SDK's supported-model list, so the /model picker shows the real
+    // set (incl. Fable + version labels) on every device without hardcoding.
+    models: roomModels || undefined,
     // cwd + version: the host's working dir + thinkpool-pair version, shown in
     // the room's welcome banner. Re-sent per announce so late joiners get them.
     cwd, version: VERSION,
@@ -724,7 +732,7 @@ const announce = () =>
       // turnActive). Authoritative — the bridge owns the turn — so the /code
       // dashboard reads "N agents working" off the roster instead of sniffing
       // the live code-event stream (which a passive dashboard channel misses).
-      ...[...sessions.entries()].map(([id, s]) => ({ id, cmd: s.cmd, kind: 'structured', alive: true, busy: s.session?.turnActive ?? false, commands: s.commands, mode: s.mode || undefined, name: termNames[id] || undefined, ...(s.archiveOldestSeq != null ? { oldestSeq: s.archiveOldestSeq } : {}), ...(s.spawnedBy ? { spawned: true, spawnedBy: s.spawnedBy } : {}), ...(s.flowSessionId ? { flowId: s.flowSessionId, flowRole: s.flowTaskKey ? 'lane' : 'conductor' } : {}) })),
+      ...[...sessions.entries()].map(([id, s]) => ({ id, cmd: s.cmd, kind: 'structured', alive: true, busy: s.session?.turnActive ?? false, commands: s.commands, mode: s.mode || undefined, name: termNames[id] || undefined, model: s.model || undefined, ...(s.archiveOldestSeq != null ? { oldestSeq: s.archiveOldestSeq } : {}), ...(s.spawnedBy ? { spawned: true, spawnedBy: s.spawnedBy } : {}), ...(s.flowSessionId ? { flowId: s.flowSessionId, flowRole: s.flowTaskKey ? 'lane' : 'conductor' } : {}) })),
     ],
   })
 
@@ -1620,6 +1628,14 @@ function openStructured({ id, model, resume, log, commands, mode, spawnedBy, rol
       // (normal, spawn, flow lane, cross-room) since they all flow through onEvent.
       { const busyNow = entry.session?.turnActive ?? false
         if (busyNow !== entry._busyAnn) { entry._busyAnn = busyNow; announce() } }
+      // Capture this session's current MODEL (resolved full id, with version — from
+      // system/result `model` or usage `ctx.model`) and the SDK's supported-model
+      // LIST (from the `models` event) so the announce carries them to EVERY device.
+      // Re-announce on change so a switch / late device sees it without a turn (the
+      // old localStorage cache was per-device; branch showed on every other device).
+      { const m = evt.model || evt.ctx?.model
+        if (m && m !== entry.model) { entry.model = m; announce() }
+        if (evt.kind === 'models' && Array.isArray(evt.models) && evt.models.length) { roomModels = evt.models; announce() } }
       // FL-B2 — fold this flow lane's completed-turn output tokens into its budget so the
       // autopilot cap can halt the next wave before overrun (output_tokens = the billed
       // reasoning+output spend the indicator already tracks; conservative enough for a guard).
@@ -2409,7 +2425,19 @@ flowChannel
     cleanupFlowLanes(payload.flowId, 600)
     process.stderr.write(`\n  ${A.yel}◆ flow cancelled — closing its lanes (${String(payload.flowId).replace(/-/g, '').slice(0, 8)}).${A.rst}\n`)
   })
-  .subscribe()
+  .subscribe(status => {
+    // BRG-2 (audit 2026-07-02): tpflow had a bare subscribe with no status handler, so a
+    // channel-specific CHANNEL_ERROR (socket still healthy → the main tpcode watchdog
+    // never trips) dropped flow dispatch/plan/done silently until the next bridge
+    // restart. Surface it. supabase-js auto-rejoins every channel on a socket reconnect,
+    // so a transient drop self-heals; an active per-channel re-subscribe is deliberately
+    // NOT added here — re-subscribing a live supabase channel is a known lifecycle
+    // footgun (the 2026-06-30 channel-collision family) and can't be two-device verified
+    // from a single host.
+    if (status === 'CHANNEL_ERROR' || status === 'TIMED_OUT' || status === 'CLOSED') {
+      process.stderr.write(`\n  ⚠ flow realtime ${status} (tpflow:${room}).\n`)
+    }
+  })
 
 // Watchdog — if the realtime channel is stuck (never connected, or dropped and
 // not recovered) for >60s, exit non-zero so a supervisor/launchd restarts a
@@ -2565,6 +2593,10 @@ async function shutdown(code = 0, farewell = true) {
   // socket is alive; on a wedge it won't flush and the hard backstop above wins).
   try { await channel.untrack() } catch { /* noop */ }
   try { await supabase.removeChannel(channel) } catch { /* noop */ }
+  // BRG-2 (audit 2026-07-02): shutdown removed only the room channel, leaking the flow
+  // topic (no presence to untrack, but the subscription + socket join outlived the
+  // process teardown). Close it too so shutdown is symmetric.
+  try { await supabase.removeChannel(flowChannel) } catch { /* noop */ }
   setTimeout(() => process.exit(code), 250)   // grace for the leave/close frames to flush
 }
 process.on('SIGINT', () => shutdown(0))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.116",
+  "version": "0.7.118",
   "description": "Share a local coding-agent CLI (Claude Code, Codex, Gemini, Aider, …) into a ThinkPool Code room, live.",
   "type": "module",
   "bin": {