thinkpool-pair 0.7.315 → 0.7.316

package/bridge.mjs

@@ -1002,6 +1002,38 @@ function advanceStructuredTurn(entry, now = Date.now()) {
   return true
 }
 
+// Every bridge-authored task must cross the same lifecycle boundary as a
+// browser-authored code-turn. Runtime adapters claim `turnActive` synchronously,
+// but the roster deliberately trusts `_busyAnn`; calling sendTurn directly can
+// therefore leave a real turn painted idle until its first provider event.
+// Keep send + revision + visible echo + rejection boundary + announce atomic so
+// cross-posts, spawned tasks and other non-composer ingress cannot drift again.
+function dispatchStructuredTurn(entry, text, {
+  options,
+  visibleEvent,
+  rejectionMessage = 'The agent did not accept this turn; retry after the lane is available.',
+} = {}) {
+  if (!entry?.session) return { accepted: false, error: new Error('session unavailable') }
+  syncStructuredTurn(entry)
+  let accepted = false
+  let error = null
+  try { accepted = entry.session.sendTurn(text, options) !== false }
+  catch (cause) { error = cause }
+  if (accepted) beginStructuredTurn(entry)
+  else syncStructuredTurn(entry)
+  if (visibleEvent) {
+    pushLog(entry, visibleEvent)
+    bcast('code-event', { term: entry.id, evt: visibleEvent })
+  }
+  if (!accepted) {
+    const failed = { kind: 'error', message: rejectionMessage, recoverable: true }
+    pushLog(entry, failed)
+    bcast('code-event', { term: entry.id, evt: failed })
+  }
+  announce()
+  return { accepted, error }
+}
+
 function dispatchPendingSideContexts(entry) {
   if (!entry?.pendingSideContexts?.length || typeof entry.session?.sendTurn !== 'function') return false
   const outcome = dispatchSideContexts({
@@ -1436,8 +1468,13 @@ async function receiveCrossRoomPost({ fromRoom, fromHost, fromTerminalName, text
   const msg = `[From: room ${fromLabel} — relayed via the ThinkPool cross-room Ensemble, approved by a person in this room]\n${body}`
   const evt = { kind: 'you', text: msg, by: `room ${fromRoom}`, crosspost: true, relaySourceName: String(fromTerminalName || '').trim().slice(0, 80) || undefined }
   autoNameTerminal(targetId, body)
-  stampEvent(evt); pushLog(te, evt); bcast('code-event', { term: targetId, evt })
-  try { if (te.session.sendTurn(msg) === false) return { error: `Could not deliver to room ${room} — the lane refused the turn (check its visible host-memory/runtime error).` } } catch { return { error: `Could not deliver to room ${room} — the lane may have just closed.` } }
+  const dispatched = dispatchStructuredTurn(te, msg, {
+    visibleEvent: evt,
+    rejectionMessage: 'The incoming cross-room task was not accepted; retry after the lane is available.',
+  })
+  if (!dispatched.accepted) return { error: dispatched.error
+    ? `Could not deliver to room ${room} — the lane may have just closed.`
+    : `Could not deliver to room ${room} — the lane refused the turn (check its visible host-memory/runtime error).` }
   return { ok: true, ref: String(targetId).slice(0, 8) }
 }
 
@@ -2252,13 +2289,11 @@ function openStructured({ id, runtime = 'claude', model, models, effort, resume,
     // No revert, no verdict broadcast, no markFlowDone — the loop stays open.
     if (!decision.stop) {
       const next = round + 1
-      try {
-        entry.session?.sendTurn(
-          entry.runtime === 'codex'
-            ? `[Flow review — round ${next}/${REVIEW_DEFAULTS.maxRounds}] The happy path held, but you have NOT reported your checks exhausted. Dig one more round, then call submit_flow_review again — pass:false with specific evidence if you break it, or pass:true AND exhausted:true only when nothing remains to check.`
-            : `[Flow review — round ${next}/${REVIEW_DEFAULTS.maxRounds}] The happy path held, but you have NOT reported your checks exhausted and you are under both the round and budget ceilings. Dig one more round: hunt the edge cases, the reload, the second click, concurrent use, the error path — the places the builder didn't. Then re-Write FLOW_REVIEW.json — pass:false with a specific reason if you break it, or pass:true AND exhausted:true if you genuinely have nothing left to check.`,
-        )
-      } catch { /* lane may have closed mid-verdict */ }
+      dispatchStructuredTurn(entry,
+        entry.runtime === 'codex'
+          ? `[Flow review — round ${next}/${REVIEW_DEFAULTS.maxRounds}] The happy path held, but you have NOT reported your checks exhausted. Dig one more round, then call submit_flow_review again — pass:false with specific evidence if you break it, or pass:true AND exhausted:true only when nothing remains to check.`
+          : `[Flow review — round ${next}/${REVIEW_DEFAULTS.maxRounds}] The happy path held, but you have NOT reported your checks exhausted and you are under both the round and budget ceilings. Dig one more round: hunt the edge cases, the reload, the second click, concurrent use, the error path — the places the builder didn't. Then re-Write FLOW_REVIEW.json — pass:false with a specific reason if you break it, or pass:true AND exhausted:true if you genuinely have nothing left to check.`,
+        { rejectionMessage: 'The next Flow review round was not accepted; retry after the lane is available.' })
       process.stderr.write(`\n  ${A.dim}◆ review round ${round} inconclusive — digging again (${next}/${REVIEW_DEFAULTS.maxRounds}) on ${target || entry.flowTaskKey}${A.rst}\n`)
       return { ok: true, message: `Round ${round} recorded (pass, not yet exhausted). Keep hunting — asked you for round ${next}/${REVIEW_DEFAULTS.maxRounds}.` }
     }
@@ -2673,10 +2708,13 @@ function openStructured({ id, runtime = 'claude', model, models, effort, resume,
           // arrived (rides the existing code-event 'you' path — no new topic).
           const evt = { kind: 'you', text: msg, by: `terminal ${fromRef} (agent)`, crosspost: true, relaySourceName: termNames[id] || undefined }
           autoNameTerminal(target.id, args.text)
-          stampEvent(evt)
-          pushLog(te, evt)
-          bcast('code-event', { term: target.id, evt })
-          try { if (te.session.sendTurn(msg) === false) return okText(`Could not deliver to terminal ${target.ref} — it refused the turn. Check its visible host-memory/runtime error.`) } catch { return okText(`Could not deliver to terminal ${target.ref} — it may have just closed.`) }
+          const dispatched = dispatchStructuredTurn(te, msg, {
+            visibleEvent: evt,
+            rejectionMessage: 'The cross-terminal task was not accepted; retry after the lane is available.',
+          })
+          if (!dispatched.accepted) return okText(dispatched.error
+            ? `Could not deliver to terminal ${target.ref} — it may have just closed.`
+            : `Could not deliver to terminal ${target.ref} — it refused the turn. Check its visible host-memory/runtime error.`)
           return okText(`Delivered to terminal ${target.ref} (${target.cmd}). It will respond in its own lane; check back with read_terminal.`)
         },
       )] : []),
@@ -2727,9 +2765,13 @@ function openStructured({ id, runtime = 'claude', model, models, effort, resume,
           const msg = `[Task from main terminal ${fromRef}'s agent — opened as an independent MAIN CASCADE CONDUCTOR terminal, not an Ensemble child]\n${String(args.task).trim()}`
           const evt = { kind: 'you', text: msg, by: `main terminal ${fromRef} (agent)`, crosspost: true, relaySourceName: termNames[id] || undefined }
           autoNameTerminal(newId, args.task)
-          stampEvent(evt); pushLog(conductor, evt); bcast('code-event', { term: newId, evt })
-          try { if (conductor.session.sendTurn(msg) === false) return okText(`Opened main conductor ${newRef}, but host pressure prevented its runtime from starting. Existing lanes remain connected; free memory and retry the task.`) }
-          catch { return okText(`Opened main conductor ${newRef}${args?.name ? ` ("${args.name}")` : ''}, but it may still be starting — the initial task could not be delivered.`) }
+          const dispatched = dispatchStructuredTurn(conductor, msg, {
+            visibleEvent: evt,
+            rejectionMessage: 'The initial conductor task was not accepted; retry after the lane is available.',
+          })
+          if (!dispatched.accepted) return okText(dispatched.error
+            ? `Opened main conductor ${newRef}${args?.name ? ` ("${args.name}")` : ''}, but it may still be starting — the initial task could not be delivered.`
+            : `Opened main conductor ${newRef}, but host pressure prevented its runtime from starting. Existing lanes remain connected; free memory and retry the task.`)
           return okText(`Opened independent main Cascade conductor ${newRef}${args?.name ? ` ("${args.name}")` : ''} and handed it the task. It is a main terminal, not an Ensemble lane.`)
         },
       )] : []),
@@ -2847,8 +2889,13 @@ function openStructured({ id, runtime = 'claude', model, models, effort, resume,
             const msg = `[Task from terminal ${fromRef}'s agent — relayed via ThinkPool Ensemble; you are its WORKER SUB-TERMINAL, never a main terminal or Cascade conductor]\n${args.task}${reviewTarget}`
             const evt = { kind: 'you', text: msg, by: `terminal ${fromRef} (agent)`, crosspost: true, relaySourceName: termNames[id] || undefined }
             autoNameTerminal(newId, args.task)
-            stampEvent(evt); pushLog(ne, evt); bcast('code-event', { term: newId, evt })
-            try { if (ne.session.sendTurn(msg) === false) return okText(`Opened lane ${newRef}${args?.name ? ` ("${args.name}")` : ''}, but host pressure prevented its runtime from accepting the task. Existing lanes remain connected; free memory and retry.`) } catch { return okText(`Opened lane ${newRef}${args?.name ? ` ("${args.name}")` : ''}, but it may still be starting — could not hand off the task. Try post_to_terminal shortly.`) }
+            const dispatched = dispatchStructuredTurn(ne, msg, {
+              visibleEvent: evt,
+              rejectionMessage: 'The initial worker task was not accepted; retry after the lane is available.',
+            })
+            if (!dispatched.accepted) return okText(dispatched.error
+              ? `Opened lane ${newRef}${args?.name ? ` ("${args.name}")` : ''}, but it may still be starting — could not hand off the task. Try post_to_terminal shortly.`
+              : `Opened lane ${newRef}${args?.name ? ` ("${args.name}")` : ''}, but host pressure prevented its runtime from accepting the task. Existing lanes remain connected; free memory and retry.`)
             return okText(`Opened agent lane ${newRef}${args?.name ? ` ("${args.name}")` : ''} and handed it the task. It runs in its own lane — check back with read_terminal, then close_terminal when done.`)
           }
           return okText(`Opened idle agent lane ${newRef}${args?.name ? ` ("${args.name}")` : ''}. Hand it work with post_to_terminal, or a person can type into it.`)
@@ -3897,12 +3944,15 @@ channel
         }
         child.hop = 0
         const childEvent = { kind: 'you', text: task, by }
-        stampEvent(childEvent); pushLog(child, childEvent); bcast('code-event', { term: payload.id, evt: childEvent })
         const parentEvent = { kind: 'side-started', sideId: payload.id, sideName, task, by }
-        stampEvent(parentEvent); pushLog(parent, parentEvent); bcast('code-event', { term: sideParent, evt: parentEvent })
+        pushLog(parent, parentEvent); bcast('code-event', { term: sideParent, evt: parentEvent })
         const snapshot = sideSnapshot(parent.log.filter((event) => event.cid !== parentEvent.cid))
         const prompt = snapshot ? `${snapshot}\n\n--- side task ---\n${task}` : task
-        try { if (child.session.sendTurn(prompt) === false) throw new Error('runtime refused the turn') } catch {
+        const dispatched = dispatchStructuredTurn(child, prompt, {
+          visibleEvent: childEvent,
+          rejectionMessage: 'The side-lane task was not accepted; retry after the lane is available.',
+        })
+        if (!dispatched.accepted) {
           bcast('side-open-failed', { id: payload.id, parent: sideParent, message: 'The side agent could not start.' })
           endStructured(payload.id)
           return
@@ -4084,8 +4134,10 @@ channel
     const preparing = { kind: 'control', text: 'Preparing a compact handoff for main…', by }
     stampEvent(preparing); pushLog(side, preparing); bcast('code-event', { term: payload.term, evt: preparing })
     side.flush?.(); announce()
-    try { side.session.sendTurn(SIDE_HANDOFF_PROMPT) }
-    catch {
+    const dispatched = dispatchStructuredTurn(side, SIDE_HANDOFF_PROMPT, {
+      rejectionMessage: 'The side-lane handoff was not accepted; retry after the lane is available.',
+    })
+    if (!dispatched.accepted) {
       side.sideHandback = null
       const failed = { kind: 'control', text: 'Couldn’t start the handoff — try again.', by }
       stampEvent(failed); pushLog(side, failed); bcast('code-event', { term: payload.term, evt: failed })
@@ -4806,7 +4858,9 @@ flowChannel
     // to pin a cheaper/smarter conductor. Lanes get tiered below via laneModelFor.
     openStructured({ id: cid, runtime: flowRuntime, model: conductorModel, mode: flowRuntime === 'codex' ? 'plan' : 'default', rolePrompt: flowRuntime === 'claude' ? FLOW_CONDUCTOR_PROMPT : FLOW_CODEX_CONDUCTOR_PROMPT, flowSessionId: payload.flowId, flowRole: 'conductor', spawnedBy: `flow:${payload.flowId}` })
     const ce = sessions.get(cid)
-    if (ce?.session) { try { ce.session.sendTurn(payload.prompt || '') } catch { /* session still starting */ } }
+    if (ce?.session) dispatchStructuredTurn(ce, payload.prompt || '', {
+      rejectionMessage: 'The Flow conductor task was not accepted; retry after the lane is available.',
+    })
     process.stderr.write(`\n  ${A.mag}◆ flow conductor launched — flow ${String(payload.flowId).slice(0, 8)} (plan mode).${A.rst}\n`)
     announce()
   })
@@ -4953,7 +5007,9 @@ flowChannel
                 `\nProject (context): ${payload.flowPrompt || ''}\n\n` +
                 `Build your slice. Own only your files. Done = it runs + meets acceptance. Commit when done.` +
                 (flowRuntime === 'codex' || flowRuntime === 'hermes' ? ` Then call the ThinkPool mark_flow_done MCP tool; do not write FLOW_DONE.` : '')
-            try { le.session.sendTurn(spec) } catch { /* session still starting */ }
+            dispatchStructuredTurn(le, spec, {
+              rejectionMessage: `Flow slice ${t.task_key} was not accepted; retry after the lane is available.`,
+            })
           }
         }
         assignments.push({ task_key: t.task_key, laneId })

package/package.json

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