thinkpool-pair 0.7.264 → 0.7.266

package/bridge.mjs

@@ -60,6 +60,7 @@ import { canonicalRoomFilePath, waitForNativeImages } from './codex-images.mjs'
 import { createManagedLaneWorktree, removeManagedLaneWorktree } from './lane-worktree.mjs'
 import { commandOnPath } from './agent-detect.mjs'
 import { requiresSdkAdmission, sdkSmokePassed } from './sdk-admission.mjs'
+import { hermesUserInputResponse } from './question-response.mjs'
 
 const STRUCTURED_MODES = new Set(['default', 'acceptEdits', 'plan', 'review', 'bypassPermissions'])
 import { FLOW_CONDUCTOR_PROMPT, FLOW_LANE_PROMPT, FLOW_CODEX_CONDUCTOR_PROMPT, FLOW_CODEX_LANE_PROMPT, buildConductorEnv, assembleCrossWaveContext, buildLanePrompt } from './flow-conductor.mjs'
@@ -2189,10 +2190,7 @@ function openStructured({ id, runtime = 'claude', model, models, effort, resume,
             answerFormat: 'hermes',
             autoResolutionMs: args.autoResolutionMs,
           })
-          const decision = result && typeof result === 'object' ? result.decision : result
-          const answers = result && typeof result === 'object' && result.answers && typeof result.answers === 'object' ? result.answers : {}
-          const status = String(decision || '').startsWith('answer:') ? 'answered' : decision === 'timeout' ? 'timed_out' : 'dismissed'
-          return { content: [{ type: 'text', text: JSON.stringify({ status, answers }) }] }
+          return { content: [{ type: 'text', text: JSON.stringify(hermesUserInputResponse(result, questions)) }] }
         },
       )] : []),
       ...createViewportTools({ tool, z, manager: entry.viewport }),

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

@@ -31,6 +31,7 @@ import { buildCodexAppServerArgs, codexAppServerGate, createCodexAppServer } fro
 import { CodexEventMapper } from './codex-event-mapper.mjs'
 import { startCodexMcpHttp } from './codex-mcp-http.mjs'
 import { CODEX_THINKPOOL_FIRST_TURN_PREAMBLE, buildThinkPoolTurnGuidance, createRoomContextSelector, usesFullThinkPoolReminder } from './thinkpool-room-prompt.mjs'
+import { questionAnswerResponse } from './question-response.mjs'
 
 const DEFAULT_SANDBOX = 'workspace-write'
 const SAFE_SANDBOXES = new Set(['read-only', 'workspace-write', 'danger-full-access'])
@@ -316,46 +317,8 @@ export function codexApprovalResponse(decision) {
   return { decision: decision === 'always' ? 'acceptForSession' : decision === 'allow' ? 'accept' : 'decline' }
 }
 
-function legacyQuestionAnswers(decision, questions) {
-  if (typeof decision !== 'string' || !decision.startsWith('answer:')) return {}
-  const text = decision.slice(7).trim()
-  if (!text || !questions.length) return {}
-  if (questions.length === 1) {
-    const question = questions[0]
-    const prefix = `${question.header || 'Q1'}: `
-    const value = text.startsWith(prefix) ? text.slice(prefix.length) : text
-    return { [String(question.id || 0)]: { answers: [value] } }
-  }
-  const answers = {}
-  questions.forEach((question, index) => {
-    const id = String(question.id || index)
-    const marker = `${index ? '; ' : ''}${question.header || `Q${index + 1}`}: `
-    const start = text.indexOf(marker)
-    if (start < 0) return
-    const valueStart = start + marker.length
-    const nextQuestion = questions[index + 1]
-    const nextMarker = nextQuestion ? `; ${nextQuestion.header || `Q${index + 2}`}: ` : null
-    const end = nextMarker ? text.indexOf(nextMarker, valueStart) : -1
-    const value = text.slice(valueStart, end < 0 ? undefined : end).trim()
-    if (value) answers[id] = { answers: [value] }
-  })
-  return answers
-}
-
 export function codexUserInputResponse(result, questions = []) {
-  const supplied = result && typeof result === 'object' ? result.answers : null
-  const answers = {}
-  if (supplied && typeof supplied === 'object') {
-    const allowed = new Set(questions.map((question, index) => String(question?.id || index)))
-    for (const [id, value] of Object.entries(supplied)) {
-      if (!allowed.has(String(id)) || !Array.isArray(value?.answers)) continue
-      const values = value.answers.map((answer) => String(answer)).filter(Boolean)
-      if (values.length) answers[String(id)] = { answers: values }
-    }
-  }
-  if (Object.keys(answers).length) return { answers }
-  const decision = result && typeof result === 'object' ? result.decision : result
-  return { answers: legacyQuestionAnswers(decision, questions) }
+  return questionAnswerResponse(result, questions)
 }
 
 function appServerItemForMapper(item) {
@@ -430,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.'))
@@ -484,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 })
     }
   }
 
@@ -544,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
@@ -576,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
@@ -590,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
@@ -651,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 = ''
@@ -665,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.264",
+  "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": {
@@ -16,6 +16,7 @@
     "context-windows.mjs",
     "claude-session.mjs",
     "codex-session.mjs",
+    "question-response.mjs",
     "thinkpool-room-prompt.mjs",
     "thinkpool-prompt-contracts.mjs",
     "thinkpool-capabilities.json",

package/question-response.mjs

@@ -0,0 +1,52 @@
+function legacyQuestionAnswers (decision, questions) {
+  if (typeof decision !== 'string' || !decision.startsWith('answer:')) return {}
+  const text = decision.slice(7).trim()
+  if (!text || !questions.length) return {}
+  if (questions.length === 1) {
+    const question = questions[0]
+    const prefix = `${question.header || 'Q1'}: `
+    const value = text.startsWith(prefix) ? text.slice(prefix.length) : text
+    return { [String(question.id || 0)]: { answers: [value] } }
+  }
+  const answers = {}
+  questions.forEach((question, index) => {
+    const id = String(question.id || index)
+    const marker = `${index ? '; ' : ''}${question.header || `Q${index + 1}`}: `
+    const start = text.indexOf(marker)
+    if (start < 0) return
+    const valueStart = start + marker.length
+    const nextQuestion = questions[index + 1]
+    const nextMarker = nextQuestion ? `; ${nextQuestion.header || `Q${index + 2}`}: ` : null
+    const end = nextMarker ? text.indexOf(nextMarker, valueStart) : -1
+    const value = text.slice(valueStart, end < 0 ? undefined : end).trim()
+    if (value) answers[id] = { answers: [value] }
+  })
+  return answers
+}
+
+// Codex and Hermes use different native tool protocols, but the room answer is
+// one contract. Keep filtering, multi-select preservation, and legacy fallback
+// in one pure adapter so the two runtimes cannot drift independently.
+export function questionAnswerResponse (result, questions = []) {
+  const supplied = result && typeof result === 'object' ? result.answers : null
+  const answers = {}
+  if (supplied && typeof supplied === 'object') {
+    const allowed = new Set(questions.map((question, index) => String(question?.id || index)))
+    for (const [id, value] of Object.entries(supplied)) {
+      if (!allowed.has(String(id)) || !Array.isArray(value?.answers)) continue
+      const values = value.answers.map((answer) => String(answer)).filter(Boolean)
+      if (values.length) answers[String(id)] = { answers: values }
+    }
+  }
+  if (Object.keys(answers).length) return { answers }
+  const decision = result && typeof result === 'object' ? result.decision : result
+  return { answers: legacyQuestionAnswers(decision, questions) }
+}
+
+export function hermesUserInputResponse (result, questions = []) {
+  const decision = result && typeof result === 'object' ? result.decision : result
+  return {
+    status: String(decision || '').startsWith('answer:') ? 'answered' : decision === 'timeout' ? 'timed_out' : 'dismissed',
+    ...questionAnswerResponse(result, questions),
+  }
+}