@cocorograph/hub-agent 0.8.15 → 0.8.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocorograph/hub-agent",
-  "version": "0.8.15",
+  "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/dispatch-scheduler.mjs

@@ -23,10 +23,44 @@ const LIFECYCLE_TYPES = new Set([
 
 const MAX_STREAM_LANE_KEYS = 4096
 
+/**
+ * dispatch の所要時間ログを出す閾値 (ms)。
+ *
+ * ⚠️ これは計測のために足したもので、性能を変えるものではない。
+ * 「セッションの停止に 10 秒経っても応答が返らない」の中身が **一切観測できなかった**
+ * ため入れた (2026-07-31)。kill 実体は実測 0.00 秒・レーン内の tmux 処理も 0.1 秒未満
+ * なので、遅延の候補は「レーンの順番待ち」か「そもそも届いていない」に絞られるが、
+ * どちらなのかを判別する材料がログに 1 行も無かった。
+ *
+ * 全 dispatch を出すとログが膨れるので、閾値超えのものだけ出す。
+ */
+const SLOW_DISPATCH_MS = 1000
+
+/**
+ * 閾値に関係なく必ず所要時間を出す type。
+ *
+ * 停止 (kill) は低頻度なのでログ量の心配が無く、かつ「遅い / 返ってこない」の
+ * 調査対象そのものなので、速かった場合も含めて毎回記録する
+ * (速いことの記録が無いと「詰まっていない」を示せない)。
+ */
+const ALWAYS_TIMED_TYPES = new Set(["tmux.kill_session"])
+
 export function isConnectionLifecycleMessage(type) {
   return LIFECYCLE_TYPES.has(type)
 }
 
+/**
+ * 所要時間ログを出すべきか。テストから直接検査できるよう export する。
+ *
+ * @param {string} type    メッセージ種別
+ * @param {number} waitMs  レーンで順番待ちしていた時間
+ * @param {number} runMs   ハンドラ本体の実行時間
+ */
+export function shouldLogDispatchTiming(type, waitMs, runMs) {
+  if (ALWAYS_TIMED_TYPES.has(type)) return true
+  return waitMs >= SLOW_DISPATCH_MS || runMs >= SLOW_DISPATCH_MS
+}
+
 function chatMode(type) {
   if (typeof type !== "string") return null
   if (type === "claude.attach" || type.startsWith("claude.")) return "claude"
@@ -179,6 +213,8 @@ export class DispatchScheduler {
   enqueue(msg) {
     const type = msg?.type
     const sequence = ++this.sequence
+    // 順番待ち時間の起点。bypass 経路は待たないので測らない。
+    const enqueuedAt = Date.now()
     if (this.shouldBypass(type) || isConnectionLifecycleMessage(type)) {
       return this._runNow(msg)
     }
@@ -217,7 +253,21 @@ export class DispatchScheduler {
           )
           return
         }
-        await this.run(msg)
+        // レーンの順番待ち時間と、ハンドラ本体の実行時間を分けて測る。
+        // この 2 つを分けないと「遅いのは順番待ちか処理そのものか」が判別できない。
+        const startedAt = Date.now()
+        const waitMs = startedAt - enqueuedAt
+        try {
+          await this.run(msg)
+        } finally {
+          const runMs = Date.now() - startedAt
+          if (shouldLogDispatchTiming(type, waitMs, runMs)) {
+            this.logger?.info?.(
+              { type, lane, wait_ms: waitMs, run_ms: runMs },
+              "dispatch timing",
+            )
+          }
+        }
       })
       .catch((err) => {
         this.logger?.error?.(

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"
@@ -295,6 +297,36 @@ async function loadClaudeSdk(logger) {
   }
 }
 
+/** アカウント利用量取得の時間制限 (ms)。超えたらレーンを解放して次へ進む。 */
+export const ACCOUNT_USAGE_TIMEOUT_MS = 8_000
+
+/**
+ * `promise` に時間制限を設ける。制限を超えたら `null` で解決し `onTimeout` を呼ぶ。
+ *
+ * ⚠️ **元の promise はキャンセルできない**ので、裏では走り続ける。ここでの目的は
+ * 「返ってこない処理に dispatch レーンを占有させ続けない」ことであり、処理そのものを
+ * 止めることではない。時間切れを黙って握りつぶさず呼び出し側でログに残すこと
+ * (時間切れの発生回数と頻度が、詰まりの実測値そのものになる)。
+ *
+ * テストから直接呼べるよう export する。
+ */
+export function withDeadline(promise, timeoutMs, onTimeout) {
+  let timer
+  return Promise.race([
+    Promise.resolve(promise).finally(() => clearTimeout(timer)),
+    new Promise((resolve) => {
+      timer = setTimeout(() => {
+        try {
+          onTimeout?.()
+        } catch {
+          /* ログ失敗で本筋を止めない */
+        }
+        resolve(null)
+      }, timeoutMs)
+    }),
+  ])
+}
+
 /**
  * B7: 直列 dispatchChain をバイパスして即時処理してよい高頻度・低レイテンシ経路かを判定する。
  * - pty 出力データ (pty.data) と resize (pty.resize): 高頻度・順序保証不要。
@@ -3242,13 +3274,33 @@ export async function handleKillSession(msg, ctx) {
     })
     return
   }
+  // ⚠️ kill の受信・完了は必ずログに残す (2026-07-31 追加)。
+  // 「停止に 10 秒経っても応答が返らない」の調査で、agent 側に kill の痕跡が
+  // 1 行も無く、遅いのか・届いていないのか・返事が捨てられたのかを**判別できなかった**。
+  // kill は低頻度なのでログ量の懸念は無い。速かった場合も記録する
+  // (速いことの記録が無いと「agent は詰まっていない」を示せない)。
+  ctx.logger?.info?.({ names, request_id: msg.request_id }, "tmux kill_session received")
+  const killStartedAt = Date.now()
   const r = await killFn(names)
-  ctx.client.send({
+  const killMs = Date.now() - killStartedAt
+  const sent = ctx.client.send({
     type: "tmux.kill_session.result",
     request_id: msg.request_id,
     killed: r.killed,
     failed: r.failed,
   })
+  // 送信できたか自体を残す。ws が閉じていると result は黙って捨てられるため、
+  // 「kill は成功したのに要求元へ返っていない」を後から特定できるようにする。
+  ctx.logger?.info?.(
+    {
+      request_id: msg.request_id,
+      killed: r.killed.length,
+      failed: r.failed.length,
+      kill_ms: killMs,
+      result_sent: sent === true,
+    },
+    "tmux kill_session done",
+  )
   for (const name of r.killed) {
     try {
       ctx.client.send({ type: "session.gone", session_name: name })
@@ -3259,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 {
@@ -4307,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)
@@ -4447,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
@@ -4913,132 +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 {
-              const acct = await ctx.claudeBridge.getAccountUsage()
-              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: