thinkpool-pair 0.7.77 → 0.7.78

package/claude-session.mjs

@@ -177,6 +177,21 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
   // the catch self-heals.
   const FORCE_STOP_MS = Math.max(STALL_MS * 3, parseInt(process.env.TP_FORCE_STOP_MS, 10) || 300000)
   let forceStopped = false
+  // Set while an interrupt is settling. q.interrupt() doesn't end the turn cleanly on this
+  // SDK — it surfaces a REDUNDANT pair of terminal results (subtype `aborted` AND
+  // `error_during_execution`) and re-inits the session. abort() emits the single canonical
+  // aborted boundary itself; this flag tells the result handler to swallow the SDK's extra
+  // teardown results so the web never sees a second turn-end. Without it, the web suppresses
+  // only the first (isAbortEcho) and the second buried the flushed steer — "Stop injects the
+  // queued message but nothing happens". Cleared by the first real (non-teardown) result.
+  // Verified: bridge/test-steer-after-abort.mjs (Maks 2026-06-26). The teardown results
+  // arrive async and can interleave with the NEXT turn (a late error_during_execution can
+  // land after the steer's own output), so the window is bounded by a timer rather than
+  // cleared on the next result — "all teardown has arrived" isn't observable. `success`
+  // results are never swallowed, so the flushed steer's completion always surfaces.
+  let interrupting = false
+  let interruptTimer = null
+  const INTERRUPT_SWALLOW_MS = 6000
   // ── Haiku suggestion fallback ──
   // Claude Code's own `prompt_suggestion` rarely fires in /code — the binary suppresses it
   // per-turn (cache_cold when a turn's tokens > 10k, rate_limit when throttled, first turn).
@@ -504,6 +519,11 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
           }
           case 'result':
             if (m.session_id) sessionId = m.session_id
+            // Swallow the interrupt's redundant teardown results (see `interrupting` above):
+            // abort() already emitted the one canonical aborted boundary. `success` (and any
+            // non-teardown subtype) always emits; only the aborted/error_during_execution pair
+            // the interrupt churns out is dropped, and only inside the timer-bounded window.
+            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
             restartCount = 0                 // a successful turn refills the auto-restart budget
@@ -590,6 +610,15 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
     // Graceful interrupt (Esc / Stop) — stops the current turn but keeps the
     // session alive for the next one. ac.abort() is teardown only (end()).
     async abort() {
+      // Swallow the SDK's redundant interrupt teardown (aborted + error_during_execution +
+      // re-init) — we emit the one canonical boundary below. Set BEFORE interrupt so the
+      // teardown results, which arrive async on the query loop, are caught; the timer bounds
+      // the window so a genuine later turn failure still surfaces.
+      if (turnActive) {
+        interrupting = true
+        clearTimeout(interruptTimer)
+        interruptTimer = setTimeout(() => { interrupting = false }, INTERRUPT_SWALLOW_MS)
+      }
       try { await q?.interrupt?.() } catch { /* noop */ }
       // interrupt() stops the turn but emits NO terminal message. Without one the
       // struct stream ends on a non-terminal event, so on resume the SDK treats the
@@ -599,7 +628,7 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
       // SDK already surfaced one for the interrupt. (restored from 0.7.49)
       if (turnActive) { turnActive = false; emit({ kind: 'result', subtype: 'aborted', sessionId }) }
     },
-    end() { closed = true; clearInterval(stallTimer); input.end(); try { ac.abort() } catch { /* noop */ } },
+    end() { closed = true; clearInterval(stallTimer); clearTimeout(interruptTimer); input.end(); try { ac.abort() } catch { /* noop */ } },
     get sessionId() { return sessionId },
     get mode() { return mode },
     get turnActive() { return turnActive },   // a turn is in flight (gates between-turns update restart — Slice 3 Contract #1)

package/package.json

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