thinkpool-pair 0.7.236 → 0.7.237

package/bridge.mjs

@@ -2616,12 +2616,29 @@ function openStructured({ id, runtime = 'claude', model, effort, resume, log, co
       // run on different registered providers. (bridge-truth slice.)
       { const onBuiltin = entry.runtime !== 'hermes' && (!entry.provider || entry.provider === 'anthropic')
         const m = (entry.runtime === 'hermes' || onBuiltin) ? (evt.model || evt.ctx?.model) : null
-        if (m && m !== entry.model) { entry.model = m; announce() }
+        if (m && m !== entry.model) { entry.model = m; announce(); if (evt.kind === 'model-switch') persist() }
         // A custom Anthropic-compatible endpoint may expose its own catalog through the
         // same SDK method. Never publish that as the ROOM's Claude catalog: its models
         // already render in the provider group and otherwise leak under ANTHROPIC.
         if (entry.runtime === 'hermes' && evt.kind === 'models' && Array.isArray(evt.models) && evt.models.length) { entry.models = evt.models; announce() }
         else if (onBuiltin && evt.kind === 'models' && Array.isArray(evt.models) && evt.models.length) { roomModels = evt.models; announce() } }
+      // Hermes model changes are asynchronous ACP requests. Keep the previous model
+      // authoritative until Hermes acknowledges session/set_model; then settle the
+      // originating control line exactly once. A rejected model never poisons the
+      // saved session or leaves a cross-device chip claiming the optimistic pick.
+      if (evt.kind === 'model-switch') {
+        const request = entry.pendingModelSwitch
+        entry.pendingModelSwitch = null
+        const requested = evt.requested || request?.model || 'requested model'
+        const text = evt.status === 'success'
+          ? `switched model → ${evt.model || requested}`
+          : `couldn’t switch to ${requested} — still using ${entry.model || 'the previous model'}`
+        const control = { kind: 'control', text, by: request?.by || null, cid: request?.cid || undefined }
+        pushLog(entry, control)
+        bcast('code-event', { term: id, evt: control })
+        entry.flush?.()
+        announce()
+      }
       // Cache the last usage/ctx meter on the entry (persisted + replayed — see
       // openStructured). Chrome events bypass pushLog/persist in emitTail below, so
       // usage needs an explicit persist() here to survive a bridge restart.
@@ -2700,7 +2717,7 @@ function openStructured({ id, runtime = 'claude', model, effort, resume, log, co
       // card) and is intentionally NOT chrome, so it persists + replays.
       // 'suggestion' is Claude Code's predicted-next-prompt ghost text — ephemeral
       // composer UI, broadcast to both clients but never logged/persisted/replayed.
-      const chrome = evt.kind === 'mode' || evt.kind === 'usage' || evt.kind === 'clear' || evt.kind === 'compact' || evt.kind === 'stalled' || evt.kind === 'suggestion' || evt.kind === 'assistant_stream'
+      const chrome = evt.kind === 'mode' || evt.kind === 'usage' || evt.kind === 'clear' || evt.kind === 'compact' || evt.kind === 'stalled' || evt.kind === 'suggestion' || evt.kind === 'assistant_stream' || evt.kind === 'model-switch'
       // The compact turn settled with `entry.compacting` STILL TRUE — which, because the
       // `compaction` branch above clears the flag the moment the milestone lands, means
       // exactly one thing: NO compaction happened. Three ways to get here, all of which
@@ -3428,10 +3445,19 @@ channel
     const mm = text.match(/^\/model\b\s*(\S+)?/)
     if (mm) {
       if (mm[1]) {
+        if (s.runtime === 'hermes' && s.pendingModelSwitch) {
+          ctlLine(`finish the current Hermes model switch before choosing another model`)
+          return
+        }
         if (s.session.setModel(mm[1]) === false) {
           ctlLine(`finish or stop the current ${structuredRuntimeMetadata(s.runtime)?.label || 'agent'} turn before switching models`)
           return
         }
+        if (s.runtime === 'hermes') {
+          s.pendingModelSwitch = { model: mm[1], by: payload.by, cid: payload.cid }
+          bcast('code-event', { term: payload.term, evt: { kind: 'model-switch', status: 'pending', requested: mm[1], ts: Date.now() } })
+          return
+        }
         // Reflect the switch in the announce IMMEDIATELY (before any turn). The SDK
         // only echoes the resolved full id on the next turn, and meta/ctx model go
         // stale until then, so without this the chip snapped back to the old model

package/event-id.mjs

@@ -61,7 +61,7 @@ export function makeSeqCounter(startAfter = 0) {
 // consumed a seq + set the durable archive floor while the client dropped them, leaving
 // the client's oldest RENDERED seq above the floor → a phantom "load earlier history"
 // pill on a fresh lane (models fires on every session init) that fetched nothing.
-export const NO_SEQ_KINDS = new Set(['system', 'thinking_tokens', 'effort', 'models', 'queue-add', 'queue-cancel', 'propose-done', 'update-available'])
+export const NO_SEQ_KINDS = new Set(['system', 'thinking_tokens', 'effort', 'models', 'model-switch', 'queue-add', 'queue-cancel', 'propose-done', 'update-available'])
 export const seqable = (evt) => !!evt && typeof evt === 'object' && !NO_SEQ_KINDS.has(evt.kind)
 
 // Highest numeric `seq` across a log of events (0 when none) — the floor a restored

package/hermes-session.mjs

@@ -66,6 +66,7 @@ export function startHermesSession({
   const abortedTurns = new Set()
   let retireClient = () => {}
   let resuming = false
+  let modelSwitchPending = false
 
   const emit = (event) => { try { onEvent?.(event) } catch { /* consumer isolation */ } }
 
@@ -277,12 +278,16 @@ export function startHermesSession({
       void mcpHttp?.close().catch(() => {})
     },
     setModel(nextModel) {
-      if (!nextModel || turnActive) return false
-      void boot().then(() => client.request('session/set_model', { sessionId, modelId: String(nextModel) })).then(() => {
-        activeModel = String(nextModel)
+      if (!nextModel || turnActive || modelSwitchPending) return false
+      const requested = String(nextModel)
+      modelSwitchPending = true
+      void boot().then(() => client.request('session/set_model', { sessionId, modelId: requested })).then(() => {
+        if (ended) return
+        activeModel = requested
         if (mapper) mapper.model = activeModel
-        emit({ kind: 'note', text: `model → ${activeModel}` })
-      }).catch((error) => emit({ kind: 'error', message: `Hermes model switch failed: ${error?.message || error}`, recoverable: true }))
+        emit({ kind: 'model-switch', status: 'success', model: activeModel, requested })
+      }).catch((error) => { if (!ended) emit({ kind: 'model-switch', status: 'failed', model: activeModel, requested, message: `Hermes model switch failed: ${error?.message || error}` }) })
+        .finally(() => { modelSwitchPending = false })
       return true
     },
     setMode(nextMode) {

package/package.json

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

package/runtime-registry.mjs

@@ -3,17 +3,17 @@ import path from 'node:path'
 const RUNTIMES = Object.freeze({
   claude: Object.freeze({
     id: 'claude', command: 'claude', label: 'Claude Code', protocol: 'agent-sdk',
-    structured: true, flow: true, canSteer: false, images: true, nativeModelCatalog: false, defaultMode: 'default',
+    structured: true, flow: true, canSteer: false, images: true, nativeModelCatalog: false, effortControl: true, defaultMode: 'default',
     modes: Object.freeze(['default', 'acceptEdits', 'plan', 'bypassPermissions']),
   }),
   codex: Object.freeze({
     id: 'codex', command: 'codex', label: 'Codex', protocol: 'codex-app-server',
-    structured: true, flow: true, canSteer: true, images: true, nativeModelCatalog: true, defaultMode: 'bypassPermissions',
+    structured: true, flow: true, canSteer: true, images: true, nativeModelCatalog: true, effortControl: true, defaultMode: 'bypassPermissions',
     modes: Object.freeze(['default', 'acceptEdits', 'plan', 'bypassPermissions', 'review']),
   }),
   hermes: Object.freeze({
     id: 'hermes', command: 'thinkpool', label: 'Hermes Agent', protocol: 'acp',
-    structured: true, flow: false, canSteer: true, images: true, nativeModelCatalog: true, defaultMode: 'default',
+    structured: true, flow: false, canSteer: true, images: true, nativeModelCatalog: true, effortControl: false, defaultMode: 'default',
     modes: Object.freeze(['default', 'acceptEdits']),
     beta: true,
   }),