thinkpool-pair 0.7.137 → 0.7.139

package/claude-session.mjs

@@ -185,6 +185,12 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
   const ac = new AbortController()
   let input = makeInputStream()   // `let`: auto-restart swaps in a fresh stream
   let sessionId = resume || null
+  // persistedSessionId — the newest session id we KNOW is written to disk (the resume we
+  // were handed, then advanced on each successful result). A model-switch re-create must
+  // resume THIS, never the live `sessionId`: a resumed query can fork to a fresh session id
+  // that isn't persisted until a turn completes, so re-creating on it fails with
+  // "No conversation found" (Max 2026-07-02). This is always a resumable id.
+  let persistedSessionId = resume || null
   let closed = false
   // Lazy boot (2026-07-02): a RESTORED-IDLE terminal returns a full session object but
   // defers the expensive query() cold-start (MCP + settingSources, ~50s each) until its
@@ -222,6 +228,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
@@ -625,7 +646,11 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
   if (mcpServers && Object.keys(mcpServers).length) opts.mcpServers = { ...(opts.mcpServers || {}), ...mcpServers }
   if (cwd) opts.cwd = cwd
   if (model) opts.model = model
-  if (resume) opts.resume = resume
+  // NB: resume is NOT baked into opts — runQuery sets it per-run from the live `sessionId`
+  // (seeded from `resume`). That makes the resume target controllable: a re-create can point
+  // it at persistedSessionId, and the "No conversation found" recovery can DROP it (clearing
+  // sessionId) to re-run fresh. If it were in opts, the {...opts} spread would keep resuming
+  // the dead id even after we cleared sessionId (Max 2026-07-02 recovery loop).
   // Force-enable Claude Code's predicted-next-prompt. `promptSuggestions: true`
   // alone defers to the server-side `tengu_prompt_suggestion` feature gate, which
   // Anthropic flips on/off during rollout — so the ghost-text chip silently died
@@ -683,8 +708,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 +826,28 @@ 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
-            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.
+            // 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; if (sessionId) persistedSessionId = sessionId }   // ONLY a real success refills the
+            // auto-restart budget (else a flapping connection that lands one aborted turn between
+            // drops refills every cycle past RESTART_MAX) — and marks this session id durably
+            // persisted so a later model-switch re-create can safely resume it.
             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 +878,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
@@ -848,13 +902,55 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
         restartTimer = setTimeout(() => { restartTimer = null; if (!closed) runQuery() }, Math.min(1000 * restartCount, 4000))   // 1s, 2s, 4s backoff
         return
       }
+      // Resume target vanished (a forked session id that was never persisted, or a pruned
+      // transcript): drop the resume and re-run FRESH so the turn/switch still lands instead
+      // of hard-failing. Bounded by RESTART_MAX. Loses only the resumed history, not the turn.
+      if (/no conversation found/i.test(msg) && sessionId && restartCount < RESTART_MAX) {
+        restartCount++
+        turnActive = false
+        sessionId = null; persistedSessionId = null
+        const oldInput = input
+        input = makeInputStream()
+        try { oldInput.end() } catch { /* noop */ }
+        restartTimer = setTimeout(() => { restartTimer = null; if (!closed) runQuery() }, 300)
+        return
+      }
       // Non-recoverable, or budget exhausted: mark done so sendTurn stops
       // silently queuing into a dead stream. The bridge's onEvent self-heal
       // 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
+    // Resume the last DURABLY-PERSISTED session, not the live one: the aborted query may
+    // have forked to a session id that was never written to disk, and resuming that fails
+    // with "No conversation found" (Max 2026-07-02, sid 6db6c1e3). persistedSessionId is
+    // always resumable (the restore id, advanced on each success).
+    sessionId = persistedSessionId
+    if (!closed) runQuery()                                 // relaunch on opts.model + resume
+  }
   if (!lazy) runQuery()
 
   return {
@@ -879,16 +975,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.139",
   "description": "Share a local coding-agent CLI (Claude Code, Codex, Gemini, Aider, …) into a ThinkPool Code room, live.",
   "type": "module",
   "bin": {