thinkpool-pair 0.7.265 → 0.7.266

package/claude-session.mjs

@@ -1051,6 +1051,11 @@ export function startClaudeSession({ cwd, model, effort: initialEffort = 'high',
       // session is ending) — not a real error. Stay silent; the re-create owns what's next.
       if (myAc.signal.aborted) return
       const msg = e?.message || String(e)
+      // onEvent is also the bridge's synchronous busy-edge sampling point. The
+      // query has already ended here, so publish the failure only after clearing
+      // the turn. Otherwise a non-recoverable SDK error leaves the roster on its
+      // last `busy: true` announce until a tab refocus asks for fresh state.
+      turnActive = false
       emit({ kind: 'error', message: msg })
       // Auto-restart a transient upstream stream drop: re-run query() with
       // resume so the conversation continues. Bounded by RESTART_MAX (reset on
@@ -1058,7 +1063,6 @@ export function startClaudeSession({ cwd, model, effort: initialEffort = 'high',
       // fresh input stream is needed because the throw killed the old iterator.
       if (RECOVERABLE.test(msg) && restartCount < RESTART_MAX) {
         restartCount++
-        turnActive = false
         emit({ kind: 'note', text: `connection dropped — reconnecting (${restartCount}/${RESTART_MAX})` })
         // End the OLD input stream before swapping — else its generator leaks
         // (suspended forever) and a turn pushed into it after the throw is silently
@@ -1076,7 +1080,6 @@ export function startClaudeSession({ cwd, model, effort: initialEffort = 'high',
       // of hard-failing. Bounded by RESTART_MAX. Loses only the resumed history, not the turn.
       if (/no conversation found/i.test(msg) && sessionId && restartCount < RESTART_MAX) {
         restartCount++
-        turnActive = false
         sessionId = null; persistedSessionId = null
         const oldInput = input
         input = makeInputStream()
@@ -1088,7 +1091,6 @@ export function startClaudeSession({ cwd, model, effort: initialEffort = 'high',
       // silently queuing into a dead stream. The bridge's onEvent self-heal
       // still fires for "No conversation found" (it reopens fresh).
       closed = true
-      turnActive = false
     } finally {
       ac.signal.removeEventListener('abort', onParentAbort)
       if (qAc === myAc) qAc = null

package/codex-session.mjs

@@ -393,6 +393,22 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
     },
   })
 
+  // The bridge samples `session.turnActive` synchronously inside onEvent to
+  // announce the roster's busy edge. Codex transports report their terminal
+  // boundary before their surrounding promise/process cleanup runs, so clearing
+  // turnActive only in `finally`/`close` publishes one last stale `busy: true`
+  // announce with no later event to correct it. A tab refocus re-announcement
+  // eventually healed the roster, but until then the room stayed on "thinking".
+  // Settle at the event boundary itself for every Codex transport.
+  const pushMappedEvent = (event) => {
+    if (event?.type === 'turn.completed' || event?.type === 'turn.failed') turnActive = false
+    mapper.push(event)
+  }
+  const emitTurnBoundary = (event) => {
+    turnActive = false
+    try { onEvent?.(event) } catch { /* noop */ }
+  }
+
   const note = (text) => { try { onEvent?.({ kind: 'note', text }) } catch { /* noop */ } }
   if (requestedResume && !resumeUsable) {
     queueMicrotask(() => note('The stopped Codex turn had no resumable context; continuing in a fresh thread.'))
@@ -447,12 +463,12 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
           return
         }
       }
-      mapper.push({ type: method === 'item/started' ? 'item.started' : 'item.completed', item: appServerItemForMapper(raw) })
+      pushMappedEvent({ type: method === 'item/started' ? 'item.started' : 'item.completed', item: appServerItemForMapper(raw) })
       return
     }
     if (method === 'error') {
       const message = params.error?.message || params.message || 'codex app-server error'
-      mapper.push({ type: 'error', message })
+      pushMappedEvent({ type: 'error', message })
     }
   }
 
@@ -507,7 +523,7 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
         config: { 'features.default_mode_request_user_input': true },
       })
       appServerThreadReady = true
-      mapper.push({ type: 'thread.started', thread_id: sessionId })
+      pushMappedEvent({ type: 'thread.started', thread_id: sessionId })
       return true
     } catch (error) {
       // Fallback is safe only here: no turn/start request has been accepted, so
@@ -539,11 +555,11 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
       const completed = await appServer.waitForTurn(activeTurnId)
       const status = completed?.turn?.status
       if (aborted || status === 'interrupted') {
-        try { onEvent?.({ kind: 'result', subtype: 'aborted', sessionId, model: activeModel, costUsd: null, usage: null, numTurns: 1, durationMs: completed?.turn?.durationMs, denials: 0, resultText: null }) } catch { /* noop */ }
+        emitTurnBoundary({ kind: 'result', subtype: 'aborted', sessionId, model: activeModel, costUsd: null, usage: null, numTurns: 1, durationMs: completed?.turn?.durationMs, denials: 0, resultText: null })
       } else if (status === 'failed') {
-        mapper.push({ type: 'turn.failed', message: completed?.turn?.error?.message || 'codex turn failed' })
+        pushMappedEvent({ type: 'turn.failed', message: completed?.turn?.error?.message || 'codex turn failed' })
       } else {
-        mapper.push({ type: 'turn.completed' })
+        pushMappedEvent({ type: 'turn.completed' })
       }
     } catch (error) {
       // Once a started turn's transport fails we must not replay that prompt via
@@ -553,7 +569,7 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
       appServerThreadReady = false
       try { appServer?.end() } catch { /* noop */ }
       appServer = null
-      if (!ended) mapper.push({ type: 'turn.failed', message: `codex app-server turn failed: ${error?.message || error}` })
+      if (!ended) pushMappedEvent({ type: 'turn.failed', message: `codex app-server turn failed: ${error?.message || error}` })
     } finally {
       // A transport failure or interrupt can land after prose deltas but before
       // item/completed. Preserve that partial prose as one durable row rather
@@ -614,7 +630,7 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
         }
         if (ev.type === 'thread.started' && ev.thread_id) sessionId = sessionId || ev.thread_id
         if (ev.type === 'turn.completed' || ev.type === 'turn.failed') sawTerminalResult = true
-        mapper.push(ev)
+        pushMappedEvent(ev)
       })
       // stderr is codex's human progress channel; surface tail on failure only.
       let stderrTail = ''
@@ -628,18 +644,17 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
         child = null
         turnActive = false
         if (aborted && !sawTerminalResult) {
-          try { onEvent?.({ kind: 'result', subtype: 'aborted', sessionId, model: activeModel, costUsd: null, usage: null, numTurns: 1, durationMs: undefined, denials: 0, resultText: null }) } catch { /* noop */ }
+          emitTurnBoundary({ kind: 'result', subtype: 'aborted', sessionId, model: activeModel, costUsd: null, usage: null, numTurns: 1, durationMs: undefined, denials: 0, resultText: null })
         } else if (!aborted && !sawTerminalResult && code !== 0 && code != null) {
-          try { onEvent?.({ kind: 'error', message: `codex exec exited ${code}${stderrTail ? ': ' + stderrTail.trim().slice(-300) : ''}`, recoverable: true }) } catch { /* noop */ }
+          emitTurnBoundary({ kind: 'error', message: `codex exec exited ${code}${stderrTail ? ': ' + stderrTail.trim().slice(-300) : ''}`, recoverable: true })
         }
         resolve()
       }
       child.on('error', (e) => {
         if (settled) return
         settled = true
-        try { onEvent?.({ kind: 'error', message: `codex failed to start: ${e.message}`, recoverable: true }) } catch { /* noop */ }
         child = null
-        turnActive = false
+        emitTurnBoundary({ kind: 'error', message: `codex failed to start: ${e.message}`, recoverable: true })
         resolve()
       })
       child.on('close', finish)

package/package.json

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