thinkpool-pair 0.7.302 → 0.7.304

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/bridge.mjs

@@ -124,7 +124,7 @@ import { stampEvent, makeSeqCounter, maxSeq, seqable, capReplayEvents, chunkRepl
 import { createLatestReplayPump, requestedReplayIds } from './replay-transport.mjs'
 import { classifyCodeEvent, unknownCodeEventNotice } from './code-event-contract.mjs'
 import { fetchPairControlDeliveryAuthority } from './pair-control-authority.mjs'
-import { SIDE_HANDOFF_PROMPT, SIDE_ROLE_PROMPT, appendSideContext, assistantTextSince, sideContextBlock, sideSnapshot } from './side-lane.mjs'
+import { SIDE_HANDOFF_PROMPT, SIDE_ROLE_PROMPT, appendSideContext, assistantTextSince, dispatchSideContexts, sideContextBlock, sideSnapshot } from './side-lane.mjs'
 import { planMeterLine } from './plan-meters.mjs'
 import { priceForModel } from './model-prices.mjs'
 import { makeThrottledTrack } from './presence.mjs'
@@ -994,6 +994,32 @@ function advanceStructuredTurn(entry, now = Date.now()) {
   return true
 }
 
+function dispatchPendingSideContexts(entry) {
+  if (!entry?.pendingSideContexts?.length || typeof entry.session?.sendTurn !== 'function') return false
+  const outcome = dispatchSideContexts({
+    contexts: entry.pendingSideContexts,
+    busy: entry.session?.turnActive === true,
+    sendTurn: (prompt) => entry.session?.sendTurn(prompt),
+  })
+  entry.pendingSideContexts = outcome.pending
+  if (!outcome.dispatched) return false
+  beginStructuredTurn(entry)
+  entry.flush?.()
+  announce()
+  return true
+}
+
+function schedulePendingSideContexts(entry) {
+  if (!entry?.pendingSideContexts?.length || entry._sideContextTimer) return
+  entry._sideContextTimer = setTimeout(() => {
+    entry._sideContextTimer = null
+    if (dispatchPendingSideContexts(entry)) {
+      process.stderr.write('\n  ◆ started main turn from side-lane handoff.\n')
+    }
+  }, 0)
+  entry._sideContextTimer.unref?.()
+}
+
 function stampStructuredTurn(entry, event) {
   if (event && event.turnRev == null && Number(entry?._turnRev) > 0) event.turnRev = entry._turnRev
   return event
@@ -3238,6 +3264,7 @@ function openStructured({ id, runtime = 'claude', model, models, effort, resume,
             const done = { kind: 'control', text: 'Brought to main.', by: request.by }
             stampEvent(done); pushLog(entry, done); bcast('code-event', { term: id, evt: done })
             parent.flush?.()
+            schedulePendingSideContexts(parent)
           } else {
             const failed = { kind: 'control', text: parent ? 'Couldn’t prepare a handoff — try again.' : 'The main terminal is no longer available.', by: request.by }
             stampEvent(failed); pushLog(entry, failed); bcast('code-event', { term: id, evt: failed })
@@ -3252,6 +3279,9 @@ function openStructured({ id, runtime = 'claude', model, models, effort, resume,
         const stalePermissionIds = [...entry.pending.keys()]
         drainPending(entry)
         for (const pendingId of stalePermissionIds) bcast('code-perm', { term: id, id: pendingId, decision: 'deny', name: 'agent' })
+        // Bring-to-main never interrupts an active parent turn. If a handoff arrived
+        // while this lane was working, start it on the first idle tick after settle.
+        schedulePendingSideContexts(entry)
         const settledAt = Date.now()
         if (shouldRecordTurnDone({ entry, subtype: evt.subtype, startedAt, now: settledAt })) {
           persistAgentEvent({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.302",
+  "version": "0.7.304",
   "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,
+    }),
+  }
+}

package/side-lane.mjs

@@ -8,6 +8,9 @@ Focus first on reading, searching, comparing, and answering the side task. You a
 export const SIDE_HANDOFF_PROMPT = `Prepare a compact handoff for the main terminal now.
 Return only the handoff. Include: conclusion, strongest evidence, files changed or artifacts produced, and any unresolved question or recommended next action. Do not continue the investigation and do not address the reader conversationally.`
 
+export const SIDE_MAIN_TURN_PROMPT = `A room member chose Bring to main.
+Read the side-lane handoff below, incorporate the relevant findings into the main lane's current work, and respond now. If the handoff recommends a next step that is already authorized and in scope, take it; otherwise explain the concrete impact on the current work.`
+
 export function sideSnapshot(log) {
   return buildRecapFromLog(Array.isArray(log) ? log : [], SIDE_RECAP_CAP)
 }
@@ -40,3 +43,21 @@ export function appendSideContext(contexts, context, cap = 4) {
   if (!context) return Array.isArray(contexts) ? contexts.slice(-cap) : []
   return [...(Array.isArray(contexts) ? contexts : []), context].slice(-cap)
 }
+
+export function sideMainTurnPrompt(contexts) {
+  const handoffs = (Array.isArray(contexts) ? contexts : []).filter(Boolean)
+  if (!handoffs.length) return ''
+  return `${SIDE_MAIN_TURN_PROMPT}\n\n${handoffs.join('\n\n')}`
+}
+
+export function dispatchSideContexts({ contexts, busy, sendTurn }) {
+  const pending = (Array.isArray(contexts) ? contexts : []).filter(Boolean).slice(-4)
+  if (!pending.length || busy || typeof sendTurn !== 'function') return { dispatched: false, pending }
+  const prompt = sideMainTurnPrompt(pending)
+  try {
+    if (sendTurn(prompt) === false) return { dispatched: false, pending }
+  } catch {
+    return { dispatched: false, pending }
+  }
+  return { dispatched: true, pending: [] }
+}