thinkpool-pair 0.7.76 → 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).
@@ -384,7 +399,7 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
   // it; idempotent + no-op on clean transcripts. See transcript-sanitize.mjs.
   if (resume) {
     const healed = sanitizeSession(cwd || process.cwd(), resume)
-    if (healed.blocks) process.stderr.write(`\n  ◆ healed ${healed.blocks} cross-provider tool block(s) in the transcript before resume.\n`)
+    if (healed.blocks) process.stderr.write(`\n  ◆ healed ${healed.blocks} malformed tool block(s) in the transcript before resume.\n`)
   }
 
   // One-shot Haiku fallback suggestion. Runs on the SAME subscription auth as the room
@@ -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.76",
+  "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": {

package/transcript-sanitize.mjs

@@ -48,7 +48,8 @@ const ANTHROPIC_SERVER_TOOLS = new Set([
   'tool_search_tool_bm25',
 ])
 
-const MARKER = '"server_tool_use"'
+const STU_MARKER = '"server_tool_use"'
+const TR_MARKER = '"tool_result"'
 
 /**
  * Resolve a session's transcript path the same way Claude Code names it:
@@ -72,6 +73,38 @@ function fixContent(content) {
   return n
 }
 
+/* ─────────────────────────────────────────────────────────────
+   SECOND HEAL — interrupted-turn corruption (failure 2026-06-26):
+   a `tool_result` block stranded inside an ASSISTANT message.
+
+   When a turn is aborted/interrupted mid-tool-call, Claude Code can
+   persist a single assistant message holding BOTH the tool_use AND its
+   tool_result (plus stray thinking/text). Anthropic strictly 400s:
+     messages.N: tool_result blocks can only be in user messages
+   and the room wedges — every send re-hits message N and fails (exactly
+   what bricked the /code GLM session, transcript line 1196 / messages.165).
+
+   THE FIX: in an assistant content array, drop every stray tool_result
+   AND the tool_use block(s) it pairs with (same id) — removing the pair
+   together so no orphaned tool_use is left behind (an orphan would 400
+   differently: "tool_use ids were found without tool_result blocks").
+   The aborted call is dead history; dropping it lets the session resume.
+   If the message would be left empty, leave a placeholder text block
+   (Anthropic rejects a content-less assistant message). In-place, no row
+   split — so Claude Code's own uuid/parentUuid chain stays intact.
+   Returns the new content array + count removed. ───────────────────── */
+function fixToolResultInAssistant(content) {
+  if (!Array.isArray(content)) return { removed: 0, content }
+  const resultIds = new Set()
+  for (const b of content) if (b && b.type === 'tool_result') resultIds.add(b.tool_use_id)
+  if (!resultIds.size) return { removed: 0, content } // no stray result here — nothing to do
+  const before = content.length
+  let next = content.filter((b) =>
+    b && b.type !== 'tool_result' && !(b.type === 'tool_use' && resultIds.has(b.id)))
+  if (next.length === 0) next = [{ type: 'text', text: '[interrupted turn removed by transcript-sanitize]' }]
+  return { removed: before - next.length, content: next }
+}
+
 /**
  * Sanitize one transcript file in place. Returns { lines, blocks } counting the
  * transcript lines rewritten and the individual blocks flipped. A missing,
@@ -84,14 +117,19 @@ export function sanitizeTranscript(file) {
   } catch {
     return { lines: 0, blocks: 0 } // no transcript yet (fresh session) — nothing to do
   }
-  if (!raw.includes(MARKER)) return { lines: 0, blocks: 0 } // fast path: nothing illegal possible
+  const fileHasStu = raw.includes(STU_MARKER)
+  const fileHasTr = raw.includes(TR_MARKER)
+  if (!fileHasStu && !fileHasTr) return { lines: 0, blocks: 0 } // fast path: nothing illegal possible
 
   const rows = raw.split('\n')
   let lines = 0
   let blocks = 0
   for (let i = 0; i < rows.length; i++) {
     const row = rows[i]
-    if (!row || !row.includes(MARKER)) continue
+    if (!row) continue
+    const rowHasStu = row.includes(STU_MARKER)
+    const rowHasTr = row.includes(TR_MARKER)
+    if (!rowHasStu && !rowHasTr) continue
     let obj
     try {
       obj = JSON.parse(row)
@@ -99,8 +137,22 @@ export function sanitizeTranscript(file) {
       continue // never touch a line we can't parse — leave it byte-identical
     }
     let n = 0
-    if (obj.message && typeof obj.message === 'object') n += fixContent(obj.message.content)
-    n += fixContent(obj.content)
+    // Pass 1 — foreign server_tool_use → tool_use (any message).
+    if (rowHasStu) {
+      if (obj.message && typeof obj.message === 'object') n += fixContent(obj.message.content)
+      n += fixContent(obj.content)
+    }
+    // Pass 2 — stray tool_result inside an assistant message → drop it + its paired tool_use.
+    if (rowHasTr) {
+      if (obj.message && obj.message.role === 'assistant') {
+        const r = fixToolResultInAssistant(obj.message.content)
+        if (r.removed) { obj.message.content = r.content; n += r.removed }
+      }
+      if (obj.type === 'assistant' && Array.isArray(obj.content)) {
+        const r = fixToolResultInAssistant(obj.content)
+        if (r.removed) { obj.content = r.content; n += r.removed }
+      }
+    }
     if (n > 0) {
       rows[i] = JSON.stringify(obj)
       lines++
@@ -130,3 +182,27 @@ export function sanitizeSession(cwd, sessionId) {
     return { lines: 0, blocks: 0 }
   }
 }
+
+/* ─────────────────────────────────────────────────────────────
+   CLI — manual recovery for a wedged transcript (the auto-heal runs on
+   every resume via claude-session.mjs; this is the break-glass tool):
+     node bridge/transcript-sanitize.mjs <path-to-transcript.jsonl>
+     node bridge/transcript-sanitize.mjs <cwd> <sessionId>
+   Prints what it healed. A backup (<file>.bak) is written before any
+   change so a bad heal is one `mv` from undone.
+   ───────────────────────────────────────────────────────────── */
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const a = process.argv.slice(2)
+  if (a.length === 0) {
+    process.stderr.write('usage: transcript-sanitize.mjs <transcript.jsonl> | <cwd> <sessionId>\n')
+    process.exit(2)
+  }
+  const file = a.length >= 2 ? transcriptPath(a[0], a[1]) : a[0]
+  if (!fs.existsSync(file)) { process.stderr.write(`not found: ${file}\n`); process.exit(1) }
+  fs.copyFileSync(file, `${file}.bak`) // break-glass backup
+  const r = sanitizeTranscript(file)
+  process.stdout.write(r.blocks
+    ? `healed ${r.blocks} malformed tool block(s) across ${r.lines} line(s) in ${file}\n  backup: ${file}.bak\n`
+    : `no malformed tool blocks found in ${file} (already clean)\n`)
+  process.exit(0)
+}