thinkpool-pair 0.7.137 → 0.7.138

package/claude-session.mjs

@@ -222,6 +222,21 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
   let curModel = model || null    // latest model id seen (init/system + ctx); stamped on
                                   // the result event so the bridge can attribute BYOK Code
                                   // spend per-model (record_code_usage → chat_usage).
+  // A model switch on a RESUMED session can't be done live — q.setModel() RESOLVES without
+  // error but is a silent no-op there (the turn keeps running the old model). So a switch is
+  // applied by RE-CREATING the query resuming the same session on the new model (which
+  // query({resume, model}) honours). Root of Max's 2026-07-02 "reverts to Opus at start of
+  // turn": every terminal is a resumed session after a restart, so live setModel did nothing.
+  // qAc = the CURRENT query's own AbortController (child of the session `ac`) so the
+  // switch can kill JUST this query without ending the session; qDone resolves when the
+  // current runQuery loop has fully exited (its process dead) so the re-create doesn't
+  // race the old process on the session file lock (proven necessary 2026-07-02).
+  // pendingSwitch defers a mid-turn switch until the active turn finishes.
+  let qAc = null
+  let qDoneResolve = null
+  let qDone = Promise.resolve()
+  let pendingSwitch = false
+  const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
   // ── stall watchdog (C2) — stream silence ≠ done; a turn can stall (deltas pause
   // 3+ min) or abort silently with no `result`. Track turn liveness + last event
   // time; if an active turn goes quiet past STALL_MS, emit one `stalled` chrome
@@ -683,8 +698,16 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
 
   const runQuery = async () => {
     started = true
+    // Per-query AbortController (child of the session `ac`): lets a model switch kill
+    // just this query. Resolve the previous qDone in case it's still pending.
+    if (qDoneResolve) { try { qDoneResolve() } catch { /* noop */ } }
+    qDone = new Promise((res) => { qDoneResolve = res })
+    const myAc = new AbortController()
+    qAc = myAc
+    const onParentAbort = () => { try { myAc.abort() } catch { /* noop */ } }
+    ac.signal.addEventListener('abort', onParentAbort, { once: true })
     try {
-      q = query({ prompt: input.stream, options: { ...opts, ...(sessionId ? { resume: sessionId } : {}) } })
+      q = query({ prompt: input.stream, options: { ...opts, abortController: myAc, ...(sessionId ? { resume: sessionId } : {}) } })
       for await (const m of q) {
         if (closed) break
         switch (m.type) {
@@ -793,10 +816,27 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
             if (interrupting && (m.subtype === 'aborted' || m.subtype === 'error_during_execution')) { turnActive = false; break }
             turnBaseOut = 0; curMsgOut = 0   // reset the live token count for the next turn
             turnActive = false               // turn settled → stall watchdog stands down
+            // A model switch requested mid-turn was deferred — apply it now the turn is done.
+            // Defer to the next tick so recreateForSwitch (which awaits THIS loop's qDone)
+            // doesn't await itself; the setTimeout runs after this iterator yields.
+            if (pendingSwitch) { pendingSwitch = false; setTimeout(() => { if (!closed) recreateForSwitch() }, 0) }
             if (m.subtype === 'success') restartCount = 0   // ONLY a real success refills the
             // auto-restart budget — else a flapping connection that lands one aborted turn
             // between drops refills every cycle and loops far past RESTART_MAX.
             forceStopped = false
+            // Ground-truth the model from THIS turn's modelUsage (the models actually billed
+            // this turn), not the init/system messages — a RESUMED session REPLAYS the prior
+            // transcript's init messages, so curModel got polluted back to the pre-switch model
+            // even though the turn really ran on the switched one (Max 2026-07-02: chip showed
+            // Opus while inference was Fable). Pick the model that did the most generating.
+            if (m.modelUsage && typeof m.modelUsage === 'object') {
+              let best = null, bestOut = -1
+              for (const [mid, u] of Object.entries(m.modelUsage)) {
+                const out = (u?.outputTokens ?? 0)
+                if (out > bestOut) { bestOut = out; best = mid }
+              }
+              if (best) curModel = best
+            }
             emit({ kind: 'result', subtype: m.subtype, sessionId, model: curModel, costUsd: m.total_cost_usd, usage: m.usage, numTurns: m.num_turns, durationMs: m.duration_ms ?? null, denials: Array.isArray(m.permission_denials) ? m.permission_denials.length : 0 })
             // Arm the Haiku fallback: if Claude's own prompt_suggestion doesn't arrive within
             // the window, generate one from the last assistant reply. (Skip aborted turns.)
@@ -827,6 +867,9 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
       }
     } catch (e) {
       if (closed) return
+      // This query was intentionally aborted (a model switch superseded it, or the
+      // session is ending) — not a real error. Stay silent; the re-create owns what's next.
+      if (myAc.signal.aborted) return
       const msg = e?.message || String(e)
       emit({ kind: 'error', message: msg })
       // Auto-restart a transient upstream stream drop: re-run query() with
@@ -853,8 +896,32 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
       // still fires for "No conversation found" (it reopens fresh).
       closed = true
       turnActive = false
+    } finally {
+      ac.signal.removeEventListener('abort', onParentAbort)
+      if (qAc === myAc) qAc = null
+      // Await the SDK query's disposal so the underlying CLI PROCESS is actually dead
+      // before qDone resolves — otherwise a model-switch re-create races the dying process
+      // on the session file lock and the resumed query keeps the OLD model (proven 2026-07-02;
+      // q.return() waits on the transport exit, bounded internally to ~2s).
+      try { await q?.return?.() } catch { /* already disposed */ }
+      if (qDoneResolve) { qDoneResolve(); qDoneResolve = null }
     }
   }
+  // Re-create the query resuming the SAME session on the switched model (opts.model).
+  // Used when a live setModel isn't possible (resumed session). Tears the current query
+  // fully down and AWAITS its exit before re-running, so the two processes never race on
+  // the session file lock (a concurrent re-create keeps the OLD model — proven 2026-07-02).
+  const recreateForSwitch = async () => {
+    if (closed || !started) return
+    const dying = qDone
+    const oldInput = input
+    input = makeInputStream()          // fresh stream for the re-created query
+    if (qAc) { try { qAc.abort() } catch { /* noop */ } }   // kill the current query's process
+    try { oldInput.end() } catch { /* noop */ }
+    try { await dying } catch { /* noop */ }               // wait until it's actually dead
+    await sleep(300)                                        // brief lock-release margin
+    if (!closed) runQuery()                                 // relaunch on opts.model + resume
+  }
   if (!lazy) runQuery()
 
   return {
@@ -879,16 +946,19 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
     // /model is disabled in headless SDK — switch via the setModel control
     // instead, and echo a note line so both drivers see the change.
     async setModel(m) {
-      try { await q?.setModel?.(m) } catch { /* may reject unknown model */ }
-      // setModel switches only the LIVE query object. runQuery() re-runs query() with
-      // `opts` on every auto-restart (transient stream drop / reconnect), so unless we
-      // also update opts.model the reconnect re-launches on the ORIGINAL model — which
-      // is why a /model switch kept snapping back to Opus after a few turns (Max
-      // 2026-07-02: 11× "init model=claude-opus-4-8" after switching to Fable). Pin the
-      // switch into opts + curModel so every subsequent re-run carries it.
+      // Pin the switch into opts + curModel so every subsequent query re-run (auto-restart
+      // OR the re-create below) carries it.
       opts.model = m
       curModel = m
       emit({ kind: 'note', text: `model → ${m}` })
+      if (!started || closed) return   // not launched yet → the first runQuery uses opts.model
+      // Do NOT trust the live q.setModel: on a RESUMED streaming session it RESOLVES without
+      // error but is a silent no-op (the turn keeps running the old model — Max 2026-07-02).
+      // The only reliable switch is to RE-CREATE the query resuming the same session on the
+      // new model (query({resume, model}) honours it — proven). Defer a mid-turn switch to
+      // turn-end so we don't rip out an in-flight turn.
+      if (turnActive) { pendingSwitch = true; return }
+      await recreateForSwitch()
     },
     async listModels() {
       try {

package/package.json

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