thinkpool-pair 0.7.204 → 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'
@@ -1759,7 +1759,7 @@ function openStructured({ id, runtime = 'claude', model, effort, resume, log, co
   // restart. Without this, sessionData omitted it → on restart the resumed session
   // re-launched on the host default (Opus) regardless of the last switch, and the
   // switch looked like it "never changed the model" (Max 2026-07-02). Restored below.
-  const sessionData = () => ({ sessionId: entry.session?.sessionId || resume || null, runtime: entry.runtime, log: entry.log, commands: entry.commands, mode: entry.mode, effort: entry.effort, model: entry.model || null, provider: entry.provider || null, spawnedBy: entry.spawnedBy, flowSessionId: entry.flowSessionId, flowTaskKey: entry.flowTaskKey, cwd: entry.cwd, managedWorktree: entry.managedWorktree, rolePrompt: entry.rolePrompt, flowReviewTarget: entry.flowReviewTarget || null, revertTarget: entry.revertTarget || null, reviewSliceRoots: entry.reviewSliceRoots || [], openedAt: entry.openedAt || null, lastUsage: entry.lastUsage || null })
+  const sessionData = () => ({ sessionId: entry.session?.sessionId || null, runtime: entry.runtime, log: entry.log, commands: entry.commands, mode: entry.mode, effort: entry.effort, model: entry.model || null, provider: entry.provider || null, spawnedBy: entry.spawnedBy, flowSessionId: entry.flowSessionId, flowTaskKey: entry.flowTaskKey, cwd: entry.cwd, managedWorktree: entry.managedWorktree, rolePrompt: entry.rolePrompt, flowReviewTarget: entry.flowReviewTarget || null, revertTarget: entry.revertTarget || null, reviewSliceRoots: entry.reviewSliceRoots || [], openedAt: entry.openedAt || null, lastUsage: entry.lastUsage || null, carryRecap: entry.pendingRecap || null })
   const persist = () => saveSession(room, id, sessionData())
   // Synchronous flush of this session's record. Used on open (so a brand-new session
   // has a file under its id BEFORE its first event — surviving a restart inside the
@@ -2098,7 +2098,8 @@ function openStructured({ id, runtime = 'claude', model, effort, resume, log, co
   // Context-carry (2026-07-08): a non-resumable re-open (provider switch / non-resumable
   // restart) hands the FRESH session a plain-text recap of the visible log as its first
   // input, so the agent picks up the work instead of starting blank mid-conversation. Held
-  // here (transient — NOT in sessionData, a re-restart re-derives it from the log) and fired
+  // here and persist it until consumed, so a restart between /compact and the next
+  // human turn cannot strand a fresh Codex thread without its recap. It is fired
   // on the init `system` event (see onEvent) — a sendTurn before the input stream is consumed
   // is silently lost (the 2026-07-02 auto-resume bug). Empty string → nothing to carry.
   entry.pendingRecap = (typeof carryRecap === 'string' && carryRecap.trim()) ? carryRecap : null
@@ -2286,6 +2287,7 @@ function openStructured({ id, runtime = 'claude', model, effort, resume, log, co
       if (evt.kind === 'system' && entry.pendingRecap) {
         const recap = entry.pendingRecap
         entry.pendingRecap = null
+        entry.flush?.()
         try { entry.session?.sendTurn(recap) } catch { /* not live — stays idle, user can continue manually */ }
         process.stderr.write(`\n  ◆ carried ${recap.length}c context recap into fresh session (${id.slice(0, 8)}) after provider/restore switch.\n`)
       }
@@ -2423,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).
@@ -2879,11 +2895,11 @@ channel
       pushLog(s, evt)
       bcast('code-event', { term: payload.term, evt })
     }
-    // Session controls (/model, /clear) are NOT agent turns — they change the
+    // Session controls (/model, /clear, /usage, and Codex /compact) are NOT agent turns — they change the
     // shared session config. Emitting a `you` line for them strands the reader's
     // inferred "working…" state (no turn → no result to clear it; the old bug).
-    // Instead announce a ◆ control line both readers see. /compact + any other
-    // slash still flow through as a real, self-terminating turn.
+    // Instead announce a ◆ control line both readers see. Claude /compact + any
+    // other slash still flow through as a real, self-terminating turn.
     const ctlLine = (ctlText) => {
       const evt = { kind: 'control', text: ctlText, by: payload.by, cid: payload.cid }
       pushLog(s, evt)
@@ -2936,7 +2952,33 @@ channel
     // No persisted ctl line — the live indicator + the CompactionCard are the record.
     if (/^\/compact\b/.test(text)) {
       if (s.runtime === 'codex') {
-        ctlLine('Codex manages context compaction automatically')
+        if (s.session.turnActive) {
+          ctlLine('finish or stop the current Codex turn before compacting context')
+          return
+        }
+        const recap = buildRecapFromLog(s.log, RECAP_CAP, { reason: 'compact' })
+        if (!recap) {
+          ctlLine('nothing to compact — context unchanged')
+          return
+        }
+        if (s.session.clearContext?.() === false) {
+          ctlLine('Codex context compaction unavailable right now')
+          return
+        }
+        s.pendingRecap = recap
+        const ce = { kind: 'compaction', trigger: 'manual', preTokens: s.lastUsage?.ctx?.used || null, by: payload.by }
+        pushLog(s, ce)
+        bcast('code-event', { term: payload.term, evt: ce })
+        // The new native thread has only the bounded recap queued for the next
+        // human turn. Reset the visible meter to that conservative text estimate.
+        if (s.lastUsage?.ctx?.max) {
+          const used = Math.ceil(recap.length / 4)
+          const max = s.lastUsage.ctx.max
+          const usage = { kind: 'usage', ctx: { ...s.lastUsage.ctx, used, max, pct: Math.min(100, Math.round((used / max) * 100)), over: used > max } }
+          s.lastUsage = usage
+          bcast('code-event', { term: payload.term, evt: usage })
+        }
+        s.flush?.()
         return
       }
       s.compacting = true
@@ -2945,18 +2987,20 @@ 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))
-      planMeterLine().then((l) => { if (l) ctlLine(l) }).catch(() => { /* meters are never load-bearing */ })
+      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
     }
     // Context-carry (2026-07-08) point 4: a real human turn arrived BEFORE the post-switch/
@@ -2964,7 +3008,7 @@ channel
     // — a separate recap turn would race + double-fire) and clear the flag so the init handler
     // no-ops. The visible `you` echo is unchanged; the recap is context for the agent only.
     let sendText = text
-    if (s.pendingRecap) { sendText = `${s.pendingRecap}\n\n--- the person's next message ---\n${text}`; s.pendingRecap = null }
+    if (s.pendingRecap) { sendText = `${s.pendingRecap}\n\n--- the person's next message ---\n${text}`; s.pendingRecap = null; s.flush?.() }
     s.session.sendTurn(sendText)
     echoYou()
     // Pool-order fix (2026-07-02): emit the "dispatched to agent" marker HERE, right after
@@ -3193,7 +3237,7 @@ channel
             // FL-M6 — restore the flow context (id/role/cwd) so an in-flight flow survives a
             // bridge restart: the conductor keeps its subagent-block + plan interception, and
             // lanes keep their worktree cwd + the ability to mark done.
-            openStructured({ id: rec.id, runtime: rec.runtime || 'claude', model: rec.model || undefined, effort: rec.effort, provider: rec.runtime === 'codex' ? undefined : rec.provider || undefined, resume: canResume(rec) ? rec.sessionId : undefined, log: rec.log, commands: rec.commands, mode: rec.mode, spawnedBy: rec.spawnedBy, flowSessionId: rec.flowSessionId, flowTaskKey: rec.flowTaskKey, cwd: rec.cwd, managedWorktree: rec.managedWorktree, rolePrompt: rec.rolePrompt, reviewSliceRoots: rec.reviewSliceRoots, openedAt: rec.openedAt, lastUsage: rec.lastUsage,
+            openStructured({ id: rec.id, runtime: rec.runtime || 'claude', model: rec.model || undefined, effort: rec.effort, provider: rec.runtime === 'codex' ? undefined : rec.provider || undefined, resume: canResume(rec) ? rec.sessionId : undefined, log: rec.log, commands: rec.commands, mode: rec.mode, spawnedBy: rec.spawnedBy, flowSessionId: rec.flowSessionId, flowTaskKey: rec.flowTaskKey, cwd: rec.cwd, managedWorktree: rec.managedWorktree, rolePrompt: rec.rolePrompt, reviewSliceRoots: rec.reviewSliceRoots, openedAt: rec.openedAt, lastUsage: rec.lastUsage, carryRecap: rec.carryRecap,
               // Lazy-boot restored terminals that were IDLE + not part of a flow: their transcript
               // shows immediately; the query boots on first turn. Mid-turn + flow terminals boot now
               // (mid-turn needs auto-resume; flow needs its lane live).

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 }) {
+  constructor({ onEvent, model = null, sessionId = null, fsImpl = fs, usageSnapshotForSession = () => null }) {
     this._onEvent = onEvent
     this._model = model || null
     this._sessionId = sessionId || null
@@ -50,6 +50,8 @@ export class CodexEventMapper {
     this._fileBefore = new Map() // item.id → [{ path, kind, content }]
     this._fs = fsImpl
     this._systemSent = false
+    this._usageSnapshotForSession = usageSnapshotForSession
+    this._usageBaseline = null
   }
 
   /** Emit a room-event; never let a consumer throw into the stream. */
@@ -57,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
@@ -141,9 +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 = (u.output_tokens || 0) + (u.reasoning_output_tokens || 0)
+        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',
@@ -151,8 +168,10 @@ export class CodexEventMapper {
           model: this._model,
           costUsd: null,
           usage: {
-            input_tokens: u.input_tokens || 0,
-            cache_read_input_tokens: u.cached_input_tokens || 0,
+            // Claude-shape fields are mutually exclusive buckets. Codex reports
+            // 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,
             output_tokens: out,
           },

package/codex-session.mjs

@@ -65,6 +65,70 @@ export function readCodexModels({ home = process.env.CODEX_HOME || path.join(os.
   } catch { return [] }
 }
 
+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 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) {
   return SAFE_SANDBOXES.has(value) ? value : DEFAULT_SANDBOX
 }
@@ -145,12 +209,21 @@ 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()
   const queue = []
 
-  const mapper = new CodexEventMapper({ onEvent, model: model || null })
+  const mapper = new CodexEventMapper({
+    onEvent,
+    model: model || null,
+    usageSnapshotForSession: (id) => {
+      const snapshot = readCodexThreadUsage(id)
+      if (snapshot) latestUsageSnapshot = snapshot
+      return snapshot
+    },
+  })
 
   const note = (text) => { try { onEvent?.({ kind: 'note', text }) } catch { /* noop */ } }
 
@@ -180,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
@@ -250,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) {
@@ -288,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) {
@@ -300,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.204",
+  "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": {

package/recap.mjs

@@ -42,6 +42,10 @@ const FRAMING = {
     header: '[CONTEXT CARRY — this lane kept talking while your machine was asleep]',
     body: "Your bridge was offline. The lane stayed open and the people in this room kept planning here with Pool — a chat-only assistant with no file access and no tools. Everything below already happened and they have all seen it. NOTHING WAS RUN ON YOUR BEHALF: no commands were executed, no files were changed, and no plan below has been carried out. Do NOT re-greet and do NOT re-answer what is already answered. Read the recap, then wait for the people to tell you what to do with it — the plan below is a plan, not an instruction you have already been given.",
   },
+  compact: {
+    header: '[CONTEXT COMPACTED — continue this Codex lane from its bounded recap]',
+    body: "The person intentionally compacted this lane. Your prior native thread was closed and the visible conversation below is its bounded continuation context. Do NOT re-greet, do NOT re-answer completed work, and do NOT repeat tool calls that already succeeded. Continue from the person's next message using this recap as memory.",
+  },
 }
 
 /* Context-carry recap for a lane whose SDK memory CAN'T be resumed — a cross-provider