thinkpool-pair 0.7.205 → 0.7.206

package/bridge.mjs

@@ -101,7 +101,7 @@ import { formatPeek, PEEK, siblingsOf, resolveSibling, crossPostDecision, CROSSP
 import { armInterruptedResume, sendInterruptedContinue, supersedeInterruptedResume } from './interrupted-resume.mjs'
 import { turnInFlight } from './update-gate.mjs'
 import { saveSession, flushSession, deleteSession, loadAll, canResume, loadPtyId, savePtyId, loadNames, saveNames, appendDurableEvents, seedDurableEvents, readDurablePage, readDurableOldestSeq, hasDurableArchive, servesHistoryPage } from './session-store.mjs'
-import { stampEvent, makeSeqCounter, maxSeq, seqable, capReplayEvents, chunkReplayEvents, boundEventForBroadcast, inlineImageBlocks, usageReportLine, buildRecapFromLog, RECAP_CAP, trimmedBeforeSeq, firstSeq } from './event-id.mjs'
+import { stampEvent, makeSeqCounter, maxSeq, seqable, capReplayEvents, chunkReplayEvents, boundEventForBroadcast, inlineImageBlocks, usageReportLine, codexUsageReportLine, buildRecapFromLog, RECAP_CAP, trimmedBeforeSeq, firstSeq } from './event-id.mjs'
 import { planMeterLine } from './plan-meters.mjs'
 import { makeThrottledTrack } from './presence.mjs'
 import { resolveAnonKey, DEFAULT_SUPABASE_URL } from './supabase-key.mjs'
@@ -2425,6 +2425,20 @@ function openStructured({ id, runtime = 'claude', model, effort, resume, log, co
           : `\n  ${A.yel}● permission: ${req.toolName}${argStr(req.input)} — approve in the room.${A.rst}\n`)
     }),
   })
+  // A restored Codex lane may have a stale pre-0.7.206 meter persisted from the
+  // cumulative `turn.completed` bug. Replace it synchronously from the native
+  // rollout before announce/replay, so a reload is truthful even before the next
+  // human turn completes.
+  if (runtime === 'codex' && entry.session?.usageSnapshot?.context) {
+    const { used, max } = entry.session.usageSnapshot.context
+    entry.lastUsage = { kind: 'usage', ctx: {
+      used,
+      max,
+      pct: Math.min(100, Math.max(0, Math.round((used / max) * 100))),
+      over: used > max,
+      model: entry.model,
+    } }
+  }
   // Brand-new session (no restored log): write its record now so a restart that lands
   // before the first debounced save still restores this id instead of dropping it (the
   // room would otherwise show a fresh empty terminal + strand the transcript).
@@ -2973,17 +2987,19 @@ channel
       s.session.sendTurn(text)
       return
     }
-    // /usage → report this session's token + cost totals WITHOUT burning an agent turn.
-    // Computed by REPLAYING the session's own retained result events (each completed turn
-    // persists kind:'result' with usage + costUsd + model — see onEvent). No new accumulator
-    // state: the log is durable, so this survives a bridge restart for free. Reported as ◆
+    // /usage → report token totals WITHOUT burning an agent turn. Claude folds
+    // retained per-turn result events; Codex reads its native rollout snapshot
+    // because the CLI's public completion counters are lifetime thread totals.
+    // Reported as ◆
     // control lines (like /model) so both members AND late-joiners see it. Two lines: the
     // token/cost report (instant, from the retained log), then the plan meters (5h + weekly
     // utilization + server-authoritative resets) once the OAuth usage endpoint answers. The
     // meter line is fired-and-forgotten so a slow/unreachable endpoint never stalls /usage;
     // it degrades to "plan meters unavailable" rather than printing an inferred reset.
     if (/^\/usage\s*$/.test(text)) {
-      ctlLine(usageReportLine(s.model, s.log))
+      ctlLine(s.runtime === 'codex'
+        ? codexUsageReportLine(s.model, s.session?.usageSnapshot)
+        : usageReportLine(s.model, s.log))
       if (s.runtime !== 'codex') planMeterLine().then((l) => { if (l) ctlLine(l) }).catch(() => { /* meters are never load-bearing */ })
       return
     }

package/codex-event-mapper.mjs

@@ -42,7 +42,7 @@ export class CodexEventMapper {
   /**
    * @param {{onEvent:(evt)=>void, model?:string|null, sessionId?:string|null}} opts
    */
-  constructor({ onEvent, model = null, sessionId = null, fsImpl = fs, contextWindowForModel = () => null }) {
+  constructor({ onEvent, model = null, sessionId = null, fsImpl = fs, usageSnapshotForSession = () => null }) {
     this._onEvent = onEvent
     this._model = model || null
     this._sessionId = sessionId || null
@@ -50,7 +50,8 @@ export class CodexEventMapper {
     this._fileBefore = new Map() // item.id → [{ path, kind, content }]
     this._fs = fsImpl
     this._systemSent = false
-    this._contextWindowForModel = contextWindowForModel
+    this._usageSnapshotForSession = usageSnapshotForSession
+    this._usageBaseline = null
   }
 
   /** Emit a room-event; never let a consumer throw into the stream. */
@@ -58,6 +59,8 @@ export class CodexEventMapper {
 
   setModel(model) { this._model = model || null }
 
+  setUsageBaseline(snapshot) { this._usageBaseline = snapshot || null }
+
   /** Process one parsed Codex JSONL event. */
   push(ev) {
     if (!ev || typeof ev !== 'object') return
@@ -142,17 +145,22 @@ export class CodexEventMapper {
 
       case 'turn.completed': {
         const u = ev.usage || {}
-        // Map Codex usage → Claude-shape usage (what event-id.mjs folds into cost).
-        // reasoning_output_tokens are billed as output → fold in (conservative).
-        const out = (Number(u.output_tokens) || 0) + (Number(u.reasoning_output_tokens) || 0)
-        const totalInput = Number(u.input_tokens) || 0
-        const cachedInput = Math.min(totalInput, Number(u.cached_input_tokens) || 0)
-        let max = null
-        try { max = Number(this._contextWindowForModel(this._model)) } catch { /* unknown catalog → omit meter */ }
-        if (Number.isFinite(max) && max > 0) {
-          const used = totalInput + out
+        let snapshot = null
+        try { snapshot = this._usageSnapshotForSession(this._sessionId) } catch { /* unreadable rollout → omit meter */ }
+        const used = Number(snapshot?.context?.used)
+        const max = Number(snapshot?.context?.max)
+        if (Number.isFinite(used) && used >= 0 && Number.isFinite(max) && max > 0) {
           this._emit({ kind: 'usage', ctx: { used, max, pct: Math.min(100, Math.max(0, Math.round((used / max) * 100))), over: used > max, model: this._model } })
         }
+        // Codex's turn.completed values are lifetime thread totals, not turn
+        // deltas. Prefer the native rollout totals and subtract the pre-turn
+        // baseline. A fresh thread has no baseline, so its totals equal turn 1.
+        const totals = snapshot?.total || u
+        const before = this._usageBaseline?.total || {}
+        const totalInput = Math.max(0, (Number(totals.input_tokens) || 0) - (Number(before.input_tokens) || 0))
+        const cachedInput = Math.min(totalInput, Math.max(0, (Number(totals.cached_input_tokens) || 0) - (Number(before.cached_input_tokens) || 0)))
+        const out = Math.max(0, (Number(totals.output_tokens) || 0) - (Number(before.output_tokens) || 0))
+        this._usageBaseline = snapshot || null
         this._emit({
           kind: 'result',
           subtype: 'success',
@@ -161,8 +169,7 @@ export class CodexEventMapper {
           costUsd: null,
           usage: {
             // Claude-shape fields are mutually exclusive buckets. Codex reports
-            // cached_input_tokens as a subset of input_tokens, so subtract it here;
-            // usageReportLine adds the buckets and must not double-count cache hits.
+            // cached_input_tokens as a subset of input_tokens, so subtract it.
             input_tokens: totalInput - cachedInput,
             cache_read_input_tokens: cachedInput,
             cache_creation_input_tokens: 0,

package/codex-session.mjs

@@ -65,17 +65,68 @@ export function readCodexModels({ home = process.env.CODEX_HOME || path.join(os.
   } catch { return [] }
 }
 
-// The CLI's current model catalog is the authority for the runtime's usable model
-// window. Keep this separate from readCodexModels so the public announce shape stays
-// stable while the driver can emit a truthful context meter for every Codex model.
-export function readCodexContextWindow(model, { home = process.env.CODEX_HOME || path.join(os.homedir(), '.codex'), fsImpl = fs } = {}) {
-  if (!model) return null
+const rolloutPathCache = new Map()
+
+function codexRolloutPath(sessionId, { home, fsImpl }) {
+  if (!sessionId) return null
+  const cacheKey = `${home}\0${sessionId}`
+  const cached = rolloutPathCache.get(cacheKey)
+  if (cached) return cached
+  const root = path.join(home, 'sessions')
   try {
-    const data = JSON.parse(fsImpl.readFileSync(path.join(home, 'models_cache.json'), 'utf8'))
-    const hit = (Array.isArray(data?.models) ? data.models : []).find((m) => m?.slug === model)
-    const max = Number(hit?.context_window)
-    return Number.isFinite(max) && max > 0 ? Math.floor(max) : null
+    const suffix = `${sessionId}.jsonl`
+    const hit = fsImpl.readdirSync(root, { recursive: true, withFileTypes: true })
+      .find((entry) => entry.isFile() && entry.name.endsWith(suffix))
+    if (!hit) return null
+    const found = path.join(hit.parentPath || hit.path || root, hit.name)
+    rolloutPathCache.set(cacheKey, found)
+    return found
+  } catch { return null }
+}
+
+// `codex exec --json` exposes lifetime thread totals on `turn.completed`. Those
+// totals are useful for billing, but they are NOT context occupancy: an agentic
+// turn can make hundreds of cached model calls and process many context windows.
+// The native rollout's final token_count record carries both the exact last
+// request and Codex's usable window, so read only a bounded tail of that file.
+export function readCodexThreadUsage(sessionId, {
+  home = process.env.CODEX_HOME || path.join(os.homedir(), '.codex'),
+  fsImpl = fs,
+  tailBytes = 4 * 1024 * 1024,
+} = {}) {
+  const file = codexRolloutPath(sessionId, { home, fsImpl })
+  if (!file) return null
+  let fd
+  try {
+    const size = Number(fsImpl.statSync(file).size) || 0
+    const length = Math.min(size, Math.max(64 * 1024, tailBytes))
+    const buf = Buffer.alloc(length)
+    fd = fsImpl.openSync(file, 'r')
+    fsImpl.readSync(fd, buf, 0, length, size - length)
+    const lines = buf.toString('utf8').split('\n')
+    for (let i = lines.length - 1; i >= 0; i--) {
+      let row
+      try { row = JSON.parse(lines[i]) } catch { continue }
+      if (row?.payload?.type !== 'token_count' || !row.payload.info) continue
+      const info = row.payload.info
+      const last = info.last_token_usage || {}
+      const total = info.total_token_usage || {}
+      const used = Number(last.total_tokens)
+      const max = Number(info.model_context_window)
+      if (!Number.isFinite(used) || used < 0 || !Number.isFinite(max) || max <= 0) return null
+      return {
+        context: { used: Math.floor(used), max: Math.floor(max) },
+        total: {
+          input_tokens: Math.max(0, Number(total.input_tokens) || 0),
+          cached_input_tokens: Math.max(0, Number(total.cached_input_tokens) || 0),
+          output_tokens: Math.max(0, Number(total.output_tokens) || 0),
+        },
+        rateLimits: row.payload.rate_limits || null,
+      }
+    }
   } catch { return null }
+  finally { if (fd != null) { try { fsImpl.closeSync(fd) } catch { /* noop */ } } }
+  return null
 }
 
 export function normalizeCodexSandbox(value) {
@@ -158,6 +209,7 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
   let turnActive = false
   let activeModel = model || null
   let activeEffort = EFFORT_LEVELS.has(initialEffort) ? initialEffort : 'high'
+  let latestUsageSnapshot = sessionId ? readCodexThreadUsage(sessionId) : null
   let mcpHttpPromise = null
   // serialize turns: one exec at a time
   let chain = Promise.resolve()
@@ -166,7 +218,11 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
   const mapper = new CodexEventMapper({
     onEvent,
     model: model || null,
-    contextWindowForModel: (id) => readCodexContextWindow(id),
+    usageSnapshotForSession: (id) => {
+      const snapshot = readCodexThreadUsage(id)
+      if (snapshot) latestUsageSnapshot = snapshot
+      return snapshot
+    },
   })
 
   const note = (text) => { try { onEvent?.({ kind: 'note', text }) } catch { /* noop */ } }
@@ -197,6 +253,10 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
       prompt,
     })
 
+    // Snapshot lifetime totals before the turn. The mapper subtracts this from
+    // the post-turn totals so result/accounting events contain this turn only.
+    mapper.setUsageBaseline(sessionId ? readCodexThreadUsage(sessionId) : null)
+
     return new Promise((resolve) => {
       // stdin: /dev/null (spike gotcha — codex blocks on stdin otherwise)
       let stdinFd
@@ -267,6 +327,7 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
 
   return {
     get sessionId() { return sessionId },
+    get usageSnapshot() { return latestUsageSnapshot },
     get turnActive() { return turnActive },
     get started() { return turnNo > 0 || turnActive },
     sendTurn(text) {
@@ -305,6 +366,7 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
       // next turn so the selected mode is real, while ThinkPool keeps the lane log.
       sessionId = null
       turnNo = 0
+      latestUsageSnapshot = null
       return true
     },
     setEffort(nextEffort) {
@@ -317,6 +379,7 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
       if (turnActive) return false
       sessionId = null
       turnNo = 0
+      latestUsageSnapshot = null
       return true
     },
   }

package/event-id.mjs

@@ -284,6 +284,24 @@ export function usageReportLine (sessionModel, logEvents) {
   return `usage · ${turns} · ${perStr}${total}${cost}`
 }
 
+// Codex exposes exact current-context and lifetime-thread counters in its native
+// rollout telemetry. Keep this separate from usageReportLine: Claude result
+// events are per turn, while Codex's public turn.completed counters are lifetime
+// totals and cannot safely be folded from the retained log.
+export function codexUsageReportLine (sessionModel, snapshot) {
+  const ctx = snapshot?.context
+  const total = snapshot?.total
+  if (!ctx || !total) return 'usage · no completed Codex turn yet'
+  const fmtTok = (n) => n >= 1e6 ? (n / 1e6).toFixed(1) + 'M' : n >= 1e3 ? (n / 1e3).toFixed(1) + 'k' : String(Math.round(n || 0))
+  const used = Math.max(0, Number(ctx.used) || 0)
+  const max = Math.max(0, Number(ctx.max) || 0)
+  const pct = max > 0 ? Math.min(100, Math.max(0, Math.round((used / max) * 100))) : 0
+  const input = Math.max(0, Number(total.input_tokens) || 0)
+  const cached = Math.min(input, Math.max(0, Number(total.cached_input_tokens) || 0))
+  const output = Math.max(0, Number(total.output_tokens) || 0)
+  return `usage · ${prettyModelId(sessionModel)} · context ${fmtTok(used)}/${fmtTok(max)} (${pct}%) · thread ${fmtTok(input)} processed (${fmtTok(cached)} cached) / ${fmtTok(output)} out`
+}
+
 /* The context-carry recap moved to ./recap.mjs (ADR-0010 / S4, 2026-07-09).
  *
  * Why: the WEB CLIENT needs buildRecapFromLog to carry a lane's bridgeless

package/package.json

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