thinkpool-pair 0.7.277 → 0.7.279

package/bridge.mjs

@@ -3124,8 +3124,8 @@ function pendingResolution(pending, payload = {}) {
   const decision = payload.decision || 'deny'
   return pending?.payload?.answerFormat === 'dispatch'
     ? { decision, dispatchFingerprint: payload.dispatchFingerprint || null, controlItemId: payload.controlItemId || null }
-    : (pending?.payload?.answerFormat === 'codex' || pending?.payload?.answerFormat === 'hermes')
-    ? { decision, answers: payload.answers || {} }
+    : (pending?.payload?.risk === 'ask' || pending?.payload?.answerFormat === 'codex' || pending?.payload?.answerFormat === 'hermes')
+    ? { decision, answers: payload.answers || {}, responder: payload.responder || null }
     : decision
 }
 
@@ -3946,7 +3946,7 @@ channel
       if (p.timer) clearTimeout(p.timer)
       s.pending.delete(payload.id)
       s.permNotifier?.resolve(payload.id)
-      p.resolve(pendingResolution(p, { ...payload, decision: authority.decision, answers: authority.answers }))
+      p.resolve(pendingResolution(p, { ...payload, decision: authority.decision, answers: authority.answers, responder: authority.responder }))
       announce()
     })
   })

package/claude-session.mjs

@@ -99,18 +99,25 @@ export function autoAllow({ toolName, input, mode = 'default', alwaysAllow = new
 // denies (PreToolUse can't inject a tool_result) and puts the human's pick in
 // the deny reason, which IS what the model receives. Exported so the feedback
 // contract is locked in a unit test (mock requestPermission → this output).
-// `decision` is the requestPermission return: 'answer:<pick>' when the person
-// selected, anything else (including '' / dismissal / a broken path) is treated
-// as "no selection".
+// `decision` is the requestPermission return: either the legacy 'answer:<pick>'
+// string or { decision, responder } from the durable room control. Anything else
+// (including '' / dismissal / a broken path) is treated as "no selection".
 export function askUserQuestionHookOutput(decision) {
-  const ans = (typeof decision === 'string' && decision.startsWith('answer:')) ? decision.slice(7) : ''
+  const rawDecision = decision && typeof decision === 'object' ? decision.decision : decision
+  const ans = (typeof rawDecision === 'string' && rawDecision.startsWith('answer:')) ? rawDecision.slice(7) : ''
+  const responder = decision && typeof decision === 'object' ? decision.responder : null
+  const answeredBy = typeof responder?.name === 'string' && responder.name.trim()
+    ? responder.name.trim()
+    : typeof responder?.id === 'string' && responder.id
+      ? `room member ${responder.id}`
+      : 'The user'
   return {
     continue: true,
     hookSpecificOutput: {
       hookEventName: 'PreToolUse',
       permissionDecision: 'deny',
       permissionDecisionReason: ans
-        ? `The user answered in the ThinkPool room — ${ans}. Treat this as their selection and continue; do not call AskUserQuestion again for the same question.`
+        ? `${answeredBy} answered in the ThinkPool room — ${ans}. Treat this as their selection and continue; do not call AskUserQuestion again for the same question.`
         : 'The user dismissed the question in the ThinkPool room without selecting. Ask in plain prose, or proceed with a sensible default.',
     },
   }

package/codex-session.mjs

@@ -389,6 +389,12 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
   let appServer = null
   let appServerThreadReady = false
   let activeTurnId = null
+  // App Server notifications are asynchronous to turn/completed. In production a
+  // stopped turn emitted its durable `aborted` boundary, then delivered a queued
+  // item/started 89ms later and a Bash result 159.9s after that. Without a native
+  // turn fence those late rows resurrected the lane after Stop. Keep a bounded set
+  // of closed native turns and accept turn-scoped traffic only for the one active id.
+  const closedAppServerTurnIds = new Set()
   const appServerItems = new Map()
   const streamedAgentItems = new Map() // item id → { cid, text }
   let steerChain = Promise.resolve()
@@ -423,6 +429,18 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
   }
 
   const note = (text) => { try { onEvent?.({ kind: 'note', text }) } catch { /* noop */ } }
+
+  const closeAppServerTurn = (turnId = activeTurnId) => {
+    const id = String(turnId || '')
+    if (!id) return
+    closedAppServerTurnIds.add(id)
+    while (closedAppServerTurnIds.size > 64) closedAppServerTurnIds.delete(closedAppServerTurnIds.values().next().value)
+  }
+
+  const appServerTurnIsCurrent = (params = {}) => {
+    const turnId = String(params.turnId || '')
+    return !!turnId && !ended && !aborted && !closedAppServerTurnIds.has(turnId) && turnId === String(activeTurnId || '')
+  }
   if (requestedResume && !resumeUsable) {
     queueMicrotask(() => note('The stopped Codex turn had no resumable context; continuing in a fresh thread.'))
   }
@@ -439,9 +457,15 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
 
   function appServerNotification(method, params = {}) {
     if (method === 'turn/started' && params.turn?.id) {
-      activeTurnId = activeTurnId || params.turn.id
+      const turnId = String(params.turn.id)
+      if (ended || aborted) { closeAppServerTurn(turnId); return }
+      if (!activeTurnId) activeTurnId = turnId
       return
     }
+    // Every mapped App Server notification below is turn-scoped in the tested
+    // protocol and carries turnId. Fail closed on missing, stale, completed, or
+    // interrupted ids so a provider's buffered stdout cannot reopen a closed turn.
+    if ((method === 'turn/plan/updated' || method === 'item/agentMessage/delta' || method === 'item/started' || method === 'item/completed' || method === 'error') && !appServerTurnIsCurrent(params)) return
     if (method === 'turn/plan/updated') {
       const todos = (Array.isArray(params.plan) ? params.plan : []).map(({ step, status }) => ({
         content: step || '',
@@ -486,6 +510,13 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
   }
 
   async function appServerRequest(method, params = {}) {
+    // A request racing Stop must never raise a fresh room card after the turn's
+    // durable boundary. Respond with the protocol's ordinary denial shape so the
+    // native runtime can settle without reopening any ThinkPool state.
+    if (!appServerTurnIsCurrent(params)) {
+      if (method === 'item/tool/requestUserInput') return { answers: {} }
+      return { decision: 'decline' }
+    }
     const card = codexApprovalCard(method, params, appServerItems.get(params.itemId))
     if (!card) throw new Error(`Unsupported Codex App Server request: ${method}`)
     // Missing/broken room permission plumbing denies safely. App Server expects
@@ -578,10 +609,12 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
       // id. abort() already closed the room boundary; interrupt the now-known
       // native turn before waiting, and never let it continue invisibly.
       if (aborted || ended) {
+        closeAppServerTurn(activeTurnId)
         try { await appServer.interrupt({ threadId: sessionId, turnId: activeTurnId }) } catch { /* boundary is already closed */ }
         return true
       }
       const completed = await appServer.waitForTurn(activeTurnId)
+      closeAppServerTurn(completed?.turn?.id || activeTurnId)
       const status = completed?.turn?.status
       if (aborted || status === 'interrupted') {
         emitTurnBoundary({ kind: 'result', subtype: 'aborted', sessionId, model: activeModel, costUsd: null, usage: null, numTurns: 1, durationMs: completed?.turn?.durationMs, denials: 0, resultText: null })
@@ -596,6 +629,7 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
       // turns only; they can safely resume this thread through the stable driver.
       appServerDisabled = true
       appServerThreadReady = false
+      closeAppServerTurn(activeTurnId)
       try { appServer?.end() } catch { /* noop */ }
       appServer = null
       if (!ended) pushMappedEvent({ type: 'turn.failed', message: `codex app-server turn failed: ${error?.message || error}` })
@@ -625,10 +659,12 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
       activeTurnId = started?.turn?.id || started?.turnId
       if (!activeTurnId) throw new Error('Codex review/start returned no turn id')
       if (aborted || ended) {
+        closeAppServerTurn(activeTurnId)
         try { await appServer.interrupt({ threadId: sessionId, turnId: activeTurnId }) } catch { /* boundary is already closed */ }
         return true
       }
       const completed = await appServer.waitForTurn(activeTurnId)
+      closeAppServerTurn(completed?.turn?.id || activeTurnId)
       const status = completed?.turn?.status
       if (aborted || status === 'interrupted') {
         emitTurnBoundary({ kind: 'result', subtype: 'aborted', sessionId, model: activeModel, costUsd: null, usage: null, numTurns: 1, durationMs: completed?.turn?.durationMs, denials: 0, resultText: null })
@@ -640,6 +676,7 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
     } catch (error) {
       appServerDisabled = true
       appServerThreadReady = false
+      closeAppServerTurn(activeTurnId)
       try { appServer?.end() } catch { /* noop */ }
       appServer = null
       if (!ended) pushMappedEvent({ type: 'turn.failed', message: `codex review failed: ${error?.message || error}` })
@@ -834,6 +871,7 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
       const bootstrapOnly = turnActive && !activeTurnId && !child
       aborted = true
       queue.length = 0
+      closeAppServerTurn(activeTurnId)
       if (appServer && activeTurnId) { void appServer.interrupt({ threadId: sessionId, turnId: activeTurnId }).catch(() => {}) ; return }
       if (child) { try { child.kill('SIGTERM') } catch { /* noop */ } ; setTimeout(() => { try { child?.kill('SIGKILL') } catch { /* noop */ } }, 1500) }
       else if (bootstrapOnly) {
@@ -847,6 +885,7 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
       ended = true
       turnActive = false
       queue.length = 0
+      closeAppServerTurn(activeTurnId)
       if (child) { try { child.kill() } catch { /* noop */ } }
       try { appServer?.end() } catch { /* noop */ }
       void mcpHttpPromise?.then((h) => h.close()).catch(() => {})

package/package.json

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

package/pair-control-authority.mjs

@@ -34,6 +34,15 @@ export function verifyPairControlDeliveryAuthority ({ item, attempts, payload, r
     event?.actor_id === item.resolved_by && Number(event.item_version) === Number(item.version) &&
     event.correlation_key === payload.attemptKey && event.payload?.data?.transport === 'code-perm') : []
   if (matching.length !== 1) return denied('delivery_attempt_unverified')
+  const durableResponder = resolution.responder
+  const responder = durableResponder && durableResponder.id === item.resolved_by
+    ? {
+        id: item.resolved_by,
+        name: typeof durableResponder.name === 'string' && durableResponder.name.trim()
+          ? durableResponder.name.trim().slice(0, 120)
+          : null,
+      }
+    : { id: item.resolved_by, name: null }
   return Object.freeze({
     ok: true,
     code: 'durable_delivery_authorized',
@@ -41,6 +50,7 @@ export function verifyPairControlDeliveryAuthority ({ item, attempts, payload, r
     // App Server input is recovered from the durable resolution only. The public
     // broadcast intentionally remains a wake-up hint and cannot supply answers.
     answers: resolution.answers && typeof resolution.answers === 'object' ? resolution.answers : {},
+    responder: Object.freeze(responder),
     itemId: item.id,
     version: Number(item.version),
     attemptKey: payload.attemptKey,

package/question-response.mjs

@@ -38,9 +38,15 @@ export function questionAnswerResponse (result, questions = []) {
       if (values.length) answers[String(id)] = { answers: values }
     }
   }
-  if (Object.keys(answers).length) return { answers }
+  const responder = result?.responder && typeof result.responder === 'object'
+    ? {
+        id: typeof result.responder.id === 'string' ? result.responder.id : null,
+        name: typeof result.responder.name === 'string' ? result.responder.name : null,
+      }
+    : null
+  if (Object.keys(answers).length) return { answers, ...(responder ? { responder } : {}) }
   const decision = result && typeof result === 'object' ? result.decision : result
-  return { answers: legacyQuestionAnswers(decision, questions) }
+  return { answers: legacyQuestionAnswers(decision, questions), ...(responder ? { responder } : {}) }
 }
 
 export function hermesUserInputResponse (result, questions = []) {

package/thinkpool-capabilities.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "bundleVersion": 5,
+  "bundleVersion": 6,
   "contracts": [
     {
       "id": "room-coordination",
@@ -65,7 +65,7 @@
     },
     {
       "id": "room-question",
-      "version": 1,
+      "version": 2,
       "routes": [
         {
           "id": "room-question",
@@ -74,6 +74,7 @@
           "prompt": "When a missing choice genuinely blocks useful progress, use request_user_input so the question is answerable in the room; otherwise make a safe in-scope assumption and continue."
         }
       ],
+      "resultContract": "A resolved room question returns the selected answers plus the durable responder identity {id, name}; the id must match the pair-control row's resolved_by authority.",
       "impact": [
         {"path": "bridge/bridge.mjs", "diffPattern": "request_user_input"},
         {"path": "bridge/claude-session.mjs", "diffPattern": "AskUserQuestion|request_user_input"},