thinkpool-pair 0.7.303 → 0.7.305

package/account.mjs

@@ -15,7 +15,7 @@ import { createClient } from '@supabase/supabase-js'
 import os from 'node:os'
 import { saveAuth, loadAuth, loadDirs, bindDir, loadServed, rememberServed, loadDefaultDir, saveDefaultDir, claudeRecentProjectDir } from './auth-store.mjs'
 import { isSafeToRestart } from './update-gate.mjs'
-import { makeThrottledTrack, presenceSelfEchoVerdict } from './presence.mjs'
+import { makeThrottledTrack, presenceSelfEchoObservation } from './presence.mjs'
 import { publicKeyB64, announceProviders, listProviders, addProvider, addProviderModel, removeProvider, unseal } from './providers.mjs'
 import { supervisorServes, supervisorRoomsToStop } from './serve-consent.mjs'
 import { resolveServeDir } from './serve-dir.mjs'
@@ -603,16 +603,18 @@ export async function runAccount(SUPABASE_URL, SUPABASE_ANON) {
   // respawn the supervisor every ~2.5 min ("the bridge disconnects and reconnects
   // randomly", 2026-07-09 — nine respawns in an hour, track=ok on every one).
   // Binding sync does two jobs: turns presence delivery ON (the echo becomes real)
-  // and stamps presenceSyncSeenAt — the watchdog's fail-safe (no proven delivery →
-  // no escalation, ever). Proof: /tmp echo-proof (no listener → {}, listener → key).
+  // and stamps presenceSyncSeenAt. acctSubscribedAt bounds the startup case where
+  // SUBSCRIBED fires but the first sync never arrives: that is a broken Realtime
+  // channel, not an unknowable state, once the listener was attached before join.
   let presenceSyncSeenAt = 0
+  let acctSubscribedAt = 0
   acct.on('presence', { event: 'sync' }, () => { presenceSyncSeenAt = Date.now() })
 
   // Re-track on EVERY (re)subscribe, not just the first: a realtime reconnect
   // (network blip, or a token swap mid-flight) rejoins the channel and must
   // re-announce, or the dashboard would read "no bridge" until the next restart.
   await new Promise((res) => acct.subscribe((st) => {
-    if (st === 'SUBSCRIBED') { pushPresence(); res() }
+    if (st === 'SUBSCRIBED') { if (!acctSubscribedAt) acctSubscribedAt = Date.now(); pushPresence(); res() }
     else if (st === 'CLOSED' || st === 'CHANNEL_ERROR' || st === 'TIMED_OUT') {
       // Realtime dropped (the 2026-07-08 `realtime CLOSED` blip). The socket normally
       // auto-reconnects, but nudge it so presence — and the claim heartbeat that shares
@@ -1080,18 +1082,19 @@ export async function runAccount(SUPABASE_URL, SUPABASE_ANON) {
   const presenceWatch = setInterval(() => {
     if (stopping) return
     const now = Date.now()
-    // FAIL-SAFE: escalation requires PROVEN presence delivery on this channel (≥1
-    // sync ever received). An empty presenceState() without it means WE can't see —
-    // not that the track failed; respawning on that is the 0.7.174 false-positive
-    // loop. A real zombie (the bug this watchdog exists for) still escalates:
-    // delivery was proven earlier, then our key vanished from the server's state.
-    if (!presenceSyncSeenAt) { selfEchoMissingSince = 0; return }
     let present = false
     try { present = !!acct.presenceState?.()[machine] } catch { present = false }
-    if (present) { selfEchoMissingSince = 0; presenceRecycledForMissing = 0; return }
-    if (!claimHeld) { selfEchoMissingSince = 0; return }   // a standby bridge doesn't announce — never escalate
-    if (!selfEchoMissingSince) selfEchoMissingSince = now
-    const verdict = presenceSelfEchoVerdict({ tracking: claimHeld, selfEchoMissingSince, now })
+    const observation = presenceSelfEchoObservation({
+      tracking: claimHeld,
+      subscribedAt: acctSubscribedAt,
+      syncSeenAt: presenceSyncSeenAt,
+      present,
+      missingSince: selfEchoMissingSince,
+      now,
+    })
+    selfEchoMissingSince = observation.missingSince
+    if (!selfEchoMissingSince) { presenceRecycledForMissing = 0; return }
+    const verdict = observation.verdict
     if (verdict === 'recycle') {
       if (presenceRecycledForMissing === selfEchoMissingSince) return   // already recycled this episode — wait out the respawn window
       presenceRecycledForMissing = selfEchoMissingSince

package/flow-models.mjs

@@ -12,6 +12,9 @@ const CLAUDE_TIERS = {
 const CODEX_SCAFFOLD = ['gpt-5.6-luna', 'gpt-5.4-mini', 'gpt-5.3-codex-spark']
 const CODEX_BALANCED = ['gpt-5.6-terra', 'gpt-5.4']
 const HERMES_REVIEW = ['nous:anthropic/claude-sonnet-4.6', 'nous:anthropic/claude-sonnet-4.5', 'nous:anthropic/claude-sonnet-4']
+const HERMES_MODEL_ALIASES = Object.freeze({
+  fable: 'nous:anthropic/claude-fable-5',
+})
 
 export function normalizeFlowRuntime(runtime, fallback = null) {
   if (runtime === 'claude' || runtime === 'codex' || runtime === 'hermes') return runtime
@@ -27,6 +30,8 @@ export function modelCatalogValues(catalog = []) {
 const exactHermesModelId = (value) => /^[A-Za-z0-9._-]+:[A-Za-z0-9._-]+\/[A-Za-z0-9._:/-]+$/.test(value)
 
 const expandHermesModelAlias = (value) => {
+  const named = HERMES_MODEL_ALIASES[value.toLowerCase()]
+  if (named) return named
   if (/^glm[-_.]/i.test(value)) return `nous:z-ai/${value.toLowerCase()}`
   const shorthand = value.match(/^([^:/]+):([^/]+)$/)
   if (!shorthand) return value

package/package.json

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

package/presence.mjs

@@ -90,3 +90,37 @@ export function presenceSelfEchoVerdict({ tracking, selfEchoMissingSince, now, g
   if (missingMs >= graceMs) return 'recycle'
   return 'ok'
 }
+
+// Turn the supervisor's raw account-channel observation into the state consumed by
+// presenceSelfEchoVerdict. A successful SUBSCRIBED callback is enough to start a
+// bounded startup grace period even when Supabase never sends the first presence
+// sync. Without that bound, `syncSeenAt === 0` disabled the watchdog forever: the
+// HTTP claim stayed healthy while account presence and every private pair bus were
+// dead, so a genuinely live partner room was reported as offline indefinitely.
+//
+// Once a sync has been seen, the original fail-safe still applies normally: a
+// present self key clears the episode; a missing key starts at the observation tick.
+export function presenceSelfEchoObservation({
+  tracking,
+  subscribedAt,
+  syncSeenAt,
+  present,
+  missingSince,
+  now,
+  graceMs = 60_000,
+  respawnMs = 90_000,
+}) {
+  if (!tracking || !subscribedAt) return { missingSince: 0, verdict: 'ok' }
+  if (syncSeenAt && present) return { missingSince: 0, verdict: 'ok' }
+  const nextMissingSince = missingSince || (syncSeenAt ? now : subscribedAt)
+  return {
+    missingSince: nextMissingSince,
+    verdict: presenceSelfEchoVerdict({
+      tracking,
+      selfEchoMissingSince: nextMissingSince,
+      now,
+      graceMs,
+      respawnMs,
+    }),
+  }
+}