thinkpool-pair 0.7.251 → 0.7.252

package/bridge.mjs

@@ -3833,8 +3833,17 @@ channel
     const nativeImages = s.runtime === 'codex' || s.runtime === 'hermes'
       ? await waitForNativeImages(payload.files, { updir: UPDIR })
       : []
-    s.session.sendTurn(sendText, nativeImages.length ? { images: nativeImages } : undefined)
+    const accepted = s.session.sendTurn(sendText, nativeImages.length ? { images: nativeImages } : undefined)
     echoYou()
+    if (accepted === false) {
+      // A runtime that did not accept a turn must still close the optimistic
+      // user-line lifecycle. Without this boundary the client truthfully shows
+      // what the person sent but falsely leaves Thinking/Stop pinned forever.
+      const evt = { kind: 'error', message: `${structuredRuntimeMetadata(s.runtime)?.label || 'Agent'} did not accept this turn; retry after the lane is available.`, recoverable: true }
+      pushLog(s, evt)
+      bcast('code-event', { term: payload.term, evt })
+    }
+    announce()
     // Pool-order fix (2026-07-02): emit the "dispatched to agent" marker HERE, right after
     // the @pool you-line, so it inherits the NEXT seq (seqable('pool') is true) and orders
     // correctly for EVERY viewer. It used to be pushed web-side with the FIRER's wall-clock

package/hermes-session.mjs

@@ -13,6 +13,7 @@ import { classifyRisk } from './claude-session.mjs'
 export const HERMES_COMMAND = 'thinkpool'
 export const HERMES_ACP_PROTOCOL_VERSION = 1
 export const HERMES_SUPPORTED_MODES = new Set(['default', 'acceptEdits'])
+const HERMES_INITIALIZE_TIMEOUT_MS = 15_000
 
 const HERMES_SECRET_ENV_KEY = /(?:TOKEN|SECRET|PASSWORD|PRIVATE_KEY|API_KEY|ACCESS_KEY|CREDENTIAL)/i
 const HERMES_REPLAY_UPDATES = new Set(['agent_message_chunk', 'agent_thought_chunk', 'tool_call', 'tool_call_update', 'plan'])
@@ -69,6 +70,7 @@ export function startHermesSession({
   let resuming = false
   let inventoryProbe = null
   let modelSwitchPending = false
+  let bootCancelled = false
   const policyRole = hermesRole || hermesRoleFor({})
 
   const emit = (event) => { try { onEvent?.(event) } catch { /* consumer isolation */ } }
@@ -177,24 +179,45 @@ export function startHermesSession({
       }
       let retired = false
       retireClient = () => { retired = true }
-      client = clientFactory({
-        command: launchCommand, args: launchArgs, cwd: activeCwd, env: childEnv,
-        onNotification,
-        onRequest,
-        onStderr: (text) => { stderrTail = (stderrTail + text).slice(-2000) },
-        onClose: (error) => {
-          if (ended || crashed || retired) return
-          crashed = true
-          turnActive = false
-          emit({ kind: 'error', message: `Hermes ACP closed unexpectedly: ${error?.message || error}`, recoverable: true })
-        },
-      })
-      client.start()
-      const initialized = await client.request('initialize', {
+      const initializeParams = {
         protocolVersion: HERMES_ACP_PROTOCOL_VERSION,
         clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false },
         clientInfo: { name: 'thinkpool-pair', title: 'ThinkPool Code', version: '1' },
-      })
+      }
+      let initialized
+      // Cold Hermes imports take 6–9 seconds on the supported host, and the
+      // production ENOSPC incident pushed one child just beyond the old 10s
+      // cliff. Initialization is pre-session and pre-inference, so one fresh
+      // process retry is safe: no prompt or tool can have executed yet.
+      for (let attempt = 0; attempt < 2; attempt++) {
+        retired = false
+        retireClient = () => { retired = true }
+        client = clientFactory({
+          command: launchCommand, args: launchArgs, cwd: activeCwd, env: childEnv,
+          onNotification,
+          onRequest,
+          onStderr: (text) => { stderrTail = (stderrTail + text).slice(-2000) },
+          onClose: (error) => {
+            if (ended || crashed || retired) return
+            crashed = true
+            turnActive = false
+            emit({ kind: 'error', message: `Hermes ACP closed unexpectedly: ${error?.message || error}`, recoverable: true })
+          },
+        })
+        client.start()
+        try {
+          initialized = await client.request('initialize', initializeParams, HERMES_INITIALIZE_TIMEOUT_MS)
+          break
+        } catch (error) {
+          const retryable = !bootCancelled && attempt === 0 && /^initialize timed out\b/i.test(String(error?.message || error))
+          if (!retryable) throw error
+          retireClient()
+          const timedOutClient = client
+          client = null
+          timedOutClient?.end()
+          stderrTail = ''
+        }
+      }
       if (initialized?.protocolVersion !== HERMES_ACP_PROTOCOL_VERSION) {
         throw new Error(`Unsupported Hermes ACP protocol ${initialized?.protocolVersion ?? 'unknown'}; expected ${HERMES_ACP_PROTOCOL_VERSION}`)
       }
@@ -255,16 +278,32 @@ export function startHermesSession({
         await client.request('session/set_mode', { sessionId, modeId: acpMode })
       }
       emit({ kind: 'capabilities', runtime: 'hermes', protocol: 'acp', protocolVersion: initialized?.protocolVersion, capabilities: initialized?.agentCapabilities || {}, models: modelList(state?.models), flow: command === HERMES_COMMAND && clientFactory === createAcpClient })
-    })().catch((error) => {
+    })().catch(async (error) => {
       crashed = true
       client?.end()
-      void mcpHttp?.close().catch(() => {})
-      emit({ kind: 'error', message: `Hermes ACP startup failed: ${error?.message || error}${stderrTail ? `: ${stderrTail.trim().slice(-240)}` : ''}`, recoverable: true })
+      try { await mcpHttp?.close() } catch { /* startup cleanup */ }
+      mcpHttp = null
+      if (!bootCancelled) emit({ kind: 'error', message: `Hermes ACP startup failed: ${error?.message || error}${stderrTail ? `: ${stderrTail.trim().slice(-240)}` : ''}`, recoverable: true })
       throw error
-    }).finally(() => { starting = null })
+    }).finally(() => { starting = null; bootCancelled = false })
     return starting
   }
 
+  function reviveAfterExplicitRetry() {
+    if (!crashed || ended) return
+    retireClient()
+    client?.end()
+    client = null
+    mapper = null
+    crashed = false
+    stderrTail = ''
+  }
+
+  function finishAbortedTurn() {
+    if (mapper) mapper.finishTurn({ stopReason: 'cancelled' })
+    else emit({ kind: 'result', subtype: 'aborted', sessionId, model: activeModel, costUsd: null, usage: null, numTurns: 1, durationMs: undefined, denials: 0, resultText: null })
+  }
+
   async function restartAfterCancelledResponseFailure() {
     const oldClient = client
     retireClient()
@@ -288,12 +327,14 @@ export function startHermesSession({
     return blocks
   }
 
-  async function runPrompt(text, options = {}) {
-    await boot()
-    const steering = turnActive
-    const turnId = steering ? activeTurnId : ++activeTurnId
+  async function runPrompt(text, options = {}, { steering = false, turnId = activeTurnId } = {}) {
+    try { await boot() }
+    catch (error) {
+      if (abortedTurns.has(turnId)) return { stopReason: 'cancelled' }
+      throw error
+    }
+    if (abortedTurns.has(turnId)) return { stopReason: 'cancelled' }
     const body = steering ? `/steer ${String(text)}` : String(text)
-    if (!steering) turnActive = true
     let result
     try {
       result = await client.request('session/prompt', {
@@ -334,17 +375,29 @@ export function startHermesSession({
     get started() { return started },
     get models() { return [] },
     sendTurn(text, options = {}) {
-      if (ended || crashed) return false
+      if (ended) return false
+      // A crash never replays work by itself. A later explicit turn is the
+      // authority to launch a fresh ACP process and resume the same native
+      // session id; this is the recovery path the old permanent latch blocked.
+      reviveAfterExplicitRetry()
       // A busy prompt is a genuine ACP /steer call and may run concurrently.
-      if (turnActive) { void runPrompt(text, options).catch((error) => emit({ kind: 'error', message: `Hermes steering failed: ${error?.message || error}`, recoverable: true })); return true }
-      promptChain = promptChain.then(() => runPrompt(text, options)).catch((error) => {
+      if (turnActive) {
+        const turnId = activeTurnId
+        void runPrompt(text, options, { steering: true, turnId }).catch((error) => emit({ kind: 'error', message: `Hermes steering failed: ${error?.message || error}`, recoverable: true }))
+        return true
+      }
+      const turnId = ++activeTurnId
+      // Claim the turn synchronously, before the cold safety probe/import. The
+      // room can now show Thinking + Stop for the whole accepted lifecycle.
+      turnActive = true
+      promptChain = promptChain.then(() => runPrompt(text, options, { steering: false, turnId })).catch((error) => {
         turnActive = false
         emit({ kind: 'error', message: `Hermes turn failed: ${error?.message || error}`, recoverable: true })
       })
       return true
     },
     abort() {
-      if (!sessionId || !client?.alive || !turnActive) return
+      if (!turnActive) return
       const turnId = activeTurnId
       abortedTurns.add(turnId)
       // Bound retained turn ids while preserving any concurrent /steer request
@@ -352,7 +405,18 @@ export function startHermesSession({
       if (abortedTurns.size > 32) abortedTurns.delete(abortedTurns.values().next().value)
       turnActive = false
       firstTurn = false
-      mapper?.finishTurn({ stopReason: 'cancelled' })
+      if (starting) {
+        bootCancelled = true
+        retireClient()
+        client?.end()
+        finishAbortedTurn()
+        return
+      }
+      if (!sessionId || !client?.alive) {
+        finishAbortedTurn()
+        return
+      }
+      finishAbortedTurn()
       void client.notify('session/cancel', { sessionId }).catch((error) => {
         // Never display a stopped lane while the un-cancelled Hermes process
         // might still be executing. A transport failure tears down the ACP

package/package.json

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