@cocorograph/hub-agent 0.7.29 → 0.7.32

package/package.json

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

package/src/claude-history.mjs

@@ -29,6 +29,50 @@ export const MAX_HISTORY_LINES = 500
 /** UI 表示対象の SDK message type (それ以外は jsonl 内部メタなので除外)。 */
 export const DISPLAY_TYPES = new Set(["user", "assistant", "system", "result"])
 
+/**
+ * hydrate 結果のパース済みキャッシュ (2026-07-03: Cockpit セッション切替パフォーマンス改善)。
+ *
+ * 背景: CockpitChatView は resume セッション切替のたびに毎回 readSessionHistory を呼ぶが
+ * (window/page.tsx の `key={selected}` 再マウント設計)、同一ファイルが未変更のまま
+ * 数秒〜数分内に再 hydrate されるケースが大半 (行ったり来たりのセッション切替、複数タブ)。
+ * readFile → split → 全行 JSON.parse (+ MASK_ENABLED 時は tool_use 走査) は jsonl が
+ * 大きいほど無視できないコストになるため、`mtimeMs + size` が前回と一致する間は
+ * パース結果をそのまま再利用し、ディスク読み直し・再パースを丸ごとスキップする。
+ * ファイルが変わっていれば (ライブ会話が進行 / 別ターミナルから追記等) 通常どおり再読み込み
+ * して上書きするので、常に最新のファイル内容を正しく反映する (stale 表示のリスクは無い)。
+ *
+ * key: filePath, value: { mtimeMs, size, maxLines, result }。maxLines もキーの一部として
+ * 比較する (異なる maxLines でのリクエストはキャッシュを再利用しない)。
+ */
+const HYDRATE_CACHE_MAX_ENTRIES = 200
+const hydrateCache = new Map()
+
+function getHydrateCache(filePath, mtimeMs, size, maxLines) {
+  const entry = hydrateCache.get(filePath)
+  if (!entry) return null
+  if (entry.mtimeMs !== mtimeMs || entry.size !== size || entry.maxLines !== maxLines) return null
+  // LRU: 再利用したエントリを Map の末尾へ移し直す (再挿入で挿入順を更新)。
+  hydrateCache.delete(filePath)
+  hydrateCache.set(filePath, entry)
+  return entry.result
+}
+
+function setHydrateCache(filePath, mtimeMs, size, maxLines, result) {
+  hydrateCache.delete(filePath)
+  hydrateCache.set(filePath, { mtimeMs, size, maxLines, result })
+  // 上限超過分は挿入順が古いものから GC (長時間稼働の hub-agent プロセスでメモリが
+  // 際限なく増えないようにする)。
+  while (hydrateCache.size > HYDRATE_CACHE_MAX_ENTRIES) {
+    const oldestKey = hydrateCache.keys().next().value
+    hydrateCache.delete(oldestKey)
+  }
+}
+
+/** テスト用: hydrate キャッシュを全消去する。 */
+export function clearHydrateCacheForTest() {
+  hydrateCache.clear()
+}
+
 /**
  * jsonl の生 object を、Browser が SDK message として受け取れる表示用 shape に正規化する。
  * 余分な内部メタは落とし、表示・集計に必要なフィールドだけを superset で拾う。
@@ -97,6 +141,21 @@ export function jsonlPath({ cwd, session_id, projectsRoot }) {
  * @returns {Promise<{events: object[], total_lines: number, truncated: boolean}>}
  */
 export async function readSessionHistory(filePath, { maxLines = MAX_HISTORY_LINES, logger } = {}) {
+  // stat は readFile よりずっと軽い (メタデータのみ)。mtimeMs+size が前回と同じなら
+  // ファイル内容も同じとみなし、以降の readFile + 全行 parse をまるごとスキップする。
+  let st
+  try {
+    st = await stat(filePath)
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return { events: [], total_lines: 0, truncated: false }
+    }
+    logger?.warn({ err: err.message, filePath }, "claude history stat failed")
+    throw err
+  }
+  const cached = getHydrateCache(filePath, st.mtimeMs, st.size, maxLines)
+  if (cached) return cached
+
   let text
   try {
     text = await readFile(filePath, "utf-8")
@@ -143,7 +202,9 @@ export async function readSessionHistory(filePath, { maxLines = MAX_HISTORY_LINE
     if (MASK_ENABLED) event = maskMessageObject(event, toolNames)
     events.push(event)
   }
-  return { events, total_lines, truncated }
+  const result = { events, total_lines, truncated }
+  setHydrateCache(filePath, st.mtimeMs, st.size, maxLines, result)
+  return result
 }
 
 /**

package/src/claude-stream-bridge.mjs

@@ -1588,6 +1588,78 @@ export class ClaudeStreamBridge extends EventEmitter {
     return this._mergeNeedsAuthCache(servers)
   }
 
+  /**
+   * アカウント全体の 5h/7d rate-limit 使用率 + プラン種別を返す (usage.mjs
+   * recordChatUsageSnapshot に渡す想定)。mcpStatus と同じ control-only query を共有する
+   * (account-level = session/チャット非依存。statusLine が動かない純 SDK チャット運用でも
+   * 取得できる)。
+   *
+   * SDK の `usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET()` は unstable な
+   * 実験的 API のため、失敗 (未実装 SDK バージョン / 一時的なエラー等) は null を返す。
+   * 呼び出し側 (main.mjs `usage.request` ハンドラ) は null なら何もせず、既存の
+   * statusLine / transcript 推定フォールバックに委ねる。
+   *
+   * @returns {Promise<import('@anthropic-ai/claude-agent-sdk').SDKControlGetUsageResponse|null>}
+   */
+  async getAccountUsage() {
+    try {
+      const q = await this._ensureMcpControlQuery()
+      this._armMcpControlIdle()
+      if (typeof q.usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET !== "function") {
+        return null
+      }
+      return await q.usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET()
+    } catch (err) {
+      this.logger?.warn(
+        { err: err?.message },
+        "getAccountUsage failed (SDK experimental usage API)",
+      )
+      return null
+    }
+  }
+
+  /**
+   * 指定 cwd で現在ライブな (browser 接続中、または detach 猶予内の) SDK チャット
+   * session_id を返す。無ければ null。
+   *
+   * TUI モードには tuiReboundSessions による bound session 解決 (main.mjs
+   * `turnActiveForCwd`/`jsonlContextForCwd` 呼び出し) があるが、チャット (SDK stream)
+   * モードには同等の仕組みが無かった。同一 cwd の encode dir にはチャット本体の他に
+   * サブエージェント / headless `claude -p` (記憶蒸留 Stop hook 等) / 過去セッションの
+   * jsonl が堆積するため、bound 指定無しの mtime 最新フォールバックは cross-activity
+   * 汚染 (無関係な jsonl を「そのチャット」と誤認) を起こし得る。本メソッドはチャット版
+   * の bound session 解決として main.mjs (startStateLoop / tmux.list_sessions ハンドラ)
+   * から使う。同一 cwd に複数ライブセッションがある場合は最終アクティビティが最も
+   * 新しいものを採用する。
+   *
+   * @param {string} cwd
+   * @returns {string|null}
+   */
+  liveSessionIdForCwd(cwd) {
+    if (!cwd) return null
+    let best = null
+    let bestAt = -1
+    const seen = new Set()
+    for (const session of this.sessions.values()) {
+      if (seen.has(session) || session.cwd !== cwd || !session.sessionId) continue
+      seen.add(session)
+      let at = 0
+      for (const t of session.lastActivityByStream.values()) {
+        if (t > at) at = t
+      }
+      // `>=` (2026-07-03): Date.now() はミリ秒精度のため、短時間に複数セッションへ
+      // attach+input すると同一ミリ秒でタイが起き得る (テストや高速な連続操作で実測)。
+      // `this.sessions` は Map で挿入順を保持するため、タイ時は後から attach された
+      // (= イテレーション順で後に来る) セッションを採用するのが「最終アクティビティが
+      // 最も新しい」の意図に合う。厳密な `>` だと先勝ちになり意図と逆転する。
+      if (at >= bestAt) {
+        bestAt = at
+        best = session.sessionId
+      }
+    }
+    return best
+  }
+
   /**
    * `mcpServerStatus()` の結果に、needs-auth キャッシュにあるが結果へ含まれない
    * サーバーを `needs-auth` として補完する。

package/src/codex-stream-bridge.mjs

@@ -23,6 +23,13 @@
  *   - 画像/添付入力 (テキストのみ)。
  *   - acceptForSession や execpolicy/network amendment 等の高度な承認 decision
  *     (permissionReply は decision をそのまま素通しするので呼び出し側が組み立てる)。
+ *
+ * Slice 6 (履歴 hydrate) で追加: `thread/resume` のレスポンスは既定で
+ * `thread.turns[].items[]` (= ThreadItem の時系列) を含む (公式スキーマ
+ * `ThreadReadResponse.json` の Thread.turns 説明: "Only populated on thread/resume,
+ * thread/rollback, thread/fork, and thread/read (when includeTurns is true)")。
+ * 追加の `thread/read` 往復は不要で、attach() の戻り値に `history` として平坦化して
+ * 返す (browser 側での re-mount 白紙状態を解消する)。
  */
 import { EventEmitter } from "node:events"
 
@@ -39,6 +46,17 @@ const IDLE_DETACH_TTL_MS = 5 * 60 * 1000
 
 const CLIENT_INFO = { name: "cockpit-hub-agent", title: "Cockpit", version: "1.0.0" }
 
+// Slice 6: thread/resume が返す Thread.turns[].items[] を単一の時系列配列へ平坦化する。
+// turns は開始ターン順の配列、各 turn.items も時系列順のため単純結合で会話順を保てる。
+function flattenThreadItems(thread) {
+  const turns = Array.isArray(thread?.turns) ? thread.turns : []
+  const items = []
+  for (const turn of turns) {
+    if (Array.isArray(turn?.items)) items.push(...turn.items)
+  }
+  return items
+}
+
 function userInputFromMessage(message) {
   const content = message?.content
   if (typeof content === "string") {
@@ -65,7 +83,7 @@ export class CodexStreamBridge extends EventEmitter {
   }
 
   /**
-   * @returns {Promise<{resuming: boolean, threadId: string}>}
+   * @returns {Promise<{resuming: boolean, threadId: string, history: object[]}>}
    */
   async attach({ stream_id, cwd, model, effort, approvalPolicy, sandbox, resumeThreadId }) {
     if (this.sessions.has(stream_id)) {
@@ -96,7 +114,10 @@ export class CodexStreamBridge extends EventEmitter {
         ? await client.request("thread/resume", { ...startParams, threadId: resumeThreadId })
         : await client.request("thread/start", startParams)
       session.threadId = result?.thread?.id
-      return { resuming, threadId: session.threadId }
+      // 新規スレッド (thread/start) は履歴が無いので空配列。resume 時のみ平坦化する
+      // (thread/start のレスポンスは turns を持たない仕様のため呼んでも常に空)。
+      const history = resuming ? flattenThreadItems(result?.thread) : []
+      return { resuming, threadId: session.threadId, history }
     } catch (err) {
       this.sessions.delete(stream_id)
       client.stop()

package/src/config.mjs

@@ -10,7 +10,7 @@
 import { promises as fs, constants as fsConsts, readFileSync } from "node:fs"
 import path from "node:path"
 import os from "node:os"
-import { execFile } from "node:child_process"
+import { execFile, execFileSync } from "node:child_process"
 import { promisify } from "node:util"
 
 const _execFileP = promisify(execFile)
@@ -21,9 +21,20 @@ const _execFileP = promisify(execFile)
  * 重要: Windows のエージェントは WSL2 内で動くため `process.platform` は "linux" を
  * 返す。素の Linux と区別するため、WSL を検出して "wsl" を返す。
  *
+ * 判定は 3 段階のフォールバック:
+ * 1. `WSL_DISTRO_NAME` / `WSL_INTEROP` 環境変数 (対話シェルなら通常付く)
+ * 2. `/proc/version` の内容 (microsoft/wsl 文字列)
+ * 3. (2026-07-03 追加) `uname -r` のカーネルリリース文字列。systemd サービス等
+ *    非対話起動では 1 の環境変数が unit に伝播しないケースがある (WSL2 + systemd の
+ *    典型的な罠。対話シェルにしか WSL_DISTRO_NAME が無く、hub-agent をサービス化
+ *    すると引き継がれない)。`uname -r` は環境変数に依存せずカーネル自体から
+ *    "5.15.x-microsoft-standard-WSL2" のような値を返すため、より確実な最終フォールバック
+ *    として使う。
+ *
+ * @param {{execImpl?: (cmd: string, args: string[]) => string}} [opts] テスト用の exec 差し替え
  * @returns {"darwin"|"wsl"|"linux"|"win32"|string}
  */
-export function detectPlatform() {
+export function detectPlatform({ execImpl } = {}) {
   if (process.platform === "darwin") return "darwin"
   if (process.platform === "win32") return "win32"
   if (process.platform === "linux") {
@@ -32,7 +43,14 @@ export function detectPlatform() {
       const v = readFileSync("/proc/version", "utf-8").toLowerCase()
       if (v.includes("microsoft") || v.includes("wsl")) return "wsl"
     } catch {
-      /* /proc/version が読めない環境は素の linux 扱い */
+      /* /proc/version が読めない環境は次のフォールバックへ */
+    }
+    try {
+      const run = execImpl || ((cmd, args) => execFileSync(cmd, args, { encoding: "utf-8" }))
+      const release = run("uname", ["-r"]).toLowerCase()
+      if (release.includes("microsoft") || release.includes("wsl")) return "wsl"
+    } catch {
+      /* uname が無い/失敗する環境は素の linux 扱い */
     }
     return "linux"
   }

package/src/main.mjs

@@ -98,6 +98,7 @@ import {
   getUsage,
   isFreshUnboundBind,
   recordChatRateLimit,
+  recordChatUsageSnapshot,
   turnActiveForCwd,
 } from "./usage.mjs"
 import {
@@ -1343,6 +1344,61 @@ export function enrichTmuxSessionsForListResponse(
   })
 }
 
+/**
+ * state loop 内で「チャット信号 (getChatSignal) でペイン status/context_pct を上書きするか」
+ * を決める純関数 (startStateLoop から抽出、単体テスト用)。
+ *
+ * バグ修正 (2026-07): 従来コードは書き換え「後」の status で processing ガードを判定して
+ * いたため、チャット自身が processing を立てたときに自分自身の条件 (`status !== "processing"`)
+ * を満たせなくなり、SDK チャット生成中はドーナツ (context_pct) が一切更新されなかった。
+ * 本関数は判定を必ず「上書き前の pane 由来 status (paneStatus)」で行う。ペイン
+ * (capture-pane) が実際に processing (= 本物の TUI が生成中) の場合のみチャット信号での
+ * 上書きを止める。それ以外 (pane が idle 等 = SDK チャット専用ペイン含む) は常にチャット
+ * 信号を優先する。
+ *
+ * @param {string} paneStatus capture-pane 由来の生 status (上書き前)
+ * @param {number|null|undefined} paneContextPct capture-pane 由来の生 context_pct
+ * @param {{status?:string|null, context_pct?:number|null}|null} chat getChatSignal() の戻り値
+ * @returns {{status:string, contextPct:number|null|undefined}}
+ */
+export function applyChatOverlay(paneStatus, paneContextPct, chat) {
+  let status = paneStatus
+  let contextPct = paneContextPct
+  if (chat) {
+    const paneIsProcessing = paneStatus === "processing"
+    if (chat.status && !paneIsProcessing) status = chat.status
+    if (typeof chat.context_pct === "number" && !paneIsProcessing) {
+      contextPct = chat.context_pct
+    }
+  }
+  return { status, contextPct }
+}
+
+/**
+ * turnActiveForCwd / jsonlContextForCwd に渡す bound session_id を解決する純関数。
+ *
+ * TUI (tuiReboundSessions, tmux セッション名キー) を優先し、無ければ claudeBridge の
+ * ライブ SDK チャットセッション (cwd キー) にフォールバックする。チャットモードには
+ * tmux 上の bind 台帳が無いため、これが無いとチャット信号 stale (90s 無活動) 時の
+ * フォールバックが cwd の encode dir 内の別アクティビティ jsonl (サブエージェント /
+ * headless `claude -p` / 過去セッション等) を「最新」と取り違える cross-activity 汚染を
+ * 起こし得る (TUI 版は tuiReboundSessions で 2026-06 に根治済み。本関数はチャット版の同根治)。
+ *
+ * @param {Map<string,string>|null|undefined} boundSessions ctx.tuiReboundSessions
+ * @param {string} sessionName tmux セッション名
+ * @param {string|null|undefined} cwd
+ * @param {{liveSessionIdForCwd?: (cwd:string)=>string|null}|null|undefined} claudeBridge
+ * @returns {string|null}
+ */
+export function resolveStateLoopBoundSessionId(boundSessions, sessionName, cwd, claudeBridge) {
+  const tuiId = boundSessionId(boundSessions, sessionName)
+  if (tuiId) return tuiId
+  if (cwd && claudeBridge && typeof claudeBridge.liveSessionIdForCwd === "function") {
+    return claudeBridge.liveSessionIdForCwd(cwd) || null
+  }
+  return null
+}
+
 export function startStateLoop({ client, plugins, logger, intervalMs, claudeBridge, readinessTracker, boundSessions }) {
   const lastByName = new Map() // session_name → {status, context_pct}
   const lastTurnAtByName = new Map() // session_name → 最後に event ファイル化した turnAt
@@ -1379,25 +1435,25 @@ export function startStateLoop({ client, plugins, logger, intervalMs, claudeBrid
       await refreshContextWindow()
       const states = await listSessionStates({ plugins, logger })
       for (const s of states) {
-        let status = s.status
-        let contextPct = s.context_pct
         // 対話 TUI のペインから読んだ権限モード (素のシェル / SDK チャットでは null)。
         // tmux 上で直接 shift+tab した変更もここで拾い、全ブラウザへ追従させる。
         const permissionMode = s.permission_mode ?? null
         // チャットモード補完: tmux ペインのスクレイプは TUI 前提で効かないため、
         // session の cwd に一致する新鮮なチャット信号があれば status/context% を
         // 上書きする (Hub ホスト型 Cockpit のステータスドット/各行ドーナツ用)。
+        // capture-pane が processing (= ペインに "esc to interrupt" が実在 = 本物の
+        // TUI が生成中) のときのみチャット信号で上書きしない (判定は applyChatOverlay
+        // 内部で必ず「上書き前の pane 由来 status (s.status)」を使う。2026-07 バグ修正:
+        // 旧実装は書き換え後の status で判定していたため、SDK チャット生成中はドーナツが
+        // 一切更新されなかった)。素のシェル (SDK チャットのペイン) は processing を
+        // 返せないため、SDK チャットの補完は従来どおり効く。TUI 生成中に stale な SDK
+        // status (waiting) が勝ってステータスドット/三点リーダーが消える事故の防止
+        // (2026-06-12) は paneIsProcessing ガードのまま維持される。
         const chat = s.cwd ? getChatSignal(s.cwd) : null
+        const overlay = applyChatOverlay(s.status, s.context_pct, chat)
+        let status = overlay.status
+        let contextPct = overlay.contextPct
         if (chat) {
-          // capture-pane が processing (= ペインに "esc to interrupt" が実在 = 本物の
-          // TUI が生成中) のときはチャット信号で上書きしない。素のシェル (SDK チャット
-          // のペイン) は processing を返せないため、SDK チャットの補完は従来どおり効く。
-          // TUI 生成中に stale な SDK status (waiting) が勝ってステータスドット/
-          // 三点リーダーが消える事故の防止 (2026-06-12)。
-          if (chat.status && status !== "processing") status = chat.status
-          if (typeof chat.context_pct === "number" && status !== "processing") {
-            contextPct = chat.context_pct
-          }
           // チャットのターン境界 (turnAt 前進) を sort 用 session-event に橋渡し。
           // tmux ペインが動かず bundle hook が発火しないため、ここで代替発火する。
           const prevTurnAt = lastTurnAtByName.get(s.session_name) || 0
@@ -1466,6 +1522,11 @@ export function startStateLoop({ client, plugins, logger, intervalMs, claudeBrid
         //    T2: tool_use 末尾 active 中の中断マーカー無しクラッシュ判定のため、tmux pane_current_command
         //    から claude プロセス生存を 3 値で返す paneClaudeAliveOrUnknown を probe として渡す。
         //    'dead' (シェル前景)→active=false に倒す。'alive'/'unknown' は active 維持(偽陰性ゼロ)。
+        //  - チャット信号が stale (90s 無活動) でこの else-if に落ちるケース: SDK チャットは
+        //    tmux bind 台帳 (tuiReboundSessions) を持たないため、従来は boundSessionId が常に
+        //    null を返し mtime 最新 jsonl へフォールバックしていた (chat 版の cross-activity
+        //    汚染, 2026-07 発覚)。resolveStateLoopBoundSessionId が claudeBridge のライブ
+        //    セッション id へフォールバックすることで TUI と同じ方式で根治する。
         let turnActive = null
         if (chat?.status === "processing") {
           turnActive = true
@@ -1479,7 +1540,7 @@ export function startStateLoop({ client, plugins, logger, intervalMs, claudeBrid
         } else if (s.cwd) {
           turnActive = await turnActiveForCwd(
             s.cwd,
-            boundSessionId(boundSessions, s.session_name),
+            resolveStateLoopBoundSessionId(boundSessions, s.session_name, s.cwd, claudeBridge),
             s.session_name,
             { paneAliveProbe: paneClaudeAliveOrUnknown },
           )
@@ -3032,6 +3093,10 @@ async function dispatch(msg, ctx) {
             stream_id,
             resuming: info.resuming,
             thread_id: info.threadId,
+            // Slice 6: 履歴 hydrate。resume 時のみ非空 (thread/start は常に [])。
+            // consumers.py の per-stream relay は content-blind なので backend 側の
+            // 変更は不要 (_AGENT_PER_STREAM_TYPES の codex.ready がそのまま運ぶ)。
+            history: info.history || [],
           })
         } catch (err) {
           ctx.client.send({
@@ -3311,10 +3376,13 @@ async function dispatch(msg, ctx) {
         try {
           // boundSessions: 各行の context% (ドーナツ) を bound session の jsonl から引く
           // (cwd dir 内の別セッション jsonl を最新と取り違える=メタ欠陥#1 の根治)。
+          // claudeBridge: TUI bind が無い SDK チャット cwd 向けの同根治フォールバック
+          // (2026-07 追加。tmux.mjs listSessions 参照)。
           const sessions = await listTmuxSessions({
             plugins: ctx.plugins,
             logger: ctx.logger,
             boundSessions: ctx.tuiReboundSessions,
+            claudeBridge: ctx.claudeBridge,
           })
           // 各 session の最新 hook event を /tmp/cockpit_session_events/ から読んで
           // レスポンスに含める (Phase 4: ハードリロード時の lastEvent 復元用)。
@@ -3581,6 +3649,20 @@ async function dispatch(msg, ctx) {
       }
       case "usage.request": {
         try {
+          // 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)
+            } catch (err) {
+              ctx.logger?.debug?.({ err: err?.message }, "account usage snapshot skipped")
+            }
+          }
           const [usage, sessions] = await Promise.all([
             getUsage(),
             getSessionUsages(),

package/src/tmux.mjs

@@ -643,7 +643,15 @@ export async function listSessions(opts = {}) {
       //  4. それも無ければ pane scrape の正規表現フォールバック。
       const fromStatusLine = cwd ? ctxByCwd.get(cwd)?.contextPercent : null
       // bound session があればその jsonl で context% を引く (cwd dir の別セッション jsonl の取り違え回避)。
-      const boundId = boundSessionId(opts.boundSessions, s.name)
+      // TUI bind (opts.boundSessions, tmux セッション名キー) を優先し、無ければ SDK チャット
+      // (claudeBridge, cwd キー) のライブセッションへフォールバックする。チャットモードには
+      // tmux 上の bind 台帳が無いため、これが無いと cold-start (session.state snapshot 未取得)
+      // の poll 応答で cwd の別アクティビティ jsonl を「最新」と取り違える cross-activity 汚染が
+      // 起き得る (2026-07 発覚。TUI 版は本行の boundSessions 解決で既に根治済みだった)。
+      const boundId =
+        boundSessionId(opts.boundSessions, s.name) ||
+        (cwd && opts.claudeBridge?.liveSessionIdForCwd?.(cwd)) ||
+        null
       const jsonlInfo = cwd ? await jsonlContextForCwd(cwd, boundId) : null
       const context_pct =
         jsonlInfo?.isReset && typeof jsonlInfo.percent === "number"

package/src/usage.mjs

@@ -272,6 +272,125 @@ export function whenChatRateLimitsPersisted() {
   return _persistInFlight
 }
 
+// ---------------------------------------------------------------------------
+// SDK control request (`usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET`)
+// から取得した 5h/7d + plan のスナップショット (プロセス内共有 + ディスク永続化)。
+//
+// 背景: `recordChatRateLimit` (上記, SDK の `rate_limit_event`) は 2026-07 時点の
+// SDK/Claude CLI で `utilization` フィールドが送られなくなり (実測確認済み)、事実上
+// 常時 no-op 化した。加えて statusLine cache (`~/.hub/usage/latest.json`) 自体も
+// `rate_limits` を出さなくなったため (readOfficial 参照)、5h/7d はターミナル・
+// チャット両モードで estimate (transcript 集計の粗い近似) に落ちていた。
+//
+// SDK の control request `usage_EXPERIMENTAL_...()` は実測で正確な utilization/
+// resets_at を返すことを確認済み (claude-agent-sdk 0.3.198)。account-level (session
+// 非依存) なので、claude-stream-bridge.mjs の MCP control-only query を共有して
+// 定期的に呼び出し (main.mjs `usage.request` ハンドラ)、ここに記録する。
+//
+// 永続化先は statusLine cache とは別ファイル (`~/.hub/usage/chat-usage.json`)。
+// 同じ latest.json に混ぜると TUI の statusLine スクリプトが全文上書きで消してしまう
+// (旧 chatRateLimits の設計的弱点)。専用ファイルなら誰にも上書きされない。
+// ---------------------------------------------------------------------------
+
+function chatUsageCachePath() {
+  return configPath("HUB_CHAT_USAGE_CACHE", os.homedir(), ".hub", "usage", "chat-usage.json")
+}
+
+/** @type {{five_hour:{percent:number,resetAtMs:number|null}|null, seven_day:{percent:number,resetAtMs:number|null}|null, plan:string|null, updatedAtMs:number}|null} */
+let chatUsageSnapshot = null
+let _chatUsagePersistInFlight = Promise.resolve()
+
+/** SDKControlGetUsageResponse.rate_limits.{five_hour,seven_day} の 1 窓を正規化する。 */
+function normalizeRateLimitWindow(w) {
+  if (!w || typeof w !== "object") return null
+  const percent = typeof w.utilization === "number" ? w.utilization : null
+  if (percent === null) return null
+  let resetAtMs = null
+  if (typeof w.resets_at === "string") {
+    const t = Date.parse(w.resets_at)
+    if (!Number.isNaN(t)) resetAtMs = t
+  } else if (typeof w.resets_at === "number") {
+    resetAtMs = w.resets_at < 1e12 ? w.resets_at * 1000 : w.resets_at
+  }
+  return { percent, resetAtMs }
+}
+
+/**
+ * SDK control request `usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET()`
+ * の戻り値 (SDKControlGetUsageResponse) を取り込む。EXPERIMENTAL API なので形が
+ * 変わる可能性があり、想定外の入力は無視する (呼び出し側は try/catch で包む前提)。
+ *
+ * @param {{rate_limits_available?: boolean, rate_limits?: {five_hour?: object|null, seven_day?: object|null}|null, subscription_type?: string|null}|null} usageResponse
+ * @param {number} [now]
+ */
+export function recordChatUsageSnapshot(usageResponse, now = Date.now()) {
+  if (!usageResponse || typeof usageResponse !== "object") return
+  if (usageResponse.rate_limits_available === false) return
+  const rl = usageResponse.rate_limits
+  if (!rl || typeof rl !== "object") return
+  const five = normalizeRateLimitWindow(rl.five_hour)
+  const seven = normalizeRateLimitWindow(rl.seven_day)
+  if (!five && !seven) return
+  chatUsageSnapshot = {
+    five_hour: five,
+    seven_day: seven,
+    plan: usageResponse.subscription_type || chatUsageSnapshot?.plan || null,
+    updatedAtMs: now,
+  }
+  // P5(bug) と同じ直列化パターン (recordChatRateLimit 参照): 並行 persist の tmp 破壊/
+  // 中間状態読みを防ぐため、常に前回の persist 完了を待ってから次を実行する。
+  _chatUsagePersistInFlight = _chatUsagePersistInFlight.then(
+    () => persistChatUsageSnapshot(),
+    () => persistChatUsageSnapshot(),
+  )
+}
+
+async function persistChatUsageSnapshot() {
+  const snapshot = chatUsageSnapshot
+  if (!snapshot) return
+  const p = chatUsageCachePath()
+  try {
+    await fs.mkdir(path.dirname(p), { recursive: true })
+  } catch {
+    /* ignore */
+  }
+  const tmp = `${p}.tmp.${randomUUID()}`
+  try {
+    await fs.writeFile(tmp, JSON.stringify(snapshot))
+    await fs.rename(tmp, p)
+  } catch {
+    try {
+      await fs.unlink(tmp)
+    } catch {
+      /* ignore */
+    }
+  }
+}
+
+/** 直近の chat usage snapshot 書き込みの完了を待つ。テスト用。 */
+export function whenChatUsageSnapshotPersisted() {
+  return _chatUsagePersistInFlight
+}
+
+/** プロセス内メモリを優先し、無ければディスク永続化 (hub-agent 再起動直後等) を読む。 */
+async function readChatUsageSnapshot() {
+  if (chatUsageSnapshot) return chatUsageSnapshot
+  const text = await readOrNull(chatUsageCachePath())
+  if (!text) return null
+  try {
+    const j = JSON.parse(text)
+    if (j && typeof j === "object" && typeof j.updatedAtMs === "number") return j
+  } catch {
+    /* ignore */
+  }
+  return null
+}
+
+/** テスト用: chatUsageSnapshot をクリアする。 */
+export function _resetChatUsageSnapshot() {
+  chatUsageSnapshot = null
+}
+
 async function readOfficial(now) {
   const text = await readOrNull(statuslineCache())
   if (!text) return null
@@ -284,8 +403,13 @@ async function readOfficial(now) {
   const rl = j.rate_limits ?? j.rateLimits ?? {}
   const five = rl.five_hour ?? rl.fiveHour ?? rl["5h"]
   const seven = rl.seven_day ?? rl.sevenDay ?? rl["7d"]
-  if (!five && !seven) return null
   const ctx = j.context_window?.used_percentage ?? j.contextWindow?.used_percentage ?? null
+  // 2026-07: Claude CLI 2.1.197+ の statusLine は rate_limits を出さなくなった
+  // (chatUsageSnapshot 由来の SDK control request がその代替本命ソースになる。
+  // 下の getUsage() 参照)。以前は rate_limits 欠落時に無関係な context_window まで
+  // 巻き込んで握りつぶしていた (ドーナツが常に jsonl 推定フォールバックへ落ちる副作用)。
+  // rate_limits と context の両方が無いときだけ official ソースとして無意味とみなす。
+  if (!five && !seven && ctx === null) return null
 
   const bucketize = (b, defaultLimit) => {
     if (!b) return { ...emptyBucket(defaultLimit), limit: defaultLimit }
@@ -310,7 +434,10 @@ async function readOfficial(now) {
   return {
     plan: j.plan || "official",
     computedAt: now,
-    source: "official",
+    // 5h/7d の実値が伴わない (rate_limits 欠落・context のみ) ときは "official" を名乗らない。
+    // badge/表示は source を「5h/7d の信頼度」の意味で使っているため、chatUsageSnapshot 等の
+    // 上位レイヤーがまだ埋めていない時点では honest に "estimate" を返す。
+    source: five || seven ? "official" : "estimate",
     context: typeof ctx === "number" ? ctx : null,
     last5h: bucketize(five, 100),
     last7d: bucketize(seven, 100),
@@ -1025,9 +1152,13 @@ export async function getUsage() {
   // チャット(SDK) の rate_limit_event が statusLine cache より新しければ、5h/7d を
   // その実値 (utilization) で上書きする。ターミナルが statusLine を更新していない
   // チャットモードでも 5h/7d がライブで動くようになる。
+  // `>=` (2026-07-03): ファイル mtime はミリ秒未満の粒度が丸められる環境があり、
+  // 同一ミリ秒 (またはそれ以下) の解像度で statusLine 書き込みと rate_limit_event が
+  // 揃うとタイになり得る。プロセス内の直近イベント (chatRateLimits) の方が
+  // ディスク read-back より鮮度の情報として確実なため、タイ時は上書きを優先する。
   if (
     chatRateLimits.updatedAtMs > 0 &&
-    (cacheMtime === null || chatRateLimits.updatedAtMs > cacheMtime)
+    (cacheMtime === null || chatRateLimits.updatedAtMs >= cacheMtime)
   ) {
     if (chatRateLimits.five_hour) {
       result.last5h = {
@@ -1048,6 +1179,35 @@ export async function getUsage() {
       result.source = "official"
     }
   }
+
+  // SDK control request (usage_EXPERIMENTAL...) 由来のスナップショット。上の
+  // chatRateLimits (rate_limit_event) より本命の情報源 (utilization 欠落問題が無い、
+  // 2026-07 時点で実測確認済み)。statusLine / rate_limit_event のどちらよりも新しければ
+  // 上書きする。5h/7d が実際に埋まったときだけ source を official に昇格させる。
+  const chatSnap = await readChatUsageSnapshot()
+  if (chatSnap && chatSnap.updatedAtMs > 0) {
+    const baseline = Math.max(cacheMtime ?? 0, chatRateLimits.updatedAtMs || 0)
+    // `>=` (上と同じ理由): ファイル mtime とプロセス内タイムスタンプがタイになり得る。
+    // chatSnap は最も直接的な情報源 (SDK control request 実値) なのでタイ時は優先する。
+    if (chatSnap.updatedAtMs >= baseline) {
+      if (chatSnap.five_hour) {
+        result.last5h = {
+          ...result.last5h,
+          percent: chatSnap.five_hour.percent,
+          resetAtMs: chatSnap.five_hour.resetAtMs ?? result.last5h?.resetAtMs ?? null,
+        }
+      }
+      if (chatSnap.seven_day) {
+        result.last7d = {
+          ...result.last7d,
+          percent: chatSnap.seven_day.percent,
+          resetAtMs: chatSnap.seven_day.resetAtMs ?? result.last7d?.resetAtMs ?? null,
+        }
+      }
+      if (chatSnap.plan) result.plan = chatSnap.plan
+      if (chatSnap.five_hour || chatSnap.seven_day) result.source = "official"
+    }
+  }
   return result
 }