thinkpool-pair 0.7.12 → 0.7.13

package/claude-session.mjs

@@ -127,6 +127,15 @@ export function startClaudeSession({ cwd, model, resume, mode: initialMode = 'de
   const alwaysAllow = new Set()  // tool:risk signatures the user chose "don't ask again" for
   const toolStart = new Map()     // tool_use id → start time, for the duration badge
   let effort = null               // active reasoning effort for the turn (from the hook input)
+  // Live token count for the thinking indicator — mirrors Claude Code's
+  // "↓ N tokens": the turn's billed OUTPUT tokens (thinking is billed as
+  // output, so this is the full count, not just the reasoning estimate). A
+  // tool-using turn emits several assistant messages; message_delta carries
+  // the running output_tokens for the CURRENT message, so we fold finished
+  // messages into turnBaseOut and add the live message's count on top. Reset
+  // per turn on `result`.
+  let turnBaseOut = 0             // output tokens from completed messages this turn
+  let curMsgOut = 0               // latest output_tokens for the in-flight message
 
   const emit = (evt) => { try { onEvent?.(evt) } catch { /* never let a consumer throw into the loop */ } }
 
@@ -286,7 +295,11 @@ export function startClaudeSession({ cwd, model, resume, mode: initialMode = 'de
             // model reasons, surfaced as the indicator's ↓ N tokens. Coarse,
             // emitted during extended thinking; not a per-token stream.
             if (m.subtype === 'thinking_tokens') {
-              emit({ kind: 'thinking_tokens', tokens: m.estimated_tokens, delta: m.estimated_tokens_delta })
+              // The reasoning-phase estimate (smooth, but approximate). Only
+              // surface it BEFORE real output streams — once message_delta gives
+              // us authoritative output_tokens (which already include thinking),
+              // that supersedes the estimate so the count never jumps backwards.
+              if (turnBaseOut + curMsgOut === 0) emit({ kind: 'thinking_tokens', tokens: m.estimated_tokens, delta: m.estimated_tokens_delta })
               break
             }
             if (m.session_id) sessionId = m.session_id
@@ -312,8 +325,25 @@ export function startClaudeSession({ cwd, model, resume, mode: initialMode = 'de
               }
             }
             break
+          case 'stream_event': {
+            // Live output-token progress for the thinking indicator. message_delta
+            // carries the running output_tokens for the current assistant message;
+            // message_start opens a new one (fold the finished message into the
+            // turn base first). Authoritative + monotonic within a turn.
+            const ev = m.event
+            if (ev?.type === 'message_start') {
+              turnBaseOut += curMsgOut
+              curMsgOut = ev.message?.usage?.output_tokens || 0
+              emit({ kind: 'thinking_tokens', tokens: turnBaseOut + curMsgOut })
+            } else if (ev?.type === 'message_delta' && ev.usage) {
+              curMsgOut = ev.usage.output_tokens ?? curMsgOut
+              emit({ kind: 'thinking_tokens', tokens: turnBaseOut + curMsgOut })
+            }
+            break
+          }
           case 'result':
             if (m.session_id) sessionId = m.session_id
+            turnBaseOut = 0; curMsgOut = 0   // reset the live token count for the next turn
             emit({ kind: 'result', subtype: m.subtype, sessionId, costUsd: m.total_cost_usd, usage: m.usage, numTurns: m.num_turns })
             // Surface a usage/context meter (chrome, not a transcript line). The
             // context window % comes from the control request; cost is cumulative.

package/package.json

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