thinkpool-pair 0.7.138 → 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
@@ -640,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
@@ -820,9 +830,10 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
             // 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.
+            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
@@ -891,6 +902,19 @@ 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).
@@ -920,6 +944,11 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
     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()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.138",
+  "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": {