thinkpool-pair 0.7.235 → 0.7.236

package/hermes-event-mapper.mjs

@@ -109,6 +109,18 @@ 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,
+        })
+      }
+    }
+    this.tools.clear()
     const blocks = []
     if (this.thought) blocks.push({ type: 'thinking', text: this.thought })
     if (this.text) blocks.push({ type: 'text', text: this.text })

package/hermes-probe.mjs

@@ -8,11 +8,14 @@ export function probeHermesRuntime({ command = 'thinkpool', prefixArgs = [], exe
     const version = clean(versionOutput).match(/Hermes Agent v([^\s]+)/i)?.[1] || null
     execFile(command, [...prefixArgs, 'acp', '--check'], { encoding: 'utf8', env, timeout: 15_000, stdio: ['ignore', 'pipe', 'pipe'] })
     const hooksOutput = execFile(command, [...prefixArgs, 'hooks', 'list'], { encoding: 'utf8', env, timeout: 10_000, stdio: ['ignore', 'pipe', 'pipe'] })
+    const doctorOutput = execFile(command, [...prefixArgs, 'hooks', 'doctor'], { encoding: 'utf8', env, timeout: 10_000, stdio: ['ignore', 'pipe', 'pipe'] })
     const guardOutput = execFile(command, [...prefixArgs, 'hooks', 'test', 'pre_tool_call', '--for-tool', 'delegate_task'], { encoding: 'utf8', env, timeout: 10_000, stdio: ['ignore', 'pipe', 'pipe'] })
+    const doctorHealthy = /All shell hooks look healthy/i.test(doctorOutput)
+      && !/(?:issue\(s\) found|modified since approval|⚠)/i.test(doctorOutput)
     const delegationBlocked = /(?:action|decision)["']?\s*[:=]\s*["']block/i.test(guardOutput)
       && /ThinkPool blocks hidden Hermes delegation/i.test(guardOutput)
       && /pre_tool_call[\s\S]*delegate_task[\s\S]*(?:✓ allowed|allowed)/i.test(hooksOutput)
-    if (!delegationBlocked) return { available: false, version, reason: 'delegate_task is not structurally blocked by the dedicated Hermes profile' }
+    if (!doctorHealthy || !delegationBlocked) return { available: false, version, reason: 'delegate_task guard is not healthy, unchanged, allowlisted, and structurally blocking in the dedicated Hermes profile' }
     return { available: true, version, acpProtocol: 1, delegationBlocked: true }
   } catch (error) {
     return { available: false, version: null, reason: clean(error?.stderr || error?.message || error) }

package/hermes-session.mjs

@@ -14,6 +14,7 @@ export const HERMES_ACP_PROTOCOL_VERSION = 1
 export const HERMES_SUPPORTED_MODES = new Set(['default', 'acceptEdits'])
 
 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'])
 export const hermesChildEnv = (env = {}) => Object.fromEntries(
   Object.entries(env).filter(([key]) => !HERMES_SECRET_ENV_KEY.test(key)),
 )
@@ -61,6 +62,10 @@ export function startHermesSession({
   let firstTurn = true
   let stderrTail = ''
   let promptChain = Promise.resolve()
+  let activeTurnId = 0
+  const abortedTurns = new Set()
+  let retireClient = () => {}
+  let resuming = false
 
   const emit = (event) => { try { onEvent?.(event) } catch { /* consumer isolation */ } }
 
@@ -79,7 +84,10 @@ export function startHermesSession({
   }
 
   function onNotification(method, params) {
-    if (method === 'session/update') mapper?.push(params)
+    if (method !== 'session/update') return
+    const update = params?.update || params
+    if (resuming && HERMES_REPLAY_UPDATES.has(update?.sessionUpdate)) return
+    mapper?.push(params)
   }
 
   async function boot() {
@@ -101,13 +109,15 @@ export function startHermesSession({
         const profile = probeHermesRuntime({ command, env: childEnv })
         if (!profile.available) throw new Error(`Hermes profile safety check failed: ${profile.reason || 'runtime unavailable'}`)
       }
+      let retired = false
+      retireClient = () => { retired = true }
       client = clientFactory({
         command, args, cwd: activeCwd, env: childEnv,
         onNotification,
         onRequest,
         onStderr: (text) => { stderrTail = (stderrTail + text).slice(-2000) },
         onClose: (error) => {
-          if (ended || crashed) return
+          if (ended || crashed || retired) return
           crashed = true
           turnActive = false
           emit({ kind: 'error', message: `Hermes ACP closed unexpectedly: ${error?.message || error}`, recoverable: true })
@@ -129,10 +139,14 @@ export function startHermesSession({
         if (!initialized?.agentCapabilities?.sessionCapabilities?.resume) {
           throw new Error(`Hermes session ${sessionId} cannot be resumed by this ACP release; no fresh session was substituted`)
         }
-        try { state = await client.request('session/resume', { ...params, sessionId }, 30_000) }
+        try {
+          resuming = true
+          state = await client.request('session/resume', { ...params, sessionId }, 30_000)
+        }
         catch (error) {
           throw new Error(`Hermes session ${sessionId} is not available; no fresh session was substituted (${error?.message || error})`)
         }
+        finally { resuming = false }
       } else state = await client.request('session/new', params, 30_000)
       if (!sessionId) sessionId = state?.sessionId || null
       if (!sessionId) throw new Error('Hermes ACP did not return a session id')
@@ -158,6 +172,15 @@ export function startHermesSession({
     return starting
   }
 
+  async function restartAfterCancelledResponseFailure() {
+    const oldClient = client
+    retireClient()
+    client = null
+    mapper = null
+    oldClient?.end()
+    await boot()
+  }
+
   function promptBlocks(text, options = {}) {
     const rawText = String(text)
     // Hermes handles /steer, /queue, /compact and /reset only when the slash is
@@ -175,14 +198,33 @@ export function startHermesSession({
   async function runPrompt(text, options = {}) {
     await boot()
     const steering = turnActive
+    const turnId = steering ? activeTurnId : ++activeTurnId
     const body = steering ? `/steer ${String(text)}` : String(text)
     if (!steering) turnActive = true
-    const result = await client.request('session/prompt', {
-      sessionId,
-      prompt: promptBlocks(body, options),
-      messageId: randomUUID(),
-    }, 0)
+    let result
+    try {
+      result = await client.request('session/prompt', {
+        sessionId,
+        prompt: promptBlocks(body, options),
+        messageId: randomUUID(),
+      }, 0)
+    } catch (error) {
+      // Hermes 0.18.2 successfully interrupts the model/tool, then its ACP
+      // prompt handler can reject with Internal error while constructing the
+      // cancelled response. The bridge already owns the canonical aborted
+      // boundary below, so a late response failure for that exact turn is not a
+      // second turn failure. Process-close errors still surface through onClose.
+      if (abortedTurns.has(turnId)) {
+        // Hermes 0.18.2 throws before clearing its transient is_running flag.
+        // Resume the same persisted session in a fresh per-lane ACP process so
+        // the next queued prompt cannot disappear into that stale runtime queue.
+        if (!ended) await restartAfterCancelledResponseFailure()
+        return { stopReason: 'cancelled' }
+      }
+      throw error
+    }
     if (!steering) {
+      if (abortedTurns.has(turnId)) return result
       turnActive = false
       firstTurn = false
       mapper.finishTurn({ stopReason: result?.stopReason, usage: result?.usage })
@@ -209,8 +251,23 @@ export function startHermesSession({
       return true
     },
     abort() {
-      if (!sessionId || !client?.alive) return
-      void client.notify('session/cancel', { sessionId }).catch(() => { /* process already closed */ })
+      if (!sessionId || !client?.alive || !turnActive) return
+      const turnId = activeTurnId
+      abortedTurns.add(turnId)
+      // Bound retained turn ids while preserving any concurrent /steer request
+      // that may settle after the primary prompt response.
+      if (abortedTurns.size > 32) abortedTurns.delete(abortedTurns.values().next().value)
+      turnActive = false
+      firstTurn = false
+      mapper?.finishTurn({ stopReason: 'cancelled' })
+      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
+        // process and makes the lane honestly non-resumable until restart.
+        crashed = true
+        client?.end()
+        emit({ kind: 'error', message: `Hermes cancellation delivery failed; ACP process stopped: ${error?.message || error}`, recoverable: true })
+      })
     },
     end() {
       ended = true

package/hermes-setup.mjs

@@ -39,11 +39,16 @@ function snapshotFile(filePath, fsImpl) {
   return {
     content: fsImpl.readFileSync(filePath),
     mode: fsImpl.statSync(filePath).mode & 0o777,
+    atimeMs: fsImpl.statSync(filePath).atimeMs,
+    mtimeMs: fsImpl.statSync(filePath).mtimeMs,
   }
 }
 
 function restoreFile(filePath, snapshot, fsImpl) {
-  if (snapshot) atomicWrite(filePath, snapshot.content, { fsImpl, mode: snapshot.mode })
+  if (snapshot) {
+    atomicWrite(filePath, snapshot.content, { fsImpl, mode: snapshot.mode })
+    fsImpl.utimesSync?.(filePath, snapshot.atimeMs / 1000, snapshot.mtimeMs / 1000)
+  }
   else fsImpl.rmSync(filePath, { force: true })
 }
 
@@ -116,13 +121,19 @@ export function setupHermesRuntime({
   ]
 
   const guardPath = hermesGuardPath({ homeDir, env, platform })
+  const allowlistPath = path.join(profilePath, 'shell-hooks-allowlist.json')
   const guardSnapshot = snapshotFile(guardPath, fsImpl)
   const configSnapshot = snapshotFile(configPath, fsImpl)
+  const allowlistSnapshot = snapshotFile(allowlistPath, fsImpl)
   try {
     atomicWrite(guardPath, guardSource, { fsImpl, mode: 0o700 })
     atomicWrite(configPath, YAML.stringify(config, { lineWidth: 0 }), { fsImpl, mode: 0o600 })
 
     const consentEnv = { ...env, HERMES_ACCEPT_HOOKS: '1' }
+    // Hermes does not refresh an existing approval when the same command's
+    // script mtime changes. Revoke only ThinkPool's exact guard command, then
+    // let the synthetic test consent to that exact command again.
+    run([...profileArgs, 'hooks', 'revoke', commandText(guardPath)], { env: consentEnv })
     const testOutput = run([...profileArgs, 'hooks', 'test', 'pre_tool_call', '--for-tool', 'delegate_task'], { env: consentEnv })
     if (!/(?:action|decision)["']?\s*[:=]\s*["']block/i.test(testOutput)
       || !/ThinkPool blocks hidden Hermes delegation/i.test(testOutput)) {
@@ -137,6 +148,7 @@ export function setupHermesRuntime({
     try {
       restoreFile(configPath, configSnapshot, fsImpl)
       restoreFile(guardPath, guardSnapshot, fsImpl)
+      restoreFile(allowlistPath, allowlistSnapshot, fsImpl)
     } catch (rollbackError) {
       error.message = `${error.message}; rollback also failed: ${clean(rollbackError.message)}`
     }

package/package.json

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