@cocorograph/hub-agent 0.8.16 → 0.8.17

package/package.json

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

package/src/claude-credentials.mjs

@@ -26,8 +26,51 @@ import { createHash } from "node:crypto"
 import { execFile } from "node:child_process"
 import { promisify } from "node:util"
 
+import { AsyncTtlCache } from "./async-ttl-cache.mjs"
+import { hasFileCredentials } from "./profiles.mjs"
+
 const execFileP = promisify(execFile)
 
+/**
+ * 認証在否チェックの短期キャッシュ TTL (ms)。
+ *
+ * ログイン状態は分単位でしか変わらないのに、`usage.request` (Cockpit のウィンドウ数 ×
+ * 60 秒周期) が来るたびに `security` コマンドを 1〜3 回 spawn していた。config
+ * ディレクトリ単位で 30 秒だけ結果を共有し、同時要求は single-flight に畳む。
+ * プロファイル切替直後は呼び出し側が clearCredentialCheckCache() で明示的に捨てる。
+ */
+export const CREDENTIAL_CHECK_TTL_MS = 30_000
+
+/** @type {Map<string, AsyncTtlCache>} configDir -> Keychain 在否 */
+const keychainCheckCache = new Map()
+/** @type {Map<string, AsyncTtlCache>} configDir -> .credentials.json 在否 */
+const fileCheckCache = new Map()
+
+function cachedCheck(store, configDir, build) {
+  const key = String(configDir)
+  let cache = store.get(key)
+  if (!cache) {
+    cache = new AsyncTtlCache({ ttlMs: CREDENTIAL_CHECK_TTL_MS })
+    store.set(key, cache)
+  }
+  return cache.get(build)
+}
+
+/**
+ * 認証在否キャッシュを捨てる (プロファイル切替直後・テストの状態初期化用)。
+ * configDir 省略時は全件。
+ */
+export function clearCredentialCheckCache(configDir) {
+  if (configDir === undefined) {
+    for (const cache of keychainCheckCache.values()) cache.clear()
+    for (const cache of fileCheckCache.values()) cache.clear()
+    return
+  }
+  const key = String(configDir)
+  keychainCheckCache.get(key)?.clear()
+  fileCheckCache.get(key)?.clear()
+}
+
 /**
  * 既定 (プライマリ) プロファイルで CLAUDE_CONFIG_DIR が未設定のとき、Claude Code は
  * ハッシュ無しの素のサービス名 `Claude Code-credentials` に OAuth トークンを保存する
@@ -100,11 +143,30 @@ export async function existsGenericPassword(service, opts = {}) {
  * 含める (PLAIN_CREDENTIAL_SERVICE のコメント参照)。含めないと既定プロファイルが常に
  * 空振りして「要ログイン」が出っぱなしになる。
  *
+ * ⚠️ キャッシュは **opts 無しの呼び出しだけ**に効かせる。`opts.execFileP` 等で挙動を
+ * 差し替える呼び出し (テストの分岐検査) までキャッシュすると、実際の分岐を通らないまま
+ * 前回値を返してしまい検査が空振りする。
+ *
  * @param {string} configDir
  * @param {{execFileP?: Function}} [opts]
  * @returns {Promise<boolean>}
  */
 export async function profileHasKeychainCredentials(configDir, opts = {}) {
+  if (opts && Object.keys(opts).length > 0) {
+    return probeKeychainCredentials(configDir, opts)
+  }
+  return cachedCheck(keychainCheckCache, configDir, () =>
+    probeKeychainCredentials(configDir, {}),
+  )
+}
+
+/**
+ * Keychain 在否の実処理 (キャッシュを挟まない)。
+ * @param {string} configDir
+ * @param {{execFileP?: Function}} opts
+ * @returns {Promise<boolean>}
+ */
+async function probeKeychainCredentials(configDir, opts) {
   const candidates = new Set([configDir])
   try {
     candidates.add(await fs.realpath(configDir))
@@ -139,3 +201,17 @@ export async function profileHasKeychainCredentials(configDir, opts = {}) {
   }
   return false
 }
+
+/**
+ * Keychain の無いプラットフォーム向け在否判定 (profiles.mjs の hasFileCredentials) の
+ * キャッシュ版。TTL・クリア導線は Keychain 版と共通 (clearCredentialCheckCache)。
+ *
+ * ⚠️ 実処理は profiles.mjs 側が正本。ここは呼び出し頻度を落とすためのラッパで、
+ * 判定ロジックは持たない。
+ *
+ * @param {string} configDir
+ * @returns {Promise<boolean>}
+ */
+export async function hasFileCredentialsCached(configDir) {
+  return cachedCheck(fileCheckCache, configDir, () => hasFileCredentials(configDir))
+}

package/src/codex-stream-bridge.mjs

@@ -329,6 +329,7 @@ export class CodexStreamBridge extends EventEmitter {
     historyMaxItems,
     historyMaxBytes,
     listThreadsCacheTtlMs,
+    accountRateLimitsCacheTtlMs,
   } = {}) {
     super()
     this.codexCmd = codexCmd
@@ -369,6 +370,14 @@ export class CodexStreamBridge extends EventEmitter {
     // AsyncTtlCache が single-flight と、thread/start 中の世代切替をまとめて担う。
     this._listThreadsCacheTtlMs = listThreadsCacheTtlMs ?? 5_000
     this._listThreadsCache = new Map()
+    // アカウント利用制限 (5h/7d) は **アカウント全体の値** で、Cockpit のウィンドウ数だけ
+    // 別々に取りに行く必要がない。1 回の取得ごとに `codex app-server` を spawn →
+    // initialize → 停止しており、control レーンの実測占有 (2026-08-01: 92 秒中 73.3 秒) の
+    // 主因になっていた。profileId 単位で短期キャッシュし、TTL 内は app-server を
+    // **一切起動しない**。同時要求は AsyncTtlCache の single-flight で 1 本に畳む。
+    this._accountRateLimitsCacheTtlMs = accountRateLimitsCacheTtlMs ?? 45_000
+    /** @type {Map<string, AsyncTtlCache>} profileId -> cache */
+    this._accountRateLimitsCache = new Map()
   }
 
   /**
@@ -1037,6 +1046,25 @@ export class CodexStreamBridge extends EventEmitter {
    * Cockpit フッターを最新化できる。呼び出し側は認証済みプロファイルの場合だけ呼ぶ。
    */
   async readAccountRateLimits({ cwd, profileId = "default" } = {}) {
+    let cache = this._accountRateLimitsCache.get(profileId)
+    if (!cache) {
+      cache = new AsyncTtlCache({ ttlMs: this._accountRateLimitsCacheTtlMs })
+      this._accountRateLimitsCache.set(profileId, cache)
+    }
+    try {
+      // ⚠️ 失敗を **キャッシュの外** で受けるのが要点。AsyncTtlCache は build 失敗を
+      // キャッシュしないため、一時的な取得失敗が TTL 分だけ再試行を止めることがない。
+      // 失敗時フォールバック (直近の成功値) は従来どおりここで効かせる。
+      return await cache.get(() => this._fetchAccountRateLimits({ cwd, profileId }))
+    } catch (err) {
+      const cached = this._accountRateLimitsByProfile.get(profileId)
+      if (cached) return cached
+      throw err
+    }
+  }
+
+  /** app-server を 1 本 spawn して account/rateLimits/read を取る実処理 (キャッシュ miss 時のみ)。 */
+  async _fetchAccountRateLimits({ cwd, profileId }) {
     const client = this._clientFactory({ cwd: cwd || process.cwd(), codexCmd: this.codexCmd, logger: this.logger })
     client.start()
     try {
@@ -1045,15 +1073,20 @@ export class CodexStreamBridge extends EventEmitter {
       const result = await client.request("account/rateLimits/read", {})
       this._accountRateLimitsByProfile.set(profileId, result)
       return result
-    } catch (err) {
-      const cached = this._accountRateLimitsByProfile.get(profileId)
-      if (cached) return cached
-      throw err
     } finally {
       client.stop()
     }
   }
 
+  /** プロファイル切替等で「別アカウントの値を見せない」ために使う (省略時は全 profile)。 */
+  clearAccountRateLimitsCache(profileId) {
+    if (profileId === undefined) {
+      for (const cache of this._accountRateLimitsCache.values()) cache.clear()
+      return
+    }
+    this._accountRateLimitsCache.get(profileId)?.clear()
+  }
+
   _wireClient(session) {
     const { client } = session
     client.on("notification", (msg) => this._onNotification(session, msg))

package/src/main.mjs

@@ -86,6 +86,8 @@ import {
 // 名前衝突を避けて namespace import する。
 import * as codexProfiles from "./codex-profiles.mjs"
 import {
+  clearCredentialCheckCache,
+  hasFileCredentialsCached,
   isKeychainPlatform,
   profileHasKeychainCredentials,
 } from "./claude-credentials.mjs"
@@ -3309,6 +3311,237 @@ export async function handleKillSession(msg, ctx) {
   }
 }
 
+/** usage.response の中身を共有する TTL (ms)。frontend の poll は既定 60 秒周期。 */
+export const USAGE_RESPONSE_TTL_MS = 4_000
+
+/**
+ * usage.response の **中身だけ** を共有する短期キャッシュ。
+ *
+ * usage.request が返すのはアカウント全体の 5h/7d 利用量で、どのウィンドウから聞いても
+ * 同じ答えになる。にもかかわらず N 個のウィンドウが別々に取りに行き、1 回ごとに
+ * `security` spawn ・SDK control RPC ・`codex app-server` の起動/停止を伴っていたため、
+ * control レーンの実測占有 (2026-08-01: 92 秒中 73.3 秒) の主因になっていた。
+ *
+ * ⚠️ **request_id は絶対にここへ入れない**。キャッシュした payload に前の要求の
+ * request_id が混ざると、別ウィンドウの要求に他人の応答が返る。送信時に各要求の
+ * request_id を後から差し込む (handleUsageRequest 参照)。
+ */
+export const usageResponseCache = new AsyncTtlCache({ ttlMs: USAGE_RESPONSE_TTL_MS })
+
+/** 前回 build 以降に「キャッシュで返した」要求数 (= 畳めた重複の実測値)。 */
+let usageServedFromCacheSinceLastBuild = 0
+
+/**
+ * usage.response の中身 (usage / sessions / codexUsage / codexSessions) を組み立てる。
+ * キャッシュ miss のときだけ実行される。
+ *
+ * 戻り値は `{ payload, timings }`。**payload はそのまま応答に展開する中身**、timings は
+ * 内訳の所要時間で、ログにだけ使う (応答には出さない)。ログの発火は呼び出し側
+ * (handleUsageRequest) が「実際に build したときだけ」行う。
+ *
+ * @returns {Promise<{payload: object, timings: object}>}
+ */
+export async function buildUsagePayload(ctx) {
+  const startedAt = Date.now()
+  let credentialsMs = 0
+  let accountUsageMs = 0
+  let localUsageMs = 0
+  let codexRateLimitsMs = 0
+
+  const credentialsStartedAt = Date.now()
+  const activeClaudeProfile = await getActiveProfile()
+  const claudeHasCredentials = isKeychainPlatform()
+    ? await profileHasKeychainCredentials(activeClaudeProfile.configDir)
+    : await hasFileCredentialsCached(activeClaudeProfile.configDir)
+  credentialsMs = Date.now() - credentialsStartedAt
+
+  // 5h/7d の本命ソース: SDK control request (アカウント全体、session 非依存)。
+  // statusLine が rate_limits を出さなくなった環境 (2026-07 時点の Claude CLI) でも
+  // ここでライブ更新できる。frontend の usage.request ポーリング (既定 60s) 頻度に
+  // 相乗りするだけで十分な鮮度が保てるため、専用タイマーは設けない。EXPERIMENTAL
+  // API の失敗は getAccountUsage 内で握りつぶし null を返す (recordChatUsageSnapshot
+  // は no-op) ので、既存の statusLine/transcript フォールバックは無傷で残る。
+  if (ctx.claudeBridge) {
+    const accountUsageStartedAt = Date.now()
+    try {
+      // ⚠️ getAccountUsage は SDK のサブプロセスを spawn する。**時間制限が無いと
+      // 返ってこないときに control レーン全体が止まる** (usage.request は 60 秒周期で
+      // control レーンに乗り、そこにセッション停止も並ぶ)。同種の head-of-line
+      // blocking で cold p95 40〜54 秒を計測した記録が isReadOnlyRpc の注記にある。
+      // 時間切れは握りつぶさず warn で残す (これ自体が「詰まりの実測値」になる)。
+      const acct = await withDeadline(
+        ctx.claudeBridge.getAccountUsage(),
+        ACCOUNT_USAGE_TIMEOUT_MS,
+        () =>
+          ctx.logger?.warn?.(
+            { timeout_ms: ACCOUNT_USAGE_TIMEOUT_MS },
+            "account usage timed out (dispatch lane released)",
+          ),
+      )
+      if (acct) recordChatUsageSnapshot(acct, Date.now(), activeClaudeProfile.id)
+    } catch (err) {
+      ctx.logger?.debug?.({ err: err?.message }, "account usage snapshot skipped")
+    }
+    accountUsageMs = Date.now() - accountUsageStartedAt
+  }
+
+  const localUsageStartedAt = Date.now()
+  let [usage, sessions] = await Promise.all([
+    getUsage({ profileId: activeClaudeProfile.id }),
+    getSessionUsages(),
+  ])
+  localUsageMs = Date.now() - localUsageStartedAt
+  // 未ログインで残ったローカル transcript/cache をアカウント利用量として見せない。
+  if (!claudeHasCredentials) {
+    usage = null
+    sessions = []
+  }
+
+  // Codex 版 (Stream B3, 2026-07-03): rollout jsonl の token_count イベントから
+  // 5h/7d + context% を取る。⚠️ Codex の 5h/7d は ChatGPT/OpenAI サブスクリプション
+  // の残量であり、上の `usage` (Claude/Anthropic サブスクリプション) とは別契約の
+  // 別数値のため、`usage` にマージせず独立フィールド `codexUsage`/`codexSessions`
+  // として返す (frontend 側でどちらのアカウントの残量か混同しないため)。
+  let codexUsage = null
+  let codexSessions = []
+  const activeCodexProfile = await codexProfiles.getActiveProfile()
+  const codexHasCredentials = await codexProfiles.hasCodexCredentials(activeCodexProfile.configDir)
+  if (ctx.codexBridge && codexHasCredentials) {
+    try {
+      // 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 件から取る (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 }
+        }
+      }
+      // ライブ session の有無にかかわらず、起動直後の account RPC を優先する。
+      // rollout は context の補助だけにし、5h/7d はプロファイル固有の最新実値にする。
+      const codexRateLimitsStartedAt = Date.now()
+      const rateLimits = await ctx.codexBridge.readAccountRateLimits({
+        profileId: activeCodexProfile.id,
+      })
+      codexRateLimitsMs = Date.now() - codexRateLimitsStartedAt
+      const accountUsage = codexUsageFromAccountRateLimits(rateLimits)
+      if (accountUsage) {
+        codexUsage = { ...accountUsage, context: codexUsage?.context ?? null }
+        recordAccountUsageSnapshot("codex", activeCodexProfile.id, codexUsage)
+      }
+    } catch (err) {
+      ctx.logger?.debug?.({ err: err?.message }, "codex usage snapshot skipped")
+    }
+  }
+  // Agent 再起動後や一時的な account RPC 失敗時も、同一 profile の最終取得値だけを
+  // 表示する。未ログインならここへ到達せず、表示も完全に隠す。
+  if (codexHasCredentials && !codexUsage) {
+    codexUsage = await readAccountUsageSnapshot("codex", activeCodexProfile.id)
+  }
+
+  return {
+    payload: { usage, sessions, codexUsage, codexSessions },
+    timings: {
+      credentials_ms: credentialsMs,
+      account_usage_ms: accountUsageMs,
+      local_usage_ms: localUsageMs,
+      codex_ratelimits_ms: codexRateLimitsMs,
+      total_ms: Date.now() - startedAt,
+    },
+  }
+}
+
+/**
+ * usage.request の処理。中身は TTL キャッシュ + single-flight で共有し、request_id
+ * だけを要求ごとに差し込む。
+ *
+ * ⚠️ 送信オブジェクトは `...payload` を先に展開し **request_id を後から上書き** する。
+ * 万一 payload 側に request_id が混入しても、他人の応答が返る事故にならないため。
+ *
+ * テストから直接呼べるよう export。中身の組み立ては deps.build で差し替え可能。
+ */
+export async function handleUsageRequest(msg, ctx, deps = {}) {
+  const build = deps.build || (() => buildUsagePayload(ctx))
+  try {
+    // build を実行したのが自分かどうか。single-flight で畳まれた caller の closure は
+    // 呼ばれないため、そのまま「キャッシュで返した件数」の計測になる。
+    let built = false
+    const result = await usageResponseCache.get(() => {
+      built = true
+      return build()
+    })
+    if (built) {
+      // 効果を数字で確認するための内訳。**build したときだけ** 出す (ヒット時は出さない。
+      // ウィンドウ数 × poll で件数が多く、ログが埋まるため)。
+      // served_from_cache_since_last_build が「畳めた重複」の実測値になる。
+      ctx.logger?.info?.(
+        {
+          ...result.timings,
+          served_from_cache_since_last_build: usageServedFromCacheSinceLastBuild,
+        },
+        "usage request timing",
+      )
+      usageServedFromCacheSinceLastBuild = 0
+    } else {
+      usageServedFromCacheSinceLastBuild += 1
+    }
+    ctx.client.send({
+      type: "usage.response",
+      ...result.payload,
+      request_id: msg.request_id,
+    })
+  } catch (err) {
+    ctx.client.send({
+      type: "usage.response",
+      usage: null,
+      sessions: [],
+      codexUsage: null,
+      codexSessions: [],
+      error: err.message,
+      request_id: msg.request_id,
+    })
+  }
+}
+
 async function dispatch(msg, ctx) {
   const t = msg?.type || ""
   try {
@@ -4357,6 +4590,10 @@ async function dispatch(msg, ctx) {
           // tmux TUI セッションも旧アカウントのまま残さない: kill → 同名・同 cwd で再作成。
           const tmuxResult = await restartAllTmuxSessionsForProfileSwitch(ctx)
           tmuxSessionsSnapshotCache.clear()
+          // アカウントが変わったので、旧アカウントの利用量・認証在否を TTL の残り時間だけ
+          // 見せ続けないよう明示的に捨てる (直後の needs_login 判定も実測値になる)。
+          usageResponseCache.clear()
+          clearCredentialCheckCache()
           // 切替先の config ディレクトリに認証情報が無ければ要ログイン (バッジ/案内用)。
           const hasCreds = isKeychainPlatform()
             ? await profileHasKeychainCredentials(target.configDir)
@@ -4497,6 +4734,10 @@ async function dispatch(msg, ctx) {
           const before = ctx.codexBridge?.sessions?.size ?? 0
           ctx.codexBridge?.shutdown()
           tmuxSessionsSnapshotCache.clear()
+          // Codex アカウントが変わったので、旧アカウントの 5h/7d を TTL の残り時間だけ
+          // 見せ続けない (rate limits 自体は profileId 別キャッシュなので混ざらないが、
+          // usage.response の中身は両アカウントを束ねているため明示的に捨てる)。
+          usageResponseCache.clear()
           const hasCreds = await codexProfiles.hasCodexCredentials(target.configDir)
           const needsLogin = !hasCreds
           const isDefaultTarget = target.id === codexProfiles.DEFAULT_CODEX_PROFILE_ID
@@ -4963,145 +5204,7 @@ async function dispatch(msg, ctx) {
         return
       }
       case "usage.request": {
-        try {
-          const activeClaudeProfile = await getActiveProfile()
-          const claudeHasCredentials = isKeychainPlatform()
-            ? await profileHasKeychainCredentials(activeClaudeProfile.configDir)
-            : await hasFileCredentials(activeClaudeProfile.configDir)
-          // 5h/7d の本命ソース: SDK control request (アカウント全体、session 非依存)。
-          // statusLine が rate_limits を出さなくなった環境 (2026-07 時点の Claude CLI) でも
-          // ここでライブ更新できる。frontend の usage.request ポーリング (既定 60s) 頻度に
-          // 相乗りするだけで十分な鮮度が保てるため、専用タイマーは設けない。EXPERIMENTAL
-          // API の失敗は getAccountUsage 内で握りつぶし null を返す (recordChatUsageSnapshot
-          // は no-op) ので、既存の statusLine/transcript フォールバックは無傷で残る。
-          if (ctx.claudeBridge) {
-            try {
-              // ⚠️ getAccountUsage は SDK のサブプロセスを spawn する。**時間制限が無いと
-              // 返ってこないときに control レーン全体が止まる** (usage.request は 60 秒周期で
-              // control レーンに乗り、そこにセッション停止も並ぶ)。同種の head-of-line
-              // blocking で cold p95 40〜54 秒を計測した記録が isReadOnlyRpc の注記にある。
-              // 時間切れは握りつぶさず warn で残す (これ自体が「詰まりの実測値」になる)。
-              const acct = await withDeadline(
-                ctx.claudeBridge.getAccountUsage(),
-                ACCOUNT_USAGE_TIMEOUT_MS,
-                () =>
-                  ctx.logger?.warn?.(
-                    { timeout_ms: ACCOUNT_USAGE_TIMEOUT_MS },
-                    "account usage timed out (dispatch lane released)",
-                  ),
-              )
-              if (acct) recordChatUsageSnapshot(acct, Date.now(), activeClaudeProfile.id)
-            } catch (err) {
-              ctx.logger?.debug?.({ err: err?.message }, "account usage snapshot skipped")
-            }
-          }
-          let [usage, sessions] = await Promise.all([
-            getUsage({ profileId: activeClaudeProfile.id }),
-            getSessionUsages(),
-          ])
-          // 未ログインで残ったローカル transcript/cache をアカウント利用量として見せない。
-          if (!claudeHasCredentials) {
-            usage = null
-            sessions = []
-          }
-
-          // Codex 版 (Stream B3, 2026-07-03): rollout jsonl の token_count イベントから
-          // 5h/7d + context% を取る。⚠️ Codex の 5h/7d は ChatGPT/OpenAI サブスクリプション
-          // の残量であり、上の `usage` (Claude/Anthropic サブスクリプション) とは別契約の
-          // 別数値のため、`usage` にマージせず独立フィールド `codexUsage`/`codexSessions`
-          // として返す (frontend 側でどちらのアカウントの残量か混同しないため)。
-          let codexUsage = null
-          let codexSessions = []
-          const activeCodexProfile = await codexProfiles.getActiveProfile()
-          const codexHasCredentials = await codexProfiles.hasCodexCredentials(activeCodexProfile.configDir)
-          if (ctx.codexBridge && codexHasCredentials) {
-            try {
-              // 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 件から取る (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 }
-                }
-              }
-              // ライブ session の有無にかかわらず、起動直後の account RPC を優先する。
-              // rollout は context の補助だけにし、5h/7d はプロファイル固有の最新実値にする。
-              const accountUsage = codexUsageFromAccountRateLimits(
-                await ctx.codexBridge.readAccountRateLimits({ profileId: activeCodexProfile.id }),
-              )
-              if (accountUsage) {
-                codexUsage = { ...accountUsage, context: codexUsage?.context ?? null }
-                recordAccountUsageSnapshot("codex", activeCodexProfile.id, codexUsage)
-              }
-            } catch (err) {
-              ctx.logger?.debug?.({ err: err?.message }, "codex usage snapshot skipped")
-            }
-          }
-          // Agent 再起動後や一時的な account RPC 失敗時も、同一 profile の最終取得値だけを
-          // 表示する。未ログインならここへ到達せず、表示も完全に隠す。
-          if (codexHasCredentials && !codexUsage) {
-            codexUsage = await readAccountUsageSnapshot("codex", activeCodexProfile.id)
-          }
-
-          ctx.client.send({
-            type: "usage.response",
-            request_id: msg.request_id,
-            usage,
-            sessions,
-            codexUsage,
-            codexSessions,
-          })
-        } catch (err) {
-          ctx.client.send({
-            type: "usage.response",
-            request_id: msg.request_id,
-            usage: null,
-            sessions: [],
-            codexUsage: null,
-            codexSessions: [],
-            error: err.message,
-          })
-        }
+        await handleUsageRequest(msg, ctx)
         return
       }
       default: