@cocorograph/hub-agent 0.7.84 → 0.7.86

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocorograph/hub-agent",
-  "version": "0.7.84",
+  "version": "0.7.86",
   "description": "Hub Hosted Cockpit のローカル常駐 agent。Hub と outbound WSS で接続し、ローカルの tmux/pty を中継する。",
   "type": "module",
   "license": "UNLICENSED",

package/src/codex-stream-bridge.mjs

@@ -870,6 +870,11 @@ export class CodexStreamBridge extends EventEmitter {
     }
     this.emit("event", {
       stream_id,
+      // producer_seq: この通知を出した **session(producer) の immutable ID**（生成時に振る
+      // 単調増加 seq）。stream_id は購読端末で reattach/detach で付け替わるため、context% の
+      // live store キーには使えない (T06407 増分2: stale slot / Map リークの原因)。producer 単位で
+      // live tokenUsage を保持し、cwd の権威 producer で代表を選ぶために main.mjs へ渡す。
+      producer_seq: session.seq,
       thread_id: session.threadId,
       cwd: session.cwd,
       notification: { method: msg.method, params: msg.params },
@@ -957,6 +962,7 @@ export class CodexStreamBridge extends EventEmitter {
     }
     this.emit("exit", {
       stream_id: session.stream_id,
+      producer_seq: session.seq,
       thread_id: session.threadId,
       code: info.code,
       reason: info.signal ? `signal:${info.signal}` : "process-exit",
@@ -1316,21 +1322,51 @@ export class CodexStreamBridge extends EventEmitter {
     return out
   }
 
+  /**
+   * 指定 cwd の「権威セッション」を返す（T06407 増分2, axis2 の単一正本）。同一 cwd に複数
+   * ライブ codex セッションがあるとき、**最終活性が最新のもの**（＝いまユーザーが使っている
+   * 会話）を選ぶ。sendToCwd の宛先選定と同じ規則に揃える。
+   *
+   * ⚠️ context%（ドーナツ）は thread 固有の値なので「どのセッションから読んでも同じ」という
+   * 旧 rate-limit 前提（先着 1 件で十分）は成り立たない。state loop（threadIdForCwd 経由）と
+   * usage.response（per-cwd 集計）が **別の thread を選ぶと両経路が収束せずドーナツが前後する**
+   * ため、両経路をこの一意規則へ寄せる。「最新」は閲覧 keepalive で動く lastActivityMs では
+   * なく会話ターン境界時刻 lastTurnAtMs を基準にする（見ているだけの古い会話が本命を追い越す
+   * のを防ぐ）。
+   *
+   * @param {string} cwd
+   * @returns {object|null} 権威セッション（無ければ null）
+   */
+  liveSessionForCwd(cwd) {
+    if (!cwd) return null
+    let best = null
+    let bestAt = -1
+    // 案B: distinct session で走査（多対一 Map の重複を除く）。
+    for (const session of this._liveSessions()) {
+      if (session.cwd !== cwd || !session.threadId) continue
+      const at = session.lastTurnAtMs ?? session.lastActivityMs ?? 0
+      if (at >= bestAt) {
+        bestAt = at
+        best = session
+      }
+    }
+    return best
+  }
+
   /**
    * 指定 cwd に一致するライブ (attach 済み) codex セッションの threadId を返す。
    * Claude 版 `liveSessionIdForCwd` の対 (main.mjs の state loop / terminal mirror から
-   * cwd → threadId 解決に使う)。複数一致時は先に見つかったものを返す (5h/7d はアカウント
-   * 全体の値のためどのセッションから読んでも同じ契約の残量、代表 1 件で十分)。
+   * cwd → threadId 解決に使う)。
+   *
+   * ⚠️ T06407 増分2: 旧実装は「先に見つかったもの」を返していたが、これは 5h/7d（アカウント
+   * 全体で代表 1 件で十分）前提だった。context% は thread 固有なので liveSessionForCwd の
+   * 権威規則（最終活性が最新）で解決し、usage.response の per-cwd 集計と収束させる。
    *
    * @param {string} cwd
    * @returns {string|null}
    */
   threadIdForCwd(cwd) {
-    if (!cwd) return null
-    for (const session of this.sessions.values()) {
-      if (session.cwd === cwd && session.threadId) return session.threadId
-    }
-    return null
+    return this.liveSessionForCwd(cwd)?.threadId ?? null
   }
 
   /**
@@ -1526,6 +1562,7 @@ export class CodexStreamBridge extends EventEmitter {
     )
     this.emit("exit", {
       stream_id: session.stream_id,
+      producer_seq: session.seq,
       thread_id: session.threadId,
       code: 0,
       reason: "idle-reaped",
@@ -1679,6 +1716,19 @@ export class CodexStreamBridge extends EventEmitter {
           ? "codex session killed MID-TURN by agent shutdown"
           : "codex session stopped by agent shutdown",
       )
+      // T06407 増分2 (codex-review round2 major#1): shutdown 経由の撤去 (codex.profile.switch /
+      // プロセス終了) でも producer live store を掃除する。この後の client.stop() が誘発する
+      // client "exit" は _onClientExit が session.dead=true で early-return するため exit を
+      // emit しない。ここで明示的に emit し、main.mjs の exit ハンドラ
+      // (forgetCodexLiveTokenUsage) を必ず通す。これが無いと profile 切替ごとに producer Map が
+      // リークする。dead は既に上で立てているので二重 emit にはならない。
+      this.emit("exit", {
+        stream_id: session.stream_id,
+        producer_seq: session.seq,
+        thread_id: session.threadId,
+        code: 0,
+        reason: "agent-shutdown",
+      })
       session.client.stop()
     }
     this.sessions.clear()

package/src/main.mjs

@@ -117,16 +117,20 @@ import { JsonlLiveWatchers } from "./jsonl-live-watchers.mjs"
 import { SiblingInjectBridge } from "./sibling-inject.mjs"
 import {
   boundSessionId,
+  codexContextPercentFromTokenUsage,
+  codexLiveContextForProducer,
   codexSessionUsages,
   codexTurnActiveForThread,
   codexUsageForThread,
   contextWindowSize,
+  forgetCodexLiveTokenUsage,
   getSessionUsages,
   getUsage,
   isFreshUnboundBind,
   jsonlContextForCwd,
   recordChatRateLimit,
   recordChatUsageSnapshot,
+  recordCodexLiveTokenUsage,
   turnActiveForCwd,
 } from "./usage.mjs"
 import {
@@ -966,7 +970,15 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
   // (codex 側にまだ存在しない/後続スライス)。ステータスドット用のチャット信号は
   // turn/started・turn/completed のみ最小限で反映する (claude の assistant/result 相当)。
   if (codexBridge) {
-    codexBridge.on("event", ({ stream_id, thread_id, cwd, notification }) => {
+    // T06407 増分2 (codex-review round1 major#3): この producer(session.seq) が cwd の
+    // **権威 producer** (liveSessionForCwd = 会話ターン最新) かを判定する。チャット信号
+    // (recordChatActivity) の context/sessionId は権威 producer の分だけ書く。非権威 producer
+    // の context/sessionId をチャット信号へ書くと、権威 thread の live 未取得の窓で overlay 経由
+    // に混入し、usage.response (権威 producer ベース) と分岐してドーナツが前後する。
+    const isCodexAuthority = (cwd, producerSeq) =>
+      typeof producerSeq === "number" &&
+      codexBridge?.liveSessionForCwd?.(cwd)?.seq === producerSeq
+    codexBridge.on("event", ({ stream_id, producer_seq, thread_id, cwd, notification }) => {
       if (notification.method === "turn/started") {
         // S1 (2026-07): contextPct を渡していなかったため、Codex 選択中は状態ドット
         // (processing/waiting) こそ更新されるがコンテキスト% は claude 由来の古い値の
@@ -975,18 +987,17 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
         ;(async () => {
           let contextPct = null
           try {
-            const usage = await codexUsageForThread(thread_id)
+            const usage = await codexUsageForThread(thread_id, { producerSeq: producer_seq })
             contextPct = typeof usage?.context === "number" ? usage.context : null
           } catch {
             /* ignore */
           }
           try {
-            recordChatActivity(cwd, "codex", {
-              status: "processing",
-              contextPct,
-              inputPending: false,
-              sessionId: thread_id || null,
-            })
+            recordChatActivity(
+              cwd,
+              "codex",
+              buildCodexChatPatch("processing", contextPct, thread_id, isCodexAuthority(cwd, producer_seq)),
+            )
           } catch {
             /* ignore */
           }
@@ -995,22 +1006,46 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
         ;(async () => {
           let contextPct = null
           try {
-            const usage = await codexUsageForThread(thread_id)
+            const usage = await codexUsageForThread(thread_id, { producerSeq: producer_seq })
             contextPct = typeof usage?.context === "number" ? usage.context : null
           } catch {
             /* ignore */
           }
           try {
-            recordChatActivity(cwd, "codex", {
-              status: "waiting",
-              contextPct,
-              inputPending: false,
-              sessionId: thread_id || null,
-            })
+            recordChatActivity(
+              cwd,
+              "codex",
+              buildCodexChatPatch("waiting", contextPct, thread_id, isCodexAuthority(cwd, producer_seq)),
+            )
           } catch {
             /* ignore */
           }
         })()
+      } else if (notification.method === "thread/tokenUsage/updated") {
+        // T06407 増分2 (症状⑥ ドーナツ前後動の根治): App Server の live tokenUsage を
+        // context% の正本にする。**producer(session.seq) 単位**でストアへ記録し (usage.response /
+        // state loop が cwd の権威 producer の seq で参照する)、同時にチャット信号 (overlay 経路) の
+        // context_pct も同じ live 値で更新する。status は上書きしない (このイベントはターン進行中に
+        // 届くため keep-prev。processing/waiting は turn/started・turn/completed が管理する)。
+        const tokenUsage = notification.params?.tokenUsage
+        if (typeof producer_seq === "number" && tokenUsage) {
+          try {
+            recordCodexLiveTokenUsage(producer_seq, tokenUsage)
+          } catch {
+            /* ignore */
+          }
+          // major#3: チャット信号の context/sessionId は権威 producer のときだけ書く。
+          if (isCodexAuthority(cwd, producer_seq)) {
+            const contextPct = codexContextPercentFromTokenUsage(tokenUsage)
+            if (typeof contextPct === "number" && cwd) {
+              try {
+                recordChatActivity(cwd, "codex", { contextPct, sessionId: thread_id })
+              } catch {
+                /* ignore */
+              }
+            }
+          }
+        }
       }
       client.send({ type: "codex.event", stream_id, thread_id, event: notification })
     })
@@ -1032,7 +1067,15 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
         params,
       })
     })
-    codexBridge.on("exit", ({ stream_id, thread_id, code, reason }) => {
+    codexBridge.on("exit", ({ stream_id, producer_seq, thread_id, code, reason }) => {
+      // T06407 増分2: この producer(session.seq) の live tokenUsage スロットを破棄する。
+      // seq は immutable なので、reattach で stream_id が付け替わっても alias slot / Map リークは
+      // 生じない (stream_id キー時代の major#1 を解消)。
+      try {
+        forgetCodexLiveTokenUsage(producer_seq)
+      } catch {
+        /* ignore */
+      }
       client.send({ type: "codex.exit", stream_id, thread_id, code, reason })
     })
     codexBridge.on("error", ({ stream_id, thread_id, error }) => {
@@ -2162,6 +2205,45 @@ export function applyChatOverlay(paneStatus, paneContextPct, chat) {
   return { status, contextPct }
 }
 
+/**
+ * T06407 増分2 (codex-review round1 major#3): codex チャット信号 (recordChatActivity) の
+ * patch を組み立てる。status (processing/waiting) は cwd レベルの「ターン進行中か」信号なので
+ * 常に書き、**context_pct / sessionId は権威 producer のときだけ**含める。非権威 producer の
+ * context/sessionId をチャット信号へ書くと、権威 thread の live 未取得の窓で overlay 経由に
+ * 混入し、usage.response (権威 producer ベース) と分岐してドーナツが前後する。
+ *
+ * @param {'processing'|'waiting'} status
+ * @param {number|null} contextPct
+ * @param {string|null} threadId
+ * @param {boolean} isAuthority この producer が cwd の権威 (liveSessionForCwd) か
+ * @returns {{status:string, inputPending:boolean, contextPct?:number, sessionId?:string|null}}
+ */
+export function buildCodexChatPatch(status, contextPct, threadId, isAuthority) {
+  const patch = { status, inputPending: false }
+  if (isAuthority) {
+    patch.sessionId = threadId || null
+    if (typeof contextPct === "number") patch.contextPct = contextPct
+  }
+  return patch
+}
+
+/**
+ * T06407 増分2 (codex-review round2 major#2): usage.response の codexSessions を、集計に
+ * 使った producer が **今なお cwd の権威**である entry だけへ絞る post-await ガード。
+ * codexSessionUsages の rollout I/O 中に別 session が権威化した cwd の entry (= 旧 producer の
+ * context) を破棄する。破棄された cwd は frontend が state loop の live.context_pct へフォール
+ * バックする (毎 tick 権威を同期解決 = TOCTOU 無し)。
+ *
+ * @param {Array<{cwd:string, contextPercent:number, ...}>} codexSessions codexSessionUsages の結果
+ * @param {Map<string, number>} producerByCwd cwd → 集計に使った producer seq
+ * @param {(cwd:string)=>number|undefined} seqForCwd cwd → 現在の権威 producer seq
+ * @returns {Array} 権威が一致する entry のみ
+ */
+export function filterCodexSessionsByAuthority(codexSessions, producerByCwd, seqForCwd) {
+  if (!Array.isArray(codexSessions)) return []
+  return codexSessions.filter((e) => seqForCwd(e.cwd) === producerByCwd.get(e.cwd))
+}
+
 /**
  * S1 (2026-07): claude.attach / codex.attach の直後に、その cwd に対応する session.state を
  * 1 回だけ即時 push する。startStateLoop の周期 (既定 5s) を待つと、エンジン切替や新規
@@ -2449,10 +2531,31 @@ export function startStateLoop({ client, plugins, logger, intervalMs, claudeBrid
         //    分岐の優先順位は decideTurnActiveSource (純関数、単体テスト済み) が権威。
         let turnActive = null
         // codex 行のときだけ rollout ベース判定の材料を引く (claude 行では常に null)。
-        const codexThreadId =
+        // cwd の**権威 producer session** を 1 度だけ引き、threadId(turn_active 判定用) と
+        // seq(context% の live source 参照キー) の両方を同一 session から取る。これで
+        // usage.response の per-cwd 集計 (同じ liveSessionForCwd) と同じ producer を選び収束する
+        // (axis2)。liveSessionForCwd は会話ターン最新 (lastTurnAtMs) の一意規則。
+        const codexAuthSession =
           s.cwd && sessionCliKind === "codex"
-            ? codexBridge?.threadIdForCwd?.(s.cwd) || null
+            ? codexBridge?.liveSessionForCwd?.(s.cwd) || null
             : null
+        const codexThreadId = codexAuthSession?.threadId || null
+        // T06407 増分2 (axis3): codex 行の context%(ドーナツ) は TTL 非依存の live store
+        // (thread/tokenUsage/updated 由来) を権威 producer(seq) で引き、chat overlay より優先して
+        // 恒久収束させる。ただし **applyChatOverlay と同じ paneIsProcessing ガードを尊重する**:
+        // 本物の TUI が生成中 (capture-pane が processing = "esc to interrupt" 実在) のときは、
+        // その pane 由来の実 context_pct を stale な live 値で上書きしない (warm chat と Codex TUI
+        // 併存時の TUI ドーナツ破壊を防ぐ。chat overlay は既に上書きを見送っている)。素のシェル
+        // (chat モードのペイン) は processing を返せないため override は従来通り効く。
+        const paneIsProcessing = s.status === "processing"
+        if (
+          sessionCliKind === "codex" &&
+          typeof codexAuthSession?.seq === "number" &&
+          !paneIsProcessing
+        ) {
+          const liveCtx = codexLiveContextForProducer(codexAuthSession.seq)
+          if (typeof liveCtx === "number") contextPct = liveCtx
+        }
         const turnActiveSource = decideTurnActiveSource({
           chatStatus: chat?.status,
           cwd: s.cwd,
@@ -4529,9 +4632,19 @@ async function dispatch(msg, ctx) {
                 contextPct: 0,
               }).catch(() => {})
             } else {
-              codexUsageForThread(info.threadId)
+              // 増分2: context% は cwd の権威 producer(seq) の live を正本にする (resume 直後の
+              // このセッションは lastTurnAtMs=now で権威。live 未取得なら rollout フォールバック)。
+              const resumeProducerSeq = ctx.codexBridge?.liveSessionForCwd?.(resolvedCwd)?.seq
+              codexUsageForThread(info.threadId, { producerSeq: resumeProducerSeq })
                 .catch(() => null)
                 .then((usage) => {
+                  // ⚠️ codex-review round2 major#2: rollout I/O 中に別 session が権威化しうる。
+                  // await 後に権威 seq を再検証し、この resume session が現権威でなければ即時 push を
+                  // 見送る (古い context/sessionId を書かない。state loop が ≤5s で正す)。
+                  const stillAuthority =
+                    resumeProducerSeq != null &&
+                    ctx.codexBridge?.liveSessionForCwd?.(resolvedCwd)?.seq === resumeProducerSeq
+                  if (!stillAuthority) return undefined
                   const contextPct = typeof usage?.context === "number" ? usage.context : 0
                   recordChatActivity(resolvedCwd, "codex", {
                     status: "waiting",
@@ -5414,14 +5527,53 @@ async function dispatch(msg, ctx) {
           let codexSessions = []
           if (ctx.codexBridge && ctx.codexBridge.sessions.size > 0) {
             try {
-              const liveCodex = Array.from(ctx.codexBridge.sessions.values())
-                .filter((s) => s.threadId && s.cwd)
-                .map((s) => ({ sessionId: s.threadId, cwd: s.cwd, threadId: s.threadId }))
+              // T06407 増分2 (axis2): per-cwd の context% は **cwd ごとに権威 producer 1 件**へ
+              // 集約する。旧実装は全 live session を codexSessions へ流していたため、同一 cwd に
+              // 複数 thread があると frontend の usageByCwd (updatedAtMs 同値で first-wins) が
+              // 任意のスレッドを拾い、state loop (権威 producer) と別 thread を選んでドーナツが
+              // 前後した。liveSessionForCwd の同一規則で cwd → 権威 producer(session) を一意化し、
+              // producerSeq を context% の live source として通して両経路を収束させる。
+              const cwds = new Set()
+              for (const s of ctx.codexBridge.sessions.values()) {
+                if (s.threadId && s.cwd) cwds.add(s.cwd)
+              }
+              const liveCodex = []
+              for (const cwd of cwds) {
+                const authoritative = ctx.codexBridge.liveSessionForCwd?.(cwd)
+                if (authoritative?.threadId) {
+                  liveCodex.push({
+                    sessionId: authoritative.threadId,
+                    cwd: authoritative.cwd,
+                    threadId: authoritative.threadId,
+                    producerSeq: authoritative.seq,
+                  })
+                }
+              }
               if (liveCodex.length > 0) {
                 // 5h/7d はアカウント全体の値 (どの live session から読んでも同じ契約の残量)
-                // なので、代表として最初の 1 件から取る。
-                codexUsage = await codexUsageForThread(liveCodex[0].threadId)
+                // なので、代表として最初の 1 件から取る (context% はその producer の live を使う)。
+                codexUsage = await codexUsageForThread(liveCodex[0].threadId, {
+                  producerSeq: liveCodex[0].producerSeq,
+                })
                 codexSessions = await codexSessionUsages(liveCodex)
+                // ⚠️ codex-review round2 major#2: codexSessionUsages の rollout I/O 中に cwd の
+                // 権威 producer が別 session へ移りうる。await 後に各 cwd の現権威 seq を再検証し、
+                // 集計に使った producer が現権威でない entry は破棄する (古い producer の context を
+                // codexCtxByCwd へ出さない)。破棄した cwd は frontend が state loop の
+                // live.context_pct (毎 tick 権威を同期解決=TOCTOU 無し) にフォールバックする。
+                const seqForCwd = (cwd) => ctx.codexBridge.liveSessionForCwd?.(cwd)?.seq
+                const producerByCwd = new Map(liveCodex.map((e) => [e.cwd, e.producerSeq]))
+                codexSessions = filterCodexSessionsByAuthority(
+                  codexSessions,
+                  producerByCwd,
+                  seqForCwd,
+                )
+                // codex-review round3 minor#1: 集約 codexUsage.context は代表 producer
+                // (liveCodex[0]) の値。await 中に代表が権威を失っていたら旧 context を出さない
+                // (context だけ null 化。5h/7d は account-wide なので保持する)。
+                if (codexUsage && seqForCwd(liveCodex[0].cwd) !== liveCodex[0].producerSeq) {
+                  codexUsage = { ...codexUsage, context: null }
+                }
               }
             } catch (err) {
               ctx.logger?.debug?.({ err: err?.message }, "codex usage snapshot skipped")

package/src/usage.mjs

@@ -1483,29 +1483,236 @@ export function _resetCodexTokenCountMemo() {
   _codexTokenCountMemo.clear()
 }
 
+/**
+ * Codex rate limit の窓分類定数 (T06407)。5h 窓 = 300 分、7d 窓 = 10080 分。
+ * ⚠️ 位置 (primary/secondary) は 5h/7d を保証しない。実測 (0.144.x / pro プラン) では
+ * primary が windowDurationMins=10080 (=7日)・secondary=null を返す。よって窓の分類は
+ * **duration で行う** (症状⑦「7d が進まない」の根治)。閾値は 5h と 7d の中点 (~5190 分)。
+ */
+const CODEX_5H_WINDOW_MINS = 300
+const CODEX_7D_WINDOW_MINS = 10080
+/** 分類スロットの正準窓長。窓は「最も近い正準窓」のスロットへ割り当てる（中点固定分割だと
+ *  将来 1h+5h のような同帯 2 窓で実 5h を取りこぼす。codex-review minor 対応）。 */
+const CODEX_RATE_LIMIT_SLOTS = [
+  { key: "last5h", canonicalMins: CODEX_5H_WINDOW_MINS },
+  { key: "last7d", canonicalMins: CODEX_7D_WINDOW_MINS },
+]
+
+/** RateLimitWindow (App Server = camelCase / rollout jsonl = snake_case の両対応) から
+ *  used% を読む。値が無ければ null (= その窓は「未提供」)。 */
+function codexWindowUsedPercent(w) {
+  if (!w) return null
+  if (typeof w.usedPercent === "number") return w.usedPercent
+  if (typeof w.used_percent === "number") return w.used_percent
+  return null
+}
+
+/** RateLimitWindow の窓長 (分)。camelCase/snake_case 両対応。不明なら null。 */
+function codexWindowMins(w) {
+  if (!w) return null
+  if (typeof w.windowDurationMins === "number") return w.windowDurationMins
+  if (typeof w.window_minutes === "number") return w.window_minutes
+  return null
+}
+
+/** RateLimitWindow の resets 時刻 (ms)。camelCase/snake_case 両対応。秒→ms 補正あり。 */
+function codexWindowResetMs(w) {
+  if (!w) return null
+  const raw =
+    typeof w.resetsAt === "number"
+      ? w.resetsAt
+      : typeof w.resets_at === "number"
+        ? w.resets_at
+        : null
+  if (typeof raw !== "number") return null
+  return raw < 1e12 ? raw * 1000 : raw
+}
+
+/** 「未提供」bucket。欠落窓を 0% と誤表示せず、frontend が「未提供」と描画できるよう
+ *  provided:false / percent:null を返す (fail-soft で沈黙させない)。 */
+function codexNotProvidedBucket() {
+  return {
+    tokens: 0,
+    messages: 0,
+    limit: CODEX_DEFAULT_LIMIT,
+    percent: null,
+    provided: false,
+    windowMinutes: null,
+    oldestTsMs: null,
+    resetAtMs: null,
+  }
+}
+
+/**
+ * RateLimitSnapshot (App Server の `account/rateLimits/read`/`updated` または rollout の
+ * `rate_limits`、両 casing) を **窓長で 5h/7d スロットへ分類**する (T06407)。
+ *
+ * - primary/secondary の**位置に依存しない**。各窓の windowDurationMins/window_minutes を見て、
+ *   **正準窓長に最も近いスロット**へ割り当てる (5h=300 分 / 7d=10080 分)。
+ * - 提供されない窓 (null / used% 欠落 / duration 不明) は 0% ではなく「未提供」で返す。
+ * - 同一スロットに複数窓が来たら、そのスロットの正準窓長に**より近い**窓を採用する
+ *   (先着でなく最近傍。将来 1h+5h のような同帯 2 窓でも実 5h を取りこぼさない)。
+ *
+ * @param {object|null} snapshot RateLimitSnapshot 相当 ({ primary, secondary, ... })
+ * @returns {{ last5h: object, last7d: object }} 各 bucket は provided:true|false を持つ
+ */
+export function classifyCodexRateLimitWindows(snapshot) {
+  const result = { last5h: codexNotProvidedBucket(), last7d: codexNotProvidedBucket() }
+  if (!snapshot) return result
+  // 各スロットに「これまで割り当てた窓の正準窓長からの距離」を持ち、より近い窓で上書きする。
+  const bestDist = { last5h: Infinity, last7d: Infinity }
+  for (const w of [snapshot.primary, snapshot.secondary]) {
+    const usedPercent = codexWindowUsedPercent(w)
+    if (usedPercent === null) continue
+    const mins = codexWindowMins(w)
+    // duration 不明は分類できない → 未提供のままにする (位置で 5h/7d に決め打ちしない)。
+    if (mins === null) continue
+    // 最も近い正準窓のスロットへ割り当てる。
+    let slot = null
+    let slotDist = Infinity
+    for (const s of CODEX_RATE_LIMIT_SLOTS) {
+      const d = Math.abs(mins - s.canonicalMins)
+      if (d < slotDist) {
+        slotDist = d
+        slot = s.key
+      }
+    }
+    // 同一スロットに複数窓が来たら、正準窓長により近い方を採用 (先着でなく最近傍)。
+    if (slotDist >= bestDist[slot]) continue
+    bestDist[slot] = slotDist
+    result[slot] = {
+      tokens: 0,
+      messages: 0,
+      limit: CODEX_DEFAULT_LIMIT,
+      percent: usedPercent,
+      provided: true,
+      windowMinutes: mins,
+      oldestTsMs: null,
+      resetAtMs: codexWindowResetMs(w),
+    }
+  }
+  return result
+}
+
+// ---------------------------------------------------------------------------
+// Codex context%（ドーナツ）の live source（T06407 増分2, 症状⑥ ドーナツ前後動の根治）
+//
+// 従来 context% は「rollout の token_count を state loop / 60 秒ポーリングが**別々に**読む」
+// 二重ソースで、cadence・キー(cwd/threadId)・rollout 書込ラグの差で値が前後していた。
+// App Server の `thread/tokenUsage/updated`（ターン中 live push）を正本にし、rollout を最終
+// フォールバックへ格下げすることで両経路を同一 live 値へ収束させる。
+//
+// ⚠️ store のキーは **producer(session) の immutable seq**（codex-stream-bridge の
+// `session.seq`）にする。context% は thread ではなく **producer(session) の属性**であり、
+// 以下の理由で threadId でも stream_id でもキーにできない（codex-review round1 の指摘 3 点）:
+//   - stream_id は購読端末 ID で reattach/detach で付け替わる → alias slot が残り Map リーク、
+//     exit は現 primary しか消せず stale が残る（指摘1）。
+//   - 同一 thread に複数 producer(resume) がありうるので threadId 単独では混線する。
+//   - 「受信時刻 latest を代表」は旧 producer の遅延通知が後着時刻で再び代表を奪う（指摘2）。
+// 代表の選択は **cwd の権威 producer**（liveSessionForCwd の seq）を呼び出し側が渡して引く
+// （codexLiveContextForProducer(seq)）。受信時刻に依存しないので前後動しない。
+//
+// ⚠️ tokenUsage の shape は App Server wire = **camelCase**（total / last:{totalTokens,...} /
+// modelContextWindow）。rollout jsonl の last_token_usage は snake_case で、そちらは
+// codexUsageForThread 内の従来ロジックが扱う。
+//
+// @type {Map<number, { tokenUsage: object, atMs: number }>}
+const _codexLiveTokenUsageByProducer = new Map()
+
+/** `thread/tokenUsage/updated` を受けて **producer(session.seq) 単位**で live tokenUsage を
+ *  記録する。
+ *  @param {number} producerSeq codex-stream-bridge の immutable な session.seq
+ *  @param {object} tokenUsage ThreadTokenUsage (camelCase)
+ *  @param {{ atMs?: number }} [opts]
+ *  atMs 単調ガードで、同一 producer 内で順序前後した古い更新を捨てる。 */
+export function recordCodexLiveTokenUsage(producerSeq, tokenUsage, opts = {}) {
+  if (typeof producerSeq !== "number" || !Number.isFinite(producerSeq) || !tokenUsage) return
+  const atMs = typeof opts.atMs === "number" ? opts.atMs : Date.now()
+  const prev = _codexLiveTokenUsageByProducer.get(producerSeq)
+  // 同一 producer 内の古い更新（atMs が後退）は捨てる。
+  if (prev && typeof prev.atMs === "number" && atMs < prev.atMs) return
+  _codexLiveTokenUsageByProducer.set(producerSeq, { tokenUsage, atMs })
+}
+
+/** セッション終了時に producer(session.seq) の live tokenUsage を破棄する。seq は immutable
+ *  なので alias slot / リークは生じない（stream_id キー時代の指摘1を解消）。 */
+export function forgetCodexLiveTokenUsage(producerSeq) {
+  if (typeof producerSeq !== "number") return
+  _codexLiveTokenUsageByProducer.delete(producerSeq)
+}
+
+/** テスト用: live tokenUsage ストアをクリアする。 */
+export function _resetCodexLiveTokenUsage() {
+  _codexLiveTokenUsageByProducer.clear()
+}
+
+/** camelCase の ThreadTokenUsage から context%(占有率) を算出する。分母(窓)や last が
+ *  無ければ null。context 窓は last(直近ターンで実際に窓へ載った分)で測る (total は会話累積で
+ *  100% に張り付くため。rollout 版と同じ設計)。 */
+export function codexContextPercentFromTokenUsage(tokenUsage) {
+  const windowSize = tokenUsage?.modelContextWindow
+  const last = tokenUsage?.last
+  if (!last || typeof windowSize !== "number" || windowSize <= 0) return null
+  const tokens =
+    typeof last.totalTokens === "number"
+      ? last.totalTokens
+      : (last.inputTokens || 0) + (last.cachedInputTokens || 0) + (last.outputTokens || 0)
+  if (typeof tokens !== "number") return null
+  return Math.min(100, Math.round((tokens / windowSize) * 1000) / 10)
+}
+
+/** producer(session.seq) の live context%(App Server 正本)。呼び出し側は cwd の権威 producer
+ *  (liveSessionForCwd の seq) を渡す。live tokenUsage 未取得 / 算出不能なら null（呼び出し側が
+ *  rollout へフォールバックする）。 */
+export function codexLiveContextForProducer(producerSeq) {
+  if (typeof producerSeq !== "number") return null
+  const e = _codexLiveTokenUsageByProducer.get(producerSeq)
+  if (!e) return null
+  return codexContextPercentFromTokenUsage(e.tokenUsage)
+}
+
 /**
  * 指定 threadId の Codex セッションから usage (5h/7d + context%) を返す。
  * Claude の `getUsage()` と同じ shape (`UsageStats`) を返すため、frontend / wire
  * protocol の分岐を増やさずに済む。
  *
+ * context%(ドーナツ) は **呼び出し側が渡す権威 producer の live tokenUsage** を正本とし
+ * (codexLiveContextForProducer)、無ければ rollout の last_token_usage にフォールバックする
+ * (T06407 増分2)。これで state loop / usage.response の両経路が同一 live 値へ収束し、
+ * ドーナツの前後動 (症状⑥) が解消する。producerSeq を渡さない旧経路は rollout のみ。
+ *
  * ⚠️ `last5h`/`last7d` は Codex 側アカウント全体の rate limit（ChatGPT/OpenAI
  * サブスクリプション）であり、Claude の `last5h`/`last7d`（Anthropic サブスク）とは
  * **別契約の別数値**。呼び出し側で Claude usage と単純合算/上書きしないこと
  * （どちらのアカウントの残量か分からなくなる）。
  *
  * @param {string} threadId
+ * @param {{ producerSeq?: number }} [opts] producerSeq: この thread を表示する cwd の権威
+ *   producer(session.seq)。context% の live source として使う。
  * @returns {Promise<import("./usage.mjs").UsageStats|null>} 見つからなければ null
  */
-export async function codexUsageForThread(threadId) {
+export async function codexUsageForThread(threadId, opts = {}) {
   if (!threadId) return null
   const fp = await findCodexRolloutFile(threadId)
-  if (!fp) return null
-  const found = await latestTokenCountFromRollout(fp)
-  if (!found) return null
-  const info = found.payload.info
-  const rateLimits = found.payload.rate_limits
-
-  let contextPercent = null
+  const found = fp ? await latestTokenCountFromRollout(fp) : null
+  // 増分2: context% は権威 producer の App Server live tokenUsage を正本にする。
+  // ⚠️ codex-review round2 major#2: live は rollout I/O の **後** に読む。I/O 中に起きた同一
+  // producer の token 更新を反映し、I/O 中に producer が exit していれば live は null になって
+  // rollout フォールバックへ正しく落ちる（I/O 前スナップショットだと exit 済み producer の古い
+  // context を返してしまう）。呼び出し側はさらに await 後に権威 seq を再検証する。
+  // ⚠️ live が取れていれば rollout 不在（新スレッド / 書込ラグ中）でも usage を返す。旧実装は
+  // rollout 不在で early-return null し、rollout が書かれるまで live-only の context を
+  // usage.response / codexSessions へ出せなかった。rate limit は rollout 由来のため rollout
+  // 不在時は「未提供」になる（context だけ live で出す）。
+  const liveContext =
+    typeof opts.producerSeq === "number" ? codexLiveContextForProducer(opts.producerSeq) : null
+  // live も rollout も無ければ従来どおり null。
+  if (liveContext === null && !found) return null
+  const info = found?.payload?.info
+  const rateLimits = found?.payload?.rate_limits ?? null
+
+  // live tokenUsage が取れていれば context の正本にし、rollout では上書きしない。
+  let contextPercent = liveContext
   const windowSize = info?.model_context_window
   // context 窓の「現在の占有率」は last_token_usage（直近ターンで実際に窓へ載った
   // トークン）で測る。total_token_usage は会話累積（キャッシュ再利用分も加算し
@@ -1514,8 +1721,14 @@ export async function codexUsageForThread(threadId) {
   // 窓 258,400 = 519% → 100% 張り付き。実占有は last=66,973 → 25.9%）。Codex は
   // 自動コンパクションで実文脈を使い回すため、累積で割ると必ず張り付く。
   // last_token_usage が無い旧 Codex 版のみ従来の total_token_usage にフォールバック。
+  // ⚠️ live tokenUsage が取れていれば (contextPercent!==null) rollout では上書きしない。
   const usageForContext = info?.last_token_usage ?? info?.total_token_usage
-  if (usageForContext && typeof windowSize === "number" && windowSize > 0) {
+  if (
+    contextPercent === null &&
+    usageForContext &&
+    typeof windowSize === "number" &&
+    windowSize > 0
+  ) {
     const tokens =
       typeof usageForContext.total_tokens === "number"
         ? usageForContext.total_tokens
@@ -1525,38 +1738,31 @@ export async function codexUsageForThread(threadId) {
     contextPercent = Math.min(100, Math.round((tokens / windowSize) * 1000) / 10)
   }
 
-  const bucketize = (w) => {
-    if (!w || typeof w.used_percent !== "number") return emptyBucket(CODEX_DEFAULT_LIMIT)
-    let resetMs = null
-    if (typeof w.resets_at === "number") {
-      resetMs = w.resets_at < 1e12 ? w.resets_at * 1000 : w.resets_at
-    }
-    return {
-      tokens: 0,
-      messages: 0,
-      limit: CODEX_DEFAULT_LIMIT,
-      percent: w.used_percent,
-      oldestTsMs: null,
-      resetAtMs: resetMs,
-    }
-  }
+  // T06407: 位置固定 (primary→5h / secondary→7d) をやめ、windowDurationMins で分類する。
+  // rollout の rate_limits は snake_case (window_minutes / used_percent / resets_at) だが
+  // classifyCodexRateLimitWindows が両 casing を吸収する。欠落窓は 0% でなく「未提供」。
+  const { last5h, last7d } = classifyCodexRateLimitWindows(rateLimits)
 
   return {
     plan: rateLimits?.plan_type || "codex",
     computedAt: Date.now(),
     source: rateLimits ? "official" : "estimate",
     context: contextPercent,
-    last5h: bucketize(rateLimits?.primary),
-    last7d: bucketize(rateLimits?.secondary),
+    last5h,
+    last7d,
   }
 }
 
 /**
- * 複数の Codex セッション (threadId + cwd + sessionId) から `SessionUsageEntry[]`
+ * 複数の Codex セッション (threadId + cwd + sessionId + producerSeq) から `SessionUsageEntry[]`
  * (Claude の `getSessionUsages()` と同 shape) を返す。見つからなかった/context 不明な
  * セッションは結果から除外する (Claude 版と同じ「分かるものだけ返す」約束)。
  *
- * @param {Array<{sessionId: string, cwd: string, threadId: string}>} liveSessions
+ * ⚠️ 呼び出し側 (usage.response) は cwd ごとに **権威 producer 1 件**へ集約して渡す。
+ * producerSeq を context% の live source として codexUsageForThread へ通し、state loop と
+ * 同一の live 値へ収束させる (T06407 増分2, axis2)。
+ *
+ * @param {Array<{sessionId: string, cwd: string, threadId: string, producerSeq?: number}>} liveSessions
  * @returns {Promise<Array<{sessionId: string, cwd: string, contextPercent: number, updatedAtMs: number}>>}
  */
 export async function codexSessionUsages(liveSessions) {
@@ -1564,9 +1770,9 @@ export async function codexSessionUsages(liveSessions) {
   const now = Date.now()
   const out = []
   await Promise.all(
-    liveSessions.map(async ({ sessionId, cwd, threadId }) => {
+    liveSessions.map(async ({ sessionId, cwd, threadId, producerSeq }) => {
       if (!threadId || !cwd) return
-      const usage = await codexUsageForThread(threadId)
+      const usage = await codexUsageForThread(threadId, { producerSeq })
       if (!usage || typeof usage.context !== "number") return
       out.push({
         sessionId: sessionId || threadId,