thinkpool-pair 0.7.97 → 0.7.98

package/bridge.mjs

@@ -456,6 +456,15 @@ const channel = supabase.channel(`tpcode:${room}`, {
   config: { broadcast: { self: false }, presence: { key: `bridge:${name}` } },
 })
 
+// Thinkpool Flow rides its OWN topic, separate from the room's primary tpcode channel.
+// The web's useFlow hook is a child of CodeRoom, so its effect runs before the room's —
+// sharing tpcode meant useFlow created/owned/removed the room's channel and killed
+// realtime on room open (the 2026-06-30 snag). A dedicated topic keeps the two lifecycles
+// from colliding. The bridge is a separate client, so a second channel here is free.
+const flowChannel = supabase.channel(`tpflow:${room}`, {
+  config: { broadcast: { self: false } },
+})
+
 // ── terminal registry ──────────────────────────────────────────────
 // id → { term (pty), cmd, attached, scrollback, buf }
 const terms = new Map()
@@ -525,14 +534,14 @@ const defendFrame = (event, payload) => {
   return p
 }
 
-const bcast = (event, payload) => {
+const bcast = (event, payload, ch = channel) => {
   if (event === 'pty-out' || event === 'code-event') lastActivity = Date.now()
   payload = defendFrame(event, payload)
   try {
-    if (channel.channelAdapter?.canPush?.() ?? true) {
-      channel.send({ type: 'broadcast', event, payload })
+    if (ch.channelAdapter?.canPush?.() ?? true) {
+      ch.send({ type: 'broadcast', event, payload })
     } else {
-      channel.httpSend(event, payload).catch(() => { /* offline — replay covers it */ })
+      ch.httpSend(event, payload).catch(() => { /* offline — replay covers it */ })
     }
   } catch { /* noop */ }
 }
@@ -1295,7 +1304,7 @@ function openStructured({ id, model, resume, log, commands, mode, spawnedBy, rol
           if (!entry.flowSessionId || !entry.flowTaskKey) return okText('Not a Flow lane — nothing to mark done.')
           let commitSha = null
           try { commitSha = execFileSync('git', ['-C', entry.cwd || process.cwd(), 'rev-parse', 'HEAD'], { encoding: 'utf8' }).trim() } catch { /* no commits yet */ }
-          bcast('flow-task-done', { term: id, flowId: entry.flowSessionId, taskKey: entry.flowTaskKey, laneId: id, commitSha })
+          bcast('flow-task-done', { term: id, flowId: entry.flowSessionId, taskKey: entry.flowTaskKey, laneId: id, commitSha }, flowChannel)
           process.stderr.write(`\n  ${A.cyan}◆ flow slice done — ${entry.flowTaskKey} (${commitSha ? commitSha.slice(0, 8) : 'no commit'})${A.rst}\n`)
           return okText(`Slice "${entry.flowTaskKey}" marked done${commitSha ? ` (commit ${commitSha.slice(0, 8)})` : ' (no commit yet — commit, then re-call)'}. The room records it + dispatches any slices that depended on you.`)
         },
@@ -1374,7 +1383,7 @@ function openStructured({ id, model, resume, log, commands, mode, spawnedBy, rol
       // task-graph + flips status → awaiting_approval → FlowPlanCard renders. Park
       // the conductor ('keep' = stay in plan mode, idle; lane dispatch is Step 2).
       if (entry.flowSessionId && req.risk === 'plan') {
-        bcast('flow-plan', { term: id, flowId: entry.flowSessionId, plan: req.plan || '' })
+        bcast('flow-plan', { term: id, flowId: entry.flowSessionId, plan: req.plan || '' }, flowChannel)
         process.stderr.write(`\n  ${A.mag}◆ flow plan ready — flow ${String(entry.flowSessionId).slice(0, 8)}.${A.rst}\n`)
         resolve('keep')
         return
@@ -1494,63 +1503,6 @@ channel
     }
     shutdown()
   })
-  .on('broadcast', { event: 'flow-start' }, ({ payload }) => {
-    // Ensemble Flow — the room asks this bridge to launch a CONDUCTOR for a Flow run.
-    // The room already created the flow_sessions row (flowId); the conductor opens in
-    // plan mode (so ExitPlanMode is permitted), seeded with the build prompt. It
-    // decomposes → calls ExitPlanMode(planJson) → the requestPermission flow-plan branch
-    // broadcasts flow-plan back. `host` routes to one bridge in multi-machine rooms.
-    if (!payload?.flowId) return
-    if (payload.host && payload.host !== name) return
-    for (const [, e] of sessions) if (e.flowSessionId === payload.flowId) return   // already conducting this flow
-    const cid = randomUUID()
-    termNames[cid] = `Flow · ${String(payload.flowId).slice(0, 6)}`
-    saveNames(room, termNames)
-    openStructured({ id: cid, mode: 'plan', rolePrompt: FLOW_CONDUCTOR_PROMPT, flowSessionId: payload.flowId })
-    const ce = sessions.get(cid)
-    if (ce?.session) { try { ce.session.sendTurn(payload.prompt || '') } catch { /* session still starting */ } }
-    process.stderr.write(`\n  ${A.mag}◆ flow conductor launched — flow ${String(payload.flowId).slice(0, 8)} (plan mode).${A.rst}\n`)
-    announce()
-  })
-  .on('broadcast', { event: 'flow-dispatch' }, ({ payload }) => {
-    // Ensemble Flow — the room approved the plan + sends the READY tasks. Spawn one
-    // worktree-isolated lane per task (FLOW_LANE_PROMPT, its own git tree so lanes
-    // never collide — M57). Seed each lane with its slice spec, then echo the
-    // assignments back so the room marks the tasks dispatched + flips the flow to
-    // building (DB writes stay room-side, member-authed).
-    if (!payload?.flowId || !Array.isArray(payload.tasks)) return
-    if (payload.host && payload.host !== name) return
-    const assignments = []
-    for (const t of payload.tasks) {
-      try {
-        const { dir } = createFlowWorktree({ flowId: payload.flowId, taskKey: t.task_key })
-        const laneId = randomUUID()
-        termNames[laneId] = `Flow · ${t.task_key}`
-        saveNames(room, termNames)
-        openStructured({ id: laneId, cwd: dir, mode: 'acceptEdits', rolePrompt: FLOW_LANE_PROMPT, flowSessionId: payload.flowId, flowTaskKey: t.task_key, spawnedBy: `flow:${payload.flowId}` })
-        const le = sessions.get(laneId)
-        if (le?.session) {
-          const spec =
-            `[Flow lane — slice "${t.task_key}" of flow ${String(payload.flowId).slice(0, 8)}]\n` +
-            `TITLE: ${t.title}\n` +
-            `SCOPE (files you OWN — edit ONLY these): ${t.scope || '(none stated)'}\n` +
-            `ACCEPTANCE (done = this runs + proves it): ${t.acceptance || '(meet the title)'}\n` +
-            (t.deps && t.deps.length ? `DEPENDS ON (already built): ${t.deps.join(', ')}\n` : '') +
-            `\nProject (context): ${payload.flowPrompt || ''}\n\n` +
-            `Build your slice. Own only your files. Done = it runs + meets acceptance. Commit when done.`
-          try { le.session.sendTurn(spec) } catch { /* session still starting */ }
-        }
-        assignments.push({ task_key: t.task_key, laneId })
-      } catch (e) {
-        process.stderr.write(`\n  ${A.yel}◆ flow dispatch failed for ${t.task_key}: ${e?.message || e}${A.rst}\n`)
-      }
-    }
-    if (assignments.length) {
-      bcast('flow-dispatched', { term: 'flow', flowId: payload.flowId, assignments })
-      process.stderr.write(`\n  ${A.mag}◆ flow dispatched ${assignments.length} lane(s) — flow ${String(payload.flowId).slice(0, 8)}.${A.rst}\n`)
-      announce()
-    }
-  })
   .on('broadcast', { event: 'term-open' }, ({ payload }) => {
     if (!payload?.id || !payload?.cmd) return
     // Multi-bridge rooms: a targeted open is for ONE machine. Untargeted
@@ -1830,6 +1782,72 @@ channel
     }
   })
 
+// ── Thinkpool Flow control channel (tpflow:<room>) ──────────────────────────
+// Separate from the room channel above so the web's useFlow hook can own its own
+// topic without colliding with the room's tpcode channel (see the flowChannel def +
+// useFlow.js for the 2026-06-30 collision this fixes). Inbound: flow-start (launch a
+// conductor) + flow-dispatch (spawn lanes). Outbound (via bcast(..., flowChannel)):
+// flow-plan, flow-dispatched, flow-task-done.
+flowChannel
+  .on('broadcast', { event: 'flow-start' }, ({ payload }) => {
+    // Ensemble Flow — the room asks this bridge to launch a CONDUCTOR for a Flow run.
+    // The room already created the flow_sessions row (flowId); the conductor opens in
+    // plan mode (so ExitPlanMode is permitted), seeded with the build prompt. It
+    // decomposes → calls ExitPlanMode(planJson) → the requestPermission flow-plan branch
+    // broadcasts flow-plan back. `host` routes to one bridge in multi-machine rooms.
+    if (!payload?.flowId) return
+    if (payload.host && payload.host !== name) return
+    for (const [, e] of sessions) if (e.flowSessionId === payload.flowId) return   // already conducting this flow
+    const cid = randomUUID()
+    termNames[cid] = `Flow · ${String(payload.flowId).slice(0, 6)}`
+    saveNames(room, termNames)
+    openStructured({ id: cid, mode: 'plan', rolePrompt: FLOW_CONDUCTOR_PROMPT, flowSessionId: payload.flowId })
+    const ce = sessions.get(cid)
+    if (ce?.session) { try { ce.session.sendTurn(payload.prompt || '') } catch { /* session still starting */ } }
+    process.stderr.write(`\n  ${A.mag}◆ flow conductor launched — flow ${String(payload.flowId).slice(0, 8)} (plan mode).${A.rst}\n`)
+    announce()
+  })
+  .on('broadcast', { event: 'flow-dispatch' }, ({ payload }) => {
+    // Ensemble Flow — the room approved the plan + sends the READY tasks. Spawn one
+    // worktree-isolated lane per task (FLOW_LANE_PROMPT, its own git tree so lanes
+    // never collide — M57). Seed each lane with its slice spec, then echo the
+    // assignments back so the room marks the tasks dispatched + flips the flow to
+    // building (DB writes stay room-side, member-authed).
+    if (!payload?.flowId || !Array.isArray(payload.tasks)) return
+    if (payload.host && payload.host !== name) return
+    const assignments = []
+    for (const t of payload.tasks) {
+      try {
+        const { dir } = createFlowWorktree({ flowId: payload.flowId, taskKey: t.task_key })
+        const laneId = randomUUID()
+        termNames[laneId] = `Flow · ${t.task_key}`
+        saveNames(room, termNames)
+        openStructured({ id: laneId, cwd: dir, mode: 'acceptEdits', rolePrompt: FLOW_LANE_PROMPT, flowSessionId: payload.flowId, flowTaskKey: t.task_key, spawnedBy: `flow:${payload.flowId}` })
+        const le = sessions.get(laneId)
+        if (le?.session) {
+          const spec =
+            `[Flow lane — slice "${t.task_key}" of flow ${String(payload.flowId).slice(0, 8)}]\n` +
+            `TITLE: ${t.title}\n` +
+            `SCOPE (files you OWN — edit ONLY these): ${t.scope || '(none stated)'}\n` +
+            `ACCEPTANCE (done = this runs + proves it): ${t.acceptance || '(meet the title)'}\n` +
+            (t.deps && t.deps.length ? `DEPENDS ON (already built): ${t.deps.join(', ')}\n` : '') +
+            `\nProject (context): ${payload.flowPrompt || ''}\n\n` +
+            `Build your slice. Own only your files. Done = it runs + meets acceptance. Commit when done.`
+          try { le.session.sendTurn(spec) } catch { /* session still starting */ }
+        }
+        assignments.push({ task_key: t.task_key, laneId })
+      } catch (e) {
+        process.stderr.write(`\n  ${A.yel}◆ flow dispatch failed for ${t.task_key}: ${e?.message || e}${A.rst}\n`)
+      }
+    }
+    if (assignments.length) {
+      bcast('flow-dispatched', { term: 'flow', flowId: payload.flowId, assignments }, flowChannel)
+      process.stderr.write(`\n  ${A.mag}◆ flow dispatched ${assignments.length} lane(s) — flow ${String(payload.flowId).slice(0, 8)}.${A.rst}\n`)
+      announce()
+    }
+  })
+  .subscribe()
+
 // 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
 // clean process. Healthy long-lived connections never trip this (brokenSince=0).

package/package.json

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