thinkpool-pair 0.7.114 → 0.7.116

package/bridge.mjs

@@ -450,11 +450,18 @@ const repoLabel = path.basename(cwd)
 // thinkpool-pair's own version — surfaced in the room's welcome banner.
 let VERSION = null
 try { VERSION = JSON.parse(fs.readFileSync(new URL('./package.json', import.meta.url), 'utf8')).version } catch { /* unknown — banner omits it */ }
-let branch = null
-try {
-  const head = fs.readFileSync(path.join(cwd, '.git', 'HEAD'), 'utf8').trim()
-  branch = head.startsWith('ref:') ? head.split('/').pop() : head.slice(0, 7)
-} catch { /* not a git repo — fine */ }
+// Read the CURRENT branch LIVE (not once at boot) so the room's mode row reflects a
+// branch switch instead of showing whatever branch the dir was on when the bridge spawned
+// (the stale-branch bug). Handles a .git dir (normal checkout) AND a .git FILE (linked
+// worktree → "gitdir: <path>"). Cheap byte reads, no subprocess.
+function readBranch() {
+  try {
+    let gitPath = path.join(cwd, '.git')
+    if (fs.statSync(gitPath).isFile()) gitPath = fs.readFileSync(gitPath, 'utf8').replace(/^gitdir:\s*/i, '').trim()
+    const head = fs.readFileSync(path.join(gitPath, 'HEAD'), 'utf8').trim()
+    return head.startsWith('ref:') ? head.split('/').pop() : head.slice(0, 7)
+  } catch { return null /* not a git repo — fine */ }
+}
 
 // ── room file drops ────────────────────────────────────────────────
 // Files dropped/pasted in the web room arrive as `file-put { id, name, url }`
@@ -522,6 +529,22 @@ function recordRoomSpend (tokens) {
   if (BUDGET_OFF || !codeAuthToken || !room || !tokens) return
   budgetRpc('record_spend', { p_room: room, p_tokens: tokens }).catch(() => { /* best-effort — next turn's check reconciles */ })
 }
+// Fire-and-forget: log a completed Code turn's BYOK token usage per-MODEL into
+// chat_usage (via record_code_usage → attributes to the room owner) so the
+// Settings "AI usage" card counts ThinkPool Code, not just chat. Independent of
+// TP_BUDGET_OFF (that only governs the cap ledger; usage accounting should still
+// run). input = full input incl. cache; cached = cache-read slice; both mapped to
+// pricing.js's rowCostEur formula. No model → skip (can't price/label it).
+function recordCodeUsage (model, usage) {
+  if (!codeAuthToken || !room || !model) return
+  const u = usage || {}
+  const input  = (u.input_tokens || 0) + (u.cache_creation_input_tokens || 0) + (u.cache_read_input_tokens || 0)
+  const output = u.output_tokens || 0
+  const cached = u.cache_read_input_tokens || 0
+  if (!input && !output) return
+  budgetRpc('record_code_usage', { p_room: room, p_model: model, p_input: input, p_output: output, p_cached: cached })
+    .catch(() => { /* best-effort — usage accounting is not load-bearing for the turn */ })
+}
 // Pre-flight gate. Returns true if the turn must be REFUSED (room cap reached). Refusal is
 // legible (a ◆ control line both readers + late-joiners see), never a silent stall.
 async function budgetBlocked (s, term) {
@@ -660,7 +683,7 @@ const termNames = loadNames(room)
 
 const announce = () =>
   bcast('bridge', {
-    v: 2, name, repo: repoLabel, branch,
+    v: 2, name, repo: repoLabel, branch: readBranch(),
     // cwd + version: the host's working dir + thinkpool-pair version, shown in
     // the room's welcome banner. Re-sent per announce so late joiners get them.
     cwd, version: VERSION,
@@ -1606,7 +1629,7 @@ function openStructured({ id, model, resume, log, commands, mode, spawnedBy, rol
       }
       // Budget caps — fold EVERY completed turn's output tokens into the room's durable
       // monthly ledger (lanes + normal turns), so check_budget can pre-flight the next one.
-      if (evt.kind === 'result' && evt.usage) recordRoomSpend(evt.usage.output_tokens || 0)
+      if (evt.kind === 'result' && evt.usage) { recordRoomSpend(evt.usage.output_tokens || 0); recordCodeUsage(evt.model, evt.usage) }
       // FL-B1 (lane) — a flow lane that ENDS ITS TURN is done: a bypass lane runs its slice
       // to completion in one turn, then narrates "done" and stops. Models often skip the
       // explicit signal (FLOW_DONE / mark_flow_done), which left the slice stuck 'dispatched'
@@ -1759,6 +1782,23 @@ function endStructured(id) {
   if (s) announce()
 }
 
+// Close every lane of a FINISHED flow — its task lanes AND its conductor — after a grace
+// so the final output / assembled result stays readable. A flow lane is keyed by
+// flowSessionId (task lanes) or spawnedBy `flow:<id>` (the conductor). Without this a flow
+// that assembles or is cancelled leaves its lanes running forever with no owner to close
+// them (only the spawner can close_terminal) — the dormant-lane bug Max hit.
+function cleanupFlowLanes(flowId, graceMs = 4000) {
+  if (!flowId) return
+  const marker = `flow:${flowId}`
+  setTimeout(() => {
+    for (const [sid, e] of [...sessions]) {
+      if (e.flowSessionId === flowId || e.spawnedBy === marker) {
+        try { endStructured(sid) } catch { /* already gone */ }
+      }
+    }
+  }, graceMs)
+}
+
 // Slice 3 — surface a pending update to the room as the "update ready" chip:
 // broadcast a chrome code-event per structured term + stash it on the announce so
 // reloads/late-joiners see it too. The restart itself is gated to between turns.
@@ -2311,6 +2351,7 @@ flowChannel
       bcast('flow-assembled', { term: 'flow', flowId: payload.flowId, previewUrl, outDir, files: merged.files, conflicts: merged.conflicts }, flowChannel)
       process.stderr.write(`\n  ${A.mag}◆ flow assembled — ${merged.files.length} file(s)${merged.conflicts.length ? `, ${merged.conflicts.length} conflict(s)` : ''}${previewUrl ? ` · preview ${previewUrl}` : ''} (flow ${short}).${A.rst}\n`)
       announce()
+      cleanupFlowLanes(payload.flowId)   // flow assembled → retire its lanes + conductor (no orphans)
     } catch (e) {
       process.stderr.write(`\n  ${A.yel}◆ flow assemble failed: ${e?.message || e}${A.rst}\n`)
     }
@@ -2359,6 +2400,15 @@ flowChannel
       process.stderr.write(`\n  ${A.yel}◆ flow slice reverted — ${payload.taskKey} (${branch}).${A.rst}\n`)
     } catch (e) { process.stderr.write(`\n  ${A.yel}◆ flow revert failed: ${e?.message || e}${A.rst}\n`) }
   })
+  .on('broadcast', { event: 'flow-cancel' }, ({ payload }) => {
+    // A user cancelled the flow (or it was interrupted). The client also flips the DB
+    // status; here we CLOSE the flow's lanes + conductor so they don't orphan (only the
+    // spawner could close_terminal them otherwise — the dormant-lane bug). Host-gated.
+    if (!payload?.flowId) return
+    if (payload.host && payload.host !== name) return
+    cleanupFlowLanes(payload.flowId, 600)
+    process.stderr.write(`\n  ${A.yel}◆ flow cancelled — closing its lanes (${String(payload.flowId).replace(/-/g, '').slice(0, 8)}).${A.rst}\n`)
+  })
   .subscribe()
 
 // Watchdog — if the realtime channel is stuck (never connected, or dropped and

package/claude-session.mjs

@@ -152,6 +152,7 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
   // open a terminal with TP_MCP_STRICT=1 (below) for the B-side to isolate MCP's share.
   const spawnT0 = Date.now()
   let readyLogged = false
+  let modelsSent = false   // one-shot: emit the SDK's supported-model list on first init
   let q = null            // the live Query — control requests (interrupt /
                           // setPermissionMode) route through it once streaming.
   // The session is CREATED in the caller's chosen mode (not hard-coded default):
@@ -170,6 +171,9 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
   // 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
+  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).
   // ── 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
@@ -196,6 +200,22 @@ 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
+  // Waiting on a HUMAN decision (permission card / plan gate / AskUserQuestion)
+  // is NOT a wedge — the turn is correctly idle until the person answers. Every
+  // interactive gate goes through requestPermission, so wrap it once to bump a
+  // counter while a card is pending; the stall watchdog below stands down while
+  // awaitingUser > 0. Without this, a slow human answer (e.g. a late
+  // AskUserQuestion pick) trips FORCE_STOP_MS, the turn is force-stopped, and the
+  // answer lands on a dead turn ("agent went silent … send again to resume").
+  // On release, stamp lastEvtTs = now so the resumed turn isn't force-stopped on
+  // the very next tick by a now-stale (minutes-old) timestamp.
+  let awaitingUser = 0
+  const _requestPermission = requestPermission
+  requestPermission = async (req) => {
+    awaitingUser++
+    try { return await _requestPermission?.(req) }
+    finally { awaitingUser = Math.max(0, awaitingUser - 1); lastEvtTs = Date.now() }
+  }
   // 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
@@ -224,7 +244,7 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
 
   const emit = (evt) => { lastEvtTs = Date.now(); if (evt && evt.kind !== 'stalled') stalledSent = false; try { onEvent?.(evt) } catch { /* never let a consumer throw into the loop */ } }
   const stallTimer = setInterval(() => {
-    if (!turnActive) return
+    if (!turnActive || awaitingUser > 0) return   // awaiting a human decision ≠ wedged
     const quiet = Date.now() - lastEvtTs
     if (quiet > FORCE_STOP_MS && !forceStopped) {
       // True wedge — no result, no error, just silence. Unblocks between-turns
@@ -649,7 +669,22 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
             // m.slash_commands (init message) — the commands this session really
             // supports: built-ins + the host's custom .claude/commands. Surfaced
             // so the room composer's autocomplete lists what ACTUALLY exists.
+            curModel = m.model || model || curModel
             emit({ kind: 'system', sessionId, model: m.model || model || null, commands: Array.isArray(m.slash_commands) ? m.slash_commands : undefined })
+            // Dynamic model list — ask the SDK for its OWN supported models and surface
+            // them to the room so the /model picker renders live options (incl. new
+            // models like Fable) instead of a hardcoded three-item list. Fire-and-forget:
+            // older rooms just never receive it and keep their static fallback; a query
+            // that lacks supportedModels() (old SDK) silently no-ops. One-shot per session.
+            if (!modelsSent) {
+              modelsSent = true
+              Promise.resolve(q?.supportedModels?.()).then((ms) => {
+                const models = (ms || [])
+                  .map((x) => ({ value: x?.value, displayName: x?.displayName, description: x?.description }))
+                  .filter((x) => x.value)
+                if (models.length) emit({ kind: 'models', models })
+              }).catch(() => { /* no list available — room keeps its fallback */ })
+            }
             break
           case 'assistant':
             // Stamp tool-call start times so tool_result can report a duration.
@@ -700,7 +735,7 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
             turnActive = false               // turn settled → stall watchdog stands down
             restartCount = 0                 // a successful turn refills the auto-restart budget
             forceStopped = false
-            emit({ kind: 'result', subtype: m.subtype, sessionId, 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 })
+            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.)
             if (sugTimer) clearTimeout(sugTimer)
@@ -711,7 +746,7 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
               let ctx = null
               try {
                 const c = await q?.getContextUsage?.()
-                if (c) ctx = { used: c.totalTokens, max: c.maxTokens, pct: Math.round(c.percentage), model: c.model }
+                if (c) { ctx = { used: c.totalTokens, max: c.maxTokens, pct: Math.round(c.percentage), model: c.model }; if (c.model) curModel = c.model }
               } catch { /* control req may be unavailable */ }
               const u = m.usage || {}
               emit({ kind: 'usage', costUsd: m.total_cost_usd ?? null, tokens: (u.input_tokens || 0) + (u.output_tokens || 0), ctx })
@@ -775,8 +810,12 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
     async listModels() {
       try {
         const ms = await q?.supportedModels?.()
-        const names = (ms || []).map((x) => x.model || x.id || x.name).filter(Boolean)
-        emit({ kind: 'note', text: names.length ? `models: ${names.join(', ')}` : 'no model list available' })
+        const models = (ms || [])
+          .map((x) => ({ value: x?.value, displayName: x?.displayName, description: x?.description }))
+          .filter((x) => x.value)
+        // Structured event drives the picker; the note is a human-readable echo for the log.
+        if (models.length) emit({ kind: 'models', models })
+        emit({ kind: 'note', text: models.length ? `models: ${models.map((x) => x.value).join(', ')}` : 'no model list available' })
       } catch { emit({ kind: 'note', text: 'usage: /model <name>' }) }
     },
     // Graceful interrupt (Esc / Stop) — stops the current turn but keeps the

package/package.json

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