thinkpool-pair 0.7.255 → 0.7.257

package/bridge.mjs

@@ -2103,6 +2103,43 @@ function openStructured({ id, runtime = 'claude', model, models, effort, resume,
     entry.spawnTimes = [...(entry.spawnTimes || []).filter((t) => Number.isFinite(t) && t > now - SPAWN.windowMs), now]
     return gate
   }
+  const requestRoomDecision = (req) => new Promise((resolve) => {
+    // FLOW conductor plan → intercept (no generic card). The plan JSON rides
+    // ExitPlanMode's `plan` arg. Broadcast to the room; its useFlow persists the
+    // 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 || '' }, flowChannel)
+      process.stderr.write(`\n  ${A.mag}◆ flow plan ready — flow ${String(entry.flowSessionId).slice(0, 8)}.${A.rst}\n`)
+      resolve('keep')
+      return
+    }
+    // Keep the broadcast payload with the resolver so a reconnect can re-send it
+    // (replay-request handler) — pending cards never enter the replayed event log.
+    const payload = attachDurablePermissionSource(entry, { term: id, id: req.id, toolName: req.toolName, input: req.input, risk: req.risk, plan: req.plan, questions: req.questions, asker: req.asker, answerFormat: req.answerFormat, autoResolutionMs: req.autoResolutionMs })
+    const pending = { resolve, payload, timer: null }
+    entry.pending.set(req.id, pending)
+    announce()
+    bcast('code-perm-req', payload)
+    if (isUserFacingLane(entry)) entry.permNotifier?.arm(req.id, permissionSummary(payload))
+    process.stderr.write(req.risk === 'plan'
+      ? `\n  ${A.mag}◆ plan ready — approve in the room.${A.rst}\n`
+      : req.risk === 'ask'
+        ? `\n  ${A.cyan}● ${req.asker || structuredRuntimeMetadata(runtime)?.label || 'Agent'} is asking: ${(req.questions || []).map((q) => q.question).join(' / ').slice(0, 100)} — answer in the room.${A.rst}\n`
+        : `\n  ${A.yel}● permission: ${req.toolName}${argStr(req.input)} — approve in the room.${A.rst}\n`)
+    const autoResolutionMs = Number(req.autoResolutionMs)
+    if (req.risk === 'ask' && Number.isFinite(autoResolutionMs) && autoResolutionMs > 0) {
+      pending.timer = setTimeout(() => {
+        if (entry.pending.get(req.id) !== pending) return
+        entry.pending.delete(req.id)
+        entry.permNotifier?.resolve(req.id)
+        bcast('code-perm', { term: id, id: req.id, decision: 'timeout', name: req.asker || 'agent' })
+        try { resolve(pendingResolution(pending, { decision: 'timeout', answers: {} })) } catch { /* noop */ }
+        announce()
+      }, autoResolutionMs)
+      pending.timer.unref?.()
+    }
+  })
   // B2 cross-terminal peek — an in-process, READ-ONLY tool the agent can call to
   // see a SIBLING terminal's recent output (vs B1's always-on @pool digest). The
   // handler closes over the module-scope `sessions`/`terms` Maps + this session's
@@ -2113,6 +2150,41 @@ function openStructured({ id, runtime = 'claude', model, models, effort, resume,
     name: 'thinkpool',
     version: '1.0.0',
     tools: [
+      ...(runtime === 'hermes' && hermesRoleFor({ flowRole: entry.flowRole, sliceType: entry.sliceType }) === 'ordinary' ? [tool(
+        'request_user_input',
+        'Ask the people in this ThinkPool room one to three multiple-choice questions and wait for their answer. Use this for choices that genuinely block useful progress. Each question needs two or three mutually exclusive options; a free-text answer remains available in the room card.',
+        {
+          questions: z.array(z.object({
+            id: z.string().min(1).max(80),
+            header: z.string().min(1).max(12),
+            question: z.string().min(1).max(500),
+            options: z.array(z.object({
+              label: z.string().min(1).max(80),
+              description: z.string().min(1).max(240),
+            })).min(2).max(3),
+            multiSelect: z.boolean().optional(),
+            isSecret: z.boolean().optional(),
+          })).min(1).max(3),
+          autoResolutionMs: z.number().int().min(60_000).max(240_000).optional(),
+        },
+        async (args) => {
+          const questions = args.questions.map((question) => ({ ...question, options: question.options.map((option) => ({ ...option })) }))
+          const result = await requestRoomDecision({
+            id: `hermes-question:${randomUUID()}`,
+            toolName: 'AskUserQuestion',
+            input: { questions },
+            risk: 'ask',
+            questions,
+            asker: 'Hermes',
+            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 }) }] }
+        },
+      )] : []),
       ...createViewportTools({ tool, z, manager: entry.viewport }),
       tool(
         'read_terminal',
@@ -2963,49 +3035,7 @@ function openStructured({ id, runtime = 'claude', model, models, effort, resume,
       const imgs = inlineImageBlocks(evt)
       deferImageEvent(entry, id, evt, imgs, emitTail)
     },
-    requestPermission: (req) => new Promise((resolve) => {
-      // FLOW conductor plan → intercept (no generic card). The plan JSON rides
-      // ExitPlanMode's `plan` arg. Broadcast to the room; its useFlow persists the
-      // 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 || '' }, flowChannel)
-        process.stderr.write(`\n  ${A.mag}◆ flow plan ready — flow ${String(entry.flowSessionId).slice(0, 8)}.${A.rst}\n`)
-        resolve('keep')
-        return
-      }
-      // Keep the broadcast payload with the resolver so a reconnect can re-send it
-      // (replay-request handler) — pending cards never enter the replayed event log.
-      const payload = attachDurablePermissionSource(entry, { term: id, id: req.id, toolName: req.toolName, input: req.input, risk: req.risk, plan: req.plan, questions: req.questions, asker: req.asker, answerFormat: req.answerFormat, autoResolutionMs: req.autoResolutionMs })
-      const pending = { resolve, payload, timer: null }
-      entry.pending.set(req.id, pending)
-      announce()
-      bcast('code-perm-req', payload)
-      // Slice 3 — arm the grace timer. Fires a "needs you" push only if the card is
-      // STILL unanswered 20s from now (you're not in the room). Every resolve path —
-      // the code-perm broadcast, drainPending, and the bypass/acceptEdits mode-flip
-      // auto-approvals — calls permNotifier.resolve(id), which retracts the banner
-      // if it had fired. Worker + flow-slice lanes are skipped: their cards belong to
-      // an agent's fan-out, and a 12-lane flow would fan 12 banners at one person.
-      if (isUserFacingLane(entry)) entry.permNotifier?.arm(req.id, permissionSummary(payload))
-      process.stderr.write(req.risk === 'plan'
-        ? `\n  ${A.mag}◆ plan ready — approve in the room.${A.rst}\n`
-        : req.risk === 'ask'
-          ? `\n  ${A.cyan}● ${req.asker || structuredRuntimeMetadata(runtime)?.label || 'Agent'} is asking: ${(req.questions || []).map((q) => q.question).join(' / ').slice(0, 100)} — answer in the room.${A.rst}\n`
-          : `\n  ${A.yel}● permission: ${req.toolName}${argStr(req.input)} — approve in the room.${A.rst}\n`)
-      const autoResolutionMs = Number(req.autoResolutionMs)
-      if (req.risk === 'ask' && Number.isFinite(autoResolutionMs) && autoResolutionMs > 0) {
-        pending.timer = setTimeout(() => {
-          if (entry.pending.get(req.id) !== pending) return
-          entry.pending.delete(req.id)
-          entry.permNotifier?.resolve(req.id)
-          bcast('code-perm', { term: id, id: req.id, decision: 'timeout', name: req.asker || 'agent' })
-          try { resolve(pendingResolution(pending, { decision: 'timeout', answers: {} })) } catch { /* noop */ }
-          announce()
-        }, autoResolutionMs)
-        pending.timer.unref?.()
-      }
-    }),
+    requestPermission: requestRoomDecision,
   })
   // A restored Codex lane may have a stale pre-0.7.206 meter persisted from the
   // cumulative `turn.completed` bug. Replace it synchronously from the native
@@ -3043,7 +3073,7 @@ 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 === 'codex' || pending?.payload?.answerFormat === 'hermes')
     ? { decision, answers: payload.answers || {} }
     : decision
 }

package/hermes-acp-bootstrap.py

@@ -145,6 +145,57 @@ def constrained_expand(toolsets_arg=None, mcp_server_names=None):
 acp_adapter.session._expand_acp_enabled_toolsets = constrained_expand
 
 import acp_adapter.server
+
+# Hermes 0.18.2 emits the real result through ``tool.completed`` immediately,
+# but its ACP callback ignores that event and waits for the next model-step
+# summary.  Parallel Read/search calls are not always present in that summary,
+# leaving clients with a ToolCallStart and no ToolCallUpdate forever.  Complete
+# from the authoritative execution callback and consume the same per-name FIFO;
+# the later step callback then sees an empty queue and cannot double-emit.  If a
+# future Hermes release handles completion itself, it consumes the queue before
+# this wrapper runs and this compatibility branch becomes a no-op.
+from collections import deque
+import acp_adapter.events
+import acp_adapter.tools
+
+_tool_progress_factory = acp_adapter.server.make_tool_progress_cb
+def completion_aware_tool_progress_factory(
+    conn, session_id, loop, tool_call_ids, tool_call_meta,
+    edit_approval_policy_getter=None,
+):
+    upstream = _tool_progress_factory(
+        conn, session_id, loop, tool_call_ids, tool_call_meta,
+        edit_approval_policy_getter=edit_approval_policy_getter,
+    )
+
+    def progress(event_type, name=None, preview=None, args=None, **kwargs):
+        upstream(event_type, name, preview, args, **kwargs)
+        if event_type != "tool.completed" or not name:
+            return
+        queue = tool_call_ids.get(name)
+        if isinstance(queue, str):
+            queue = deque([queue])
+            tool_call_ids[name] = queue
+        if not queue:
+            return
+        tool_call_id = queue.popleft()
+        meta = tool_call_meta.pop(tool_call_id, {})
+        result = kwargs.get("result")
+        update = acp_adapter.tools.build_tool_complete(
+            tool_call_id,
+            name,
+            result=str(result) if result is not None else None,
+            function_args=meta.get("args"),
+            snapshot=meta.get("snapshot"),
+        )
+        acp_adapter.events._send_update(conn, session_id, loop, update)
+        if not queue:
+            tool_call_ids.pop(name, None)
+
+    return progress
+
+acp_adapter.server.make_tool_progress_cb = completion_aware_tool_progress_factory
+
 _register = acp_adapter.server.HermesACPAgent._register_session_mcp_servers
 async def constrained_register(self, state, mcp_servers):
     if any(getattr(server, "name", None) != "thinkpool" for server in (mcp_servers or [])):

package/hermes-event-mapper.mjs

@@ -128,16 +128,17 @@ export class HermesEventMapper {
   }
 
   finishTurn({ stopReason = 'end_turn', usage = null } = {}) {
-    if (stopReason === 'cancelled') {
-      for (const [toolCallId, tool] of this.tools) {
-        this._emit({
-          kind: 'tool_result', toolUseId: toolCallId,
-          content: [{ type: 'text', text: '[cancelled]' }],
-          isError: false,
-          durationMs: tool.startedAt ? Date.now() - tool.startedAt : undefined,
-          parentToolUseId: null,
-        })
-      }
+    for (const [toolCallId, tool] of this.tools) {
+      const cancelled = stopReason === 'cancelled'
+      this._emit({
+        kind: 'tool_result', toolUseId: toolCallId,
+        content: [{ type: 'text', text: cancelled ? '[cancelled]' : 'Hermes ended the turn without reporting this tool result.' }],
+        toolInput: tool.input || undefined,
+        isError: !cancelled && stopReason !== 'end_turn',
+        missing: !cancelled,
+        durationMs: tool.startedAt ? Date.now() - tool.startedAt : undefined,
+        parentToolUseId: null,
+      })
     }
     this.tools.clear()
     const blocks = []

package/hermes-policy.mjs

@@ -3,6 +3,7 @@
 import { PEER_MCP_TOOLS, PEER_READ_MCP_TOOLS } from './cross-terminal.mjs'
 
 export const HERMES_POLICY_VERSION = 1
+export const HERMES_QUESTION_MCP_TOOL = 'request_user_input'
 
 export const CODING_TOOLS = Object.freeze([
   'web_search', 'web_extract', 'terminal', 'process', 'read_file', 'write_file',
@@ -22,7 +23,7 @@ export const ESSENTIAL_CODING_TOOLS = Object.freeze([
   'terminal', 'process', 'read_file', 'write_file', 'patch', 'search_files',
 ])
 const ROLE_REQUIRED = Object.freeze({
-  ordinary: [...PEER_MCP_TOOLS, 'spawn_terminal', 'close_terminal'],
+  ordinary: [...PEER_MCP_TOOLS, HERMES_QUESTION_MCP_TOOL, 'spawn_terminal', 'close_terminal'],
   plan: [],
   conductor: ['submit_flow_plan'],
   builder: ['mark_flow_done'],
@@ -45,7 +46,7 @@ export function hermesPolicyForRole(role, { mcpTools } = {}) {
   // Ordinary worker leaves deliberately lack spawn/close. Main-lane proof is
   // enforced by requiredMcpTools at dispatch; keep this schema usable for a
   // non-delegating ordinary child without widening it.
-  const minimum = role === 'ordinary' ? PEER_MCP_TOOLS : required
+  const minimum = role === 'ordinary' ? [...PEER_MCP_TOOLS, HERMES_QUESTION_MCP_TOOL] : required
   for (const tool of minimum) if (!supplied.includes(tool)) throw new Error(`Hermes ${role} policy is missing required ThinkPool tool ${tool}`)
   const restricted = role === 'plan' || role === 'conductor' || role === 'reviewer' || role === 'manual-review'
   const builtinTools = restricted ? READ_ONLY_TOOLS : CODING_TOOLS
@@ -63,7 +64,7 @@ export function hermesPolicyForRole(role, { mcpTools } = {}) {
 }
 
 export function hermesRequiredMcpTools(role, { canSpawnWorkers = false } = {}) {
-  if (role === 'ordinary') return [...PEER_MCP_TOOLS, ...(canSpawnWorkers ? ['spawn_terminal', 'close_terminal'] : [])]
+  if (role === 'ordinary') return [...PEER_MCP_TOOLS, HERMES_QUESTION_MCP_TOOL, ...(canSpawnWorkers ? ['spawn_terminal', 'close_terminal'] : [])]
   return [...ROLE_REQUIRED[role]]
 }
 

package/hermes-session.mjs

@@ -6,7 +6,7 @@ import { randomUUID } from 'node:crypto'
 import { AcpClient } from './acp-client.mjs'
 import { HermesEventMapper, hermesToolFor } from './hermes-event-mapper.mjs'
 import { probeHermesRuntime } from './hermes-probe.mjs'
-import { HERMES_PLAN_SAFE_MCP_TOOLS, hermesExactInventory, hermesPolicyEnv, hermesRoleFor } from './hermes-policy.mjs'
+import { HERMES_PLAN_SAFE_MCP_TOOLS, HERMES_QUESTION_MCP_TOOL, hermesExactInventory, hermesPolicyEnv, hermesRoleFor } from './hermes-policy.mjs'
 import { startCodexMcpHttp } from './codex-mcp-http.mjs'
 import { autoAllow, classifyRisk } from './claude-session.mjs'
 import { crossPostNeedsCard } from './cross-terminal.mjs'
@@ -91,7 +91,7 @@ export function startHermesSession({
 
   const thinkpoolPeerTool = (name) => {
     const lower = String(name || '').toLowerCase()
-    return [...HERMES_PLAN_SAFE_MCP_TOOLS, 'post_to_terminal', 'post_to_session']
+    return [...HERMES_PLAN_SAFE_MCP_TOOLS, 'post_to_terminal', 'post_to_session', HERMES_QUESTION_MCP_TOOL]
       .find((candidate) => lower === candidate || lower === `mcp__thinkpool__${candidate}` || lower === `mcp_thinkpool_${candidate}`) || null
   }
 
@@ -117,6 +117,11 @@ export function startHermesSession({
     if (HERMES_PLAN_SAFE_MCP_TOOLS.includes(peerTool)) {
       return { outcome: permissionOutcome('allow', params.options) }
     }
+    // The question tool creates its own durable human-input card. Requiring a
+    // permission card before it can create that card deadlocks the interaction.
+    if (peerTool === HERMES_QUESTION_MCP_TOOL) {
+      return { outcome: permissionOutcome('allow', params.options) }
+    }
     if (peerTool === 'post_to_terminal') {
       const gate = crossPostGate ? crossPostGate() : { ok: true }
       if (!gate.ok) return { outcome: { outcome: 'cancelled' } }

package/package.json

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