thinkpool-pair 0.7.117 → 0.7.119

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).

package/package.json

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

package/service.mjs

@@ -188,6 +188,41 @@ WantedBy=default.target
   throw new Error(`unsupported platform: ${platform}`)
 }
 
+// Blocking sleep (installService runs synchronously from the interactive menu; the
+// user is watching, so we WANT to wait + report the real outcome, not fire-and-forget).
+const sleepMs = (ms) => { try { execSync(`sleep ${(ms / 1000).toFixed(2)}`) } catch { /* noop */ } }
+// Which thinkpool-pair versions are running right now (the account supervisor shows as
+// `npm exec thinkpool-pair@<ver>`). Returns a Set of version strings.
+const runningPairVersions = () => {
+  try {
+    const out = execSync(`ps ax -o command= 2>/dev/null | grep -oE 'thinkpool-pair@[0-9]+\\.[0-9]+\\.[0-9]+' | sort -u`, { encoding: 'utf8', shell: '/bin/bash' })
+    return new Set(out.split('\n').map((l) => l.trim().split('@')[1]).filter(Boolean))
+  } catch { return new Set() }
+}
+const darwinSvcLoaded = (lbl) => { try { execSync(`launchctl print gui/$(id -u)/${lbl}`, { stdio: 'ignore' }); return true } catch { return false } }
+// After the reload, CONFIRM the new pinned version is actually running — the shell
+// post can report "loaded" while an ORPHANED old child bridge (that bootout didn't
+// reap) keeps serving the OLD version, which is the "Restart & update never works"
+// bug (Max 2026-07-02). If the new version isn't up, SIGKILL lingering ROOM child
+// bridges (never the no-arg menu process) + re-bootstrap, then report the truth.
+function verifyDarwinReload(lbl, file, version) {
+  const want = String(version)
+  const up = () => darwinSvcLoaded(lbl) && runningPairVersions().has(want)
+  for (let i = 0; i < 25 && !up(); i++) sleepMs(600)            // fresh (cache-wiped) fetch takes a bit
+  if (up()) { process.stderr.write(`  ◆ verified: bridge is now running v${want}.\n`); return true }
+  process.stderr.write(`  ⚠ v${want} not up yet — clearing stale bridges and re-bootstrapping…\n`)
+  try { execSync(`launchctl bootout gui/$(id -u)/${lbl} 2>/dev/null || true`, { stdio: 'ignore' }) } catch { /* noop */ }
+  // Kill orphaned ROOM child bridges (`bridge.mjs <ROOM>`), which bootout may not have
+  // reaped. The uppercase room-code guard never matches the no-arg / `setup` menu.
+  try { execSync(`pkill -9 -f 'thinkpool-pair/bridge.mjs [A-Z0-9]' 2>/dev/null || true`, { stdio: 'ignore', shell: '/bin/bash' }) } catch { /* noop */ }
+  sleepMs(500)
+  try { execSync(`launchctl enable gui/$(id -u)/${lbl} 2>/dev/null || true`, { stdio: 'ignore' }) } catch { /* noop */ }
+  for (let i = 0; i < 25 && !up(); i++) { try { execSync(`launchctl bootstrap gui/$(id -u) "${file}" 2>/dev/null || true`, { stdio: 'ignore' }) } catch { /* noop */ } sleepMs(600) }
+  if (up()) { process.stderr.write(`  ◆ recovered: bridge is now running v${want}.\n`); return true }
+  process.stderr.write(`  ⚠ could NOT confirm v${want} is running. Recover by hand:\n      launchctl bootout gui/$(id -u)/${lbl} ; pkill -9 -f thinkpool-pair ; launchctl bootstrap gui/$(id -u) "${file}"\n`)
+  return false
+}
+
 // staleProof defaults ON for every real install: even a FIRST install can be launched from
 // a stale npx cache (the launcher itself is npx-resolved), so without the cache-wiping
 // wrapper a fresh `install-service` could pin a stale build just like the update path did.
@@ -203,6 +238,10 @@ export function installService(room, cmdArgs = [], { autoUpdate = false, version
   for (const cmd of a.post) {
     try { execSync(cmd, { stdio: 'inherit' }) } catch (e) { process.stderr.write(`  ⚠ "${cmd}" failed: ${e.message}\n`) }
   }
+  // Darwin: confirm the reload actually put the NEW version live, self-heal if not.
+  // Only for a PINNED (re)install where we know the exact version to look for — an
+  // autoUpdate (@latest) install has no fixed version number to verify against.
+  if (process.platform === 'darwin' && !autoUpdate) verifyDarwinReload(label(room), a.file, version)
   // Be honest about the cadence — it is NOT instant. The supervisor polls npm
   // roughly every 30 min (THINKPOOL_PAIR_UPDATE_INTERVAL) and only restarts once
   // every served session is idle, so a just-published version can take a while.