thinkpool-pair 0.7.204 → 0.7.205

package/bridge.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`)
       }
@@ -2879,11 +2881,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 +2938,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
@@ -2956,7 +2984,7 @@ channel
     // 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 */ })
+      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 +2992,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 +3221,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, contextWindowForModel = () => null }) {
     this._onEvent = onEvent
     this._model = model || null
     this._sessionId = sessionId || null
@@ -50,6 +50,7 @@ export class CodexEventMapper {
     this._fileBefore = new Map() // item.id → [{ path, kind, content }]
     this._fs = fsImpl
     this._systemSent = false
+    this._contextWindowForModel = contextWindowForModel
   }
 
   /** Emit a room-event; never let a consumer throw into the stream. */
@@ -143,7 +144,15 @@ export class CodexEventMapper {
         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)
+        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
+          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 } })
+        }
         this._emit({
           kind: 'result',
           subtype: 'success',
@@ -151,8 +160,11 @@ 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 here;
+            // usageReportLine adds the buckets and must not double-count cache hits.
+            input_tokens: totalInput - cachedInput,
+            cache_read_input_tokens: cachedInput,
             cache_creation_input_tokens: 0,
             output_tokens: out,
           },

package/codex-session.mjs

@@ -65,6 +65,19 @@ 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
+  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
+  } catch { return null }
+}
+
 export function normalizeCodexSandbox(value) {
   return SAFE_SANDBOXES.has(value) ? value : DEFAULT_SANDBOX
 }
@@ -150,7 +163,11 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
   let chain = Promise.resolve()
   const queue = []
 
-  const mapper = new CodexEventMapper({ onEvent, model: model || null })
+  const mapper = new CodexEventMapper({
+    onEvent,
+    model: model || null,
+    contextWindowForModel: (id) => readCodexContextWindow(id),
+  })
 
   const note = (text) => { try { onEvent?.({ kind: 'note', text }) } catch { /* noop */ } }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.204",
+  "version": "0.7.205",
   "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