@cocorograph/hub-agent 0.7.83 → 0.7.85

package/package.json

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

package/src/claude-stream-bridge.mjs

@@ -65,22 +65,24 @@ const CHAT_RESIDENT_ENABLED = process.env.HUB_AGENT_CHAT_RESIDENT !== "0"
  *  1 セッション=1 query で system/init を初回 1 回のみにする。VS Code 拡張 / Claude Web
  *  と同じ挙動)。query 起動時に options.resume で過去文脈を引き継ぐ。
  *
- *  ⚠️ デフォルト無効化 (2026-06-02): 「眠っていたセッションを起こすと
- *  『Continue from where you left off.』→『No response requested.』や /clear の
- *  local-command-caveat が合成ユーザーバブルとして表示され、処理中になり、実メッセージが
- *  キュー待ちになる」回帰が確認されたため既定 OFF に戻す。
+ *  ✅ 既定 ON へ復帰 (2026-07-21, T06118)。旧既定 OFF の理由だった「resume + 空 InputQueue」
+ *  窓 (下記) を **push 先行起動** (_startResidentTurnWithInput) で塞いだため、resumed セッション
+ *  も常駐化して安全になった。既定 ON にする狙いは **背景エージェントの信頼性回復**:
+ *  per-message (resume=1query) だとターン結果が返ると query プロセスが畳まれ、run_in_background
+ *  で起動した子エージェントが親ターンより長生きして「previous Claude Code process exited」で
+ *  孤児化・停止していた (実害)。常駐化すれば query プロセスがターンをまたいで生存する。
  *
- *  根本原因: resident 経路 (sendMessage) は **空の InputQueue のまま query を起動してから
- *  push** する設計のため、「resume + 入力がまだ空」の窓で SDK が中断/未完了セッションの
- *  自動継続ターン (Continue from where you left off) を差し込む。per-message 経路は
- *  InputQueue に push→即 close してから起動するためこの窓が無く、自動継続は起きない
- *  (0.6.4 で暴走を潰した設計)。よって resumed セッションは per-message 経路に戻す。
+ *  旧回帰の根本原因 (履歴): resident 経路 (sendMessage) が **空の InputQueue のまま query を
+ *  起動してから push** していたため、「resume + 入力がまだ空」の窓で SDK が中断/未完了
+ *  セッションの自動継続ターン (Continue from where you left off) を差し込んでいた。per-message
+ *  経路は InputQueue に push→即 close してから起動するためこの窓が無い (0.6.4 で暴走を潰した
+ *  設計)。今回 resident の 3 起動サイトも「push してから起動」に揃え、初回ターンの ultracode は
+ *  起動時 options.settings で焼き込む (applyFlagSettings のための空窓も作らない)。
  *
- *  env HUB_AGENT_CHAT_RESIDENT_RESUME="1" で個別に再有効化できる (空キュー窓を塞ぐ
- *  根治を入れたら既定 ON へ戻す候補)。新規セッションの常駐化は CHAT_RESIDENT_ENABLED 側で
- *  独立制御 (新規は resume しないため自動継続の窓が無く、既定 ON のまま安全)。 */
+ *  env HUB_AGENT_CHAT_RESIDENT_RESUME="0" で個別に無効化 (従来の per-message へロールバック)
+ *  できる。新規セッションの常駐化は CHAT_RESIDENT_ENABLED 側で独立制御。 */
 const CHAT_RESIDENT_RESUME_ENABLED =
-  process.env.HUB_AGENT_CHAT_RESIDENT_RESUME === "1"
+  process.env.HUB_AGENT_CHAT_RESIDENT_RESUME !== "0"
 
 /** MCP control 専用 query のアイドル破棄時間 (2026-06-03)。MCP サーバーは Claude Code
  *  設定 (アカウント単位) で全セッション共有のため、チャットセッションとは独立した
@@ -435,6 +437,20 @@ class ClaudeStreamSession {
      *  false に戻す。 */
     this._ultracodeCurrent = false
 
+    /** 空 InputQueue 窓封鎖 (T06118): fresh start する resume 常駐 query の「初回ターンの
+     *  ultracode 目標」。_startResidentTurnWithInput が push 先行で積むメッセージと一緒に
+     *  セットし、_runResidentQuery が起動時 options.settings へ焼き込んで消費する
+     *  (起動前 applyFlagSettings のための空 InputQueue 窓を作らないため)。 */
+    this._pendingInitialUltracode = false
+
+    /** ABA/FIFO 直列化 (T06118 codex-review major): 起動済み query 経路の sendMessage が
+     *  reconcile (applyFlagSettings) を await している間 true。この間に旧 query の generator が
+     *  自然終了しても、_runResidentQuery の finally は pending を drain して新 query を先行起動
+     *  してはならない (in-flight のこの送信が後着 pending に追い越されて FIFO が逆転するため)。
+     *  finally は query を畳むだけに留め、await 復帰後の送信が自分のメッセージを push 先行で
+     *  fresh-start する。pending はその turn settle 後に FIFO で drain される。 */
+    this._residentSendInFlight = false
+
     /** @type {Map<string, {resolve: (decision: object) => void, tool_name: string, input: object}>}
      *  permission 応答待ち。tool_name / input も保持し、reattach 時に未応答分を
      *  onPermission で再送 (replay) して「裏で動いていたセッションを開いたら確認待ち
@@ -915,15 +931,6 @@ class ClaudeStreamSession {
 
     // 改修2+4: 常駐query対象セッション。
     if (this._residentEligible) {
-      // B6: 死亡後の (再)起動経路。既に query を起動した実績があり (_residentStarted)、かつ
-      // 現在 query が無い (_residentQuery=null = 異常終了済み) 場合、既存 _inputQueue は前 query で
-      // consume し切った (generator return 済み) インスタンス。同じものを次の sdk.query に渡すと
-      // _q/_wake の残留が新 generator と競合し得るため、push 前に必ず作り直す。
-      if (this._residentStarted && !this._residentQuery) {
-        this._inputQueue = new InputQueue()
-      } else if (!this._inputQueue) {
-        this._inputQueue = new InputQueue()
-      }
       // 改修4 (A): ターンのシリアライズ。実行中ターン (busy) は InputQueue へ即 push せず
       // pending へ退避し、現ターンの result 後に 1 件ずつ drain する。前ターン未完了のまま
       // 次を push すると SDK streaming-input で割り込み扱いになり得るため (公式 interrupt 警告)。
@@ -937,31 +944,29 @@ class ClaudeStreamSession {
         this._emitQueueState()
         return { accepted: true }
       }
+      if (this._closed) return { accepted: false, reason: "queue_dead" }
       this._beginResidentTurn()
-      // 改修4 (A): 死亡ガード。常駐 query が未起動 or (エラー等で) 終了済み (_residentQuery=null)
-      // なら (再)起動する。_runResidentQuery は起動時 options.resume=this.sessionId で文脈を
-      // 復元するため、途中死からの復活でも過去コンテキストは失われない。
-      // ultracode のとき: query を先に起動 (空 InputQueue なので入力待ちでブロック) し、
-      // applyFlagSettings を await してから push することで、設定適用前にターンが
-      // 消費されるレースを防ぐ。
-      if (!this._residentQuery) {
-        this._residentStarted = true
-        this._startResidentQuery()
-      }
-      await this._reconcileResidentUltracode(ultracode)
-      // A-2 修正 (2026-07-05): 上の await 中に常駐 query の generator が自然終了している
-      // ことがある (_residentQueryReturned が finally で true になる)。その場合 this._residentQuery
-      // はまだ非 null (finally 未実行) に見えても、実体は既に誰も consume しない返却済み
-      // generator であり、そのまま push すると消失する。fresh-start と同じ手順 (InputQueue の
-      // 再生成 + 再起動) を踏んでから push することで、既存の resident 復活ガード
-      // (B6 / 異常終了時の自動再起動) に合流させる。
-      if (this._residentQueryReturned || !this._residentQuery) {
-        this._inputQueue = new InputQueue()
-        this._residentStarted = true
-        this._startResidentQuery()
+      // 空 InputQueue 窓封鎖 (T06118): fresh start。常駐 query が未起動 (初回) / 異常終了済み
+      // (_residentQuery=null = 死亡ガード B6) / generator 返却済み (_residentQueryReturned) の
+      // いずれも「新しい query を起動する」ケース。従来は空の InputQueue で起動してから push
+      // していたため「resume + 空入力」の窓で SDK が自動継続ターン (Continue from where you
+      // left off) を差し込む回帰があった。実メッセージを積んでから起動する push 先行
+      // (_startResidentTurnWithInput、per-message と同じ) に統一してこの窓を無くす。
+      // 初回ターンの ultracode は起動時 options.settings に焼き込むため、起動前 reconcile
+      // (applyFlagSettings) のための空窓も不要。
+      if (!this._residentQuery || this._residentQueryReturned) {
+        this._startResidentTurnWithInput(toSDKUserMessage(prompt), ultracode)
+        return { accepted: true }
       }
-      if (this._closed) return { accepted: false, reason: "queue_dead" }
-      this._inputQueue.push(toSDKUserMessage(prompt))
+      // 起動済みの常駐 query へ次ターンを流す。init 済みで空窓が無いため、ultracode は走行中
+      // query への applyFlagSettings (reconcile) で適用してから push する。reconcile await 中の
+      // 旧 query 終了 × 後着 pending の ABA/FIFO 逆転は _reconcileThenDeliver が直列化する
+      // (drain 経路 _drainResidentPending と共通)。
+      const outcome = await this._reconcileThenDeliver(
+        toSDKUserMessage(prompt),
+        ultracode,
+      )
+      if (outcome === "closed") return { accepted: false, reason: "queue_dead" }
       return { accepted: true }
     }
 
@@ -1244,6 +1249,24 @@ class ClaudeStreamSession {
     }
   }
 
+  /** 空 InputQueue 窓封鎖 (T06118): fresh start する resume 常駐 query を「入力を先に積んで
+   *  から起動」する (push 先行)。fresh な InputQueue を作り、実ユーザーメッセージを push して
+   *  から query を起動するため、「resume + 空入力」の窓で SDK が自動継続ターン (Continue from
+   *  where you left off) を差し込む余地が無い (per-message の push→close→起動と同じ原理)。
+   *  初回ターンの ultracode は options.settings 経由で焼き込む (_runResidentQuery が
+   *  _pendingInitialUltracode を読む) ため、起動前 applyFlagSettings のための空窓も作らない。
+   *  ⚠️ _inputQueue は必ず作り直す (B6): 前 query で consume し切った (generator return 済み)
+   *  インスタンスを次の sdk.query に渡すと _q/_wake の残留が新 generator と競合し得るため。
+   *  @param {object} sdkUserMessage toSDKUserMessage() 済みの初回ユーザーメッセージ
+   *  @param {boolean} initialUltracode 初回ターンの ultracode 目標 */
+  _startResidentTurnWithInput(sdkUserMessage, initialUltracode) {
+    this._inputQueue = new InputQueue()
+    this._inputQueue.push(sdkUserMessage)
+    this._pendingInitialUltracode = initialUltracode === true
+    this._residentStarted = true
+    this._startResidentQuery()
+  }
+
   /** 改修4 (A): 常駐 query を resume 付きで (再)起動する。_runResidentQuery 起動時に
    *  options.resume=this.sessionId で過去文脈を復元するため、途中死からの復活でも安全。 */
   _startResidentQuery() {
@@ -1282,6 +1305,45 @@ class ClaudeStreamSession {
     }
   }
 
+  /** ABA/FIFO 直列化の共通デリバリ (T06118 codex-review major×2)。起動済みの走行中 query へ
+   *  「ultracode を reconcile してから 1 メッセージを届ける」処理を、直接送信経路 (sendMessage) と
+   *  drain 経路 (_drainResidentPending) の両方から使う共通化ポイント。reconcile は control request
+   *  の往復で await するため、その窓の間に旧 query の generator が自然終了しうる (finally が走る)。
+   *  所有権ガード (_residentSendInFlight) で await 中の finally に pending drain を見送らせ、await
+   *  前後の query ハンドル比較 (ABA 検出) で交代/終了を捕捉して push 先行 fresh-start へ切り替える。
+   *
+   *  前提: 呼び出し側が既に _beginResidentTurn() 済みで、呼び出し時点の _residentQuery が走行中
+   *  (非 null・未返却) であること。
+   *  @param {object} sdkMsg toSDKUserMessage() 済みメッセージ
+   *  @param {boolean} ultracode このターンの ultracode 目標
+   *  @returns {Promise<"pushed"|"restarted"|"closed">} 届け方の結果
+   */
+  async _reconcileThenDeliver(sdkMsg, ultracode) {
+    const activeQuery = this._residentQuery
+    this._residentSendInFlight = true
+    try {
+      await this._reconcileResidentUltracode(ultracode)
+    } finally {
+      this._residentSendInFlight = false
+    }
+    if (this._closed) return "closed"
+    if (
+      this._residentQueryReturned ||
+      !this._residentQuery ||
+      this._residentQuery !== activeQuery
+    ) {
+      // ABA 検出: await 中に query が終了/交代した。finally は _residentSendInFlight を見て
+      // pending drain を見送っているので、自分のメッセージを push 先行で fresh-start する
+      // (pending はこの turn settle 後に _drainResidentPending が FIFO で流す)。await 中の
+      // finally で _busy が false へ落ちているため、_beginResidentTurn で張り直してから起動する。
+      this._beginResidentTurn()
+      this._startResidentTurnWithInput(sdkMsg, ultracode)
+      return "restarted"
+    }
+    this._inputQueue.push(sdkMsg)
+    return "pushed"
+  }
+
   /** SDK-P0-3 (2026-07-10): resident の「ターン開始」を 1 箇所に集約する。
    *  _busy を立てるのと同時に、そのターンの終端フラグ (_turnSettled) と進行フラグ
    *  (_turnProgressed) を必ずリセットする。ターン開始は 3 箇所ある
@@ -1368,10 +1430,18 @@ class ClaudeStreamSession {
     // 次の drain がやり直せる状態に必ず回復する (例外は既存方針通り warn で握る)。
     this._beginResidentTurn()
     try {
-      // ultracode reconcile (0.6.28) も await で例外を投げうるので try の中に含める。
-      await this._reconcileResidentUltracode(next.ultracode === true)
-      this._inputQueue.push(toSDKUserMessage(next.text))
-      this._emitQueueState([next.text])
+      // ABA/FIFO 直列化 (T06118 codex-review major×2): drain も reconcile を await するため、
+      // その窓で旧 query が終了して finally が「その先の pending」を新 query へ先行投入すると、
+      // 今 drain 中の next が追い越されて FIFO が逆転する。直接送信経路と同じ _reconcileThenDeliver
+      // を通し、_residentSendInFlight による finally の drain 見送り + ABA 検出で next を先に届ける。
+      const outcome = await this._reconcileThenDeliver(
+        toSDKUserMessage(next.text),
+        next.ultracode === true,
+      )
+      // codex-review minor: session が close 中 (outcome==="closed") は next を配送していない。
+      // started 通知 (queue_state に [next.text] を載せる) を出すと未配送メッセージが「開始済み」に
+      // 見えるため抑止する。closed は終端状態なので pending へ戻さず破棄でよい (session 撤去中)。
+      if (outcome !== "closed") this._emitQueueState([next.text])
     } catch (err) {
       this._busy = false
       this._pendingMessages.unshift(next)
@@ -1421,6 +1491,20 @@ class ClaudeStreamSession {
     // 改修4: 起動時に sessionId (= resumeSessionId) があれば resume チェーンで文脈を引き継ぐ。
     // query 起動時点の値のみ有効 (起動後に確定/変化する session_id は同一 query 内で継続される)。
     if (this.sessionId) options.resume = this.sessionId
+    // 空 InputQueue 窓封鎖 (T06118): fresh start の初回ターンが ultracode を要求していれば、
+    // per-message と同じく起動時 options.settings に焼き込む。こうすることで「query を空 queue
+    // で先に起動 → applyFlagSettings を await → push」という空窓経路を踏まずに済む。初回だけ
+    // 焼き込み、_ultracodeCurrent を true に揃えて次ターンの reconcile が正しく差分判定できる
+    // ようにする。読み取り後は消費 (次の (再)起動へ持ち越さない)。
+    if (this._pendingInitialUltracode === true) {
+      options.settings = {
+        ...(options.settings || {}),
+        ultracode: true,
+        enableWorkflows: true,
+      }
+      this._ultracodeCurrent = true
+    }
+    this._pendingInitialUltracode = false
     const denyPending = (reason) => this._denyAllPendingPermissions(reason)
     try {
       const q = this.sdk.query({ prompt: this._inputQueue, options })
@@ -1514,27 +1598,31 @@ class ClaudeStreamSession {
         } finally {
           this.onReap?.()
         }
-      } else if (!this._closed && this._pendingMessages.length > 0) {
+      } else if (
+        !this._closed &&
+        this._pendingMessages.length > 0 &&
+        !this._residentSendInFlight
+      ) {
         // 改修4 (A): 異常終了 (close 以外) で pending が残っていれば resume 付きで再起動し
         // 取りこぼしを防ぐ。_runResidentQuery が options.resume=this.sessionId で文脈を復元する。
-        // B6: 既存 _inputQueue の generator は既に return 済み (この query で消費し切った)。
-        // 同じインスタンスを次の sdk.query に再利用すると _q/_wake の残留状態が新しい
-        // generator と競合し得るため、再起動前に必ず作り直す。close() は this._inputQueue を
-        // close() するだけで参照を持ち越さないので、ここで差し替えても整合する。
-        this._inputQueue = new InputQueue()
+        // 空 InputQueue 窓封鎖 (T06118): ここも fresh start なので push 先行で起動する
+        // (_startResidentTurnWithInput が fresh な InputQueue を作り、実メッセージを積んでから
+        // 起動する)。従来は「空 queue で起動 → reconcile await → push」で resume + 空入力の
+        // 自動継続窓があった。異常再起動対象メッセージの ultracode は options.settings 経由で
+        // 焼き込むため、フラグ取りこぼし (0.6.28 由来) も起きない。
+        //
+        // ABA/FIFO 直列化 (T06118 codex-review major): _residentSendInFlight の間 (起動済み
+        // query 経路の sendMessage が reconcile を await 中) は、ここで pending を drain して
+        // 新 query を先行起動してはならない。in-flight の送信が後着 pending に追い越されて FIFO が
+        // 逆転するため。この場合は query を畳むだけに留め (上で _residentQuery=null 済み)、
+        // await 復帰後の送信が自分のメッセージを push 先行で fresh-start する。pending はその
+        // turn settle 後に _drainResidentPending が FIFO で流す。
         const next = this._pendingMessages.shift()
         this._beginResidentTurn()
-        this._residentStarted = true
-        // ultracode (0.6.29): query を先に起動して _residentQuery を確定させてから
-        // reconcile → push する (sendMessage の通常経路と同順)。push してから起動すると
-        // applyFlagSettings を発行する先 (_residentQuery) がまだ無く、異常再起動の対象
-        // メッセージだけ ultracode フラグが落ちる (0.6.28 由来の取りこぼし) ため、ここで揃える。
-        // _startResidentQuery → _runResidentQuery は最初の await (for await) より前に
-        // 同期で _residentQuery と _ultracodeCurrent=false を確定するので、直後の reconcile が
-        // 正しく差分判定できる。_reconcileResidentUltracode は内部で例外を握るため throw しない。
-        this._startResidentQuery()
-        await this._reconcileResidentUltracode(next.ultracode === true)
-        this._inputQueue.push(toSDKUserMessage(next.text))
+        this._startResidentTurnWithInput(
+          toSDKUserMessage(next.text),
+          next.ultracode === true,
+        )
         this._emitQueueState([next.text])
       }
       // マスク (2026-06-23): 常駐 query 終了後 (= CLI が jsonl を掴んでいない) のこの地点で、

package/src/usage.mjs

@@ -1483,6 +1483,117 @@ 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
+}
+
 /**
  * 指定 threadId の Codex セッションから usage (5h/7d + context%) を返す。
  * Claude の `getUsage()` と同じ shape (`UsageStats`) を返すため、frontend / wire
@@ -1525,29 +1636,18 @@ 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,
   }
 }