@cocorograph/hub-agent 0.8.80 → 0.8.82

package/src/main.mjs

@@ -116,7 +116,7 @@ import {
   validateInitialPrompt,
 } from "./tmux.mjs"
 import { expandTilde, prepareChatWorkspace, isCwdUnavailableError } from "./chat-workspace.mjs"
-import { buildChatSessionsSnapshot } from "./chat-sessions-snapshot.mjs"
+import { buildChatSessionsSnapshot, refreshChatSessionsSignals } from "./chat-sessions-snapshot.mjs"
 import { chatTargetsCache } from "./chat-targets.mjs"
 import { ensureChatSession } from "./chat-session-starter.mjs"
 import { beginRemoval } from "./chat-removal-guard.mjs"
@@ -125,7 +125,6 @@ import { describeLiveSessionsUnion, isSessionWarm } from "./live-sessions.mjs"
 import { applyPointerContexts, resolvePointerContexts } from "./pointer-context.mjs"
 import {
   boundSessionId,
-  codexContextPercentFromTokenUsage,
   codexUsageFromAccountRateLimits,
   codexLiveContextForProducer,
   codexSessionUsages,
@@ -136,7 +135,6 @@ import {
   getSessionUsages,
   getUsage,
   isFreshUnboundBind,
-  jsonlContextForCwd,
   recordChatRateLimit,
   recordChatUsageSnapshot,
   readAccountUsageSnapshot,
@@ -145,12 +143,14 @@ import {
   turnActiveForCwd,
 } from "./usage.mjs"
 import {
-  clearChatSignal,
-  getChatSignal,
   getPromptAcceptedAt,
-  recordChatActivity,
-  recordChatStreamTick,
   recordPromptAccepted,
+  readRowChatState,
+  conversationContext,
+  loadResumeChatContext,
+  representativeRows,
+  getRepresentativeConversation,
+  hasRepresentativeRow,
 } from "./chat-signals.mjs"
 import { cliKindForSessionName, sessionNameFor } from "./session-names.mjs"
 import {
@@ -1071,7 +1071,7 @@ export async function startDaemon({ version, claudeSdk } = {}) {
   // そのまま browser に転送する。SDK 未インストール時は claudeBridge=null で全 attach が
   // claude.error を返す経路に分岐 (dispatch 側で判定)。
   if (claudeBridge) {
-    claudeBridge.on("event", ({ stream_id, session_id, cwd, event }) => {
+    claudeBridge.on("event", ({ stream_id, session_id, cwd, session, event }) => {
       // SDK の rate_limit_event を捕捉して usage の 5h/7d 実値に反映する
       // (チャットモードでは statusLine が更新されないため、これが live 値の唯一の源)。
       if (event?.type === "rate_limit_event" && event.rate_limit_info) {
@@ -1081,76 +1081,10 @@ export async function startDaemon({ version, claudeSdk } = {}) {
           /* ignore */
         }
       }
-      // Hub ホスト型 Cockpit 用: SDK event から per-session の状態をチャット信号として
-      // 記録する。startStateLoop が cwd 一致で session.state (ステータスドット/各行
-      // ドーナツ) と session.event (ソート) に橋渡しする。チャットは tmux ペインに
-      // TUI を出さず、capture-pane スクレイプも bundle hook も発火しないための補完。
-      //   - assistant (生成中) → processing + usage から context%
-      //   - session_state_changed:idle → waiting
-      // result は結果 flush であり、SDK が権威的ターン終了と定義する idle より早く届く。
-      // assistant / idle はターンの進行/完了 = permission 応答後に必ず流れるため、
-      // ここで inputPending を落として「確認待ち」ドット/通知を自己解消させる。
-      if (event?.type === "assistant") {
-        // 分母は result で学習したセッション固有の窓サイズ (無ければグローバル概算)。
-        // マシン全体で 1 個の statusLine 値を使うと、別モデルの並走で 5 倍ずれる。
-        const pct = resolveChatContextPct(cwd, "claude", event)
-        try {
-          // cliKind は chat-signals のキーの一部 (T05945)。同一 cwd で走る codex の信号と
-          // 混ざらないよう、claude 由来のイベントは必ず "claude" バケットへ書く。
-          // sessionId は同一 CLI 内でのセッション乗り換え検知用 identity (S1)。
-          recordChatActivity(cwd, "claude", {
-            status: "processing",
-            contextPct: pct,
-            inputPending: false,
-            sessionId: session_id || null,
-          })
-        } catch {
-          /* ignore */
-        }
-      } else if (event?.type === "result") {
-        // SDK の権威的な窓サイズ (result.modelUsage[model].contextWindow) をここで学習する。
-        resolveChatContextPct(cwd, "claude", event)
-      } else if (
-        event?.type === "system" &&
-        event?.subtype === "session_state_changed" &&
-        event?.state === "idle"
-      ) {
-        try {
-          recordChatActivity(cwd, "claude", {
-            status: "waiting",
-            inputPending: false,
-            sessionId: session_id || null,
-          })
-        } catch {
-          /* ignore */
-        }
-      } else if (event?.type === "stream_event") {
-        // RC4 (症状④): 拡張思考 (thinking_delta) や長時間ツール中の partial delta では
-        // assistant / result が流れず statusAt / updatedAtMs が前進しないため、>90s の無音で
-        // getChatSignal が CHAT_SIGNAL_STALE_MS により null を返し、capture-pane が idle な
-        // 純 SDK チャットで三点リーダーが消える。stream_event 受信を throttle 付き processing
-        // tick として記録し statusAt を前進させる (本文は読まずタイムスタンプ前進のみ)。
-        try {
-          recordChatStreamTick(cwd, "claude")
-        } catch {
-          /* ignore */
-        }
-      }
+      resolveChatContextPct(session, event)
       client.send({ type: "claude.event", stream_id, session_id, event })
     })
     claudeBridge.on("permission", ({ stream_id, session_id, cwd, request_id, tool_name, input }) => {
-      // 確認待ち信号 (2026-06-02): (cwd, cliKind) キーで inputPending を立て、サイドバーの
-      // 「確認待ち」ドット & 通知の発火源にする。次の assistant/result で落ちる。
-      // これにより「裏で動いているセッションがどれか分からない」発見性の問題を解消する。
-      // T05945: 旧実装は cliKind を伝播しておらず、codex の承認カードでも claude 行の
-      // 確認待ちドットが点く (逆も然り) 交差汚染があった。CLI を明示して分離する。
-      if (cwd) {
-        try {
-          recordChatActivity(cwd, "claude", { inputPending: true })
-        } catch {
-          /* ignore */
-        }
-      }
       // 多端末共有: session_id を載せて backend が session group へ broadcast できるように
       // する (全端末に許可ダイアログ → 先着 1 件採用)。
       client.send({
@@ -1182,34 +1116,14 @@ export async function startDaemon({ version, claudeSdk } = {}) {
             /* ignore */
           }
         }
-        if (cwd && request_ids?.length) {
-          // 確認待ちドットも落とす (次の assistant/result を待たずに自己解消させる)。
-          try {
-            recordChatActivity(cwd, "claude", { inputPending: false })
-          } catch {
-            /* ignore */
-          }
-        }
       },
     )
-    claudeBridge.on("exit", ({ stream_id, code, reason, session_id }) => {
+    claudeBridge.on("exit", ({ stream_id, code, reason, session_id, cwd }) => {
       client.send({ type: "claude.exit", stream_id, code, reason, session_id })
     })
     claudeBridge.on("sessionoptions", (message) => {
       client.send(buildClaudeSessionOptionsPayload(message))
     })
-    claudeBridge.on("turnsettled", ({ cwd }) => {
-      // RC-4: result を届けずにターンが終わった (abort/異常終了)。チャット信号の
-      // status=processing を waiting に落として三点リーダー/ステータスドットの固着を防ぐ
-      // (正常完了は上の result ハンドラが既に waiting にしている)。
-      if (cwd) {
-        try {
-          recordChatActivity(cwd, "claude", { status: "waiting", inputPending: false })
-        } catch {
-          /* ignore */
-        }
-      }
-    })
     claudeBridge.on("error", ({ stream_id, session_id, error }) => {
       client.send({ type: "claude.error", stream_id, session_id, error })
     })
@@ -1218,97 +1132,15 @@ export async function startDaemon({ version, claudeSdk } = {}) {
   // codex 版 (Slice 3): codex-stream-bridge.mjs の生 notification/permission/exit/error を
   // browser にそのまま転送する。claudeBridge と同じ「素通し」方針 (codex-stream-bridge.mjs
   // 冒頭コメント参照)。claude 版にある rate_limit/MCP control query 相当の処理は無い
-  // (codex 側にまだ存在しない/後続スライス)。ステータスドット用のチャット信号は
-  // turn/started・turn/completed のみ最小限で反映する (claude の assistant/result 相当)。
+  // (codex 側にまだ存在しない/後続スライス)。live usage だけを producer 単位で記録する。
   if (codexBridge) {
-    // T06407 増分2 (codex-review round1 major#3): この producer(session.seq) が cwd の
-    // **権威 producer** (liveSessionForCwd = 会話ターン最新) かを判定する。チャット信号
-    // (recordChatActivity) の context/sessionId は権威 producer の分だけ書く。非権威 producer
-    // の context/sessionId をチャット信号へ書くと、権威 thread の live 未取得の窓で overlay 経由
-    // に混入し、usage.response (権威 producer ベース) と分岐してドーナツが前後する。
-    const isCodexAuthority = (cwd, producerSeq) =>
-      typeof producerSeq === "number" &&
-      codexBridge?.liveSessionForCwd?.(cwd)?.seq === producerSeq
     codexBridge.on("event", ({ stream_id, producer_seq, thread_id, cwd, notification }) => {
-      if (notification.method === "turn/started") {
-        // S1 (2026-07): contextPct を渡していなかったため、Codex 選択中は状態ドット
-        // (processing/waiting) こそ更新されるがコンテキスト% は claude 由来の古い値の
-        // ままだった (症状③の一因)。codexUsageForThread は rollout ファイルの I/O を
-        // 伴うため fire-and-forget (await せず、取得できた時点で反映)。
-        ;(async () => {
-          let contextPct = null
-          try {
-            const usage = await codexUsageForThread(thread_id, { producerSeq: producer_seq })
-            contextPct = typeof usage?.context === "number" ? usage.context : null
-          } catch {
-            /* ignore */
-          }
-          try {
-            recordChatActivity(
-              cwd,
-              "codex",
-              buildCodexChatPatch("processing", contextPct, thread_id, isCodexAuthority(cwd, producer_seq)),
-            )
-          } catch {
-            /* ignore */
-          }
-        })()
-      } else if (notification.method === "turn/completed") {
-        ;(async () => {
-          let contextPct = null
-          try {
-            const usage = await codexUsageForThread(thread_id, { producerSeq: producer_seq })
-            contextPct = typeof usage?.context === "number" ? usage.context : null
-          } catch {
-            /* ignore */
-          }
-          try {
-            recordChatActivity(
-              cwd,
-              "codex",
-              buildCodexChatPatch("waiting", contextPct, thread_id, isCodexAuthority(cwd, producer_seq)),
-            )
-          } catch {
-            /* ignore */
-          }
-        })()
-      } else if (notification.method === "thread/tokenUsage/updated") {
-        // T06407 増分2 (症状⑥ ドーナツ前後動の根治): App Server の live tokenUsage を
-        // context% の正本にする。**producer(session.seq) 単位**でストアへ記録し (usage.response /
-        // state loop が cwd の権威 producer の seq で参照する)、同時にチャット信号 (overlay 経路) の
-        // context_pct も同じ live 値で更新する。status は上書きしない (このイベントはターン進行中に
-        // 届くため keep-prev。processing/waiting は turn/started・turn/completed が管理する)。
-        const tokenUsage = notification.params?.tokenUsage
-        if (typeof producer_seq === "number" && tokenUsage) {
-          try {
-            recordCodexLiveTokenUsage(producer_seq, tokenUsage)
-          } catch {
-            /* ignore */
-          }
-          // major#3: チャット信号の context/sessionId は権威 producer のときだけ書く。
-          if (isCodexAuthority(cwd, producer_seq)) {
-            const contextPct = codexContextPercentFromTokenUsage(tokenUsage)
-            if (typeof contextPct === "number" && cwd) {
-              try {
-                recordChatActivity(cwd, "codex", { contextPct, sessionId: thread_id })
-              } catch {
-                /* ignore */
-              }
-            }
-          }
-        }
+      if (notification.method === "thread/tokenUsage/updated") {
+        recordCodexLiveTokenUsage(producer_seq, notification.params?.tokenUsage)
       }
       client.send({ type: "codex.event", stream_id, thread_id, event: notification })
     })
     codexBridge.on("permission", ({ stream_id, thread_id, cwd, request_id, method, params }) => {
-      if (cwd) {
-        try {
-          // T05945: codex の承認待ちは codex 行にだけ立てる (claude 行へ漏らさない)。
-          recordChatActivity(cwd, "codex", { inputPending: true })
-        } catch {
-          /* ignore */
-        }
-      }
       client.send({
         type: "codex.permission.request",
         stream_id,
@@ -1318,7 +1150,7 @@ export async function startDaemon({ version, claudeSdk } = {}) {
         params,
       })
     })
-    codexBridge.on("exit", ({ stream_id, producer_seq, thread_id, code, reason }) => {
+    codexBridge.on("exit", ({ stream_id, producer_seq, thread_id, code, reason, cwd }) => {
       // T06407 増分2: この producer(session.seq) の live tokenUsage スロットを破棄する。
       // seq は immutable なので、reattach で stream_id が付け替わっても alias slot / Map リークは
       // 生じない (stream_id キー時代の major#1 を解消)。
@@ -1554,31 +1386,6 @@ export async function refreshContextWindow() {
   }
 }
 
-/**
- * セッション単位で学習した context 窓サイズ (トークン)。
- * キーは `${cliKind}\u0000${cwd}` (chat-signals と同じ粒度)。
- *
- * 【なぜセッション単位が要るか】(2026-07-10 監査)
- * 旧実装は分子 (SDK assistant.usage = セッション単位) に対し、分母を
- * resolvedContextWindow = statusLine cache (`~/.hub/usage/latest.json`) 由来の
- * **マシン全体で 1 個のグローバル値**にしていた。同ファイルは「最後に statusLine を
- * 書いた任意のセッション」の値なので、1M 窓の Opus と 200k 窓の Sonnet を同時に
- * 走らせると、分母が取り違わってドーナツが 5 倍ずれる (分子と分母のスケール不一致)。
- *
- * SDK は `result.modelUsage[model].contextWindow` として **そのターンで実際に使われた
- * モデルの窓サイズ**を毎ターン渡してくる。これが唯一の権威なので、result のたびに
- * ここへ学習し、以降の assistant イベントの分母に使う。
- */
-const contextWindowByChatKey = new Map()
-
-/** 直近の assistant メッセージのモデル名。result の modelUsage から主対話モデルを選ぶ手掛かり。 */
-const lastAssistantModelByChatKey = new Map()
-
-/** chat-signals と同じ (cwd, cliKind) 粒度のキーを作る。 */
-export function chatKey(cwd, cliKind) {
-  return `${cliKind || "claude"}\u0000${cwd || ""}`
-}
-
 /**
  * SDK `result` の `modelUsage` から、そのセッションの context 窓サイズを選ぶ。
  *
@@ -1638,38 +1445,28 @@ export function contextPctFromUsage(u, contextWindow) {
   return Math.min(100, Math.round((tokens / win) * 1000) / 10)
 }
 
-/**
- * SDK チャットの assistant / result イベントから context% を解決し、
- * 併せて `result.modelUsage` の窓サイズを (cwd, cliKind) 単位で学習する。
- *
- * ハンドラ本体から切り出して単体テスト可能にしている (学習 → 次ターンで反映、
- * という状態遷移こそがこの機能の本体であり、純関数だけでは配線を検証できないため)。
- *
- * @returns {number|null} assistant のとき context% / それ以外は null
- */
-export function resolveChatContextPct(cwd, cliKind, event) {
-  const key = chatKey(cwd, cliKind)
+/** usage・主対話モデル・窓サイズは、イベントを生成した実体に保持する。 */
+export function resolveChatContextPct(session, event) {
+  if (!session || session._closed) return null
+  const context = conversationContext(session, "claude")
   if (event?.type === "assistant") {
-    const model = event.message?.model || null
-    if (model) lastAssistantModelByChatKey.set(key, model)
-    return event.message?.usage
-      ? contextPctFromUsage(event.message.usage, contextWindowByChatKey.get(key))
-      : null
-  }
-  if (event?.type === "result") {
-    // モデル切替やセッション回転が起きても次の result で必ず上書きされる (自己修復)。
-    const win = pickContextWindow(event.modelUsage, lastAssistantModelByChatKey.get(key))
-    if (win) contextWindowByChatKey.set(key, win)
+    if (event.message?.model) context.model = event.message.model
+    if (event.message?.usage) {
+      context.usage = event.message.usage
+      context.live = true
+      context.percent = contextPctFromUsage(context.usage, context.window)
+      return context.percent
+    }
+  } else if (event?.type === "result") {
+    const win = pickContextWindow(event.modelUsage, context.model)
+    if (win) {
+      context.window = win
+      if (context.usage) context.percent = contextPctFromUsage(context.usage, win)
+    }
   }
   return null
 }
 
-/** テスト用: 学習済みの窓サイズ / モデル名をリセットする。 */
-export function _resetContextWindowLearning() {
-  contextWindowByChatKey.clear()
-  lastAssistantModelByChatKey.clear()
-}
-
 /**
  * session_event の「サイドバー並び順に効くか (sort_affecting)」判定用の per-session 状態。
  * 「その session-run で実ユーザーターン (prompt_submit) を見たか」を持つ。
@@ -1979,7 +1776,7 @@ async function readAllSessionEvents() {
 // 複数 Cockpit タブは各自 8 秒 poll を持つため、位相がずれると agent は同じ
 // tmux/worktree/jsonl スナップショットを数秒おきに再構築してしまう。5 秒だけ成功値を
 // 共有し、同時要求は single-flight に畳む。create/kill/worktree 変更時は明示 clear する。
-const tmuxSessionsSnapshotCache = new AsyncTtlCache({ ttlMs: 5_000 })
+export const tmuxSessionsSnapshotCache = new AsyncTtlCache({ ttlMs: 5_000 })
 
 /**
  * `/tmp/cockpit_session_events/<tmux_session>.json` を fs.watch して
@@ -2260,7 +2057,7 @@ export function enrichTmuxSessionsForListResponse(sessions, lastEventByName, get
 }
 
 /**
- * state loop 内で「チャット信号 (getChatSignal) でペイン status/context_pct を上書きするか」
+ * state loop 内で「チャット信号 (readRowChatState) でペイン status/context_pct を上書きするか」
  * を決める純関数 (startStateLoop から抽出、単体テスト用)。
  *
  * バグ修正 (2026-07): 従来コードは書き換え「後」の status で processing ガードを判定して
@@ -2273,7 +2070,7 @@ export function enrichTmuxSessionsForListResponse(sessions, lastEventByName, get
  *
  * @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() の戻り値
+ * @param {{status?:string|null, context_pct?:number|null}|null} chat readRowChatState() の戻り値
  * @returns {{status:string, contextPct:number|null|undefined}}
  */
 export function applyChatOverlay(paneStatus, paneContextPct, chat) {
@@ -2289,26 +2086,35 @@ export function applyChatOverlay(paneStatus, paneContextPct, chat) {
   return { status, contextPct }
 }
 
+function codexRowSession(bridge, cwd) {
+  // 代表行（終了印を含む）は代表実体だけを見る。背景会話へ落ちると終了後も履歴 I/O が走る。
+  if (hasRepresentativeRow(cwd, "codex")) {
+    const rep = getRepresentativeConversation(cwd, "codex")
+    return rep && !rep.dead ? rep : null
+  }
+  return bridge?.liveSessionForCwd?.(cwd) ?? null
+}
+
 /**
- * T06407 増分2 (codex-review round1 major#3): codex チャット信号 (recordChatActivity) の
- * patch を組み立てる。status (processing/waiting) は cwd レベルの「ターン進行中か」信号なので
- * 常に書き、**context_pct / sessionId は権威 producer のときだけ**含める。非権威 producer の
- * context/sessionId をチャット信号へ書くと、権威 thread の live 未取得の窓で overlay 経由に
- * 混入し、usage.response (権威 producer ベース) と分岐してドーナツが前後する。
- *
- * @param {'processing'|'waiting'} status
- * @param {number|null} contextPct
- * @param {string|null} threadId
- * @param {boolean} isAuthority この producer が cwd の権威 (liveSessionForCwd) か
- * @returns {{status:string, inputPending:boolean, contextPct?:number, sessionId?:string|null}}
+ * codex 行の使用率を、行の代表会話の live 値で上書きするかを決める。
+ * @returns {number|null}
  */
-export function buildCodexChatPatch(status, contextPct, threadId, isAuthority) {
-  const patch = { status, inputPending: false }
-  if (isAuthority) {
-    patch.sessionId = threadId || null
-    if (typeof contextPct === "number") patch.contextPct = contextPct
-  }
-  return patch
+export function resolveCodexRowContextPct({ contextPct, paneIsProcessing, rowSession, liveContextPct }) {
+  if (typeof rowSession?.seq !== "number" || paneIsProcessing) return contextPct
+  if (typeof liveContextPct === "number") return liveContextPct
+  if (rowSession.isFresh === true) return 0
+  return contextPct
+}
+
+/** 代表行は状態・使用率・ID・承認待ちを一度に上書きする。 */
+export function applyRowChatState(payload, cwd, kind) {
+  const chat = readRowChatState(cwd, kind)
+  if (!chat) return payload
+  return { ...payload, status: chat.status, context_pct: chat.context_pct,
+    context_session_id: chat.sessionId, chat_session_id: chat.sessionId,
+    turn_active: chat.turn_active, inputPending: chat.inputPending, input_pending: chat.inputPending,
+    ...(Object.hasOwn(payload, "pointer_context_pct") ? { pointer_context_pct: chat.context_pct } : {}),
+    stable: chat.status !== "processing", proc_busy: false, child_busy: false, stalled: false }
 }
 
 /** 次ターンに使う desired options。現在ターンの setter 成功を観測した値ではない。 */
@@ -2450,7 +2256,7 @@ export function filterCodexSessionsByAuthority(codexSessions, producerByCwd, seq
  * `listSessionStatesFn` は単体テスト用の DI ポイント (既定は実 `listSessionStates`、tmux を
  * 起動する)。実運用では省略してよい。
  *
- * @param {{ client: object, plugins: object, logger?: object, cwd: string, cliKind: 'claude'|'codex', sessionId: string|null, contextPct?: number|null, listSessionStatesFn?: Function }} args
+ * @param {{ client: object, plugins: object, logger?: object, cwd: string, cliKind: 'claude'|'codex', sessionId: string|null, streamId?: string|null, contextPct?: number|null, listSessionStatesFn?: Function }} args
  */
 export async function pushImmediateChatState({
   client,
@@ -2459,6 +2265,7 @@ export async function pushImmediateChatState({
   cwd,
   cliKind,
   sessionId,
+  streamId,
   contextPct = 0,
   listSessionStatesFn = listSessionStates,
 }) {
@@ -2468,23 +2275,26 @@ export async function pushImmediateChatState({
     for (const s of states) {
       if (s.cwd !== cwd) continue
       if (cliKindForSessionName(s.session_name) !== cliKind) continue
+      const status = "waiting"
+      // 代表行は直後の applyRowChatState が代表会話の実 ID で上書きする。
+      const contextSessionId = sessionId ?? null
       tmuxSessionsSnapshotCache.clear()
-      client.send({
+      client.send(applyRowChatState({
         type: "session.state",
         session_name: s.session_name,
-        status: "waiting",
-        context_pct: typeof contextPct === "number" ? contextPct : 0,
-        stable: true,
+        status,
+        context_pct: typeof contextPct === "number" ? contextPct : null,
+        stable: status !== "processing",
         proc_busy: false,
         child_busy: false,
         stalled: false,
-        turn_active: false,
+        turn_active: status == null ? null : status === "processing",
         cli_kind: cliKind,
         // context_pct がどの会話の値かを明示する。frontend は ID が変わったときだけ
         // 0% を採用し、同一会話の一時的な 0/null は直近の確定値を保持する。
-        context_session_id: sessionId ?? null,
-        chat_session_id: sessionId ?? null,
-      })
+        context_session_id: contextSessionId,
+        chat_session_id: contextSessionId,
+      }, cwd, cliKind))
     }
   } catch (err) {
     logger?.warn?.({ err: err?.message, cwd }, "pushImmediateChatState failed")
@@ -2622,7 +2432,7 @@ export function decideTurnActiveSource({
   return "none"
 }
 
-export function startStateLoop({ client, plugins, logger, intervalMs, claudeBridge, codexBridge, readinessTracker, boundSessions }) {
+export function startStateLoop({ client, plugins, logger, intervalMs, claudeBridge, codexBridge, readinessTracker, boundSessions, listSessionStatesFn = listSessionStates, writeSessionEventFileFn = writeSessionEventFile }) {
   const lastByName = new Map() // session_name → {status, context_pct}
   const lastTurnAtByName = new Map() // session_name → 最後に event ファイル化した turnAt
   // session_name → 最後に書いた chat 由来 event 種別。エッジ駆動 (種別遷移時のみ書く) にして
@@ -2695,7 +2505,7 @@ export function startStateLoop({ client, plugins, logger, intervalMs, claudeBrid
       // 実コンテキスト窓サイズ (1M ベータ等) を反映。contextPctFromUsage の分母を
       // 5s ごとに最新化し、ドーナツが 200k 固定で振り切れるのを防ぐ。
       await refreshContextWindow()
-      const states = await listSessionStates({ plugins, logger })
+      const states = await listSessionStatesFn({ plugins, logger })
       for (const s of states) {
         // T05945: この行がどの CLI のセッションかは **セッション名から構造的に決まる**
         // (`<dir>` = claude / `<dir>__codex` = codex)。chat 信号の読み出し・turn_active の
@@ -2704,50 +2514,18 @@ export function startStateLoop({ client, plugins, logger, intervalMs, claudeBrid
         // チャットモード補完: 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 ガードのまま維持される。
+        // 代表が設定済みなら、その会話の値だけを使い、欠けた値は null とする。
+        // 代表未設定の行は従来の applyChatOverlay / pane processing ガードを使う。
         // (cwd, cliKind) キーで自 CLI のチャット信号だけを読む。同一 cwd の別 CLI 行が
         // 立てた status/context_pct を拾わない (交差汚染の遮断)。
-        const chat = s.cwd ? getChatSignal(s.cwd, sessionCliKind) : null
+        const representative = hasRepresentativeRow(s.cwd, sessionCliKind)
+        const chat = s.cwd ? readRowChatState(s.cwd, sessionCliKind) : null
         const overlay = applyChatOverlay(s.status, s.context_pct, chat)
-        let status = overlay.status
-        let contextPct = overlay.contextPct
-        if (chat) {
-          // チャットのターン境界を sort / 状態用 session-event に橋渡しする。
-          // tmux ペインが動かず bundle hook が発火しないため、ここで代替発火する。
-          //
-          // ⚠️ **エッジ駆動** (種別が変わったときだけ書く)。旧実装は turnAt が前進するたびに
-          // 書いており、turnAt は assistant イベント毎に前進するため **生成中ずっと
-          // prompt_submit を書き続けていた**。並行生成中のセッション同士が assistant の
-          // 到着順で入れ替わり、サイドバーが揺れる原因になる (2026-07-29)。
-          // 種別遷移でのみ書けば、prompt_submit は生成開始の 1 回だけになる。
-          //
-          // 確認待ち (inputPending) は専用 event "input_required"、生成中は "prompt_submit"、
-          // それ以外は "stop"。並び順に効くのは computeSortAffecting により prompt_submit だけ。
-          const prevTurnAt = lastTurnAtByName.get(s.session_name) || 0
-          const prevEv = lastChatEventByName.get(s.session_name)
-          const eventForTick = chatSessionEventForTick({
-            chat,
-            prevEv,
-            prevTurnAt,
-            directAt: s.cwd ? getPromptAcceptedAt(s.cwd, sessionCliKind) : undefined,
-          })
-          if (eventForTick) {
-            const { ev, at } = eventForTick
-            lastTurnAtByName.set(s.session_name, chat.turnAt)
-            lastChatEventByName.set(s.session_name, ev)
-            writeSessionEventFile(s.session_name, ev, at).catch(() => {})
-          }
-        }
+        let status = representative ? chat?.status ?? null : overlay.status
+        let contextPct = representative ? chat?.context_pct ?? null : overlay.contextPct
         // 内容安定で「確実に停止」と判定できたか (frontend が 2 サンプル消灯確認を省いて
         // 即消灯するためのフラグ)。chat 信号で processing へ上書きされた場合は false。
-        const stable = status !== "processing" && s.stable === true
+        let stable = status !== "processing" && s.stable === true
         // プロセス内省由来の busy レベル (Stop フック/ツール実行中=true)。frontend は
         // これでペイン由来の早期消灯を抑止し、tool/Stop フック中もスピナーを保つ。
         // 高速 readiness loop が維持する値をそのまま相乗せする (この loop では計算しない)。
@@ -2786,65 +2564,30 @@ export function startStateLoop({ client, plugins, logger, intervalMs, claudeBrid
           now: nowMs,
         })
 
-        // turn_active: ターンが現在進行中か (true=生成/ツール実行中 / false=待機中 / null=不明)。
-        // CockpitStatusDot の青/赤の権威ソース。サイドバーのドットと送信/停止ボタンを同じ真実で
-        // 同期させ、Esc 中断後の青固着 (PROMPT_STALE_SHORT_MS=60s) を解消する。
-        //  - チャットモード: SDK の rate_limit_event/assistant が最も新鮮なので chat.status を採用
-        //  - TUI モード: bound session の jsonl 末尾 assistant.stop_reason から判定 (turnActiveForCwd)
-        //    bound session_id を渡すことで、同一 cwd dir 内の別セッション / サブエージェント /
-        //    headless `claude -p` / `/clear` ローテの jsonl を「最新」と取り違えて turn_active を
-        //    誤る (cross-activity contamination = メタ欠陥#1) のを防ぐ。
-        //    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 と同じ方式で根治する。
-        //  - Codex (T05699 残タスク #1, 2026-07-04): この cwd にライブな codexBridge セッション
-        //    (chat モード) があれば、chat 信号の 90s TTL に依存しない rollout ベースの判定
-        //    (codexTurnActiveForThread, task_started/task_complete イベント対) を使う。長時間
-        //    ターン中に chat 信号が stale 化してドットが消える欠落を根治する。Claude 版のような
-        //    paneAliveProbe は渡さない (chat モードのペインは素のシェルのまま = 実処理は別
-        //    プロセスのため、pane 生存判定を適用すると誤って dead 扱いになる)。cwd がライブな
-        //    codex セッションと一致しなければ従来通り Claude jsonl (turnActiveForCwd) にフォール
-        //    バックする (TUI/bare codex pane は現状 bound thread 解決が無いため、これまで通り
-        //    null=不明のまま、退行はしない)。
-        //    分岐の優先順位は decideTurnActiveSource (純関数、単体テスト済み) が権威。
+        // 代表行は下の同期読み出しが turn_active も確定する。
+        // 代表未設定の行だけ、従来の履歴・pane probe を使う。
         let turnActive = null
         // codex 行のときだけ rollout ベース判定の材料を引く (claude 行では常に null)。
-        // cwd の**権威 producer session** を 1 度だけ引き、threadId(turn_active 判定用) と
-        // seq(context% の live source 参照キー) の両方を同一 session から取る。これで
-        // usage.response の per-cwd 集計 (同じ liveSessionForCwd) と同じ producer を選び収束する
-        // (axis2)。liveSessionForCwd は会話ターン最新 (lastTurnAtMs) の一意規則。
+        // 行の**代表会話の session** を 1 度だけ引き、threadId(turn_active 判定用・会話 ID) と
+        // seq(context% の live source 参照キー) の両方を同一 session から取る。⚠️ 別々に引くと
+        // 「背景会話の使用率に代表会話の ID が付く」不整合になる。usage.response と同じ
+        // codexRowSession を使い、代表が live でなければ null（別会話の値で埋めない）。
         const codexAuthSession =
           s.cwd && sessionCliKind === "codex"
-            ? codexBridge?.liveSessionForCwd?.(s.cwd) || null
+            ? codexRowSession(codexBridge, s.cwd)
             : null
         const codexThreadId = codexAuthSession?.threadId || null
         // T06407 増分2 (axis3): codex 行の context%(ドーナツ) は TTL 非依存の live store
         // (thread/tokenUsage/updated 由来) を権威 producer(seq) で引き、chat overlay より優先して
-        // 恒久収束させる。ただし **applyChatOverlay と同じ paneIsProcessing ガードを尊重する**:
-        // 本物の TUI が生成中 (capture-pane が processing = "esc to interrupt" 実在) のときは、
-        // その pane 由来の実 context_pct を stale な live 値で上書きしない (warm chat と Codex TUI
-        // 併存時の TUI ドーナツ破壊を防ぐ。chat overlay は既に上書きを見送っている)。素のシェル
-        // (chat モードのペイン) は processing を返せないため override は従来通り効く。
-        const paneIsProcessing = s.status === "processing"
-        if (
-          sessionCliKind === "codex" &&
-          typeof codexAuthSession?.seq === "number" &&
-          !paneIsProcessing
-        ) {
-          const liveCtx = codexLiveContextForProducer(codexAuthSession.seq)
-          if (typeof liveCtx === "number") {
-            contextPct = liveCtx
-          } else if (codexAuthSession.isFresh === true) {
-            // 新規 Codex thread は thread/start の時点で ID だけ確定し、最初の
-            // usage.response までは使用量がない。この間に tmux の旧 pane 値を
-            // 同じ新 thread ID で送ると、即時 push した 0% を打ち消してしまう。
-            contextPct = 0
-          }
+        // 恒久収束させる。代表未設定の行だけ、従来の pane processing ガードを使う。
+        const paneIsProcessing = !representative && s.status === "processing"
+        if (sessionCliKind === "codex") {
+          const liveCtx = typeof codexAuthSession?.seq === "number" && !paneIsProcessing
+            ? codexLiveContextForProducer(codexAuthSession.seq)
+            : null
+          contextPct = resolveCodexRowContextPct({
+            contextPct, paneIsProcessing, rowSession: codexAuthSession, liveContextPct: liveCtx,
+          })
         }
         // fresh bind は実 session_id がまだ確定していない。tmux.list の statusLine / cwd 最新
         // JSONL は直前会話の値を返し得るため、この間は必ず 0% を正本にする。これをしないと
@@ -2852,11 +2595,11 @@ export function startStateLoop({ client, plugins, logger, intervalMs, claudeBrid
         // ドーナツを復活させる。
         const freshUnbound =
           sessionCliKind === "claude" && isFreshUnboundBind(boundSessions?.get(s.session_name))
-        if (freshUnbound) contextPct = 0
-        const turnActiveSource = decideTurnActiveSource({
+        if (freshUnbound && !representative) contextPct = 0
+        const turnActiveSource = representative ? "representative" : decideTurnActiveSource({
           chatStatus: chat?.status,
           cwd: s.cwd,
-          isFreshUnbound: freshUnbound,
+          isFreshUnbound: freshUnbound && !representative,
           codexThreadId,
           sessionCliKind,
         })
@@ -2882,10 +2625,10 @@ export function startStateLoop({ client, plugins, logger, intervalMs, claudeBrid
             // 離れて detach され this.sessions から外れた warm セッションでも、稼働中ターンの turn_active
             // が維持され、非選択行のドットが赤へ誤落ちしない。加えて bare-shell pane を dead 判定して
             // 赤へ倒す paneAliveProbe 経路 (チャットは実体が SDK 子プロセスで pane は素のシェル) も回避する。
-            // chatTurnActiveForCwd が null (= この cwd にライブチャットセッション無し = 純 TUI / bare pane)
-            // のときだけ、従来の jsonl 末尾 + pane probe 経路にフォールバックする (TUI 挙動は不変)。
+            // 代表があれば、その会話の busy だけを読む。不在なら null のままにする。
+            // 代表未設定の行だけ、従来の cwd 最新 / jsonl / pane probe を使う。
             const chatActive = claudeBridge?.chatTurnActiveForCwd?.(s.cwd)
-            if (chatActive === true || chatActive === false) {
+            if (representative || chatActive === true || chatActive === false) {
               turnActive = chatActive
             } else {
               turnActive = await turnActiveForCwd(
@@ -2917,79 +2660,46 @@ export function startStateLoop({ client, plugins, logger, intervalMs, claudeBrid
             ? boundSessions?.get(s.session_name) ?? `unbound:${s.session_name}`
             : codexThreadId)
 
-        const prev = lastByName.get(s.session_name)
-        if (
-          !prev ||
-          prev.status !== status ||
-          prev.context_pct !== contextPct ||
-          prev.stable !== stable ||
-          prev.proc_busy !== procBusy ||
-          prev.child_busy !== childBusy ||
-          prev.stalled !== stalled ||
-          prev.turn_active !== turnActive ||
-          prev.cli_kind !== chatCliKind ||
-          prev.context_session_id !== contextSessionId
-        ) {
-          lastByName.set(s.session_name, {
-            status,
-            context_pct: contextPct,
-            stable,
-            proc_busy: procBusy,
-            child_busy: childBusy,
-            stalled,
-            turn_active: turnActive,
-            cli_kind: chatCliKind,
-            context_session_id: contextSessionId,
-            // 旧クライアント互換。新規 consumer は context_session_id を使う。
-            chat_session_id: contextSessionId,
+        // 履歴・pane の非同期処理が終わった後に、現在の実体を同期で読む。
+        const payload = applyRowChatState({
+          status, context_pct: contextPct, stable, proc_busy: procBusy, child_busy: childBusy,
+          stalled, turn_active: turnActive, cli_kind: chatCliKind,
+          context_session_id: contextSessionId, chat_session_id: contextSessionId,
+        }, s.cwd, sessionCliKind)
+        const currentChat = readRowChatState(s.cwd, sessionCliKind)
+        if (currentChat) {
+          // チャットのターン境界を sort / 状態用 session-event に橋渡しする。
+          // tmux ペインが動かず bundle hook が発火しないため、ここで代替発火する。
+          //
+          // ⚠️ **エッジ駆動** (種別が変わったときだけ書く)。旧実装は turnAt が前進するたびに
+          // 書いており、turnAt は assistant イベント毎に前進するため **生成中ずっと
+          // prompt_submit を書き続けていた**。並行生成中のセッション同士が assistant の
+          // 到着順で入れ替わり、サイドバーが揺れる原因になる (2026-07-29)。
+          // 種別遷移でのみ書けば、prompt_submit は生成開始の 1 回だけになる。
+          //
+          // 確認待ち (inputPending) は専用 event "input_required"、生成中は "prompt_submit"、
+          // それ以外は "stop"。並び順に効くのは computeSortAffecting により prompt_submit だけ。
+          const prevTurnAt = lastTurnAtByName.get(s.session_name) || 0
+          const prevEv = lastChatEventByName.get(s.session_name)
+          const eventForTick = chatSessionEventForTick({
+            chat: currentChat,
+            prevEv,
+            prevTurnAt,
+            directAt: s.cwd ? getPromptAcceptedAt(s.cwd, sessionCliKind) : undefined,
           })
-          // 計装 (2026-06-19, 既定 OFF=2026-06-20): 状態変化時に値を記録する。常時 info はログ肥大の
-          // 主因のため HUB_AGENT_STATE_TRACE=1 のときだけ出す。childBusy/outputActive を分けて出し、
-          // proc 内省と出力フローのどちらが busy を立てたか切り分け可能にする(障害解析用)。
-          if (STATE_TRACE) {
-          logger?.info(
-            {
-              session_name: s.session_name,
-              status,
-              proc_busy: procBusy,
-              child_busy: childBusy,
-              output_active: outputActive,
-              stalled,
-              armed,
-              stable,
-              context_pct: contextPct,
-              turn_active: turnActive,
-              cli_kind: chatCliKind,
-              context_session_id: contextSessionId,
-            },
-            "session.state push",
-          )
+          if (eventForTick) {
+            const { ev, at } = eventForTick
+            lastTurnAtByName.set(s.session_name, currentChat.turnAt)
+            lastChatEventByName.set(s.session_name, ev)
+            writeSessionEventFileFn(s.session_name, ev, at).catch(() => {})
           }
-          // state push より古い一覧を後続 poll が返すと sidebar 行の status/context が
-          // 逆戻りするため、送信前に snapshot 世代を切り替える。
+        }
+        const prev = lastByName.get(s.session_name)
+        if (!prev || Object.keys(payload).some((key) => prev[key] !== payload[key])) {
+          lastByName.set(s.session_name, payload)
+          if (STATE_TRACE) logger?.info({ session_name: s.session_name, ...payload }, "session.state push")
           tmuxSessionsSnapshotCache.clear()
-          client.send({
-            type: "session.state",
-            session_name: s.session_name,
-            status,
-            context_pct: contextPct,
-            stable,
-            proc_busy: procBusy,
-            // child_busy: outputActive を含まない真の子プロセス busy。frontend の shouldQueue が
-            // 出力残り火 (proc_busy 残存) でアイドルなのにキューへ逃がす誤キュー (症状A) を断つために使う。
-            child_busy: childBusy,
-            stalled,
-            // turn_active: ステータスドット 4 状態統一の権威ソース。null は旧クライアント互換
-            // (frontend は欠落時に旧 prompt_submit/stale 降格ロジックへフォールバック)。
-            turn_active: turnActive,
-            // cli_kind (T05945): セッション名由来の構造値 ('claude' | 'codex')。frontend の
-            // 単一セレクタ (useCockpitSessionDisplay) が「この push はどの CLI 行のものか」を
-            // 判定する唯一の軸。context_session_id は context% の会話 ID。
-            cli_kind: chatCliKind,
-            context_session_id: contextSessionId,
-            // 旧クライアント互換。新規 consumer は context_session_id を使う。
-            chat_session_id: contextSessionId,
-          })
+          client.send({ type: "session.state", session_name: s.session_name, ...payload })
         }
         // 消滅セッションの GC (perf監査/メモリリーク対策): tmux から消えたセッションの状態 Map を
         // まとめて解放する。clear() は再接続時(onReopen)のみのため、worktree 案件の生成/破棄で
@@ -3033,6 +2743,7 @@ export function startStateLoop({ client, plugins, logger, intervalMs, claudeBrid
   t0.unref?.()
 
   return {
+    tick,
     stop() {
       stopped = true
       clearInterval(ti)
@@ -3326,7 +3037,7 @@ export function handleClaudeChatInput(msg, ctx) {
   // 書かれる。bridge が拒否しても取り消さない (仕様。notifyChatPromptSubmit の JSDoc)。
   const cwdSnapshot = ctx.claudeBridge.getCwd?.(stream_id) ?? null
   if (cwdSnapshot) {
-    recordPromptAccepted(cwdSnapshot, "claude", acceptedAt)
+    recordPromptAccepted(cwdSnapshot, "claude", acceptedAt, ctx.claudeBridge.sessions?.get(stream_id), ctx.claudeBridge)
     notifyChatPromptSubmit({
       cwd: cwdSnapshot,
       cliKind: "claude",
@@ -3552,7 +3263,7 @@ export function handleCodexChatInput(msg, ctx) {
   // (handleClaudeChatInput のコメント参照)。
   const cwdSnapshot = ctx.codexBridge.getCwd?.(stream_id) ?? null
   if (cwdSnapshot) {
-    recordPromptAccepted(cwdSnapshot, "codex", acceptedAt)
+    recordPromptAccepted(cwdSnapshot, "codex", acceptedAt, ctx.codexBridge.sessions?.get(stream_id), ctx.codexBridge)
     notifyChatPromptSubmit({
       cwd: cwdSnapshot,
       cliKind: "codex",
@@ -3833,17 +3544,14 @@ export async function buildUsagePayload(ctx) {
   // 別数値のため、`usage` にマージせず独立フィールド `codexUsage`/`codexSessions`
   // として返す (frontend 側でどちらのアカウントの残量か混同しないため)。
   let codexUsage = null
+  let codexContextCwd = 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 として通して両経路を収束させる。
+      // キャッシュは従来の cwd / アカウントデータだけを作る。
+      // 代表会話の値は handleUsageRequest の送信直前に付ける。
       const cwds = new Set()
       for (const s of ctx.codexBridge.sessions.values()) {
         if (s.threadId && s.cwd) cwds.add(s.cwd)
@@ -3863,6 +3571,7 @@ export async function buildUsagePayload(ctx) {
       if (liveCodex.length > 0) {
         // 5h/7d はアカウント全体の値 (どの live session から読んでも同じ契約の残量)
         // なので、代表として最初の 1 件から取る (context% はその producer の live を使う)。
+        codexContextCwd = liveCodex[0].cwd
         codexUsage = await codexUsageForThread(liveCodex[0].threadId, {
           producerSeq: liveCodex[0].producerSeq,
         })
@@ -3910,6 +3619,7 @@ export async function buildUsagePayload(ctx) {
 
   return {
     payload: { usage, sessions, codexUsage, codexSessions },
+    codexContextCwd,
     timings: {
       credentials_ms: credentialsMs,
       account_usage_ms: accountUsageMs,
@@ -3920,6 +3630,27 @@ export async function buildUsagePayload(ctx) {
   }
 }
 
+/** キャッシュを変えず、要求の送信時点の代表で cwd ごとに置き換える。 */
+export function applyUsageRowChatState(payload, codexContextCwd = null) {
+  const result = { ...payload }
+  for (const [kind, field] of [["claude", "sessions"], ["codex", "codexSessions"]]) {
+    const cwds = representativeRows(kind)
+    if (cwds.length === 0) continue
+    const selected = new Set(cwds)
+    const entries = (payload[field] ?? []).filter((entry) => !selected.has(entry.cwd))
+    for (const cwd of cwds) {
+      const chat = readRowChatState(cwd, kind)
+      entries.push({ cwd, sessionId: chat.sessionId, contextPercent: chat.context_pct,
+        updatedAtMs: chat.turnAt, status: chat.status, inputPending: chat.inputPending,
+        context_session_id: chat.sessionId, chat_session_id: chat.sessionId })
+    }
+    result[field] = entries
+  }
+  const codexChat = readRowChatState(codexContextCwd, "codex")
+  if (codexChat && payload.codexUsage) result.codexUsage = { ...payload.codexUsage, context: codexChat.context_pct }
+  return result
+}
+
 /**
  * usage.request の処理。中身は TTL キャッシュ + single-flight で共有し、request_id
  * だけを要求ごとに差し込む。
@@ -3956,7 +3687,7 @@ export async function handleUsageRequest(msg, ctx, deps = {}) {
     }
     ctx.client.send({
       type: "usage.response",
-      ...result.payload,
+      ...applyUsageRowChatState(result.payload, result.codexContextCwd),
       request_id: msg.request_id,
     })
   } catch (err) {
@@ -4343,60 +4074,15 @@ export async function dispatch(msg, ctx) {
                 "failed to push Claude attach history",
               )
             })
-          // S1 (2026-07): セッション状態の identity 正本化。TUI の claude.tui.bind
-          // (main.mjs 内 clearChatSignal 呼び出し箇所参照) と対称に、SDK チャットの
-          // attach 時点でも前セッションのチャット信号を引き継がない。
-          //  - fresh (resume 無し): 新規セッションで session_id はまだ確定しない
-          //    (SDK が最初の assistant イベントで通知する)。ただし null を送ると frontend
-          //    は「同一会話で一時的に0%になった」と判断して旧値を保持するため、stream_id
-          //    由来の一意な仮IDを先に送る。実 session_id が来た時点で置換される。
-          //  - resume: bound session の jsonl から実 context% を解決し、cli_kind='claude' +
-          //    実 session_id で identity を確定させて即時 push する (症状③)。
-          const resolvedCwd = cwdArg || process.env.HOME || process.cwd()
-          if (resolvedCwd) {
-            if (!resumeSessionId) {
-              const freshContextSessionId = `fresh:${stream_id}`
-              clearChatSignal(resolvedCwd, "claude")
-              recordChatActivity(resolvedCwd, "claude", {
-                status: "waiting",
-                contextPct: 0,
-                inputPending: false,
-                sessionId: freshContextSessionId,
-              })
-              pushImmediateChatState({
-                client: ctx.client,
-                plugins: ctx.plugins,
-                logger: ctx.logger,
-                cwd: resolvedCwd,
-                cliKind: "claude",
-                sessionId: freshContextSessionId,
-                contextPct: 0,
-              }).catch(() => {})
-            } else {
-              jsonlContextForCwd(resolvedCwd, resumeSessionId)
-                .catch(() => null)
-                .then((jsonlCtx) => {
-                  const contextPct =
-                    typeof jsonlCtx?.percent === "number" ? jsonlCtx.percent : 0
-                  recordChatActivity(resolvedCwd, "claude", {
-                    status: "waiting",
-                    contextPct,
-                    inputPending: false,
-                    sessionId: resumeSessionId,
-                  })
-                  return pushImmediateChatState({
-                    client: ctx.client,
-                    plugins: ctx.plugins,
-                    logger: ctx.logger,
-                    cwd: resolvedCwd,
-                    cliKind: "claude",
-                    sessionId: resumeSessionId,
-                    contextPct,
-                  })
-                })
-                .catch(() => {})
-            }
+          const session = ctx.claudeBridge.sessions?.get(stream_id)
+          const resolvedCwd = session?.cwd || cwdArg || process.env.HOME || process.cwd()
+          const push = () => pushImmediateChatState({ client: ctx.client, plugins: ctx.plugins,
+            logger: ctx.logger, cwd: resolvedCwd, cliKind: "claude" })
+          if (session && resumeSessionId) {
+            void loadResumeChatContext(session, "claude").then(push).catch(() => {})
           }
+          void push().catch(() => {})
+
         } catch (err) {
           ctx.client.send({
             type: "claude.error",
@@ -4781,68 +4467,14 @@ export async function dispatch(msg, ctx) {
           } catch (err) {
             ctx.logger?.warn?.({ err: err?.message }, "failed to replay review events")
           }
-          // S1 (2026-07): claude.attach と対称の identity 正本化。Codex は thread/start
-          // 応答時点で threadId が確定するため (Claude の fresh とは異なり)、fresh でも
-          // 既に分かっている threadId を sessionId として記録する (直後の turn/started が
-          // 同じ threadId を伴って届いても identity 一致でリセットが起きないように)。
-          //  - fresh (resume 無し): ゼロ値 + 確定済み threadId で即時 push (症状④)。
-          //  - resume: codexUsageForThread で実 context% を解決し即時 push (症状③)。
-          if (resolvedCwd) {
-            // Stage4 caller レビュー major #6: fresh/resume の分岐は **実際の attach 結果**
-            // (info.resuming) で判定する。in-memory reattach は元 msg.resume_thread_id が空
-            // (fresh 再接続) でも既存 thread への復帰 = info.resuming=true なので、resume 側の
-            // 実 context% 解決に載せる (fresh 扱いで context を 0 に戻さない)。
-            if (!info.resuming) {
-              clearChatSignal(resolvedCwd, "codex")
-              recordChatActivity(resolvedCwd, "codex", {
-                status: "waiting",
-                contextPct: 0,
-                inputPending: false,
-                sessionId: info.threadId || null,
-              })
-              pushImmediateChatState({
-                client: ctx.client,
-                plugins: ctx.plugins,
-                logger: ctx.logger,
-                cwd: resolvedCwd,
-                cliKind: "codex",
-                sessionId: info.threadId || null,
-                contextPct: 0,
-              }).catch(() => {})
-            } else {
-              // 増分2: context% は cwd の権威 producer(seq) の live を正本にする (resume 直後の
-              // このセッションは lastTurnAtMs=now で権威。live 未取得なら rollout フォールバック)。
-              const resumeProducerSeq = ctx.codexBridge?.liveSessionForCwd?.(resolvedCwd)?.seq
-              codexUsageForThread(info.threadId, { producerSeq: resumeProducerSeq })
-                .catch(() => null)
-                .then((usage) => {
-                  // ⚠️ codex-review round2 major#2: rollout I/O 中に別 session が権威化しうる。
-                  // await 後に権威 seq を再検証し、この resume session が現権威でなければ即時 push を
-                  // 見送る (古い context/sessionId を書かない。state loop が ≤5s で正す)。
-                  const stillAuthority =
-                    resumeProducerSeq != null &&
-                    ctx.codexBridge?.liveSessionForCwd?.(resolvedCwd)?.seq === resumeProducerSeq
-                  if (!stillAuthority) return undefined
-                  const contextPct = typeof usage?.context === "number" ? usage.context : 0
-                  recordChatActivity(resolvedCwd, "codex", {
-                    status: "waiting",
-                    contextPct,
-                    inputPending: false,
-                    sessionId: info.threadId,
-                  })
-                  return pushImmediateChatState({
-                    client: ctx.client,
-                    plugins: ctx.plugins,
-                    logger: ctx.logger,
-                    cwd: resolvedCwd,
-                    cliKind: "codex",
-                    sessionId: info.threadId,
-                    contextPct,
-                  })
-                })
-                .catch(() => {})
-            }
+          const session = ctx.codexBridge.sessions?.get(stream_id)
+          const push = () => pushImmediateChatState({ client: ctx.client, plugins: ctx.plugins,
+            logger: ctx.logger, cwd: resolvedCwd, cliKind: "codex" })
+          if (session && info.resuming) {
+            void loadResumeChatContext(session, "codex").then(push).catch(() => {})
           }
+          void push().catch(() => {})
+
         } catch (err) {
           ctx.client.send({
             type: "codex.error",
@@ -5584,6 +5216,18 @@ export async function dispatch(msg, ctx) {
       case "chat.session.stop": {
         const result = { type: "chat.session.stop.result", request_id: msg.request_id, stopped: 0 }
         try {
+          if (msg.scope === "cwd") {
+            const cwd = typeof msg.cwd === "string" ? msg.cwd : ""
+            if (msg.cli_kind !== "claude" && msg.cli_kind !== "codex") result.error = "unsupported cli_kind"
+            else if (!cwd || !path.isAbsolute(cwd)) result.error = "cwd required"
+            else if (msg.cli_kind === "claude") {
+              result.stopped = await ctx.claudeBridge.stopSessionsFor({ cwd, reason: "chat-stop" })
+            } else {
+              result.stopped = await ctx.codexBridge.stopSessionsForCwd({ cwd, reason: "chat-stop" })
+            }
+            ctx.client.send(result)
+            return
+          }
           if (msg.cli_kind === "claude") {
             const cwd = typeof msg.cwd === "string" ? msg.cwd : ""
             const session_id = typeof msg.session_id === "string" ? msg.session_id : ""
@@ -5648,7 +5292,7 @@ export async function dispatch(msg, ctx) {
             bridges: { claudeBridge: ctx.claudeBridge, codexBridge: ctx.codexBridge },
             logger: ctx.logger,
           })
-          ctx.client.send({ type: "chat.sessions", request_id: msg.request_id, ...snapshot })
+          ctx.client.send({ type: "chat.sessions", request_id: msg.request_id, ...refreshChatSessionsSignals(snapshot, ctx.logger) })
         } catch (err) {
           ctx.client.send({
             type: "chat.sessions", request_id: msg.request_id, targets: [], live: [],
@@ -5676,7 +5320,11 @@ export async function dispatch(msg, ctx) {
             const enriched = enrichTmuxSessionsForListResponse(
               sessions,
               lastEventByName,
-              ctx.getSessionStateSnapshot,
+              (name) => {
+                const row = sessions.find((item) => item.name === name)
+                if (hasRepresentativeRow(row?.cwd, cliKindForSessionName(name))) return null
+                return ctx.getSessionStateSnapshot?.(name)
+              },
               // warm = このセッションへ依頼 (cockpit_orch.py send) を送れるか。sibling-inject の
               // 宛先候補列挙と同一関数 (live-sessions.mjs) を通す。
               (row) =>
@@ -5719,7 +5367,7 @@ export async function dispatch(msg, ctx) {
             type: "tmux.sessions",
             request_id: msg.request_id,
             ...snapshot,
-            sessions,
+            sessions: sessions.map((row) => applyRowChatState(row, row.cwd, cliKindForSessionName(row.name))),
           })
         } catch (err) {
           ctx.client.send({