thinkpool-pair 0.7.301 → 0.7.303

package/account.mjs

@@ -17,7 +17,7 @@ import { saveAuth, loadAuth, loadDirs, bindDir, loadServed, rememberServed, load
 import { isSafeToRestart } from './update-gate.mjs'
 import { makeThrottledTrack, presenceSelfEchoVerdict } from './presence.mjs'
 import { publicKeyB64, announceProviders, listProviders, addProvider, addProviderModel, removeProvider, unseal } from './providers.mjs'
-import { supervisorServes } from './serve-consent.mjs'
+import { supervisorServes, supervisorRoomsToStop } from './serve-consent.mjs'
 import { resolveServeDir } from './serve-dir.mjs'
 import { pairKeyFor, pairTopic, CROSSROOM_BUS } from './cross-terminal.mjs'
 import { installedAgentCommands } from './agent-detect.mjs'
@@ -798,6 +798,7 @@ export async function runAccount(SUPABASE_URL, SUPABASE_ANON) {
       return
     }
     let rooms = []
+    let discoverySucceeded = false
     const me = session.user.id
     try {
       // Discovery (Contract C-CODE-2, owner-only since 2026-07-06): a host bridges ONLY
@@ -805,20 +806,38 @@ export async function runAccount(SUPABASE_URL, SUPABASE_ANON) {
       // keeps rooms you merely JOINED as a guest out of auto-serve — your machine never
       // spawns into another owner's session (cross-person serving removed; pairing is
       // read-only peer peek, not hosting). The web watches tpacct:<session-owner>.
-      const { data } = await sb.from('code_sessions').select('code,name,last_active_at,owner_id,participants').eq('owner_id', me).order('last_active_at', { ascending: false }).limit(20)
+      const { data, error } = await sb.from('code_sessions')
+        .select('code,name,last_active_at,owner_id,participants,closed_at')
+        .eq('owner_id', me)
+        .is('closed_at', null)
+        .order('last_active_at', { ascending: false })
+        .limit(20)
+      if (error) throw error
       rooms = data || []
+      discoverySucceeded = true
       // Prune refused entries for rooms we can no longer serve — owned OR granted (only
       // on a SUCCESSFUL fetch, so a transient query error never wipes the set).
       const servableCodes = new Set(rooms.map((r) => r.code))
       for (const c of [...refused.keys()]) if (!servableCodes.has(c)) refused.delete(c)
     } catch { /* transient — keep existing children, retry next tick */ }
+    // The realtime shutdown broadcast is an acceleration, never the lifecycle
+    // authority. Reconcile every successful discovery read so a bridge that missed
+    // `session-deleted` still stops after its room is closed, deleted, or transferred.
+    if (discoverySucceeded) {
+      for (const room of supervisorRoomsToStop({ rooms, childRooms: children.keys(), myUid: me })) {
+        const child = children.get(room)
+        if (!child) continue
+        console.log(`child_retire sup=${SUP_ID} room=${room} pid=${child.pid || '?'} reason=not-active-owned`)
+        try { child.kill('SIGTERM') } catch { /* child exit reconciliation retries next tick */ }
+      }
+    }
     const dirs = loadDirs()
     const served = loadServed()
     for (const r of rooms) {
       const room = r.code
       if (!room || children.has(room)) { if (room) refused.delete(room); continue }   // served → not refused
       // Defense-in-depth behind the owner-only query above: serve iff we OWN the room.
-      if (!supervisorServes({ ownerId: r.owner_id, myUid: me })) continue
+      if (!supervisorServes({ ownerId: r.owner_id, myUid: me, closedAt: r.closed_at })) continue
       // Resolve the serve dir: explicit bind > last-served memory > launch dir. REFUSE
       // to auto-serve an unbound room from $HOME — that strips the agent's resume context
       // (cwd-keyed SDK sessions) and shows your home folder as the repo (FVIHV1DE).

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.301",
+  "version": "0.7.303",
   "description": "Share a local coding-agent CLI (Claude Code, Codex, Gemini, Aider, …) into a ThinkPool Code room, live.",
   "type": "module",
   "bin": {

package/serve-consent.mjs

@@ -38,9 +38,29 @@ export function serveDecision ({ ownerId, myUid }) {
 // defense-in-depth per-row check behind the supervisor's owner-only `.eq(owner_id, me)`
 // query — a broad RLS row (owned OR merely participant) must still resolve to OWNED
 // before a child is spawned. Contract C-CODE-2 (owner-only).
-export function supervisorServes ({ ownerId, myUid }) {
+export function supervisorServes ({ ownerId, myUid, closedAt = null }) {
   if (!myUid) return false
-  return ownerId === myUid
+  return ownerId === myUid && !closedAt
+}
+
+// supervisorRoomsToStop — reconcile the long-lived child map after a SUCCESSFUL
+// discovery read. Closing, deleting, or transferring a room removes it from the
+// active-owned result set; any existing child for that room must be retired even
+// when the best-effort `session-deleted` realtime broadcast was missed.
+//
+// This stays pure so a transient discovery failure can be handled by the caller:
+// account.mjs invokes it only after Supabase returned without an error. On a failed
+// fetch the existing children stay alive and the next tick retries.
+export function supervisorRoomsToStop ({ rooms, childRooms, myUid }) {
+  const activeOwned = new Set((rooms || [])
+    .filter((room) => supervisorServes({
+      ownerId: room?.owner_id,
+      myUid,
+      closedAt: room?.closed_at,
+    }))
+    .map((room) => room.code)
+    .filter(Boolean))
+  return [...(childRooms || [])].filter((code) => !activeOwned.has(code))
 }
 
 // fetchServeRow — read the room's owner with whatever identity the bridge holds

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: [] }
+}