@cocorograph/hub-agent 0.7.72 → 0.7.74

package/package.json

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

package/src/codex-stream-bridge.mjs

@@ -61,47 +61,100 @@ function siblingEnvFor(cwd) {
   }
 }
 
-// ⚠️ 2026-07-17 の事故 (「Codex チャットが 5 分で消え ask-sibling が届かない」) の教訓:
-// この TTL は **detach 済み (= ブラウザが居なくなった) セッション専用** の猶予である。
-// 旧実装は (a) detach の有無を記録せず turn/completed のたびに無条件でタイマーを張り、
-// (b) タイマー発火時に activeTurnId を再チェックしなかったため、
-//   - ブラウザを開いたままでも「最後のターン完了から 5 分」で app-server が kill され、
-//   - その 5 分間に ask-sibling が新ターンを注入すると **exec 実行中に kill** され、
-//     rollout に output の無い custom_tool_call が残って thread が永久に汚染された
-//     (codex_core の `Custom tool call output is missing for call id: ...` が以後の
-//      全ターンで出続ける)。
-// 予約は detach 済みセッションに限り、発火時にも busy/再活性を再確認すること。
-// detach 後、非 busy なセッションを生かしておく猶予。claude 側 (7 日) と違い短くする:
-// この TTL は **in-memory reattach の猶予窓** を兼ねる。WS が切れて browser disconnect が
-// codex.detach を送っても、この TTL 内に **同じ attach_id で再接続** すれば _tryReattach が
-// その session を新 stream へ付け替えて拾える (fresh 直後 rollout 0件の会話も復元可)。TTL を
-// 超えて reap されたら、再接続は通常経路 (thread/resume は rollout 正本から復元、または fresh)
-// にフォールスルーする。7 日だと再接続チャーンのたびにプロセスが積み上がる (リーク) ため短命に
-// する。ターン実行中は TTL に
-// 関わらず完走まで絶対に落とさない (_maybeReapAfterIdle が busy 中は予約しない)。
-const IDLE_DETACH_TTL_MS = 5 * 60 * 1000
-
-// 放棄セッションの reaper 閾値。claude-stream-bridge.mjs の gcDeadTerminals と同じ思想・
-// 同じ env (HUB_AGENT_DEAD_TERMINAL_TTL_MS、既定 1 時間)。detach を送らず消えた端末や、
-// codex エラーで turn/completed が来ず activeTurnId が固着したスタックセッションは、
-// detach→TTL(5分) の graceful reap 経路に乗らないため app-server が永久に残る (リーク)。
-// これを補い、「一定時間まったく通信 (browser 入力 / app-server 通知) が無い」セッションを
-// activeTurnId の有無に関わらず定期回収する。進行中の正常なターンは app-server 通知で
-// 都度 touch されるため回収されない (通知が途絶えたスタックターンのみ回収される)。
-const ABANDONED_SESSION_TTL_MS =
-  Number(process.env.HUB_AGENT_DEAD_TERMINAL_TTL_MS) || 60 * 60 * 1000
+// ── Stage 5 (2026-07-19): bounded warm pool + 長 idle TTL への再設計 ───────────
+// 旧設計: detach → **5 分** の per-session タイマーで reap（`_maybeReapAfterIdle`）＋
+// 1h の無活性 reaper（`gcAbandonedSessions`）。これは codex-review のように 1 ターンが
+// 数分〜数十分かかり、かつ **別 CLI 画面（claude チャット）から呼ぶため codex 画面が非
+// アクティブ = detach 済み**になる用途で、「ターン完了後 5 分の idle で reaped → 次の依頼が
+// 届かない」構造的ミスマッチを生んでいた（2026-07-19 調査）。
+//
+// 新設計: **周期 reconcile 一本化**（`reconcileSessions`、state loop から ~5s 毎）。
+//   - detach してもすぐ殺さず、**長 idle TTL（既定 7 日、claude softDetach と同思想）** で
+//     warm 保持する。
+//   - 際限ないプロセス蓄積は **LRU 件数上限（既定 5、マシン全体）** で防ぐ。6 個目が来たら
+//     最も使っていない **非 protected** セッションを 1 個 reap。旧「5 分で殺す」の代わりに
+//     「上限で天井を作る」ことで、TTL を長くしてもリークしない（T06500 の churn 削減も前提）。
+//   - **busy（healthy running turn）は絶対に reap しない**（TTL でも LRU でも）。
+//   - **stuck turn**（activeTurnId 固着だが app-server 通知が STUCK_TTL 途絶えた＝ハング）は
+//     protected から外れ、別途 reap 対象（プロセスリーク・固着の救済）。
+// これにより意味論は「**閲覧中＝無期限（keepalive で LRU 先頭維持）/ 直近 5 セッションは
+// detach しても 7 日 warm / 上限超過は LRU で 1 個 reap / busy は不可侵 / stuck は救済**」。
+
+// warm 保持の idle TTL（非 busy がこの時間 無活性なら reap の対象。上限内でも 7 日で頭打ち）。
+const IDLE_DETACH_TTL_MS =
+  Number(process.env.HUB_AGENT_CODEX_IDLE_DETACH_TTL_MS) || 7 * 24 * 60 * 60 * 1000
+
+// LRU warm pool の上限（マシン全体で同時に生かす codex セッション数）。超過分は最も使って
+// いない非 protected セッションから reap。1 セッション ≈ 120-140MB（node ラッパー + 本体 +
+// MCP 子）なので既定 5（~650MB）。env で調整可。
+const WARM_POOL_MAX = Number(process.env.HUB_AGENT_CODEX_WARM_POOL_MAX) || 5
+
+// stuck turn 検出の閾値。activeTurnId が立っているのに app-server 通知がこの時間途絶えた
+// セッションは「ハングしたターン」とみなし protected から外して reap する（healthy な長ターンは
+// reasoning/output delta で都度 touch されるため該当しない）。旧 `HUB_AGENT_DEAD_TERMINAL_TTL_MS`
+// を後方互換で受ける。既定 1h。
+const STUCK_TURN_TTL_MS =
+  Number(process.env.HUB_AGENT_CODEX_STUCK_TURN_TTL_MS) ||
+  Number(process.env.HUB_AGENT_DEAD_TERMINAL_TTL_MS) ||
+  60 * 60 * 1000
 
 const CLIENT_INFO = { name: "cockpit-hub-agent", title: "Cockpit", version: "1.0.0" }
 
+// T06499 (2026-07-18): 巨大スレッドの resume ガード。長期運用したスレッドの rollout は
+// 20MB 超まで肥大し得る (実測: メイン repo 540KB が正常なのに対し 20MB のスレッドあり)。
+// thread/resume 応答をそのまま平坦化して browser へ送ると、
+//   ① WS へ 20MB の JSON を積む → 転送で数秒フリーズ
+//   ② browser 側で全 item を codexHistoryToEvents → reducer merge → 数千バブル描画で
+//      メインスレッドがハング (履歴も、その裏で撃つ codex.sessions.request 由来の
+//      セッション切替バーも一切出ない = UX の断崖)
+// が起きる。thread/resume 自体はモデル側の会話コンテキスト復元のため全量が必要だが、
+// **browser へ渡す表示用履歴は末尾 N ターン分に絞る** ことで断崖を回避する。上限は
+// 「item 数」と「概算バイト数」の 2 軸で、末尾から詰めてどちらか先に達したら truncated。
+const HISTORY_MAX_ITEMS = Number(process.env.HUB_AGENT_CODEX_HISTORY_MAX_ITEMS) || 200
+const HISTORY_MAX_BYTES =
+  Number(process.env.HUB_AGENT_CODEX_HISTORY_MAX_BYTES) || 1.5 * 1024 * 1024
+
 // Slice 6: thread/resume が返す Thread.turns[].items[] を単一の時系列配列へ平坦化する。
 // turns は開始ターン順の配列、各 turn.items も時系列順のため単純結合で会話順を保てる。
-function flattenThreadItems(thread) {
+//
+// T06499: 末尾から maxItems / maxBytes の budget 内に収め、超過分は落として truncated=true を
+// 返す。末尾優先なのは「直近の会話が最も価値が高く、古い履歴は resume されたモデル側が保持して
+// いる」ため。budget を末尾から積むので、20MB スレッドでも全 item を stringify せず早期に打ち切る
+// (kept が budget に達した時点で残りの巨大な古い item には触れない)。
+// @returns {{items: object[], truncated: boolean, total: number}}
+function flattenThreadItems(thread, { maxItems = HISTORY_MAX_ITEMS, maxBytes = HISTORY_MAX_BYTES } = {}) {
   const turns = Array.isArray(thread?.turns) ? thread.turns : []
-  const items = []
+  const all = []
   for (const turn of turns) {
-    if (Array.isArray(turn?.items)) items.push(...turn.items)
+    if (Array.isArray(turn?.items)) all.push(...turn.items)
+  }
+  const total = all.length
+  const kept = []
+  let bytes = 0
+  let truncated = false
+  // 末尾 (最新) から詰める。budget 超過で打ち切り、truncated を立てる。
+  for (let i = all.length - 1; i >= 0; i--) {
+    if (kept.length >= maxItems) {
+      truncated = true
+      break
+    }
+    const item = all[i]
+    let size = 0
+    try {
+      size = JSON.stringify(item)?.length || 0
+    } catch {
+      size = 0
+    }
+    // 最低 1 件は必ず入れる (単一 item が maxBytes を超えても末尾 1 件は見せる)。
+    if (kept.length > 0 && bytes + size > maxBytes) {
+      truncated = true
+      break
+    }
+    kept.push(item)
+    bytes += size
   }
-  return items
+  kept.reverse() // 末尾から積んだので時系列順へ戻す。
+  return { items: kept, truncated, total }
 }
 
 /**
@@ -184,15 +237,34 @@ function userInputFromMessage(message) {
 }
 
 export class CodexStreamBridge extends EventEmitter {
-  constructor({ codexCmd, logger, clientFactory, detachTtlMs, rolloutPresence } = {}) {
+  constructor({
+    codexCmd,
+    logger,
+    clientFactory,
+    detachTtlMs,
+    warmPoolMax,
+    stuckTurnTtlMs,
+    rolloutPresence,
+    historyMaxItems,
+    historyMaxBytes,
+  } = {}) {
     super()
     this.codexCmd = codexCmd
     this.logger = logger
     this._clientFactory = clientFactory || ((opts) => new CodexAppServerClient(opts))
-    // テストから TTL を短縮できるよう注入可能にする (既定は 7 日)。
+    // Stage 5: warm 保持の idle TTL（既定 7 日）。テストから短縮できるよう注入可能。
     this._detachTtlMs = detachTtlMs ?? IDLE_DETACH_TTL_MS
+    // Stage 5: LRU warm pool 上限（既定 5）。テストから小さい値を注入可能。
+    this._warmPoolMax = warmPoolMax ?? WARM_POOL_MAX
+    // Stage 5: stuck turn 検出 TTL（既定 1h）。テストから短縮可能。
+    this._stuckTurnTtlMs = stuckTurnTtlMs ?? STUCK_TURN_TTL_MS
     // #4 失敗分類の rollout 存在チェック (tri-state。テストから注入可能)。
     this._rolloutPresence = rolloutPresence || codexRolloutPresence
+    // T06499: 履歴 hydrate の上限 (テストから小さい値を注入可能)。
+    this._historyLimits = {
+      maxItems: historyMaxItems ?? HISTORY_MAX_ITEMS,
+      maxBytes: historyMaxBytes ?? HISTORY_MAX_BYTES,
+    }
     /** @type {Map<string, object>} stream_id -> session record */
     this.sessions = new Map()
   }
@@ -210,7 +282,8 @@ export class CodexStreamBridge extends EventEmitter {
    * なければ、通常の attach (thread/start | thread/resume) にフォールスルーする。
    *
    * @returns {Promise<{resuming: boolean, threadId: string, history: object[],
-   *   threadStatus: string|null, lastTurnStatus: string|null, turnActive: boolean}>}
+   *   historyTruncated: boolean, threadStatus: string|null, lastTurnStatus: string|null,
+   *   turnActive: boolean}>}
    */
   async attach({ stream_id, cwd, model, effort, approvalPolicy, sandbox, resumeThreadId, attachId }) {
     if (this.sessions.has(stream_id)) {
@@ -258,14 +331,15 @@ export class CodexStreamBridge extends EventEmitter {
       threadId: null,
       activeTurnId: null,
       pendingApprovals: new Map(), // request_id -> { turnId }
-      detachTimer: null,
-      // ブラウザから codex.detach を受け取った (= 画面の持ち主が居なくなった) か。
-      // アイドル TTL reap は **このフラグが立っているセッションだけ** が対象。
+      // ブラウザから codex.detach を受け取った (= 画面の持ち主が居なくなった) か。診断・ログ用。
+      // Stage 5: 回収の可否は detachRequested ではなく lastActivityMs（LRU）と activeTurnId
+      // （busy/stuck）で決める。detach してもすぐには殺さず warm 保持する。
       // ask-sibling 注入 (sendToCwd) は「新しい持ち主が付いた」とみなして false に戻す。
       detachRequested: false,
       dead: false,
-      // 放棄セッション reaper (gcAbandonedSessions) 用の最終活性時刻。browser 入力と
-      // app-server 通知 (ターン進捗) の両方で更新する。Date.now() は hub-agent 実行環境で利用可。
+      // Stage 5 reconcile（LRU / idle TTL / stuck）用の最終活性時刻。browser 入力と app-server
+      // 通知 (ターン進捗) の両方で更新する。LRU は「最終活性が最も古い非 protected」を退避する。
+      // Date.now() は hub-agent 実行環境で利用可。
       lastActivityMs: Date.now(),
       ready: null,
     }
@@ -292,7 +366,12 @@ export class CodexStreamBridge extends EventEmitter {
       session.threadId = result?.thread?.id
       // 新規スレッド (thread/start) は履歴が無いので空配列。resume 時のみ平坦化する
       // (thread/start のレスポンスは turns を持たない仕様のため呼んでも常に空)。
-      const history = resuming ? flattenThreadItems(result?.thread) : []
+      // T06499: 巨大スレッドは末尾 N ターンに絞る (truncated=true なら browser がバナー表示)。
+      const flat = resuming
+        ? flattenThreadItems(result?.thread, this._historyLimits)
+        : { items: [], truncated: false, total: 0 }
+      const history = flat.items
+      const historyTruncated = flat.truncated
       // 案C: 権威的なターン状態を resume 応答から取り出してフロントへ渡す。
       // これによりフロントは会話末尾からの推測をやめ、Thread.status で turnActive を
       // 決められる (生成中スピナー固着バグの根治)。新規スレッドは常に idle 相当。
@@ -317,13 +396,22 @@ export class CodexStreamBridge extends EventEmitter {
           resuming,
           thread_status: turnState.threadStatus,
           live_for_cwd: this.describeLiveSessions(cwd).length,
+          // T06499: 巨大スレッド hydrate の可視化 (何件中何件を返したか)。
+          history_items: history.length,
+          history_total: flat.total,
+          history_truncated: historyTruncated,
         },
         "codex session attached",
       )
+      // Stage 5: genuine attach で 1 プロセス増えたので、LRU 上限の超過分を即時退避する
+      // （次の reconnect まで ~5s 待たず、6 個目の app-server が居座るのを防ぐ）。新セッションは
+      // たった今 touch 済み = LRU 先頭なので退避対象にならず、最も古い非 protected が落ちる。
+      this._evictWarmPoolOverflow(Date.now(), "lru-evict-on-attach")
       return {
         resuming,
         threadId: session.threadId,
         history,
+        historyTruncated,
         threadStatus: turnState.threadStatus,
         lastTurnStatus: turnState.lastTurnStatus,
         turnActive: turnState.turnActive,
@@ -374,7 +462,6 @@ export class CodexStreamBridge extends EventEmitter {
     this.sessions.delete(originalStreamId)
     session.stream_id = newStreamId
     session.detachRequested = false
-    this._cancelIdleReap(session, "reattach")
     session.lastActivityMs = Date.now()
     this.sessions.set(newStreamId, session)
     this.logger?.info?.(
@@ -389,6 +476,8 @@ export class CodexStreamBridge extends EventEmitter {
         resuming: true,
         threadId,
         history: [],
+        // reconnect の in-memory reattach は表示を保持しているので履歴を返さない = 常に非 truncated。
+        historyTruncated: false,
         threadStatus: session.activeTurnId ? "active" : "idle",
         lastTurnStatus: null,
         turnActive: !!session.activeTurnId,
@@ -501,9 +590,8 @@ export class CodexStreamBridge extends EventEmitter {
       case "turn/completed":
         session.activeTurnId = null
         this._autoResolveStalePendingApprovals(session, msg.params?.turn?.id)
-        // ⚠️ detach 済みのときだけ再評価する。ブラウザが繋がったままのセッションは
-        // ターンが終わっても生かし続ける (_maybeReapAfterIdle 内でも二重に guard)。
-        this._maybeReapAfterIdle(session, "turn-completed-after-detach")
+        // Stage 5: turn 完了後の reap 予約は不要。以降 idle になれば周期 reconcile が
+        // 長 idle TTL / LRU で扱う（detach 済みでも 7 日 warm 保持）。
         break
       default:
         break
@@ -543,7 +631,6 @@ export class CodexStreamBridge extends EventEmitter {
   _onClientExit(session, info) {
     if (session.dead) return
     session.dead = true
-    this._clearDetachTimer(session)
     this.sessions.delete(session.stream_id)
     // app-server の終了は必ず記録する。ターン実行中の exit は「rollout に output 欠落の
     // custom_tool_call を残した可能性がある」= thread 汚染の予兆なので warn で出す
@@ -593,11 +680,9 @@ export class CodexStreamBridge extends EventEmitter {
    */
   async input({ stream_id, message, model, effort }) {
     const session = this._require(stream_id)
+    // Stage 5: _touch で lastActivityMs を更新 = LRU 先頭へ。ターン開始で activeTurnId が
+    // 立ち、reconcile は healthy busy を protected 扱いにするので実行中に kill されない。
     this._touch(session)
-    // TTL 待ちのセッションに新ターンを流す = まだ使われている。予約を解除しないと
-    // ターン実行中 (exec 中) に kill され、rollout に output 欠落の custom_tool_call が
-    // 残って thread が汚染される (2026-07-17 の事故)。
-    this._cancelIdleReap(session, "input")
     const input = userInputFromMessage(message)
     if (session.activeTurnId) {
       try {
@@ -646,7 +731,6 @@ export class CodexStreamBridge extends EventEmitter {
   async interrupt({ stream_id }) {
     const session = this._require(stream_id)
     this._touch(session)
-    this._cancelIdleReap(session, "interrupt")
     if (!session.activeTurnId) return
     await session.client.request("turn/interrupt", {
       threadId: session.threadId,
@@ -658,7 +742,6 @@ export class CodexStreamBridge extends EventEmitter {
   permissionReply({ stream_id, request_id, result }) {
     const session = this._require(stream_id)
     this._touch(session)
-    this._cancelIdleReap(session, "permission-reply")
     if (!session.pendingApprovals.has(request_id)) {
       this.logger?.warn?.({ stream_id, request_id }, "codex permissionReply: unknown request_id (ignored)")
       return
@@ -670,13 +753,9 @@ export class CodexStreamBridge extends EventEmitter {
   /**
    * ブラウザ閲覧中の生存シグナル (codex.keepalive)。frontend が Codex チャットを開いて
    * いる間だけ定期送信するため、これが届く = 「人が見ている」の観測可能な証跡になる。
-   * gcAbandonedSessions は lastActivityMs しか見ないので、touch するだけで
-   * 「開いたまま無入力でも 1h で殺される」ギャップが閉じる (TTL の数字を増やす必要は無い)。
-   *
-   * ⚠️ 意図的に `_cancelIdleReap` を **呼ばない**。detach 済みセッションの 5 分 TTL は
-   * 「ブラウザが去った」という別事実に基づく予約であり、detach と in-flight keepalive が
-   * 競合しても予約を解除しない (= 明示 detach は必ず 5 分で回収される) 方が意味論が明快。
-   * 閲覧を再開したブラウザは必ず attach を送り直すので、再養子はそちらの経路で足りる。
+   * Stage 5: touch で lastActivityMs を更新すると LRU 先頭に留まるため、**閲覧中のセッションは
+   * 上限超過の LRU 退避対象にならず、長 idle TTL でも殺されない**（= 実質無期限）。ブラウザを
+   * 閉じれば keepalive も止まり、以降は detach 済み warm として LRU / 7 日 idle TTL に従う。
    *
    * @returns {boolean} 生きているセッションを touch できたら true (未知 stream は false)。
    */
@@ -688,9 +767,9 @@ export class CodexStreamBridge extends EventEmitter {
   }
 
   /**
-   * グレースフル切断。ターン実行中は完走を待ち、非 busy ならアイドル TTL 後に
-   * プロセスを reap する (claude-stream-bridge.mjs の softDetach と同じ思想。
-   * Slice 2 は多端末共有非対応なので detach = そのまま TTL 予約でよい)。
+   * グレースフル切断（Stage 5）。**すぐには reap しない**。detachRequested を立てて
+   * warm 保持し、以降は周期 reconcile（LRU 上限 / 長 idle TTL / stuck）に委ねる。これにより
+   * 「別 CLI 画面へ切替えた瞬間 5 分で殺される」問題を解消し、直近 5 セッションは 7 日 warm に。
    */
   detach({ stream_id }) {
     const session = this.sessions.get(stream_id)
@@ -703,9 +782,8 @@ export class CodexStreamBridge extends EventEmitter {
         cwd: session.cwd,
         busy: !!session.activeTurnId,
       },
-      "codex detach requested by browser",
+      "codex detach requested by browser (kept warm; reconcile handles reap)",
     )
-    this._maybeReapAfterIdle(session, "detach")
   }
 
   /**
@@ -790,10 +868,11 @@ export class CodexStreamBridge extends EventEmitter {
       )
       return false
     }
-    // TTL 待ち (browser detach 済み) のセッションでも、ask-sibling が使うなら
-    // 「新しい持ち主が付いた」とみなして回収予約を解除する。これをしないと
-    // 注入したターンの実行中に kill され、thread が汚染される (2026-07-17)。
-    this._cancelIdleReap(best, "sendToCwd (ask-sibling injection)", { readopt: true })
+    // detach 済み warm セッションでも、ask-sibling が使うなら「新しい持ち主が付いた」とみなして
+    // detachRequested を解除し touch する（LRU 先頭へ）。this.input が改めて _touch するが、注入前に
+    // 明示しておく。ターン実行中は healthy busy = protected なので reconcile で kill されない。
+    best.detachRequested = false
+    this._touch(best)
     this.logger?.info?.(
       {
         cwd,
@@ -816,92 +895,70 @@ export class CodexStreamBridge extends EventEmitter {
   }
 
   /**
-   * detach 済み・非 busy なセッションに「アイドル TTL 後の回収」を予約する。
-   *
-   * ⚠️ 予約は `detachRequested` が立っているセッションのみ。ブラウザが繋がったままの
-   * セッションを turn/completed 契機で殺してはいけない (2026-07-17 の事故)。
+   * Stage 5: セッションが「保護対象（reap 不可）」か。= **healthy な running turn**。
+   * activeTurnId が立っており、かつ app-server 通知が STUCK_TTL 以内に届いている（＝生きている
+   * ターン）。activeTurnId が固着したまま通知が STUCK_TTL 途絶えたもの（stuck/ハング）は
+   * protected ではなく reap 対象にする（プロセスリーク・固着の救済）。
    * @param {object} session
-   * @param {string} trigger 予約理由 (ログ用: 'detach' | 'turn-completed-after-detach')
+   * @param {number} now
+   * @returns {boolean}
    */
-  _maybeReapAfterIdle(session, trigger = "detach") {
-    if (!session.detachRequested) return // ブラウザが居る → 回収対象外
-    if (session.activeTurnId) return // 完走まで待つ (turn/completed で再評価される)
-    this._clearDetachTimer(session)
-    session.detachTimer = setTimeout(() => {
-      if (session.dead) return
-      // 発火時の再確認: TTL 中に ask-sibling 注入 (sendToCwd) で再活性化した、または
-      // 新しいターンが走り出したセッションを **実行中に kill しない** (rollout に
-      // output 欠落の custom_tool_call を残さないため)。
-      if (!session.detachRequested) {
-        this.logger?.info?.(
-          { stream_id: session.stream_id, thread_id: session.threadId, cwd: session.cwd },
-          "codex idle reap canceled at fire time (session re-adopted)",
-        )
-        session.detachTimer = null
-        return
-      }
-      if (session.activeTurnId) {
-        this.logger?.info?.(
-          {
-            stream_id: session.stream_id,
-            thread_id: session.threadId,
-            cwd: session.cwd,
-            turn_id: session.activeTurnId,
-          },
-          "codex idle reap deferred (turn in progress; will re-arm on turn/completed)",
-        )
-        session.detachTimer = null
-        return
-      }
-      this.logger?.info?.(
-        {
-          stream_id: session.stream_id,
-          thread_id: session.threadId,
-          cwd: session.cwd,
-          ttl_ms: this._detachTtlMs,
-          reason: "idle-detach-ttl",
-        },
-        "codex session reaped (detached and idle past TTL)",
-      )
+  _isProtected(session, now) {
+    if (!session.activeTurnId) return false
+    return now - (session.lastActivityMs ?? now) <= this._stuckTurnTtlMs
+  }
+
+  /** 実際に app-server を止めてセッションを撤去し exit を emit する（reconcile 共通処理）。 */
+  _reapSession(session, now, reason) {
+    if (session.dead) return
+    session.dead = true
+    this.sessions.delete(session.stream_id)
+    try {
       session.client.stop()
-    }, this._detachTtlMs)
-    session.detachTimer.unref?.()
+    } catch (err) {
+      this.logger?.warn?.({ stream_id: session.stream_id, err: err?.message }, "codex reap: stop threw")
+    }
     this.logger?.info?.(
       {
         stream_id: session.stream_id,
         thread_id: session.threadId,
         cwd: session.cwd,
-        ttl_ms: this._detachTtlMs,
-        trigger,
+        reason,
+        idle_ms: now - (session.lastActivityMs ?? now),
+        live_after: this.sessions.size,
       },
-      "codex idle reap armed (browser detached)",
+      "codex session reaped",
     )
+    this.emit("exit", {
+      stream_id: session.stream_id,
+      thread_id: session.threadId,
+      code: 0,
+      reason: "idle-reaped",
+    })
   }
 
   /**
-   * 予約済みのアイドル回収を取り消す。ブラウザ入力 / ask-sibling 注入 / 承認応答など
-   * 「このセッションはまだ使われている」証跡が出たら必ず呼ぶ。
-   * @param {object} session
-   * @param {string} reason ログ用
-   * @param {boolean} readopt true なら detachRequested も解除 (新しい持ち主が付いた)
+   * Stage 5: LRU warm pool 上限の超過分を退避する。生存（非 dead）セッションが上限を超えたら、
+   * **非 protected の中で最終活性が最も古いもの**から順に上限まで reap する。protected（healthy
+   * running turn）は退避対象にしないため、全部が busy のときは一時的に上限を超えたまま許容する
+   * （走行中ターンを絶対に殺さない）。genuine attach 直後と reconcile の両方から呼ぶ。
+   * @param {number} now
+   * @returns {number} 退避した数
    */
-  _cancelIdleReap(session, reason, { readopt = false } = {}) {
-    const had = !!session.detachTimer
-    this._clearDetachTimer(session)
-    if (readopt) session.detachRequested = false
-    if (had) {
-      this.logger?.info?.(
-        { stream_id: session.stream_id, thread_id: session.threadId, cwd: session.cwd, reason },
-        "codex idle reap canceled (session active again)",
-      )
-    }
-  }
-
-  _clearDetachTimer(session) {
-    if (session.detachTimer) {
-      clearTimeout(session.detachTimer)
-      session.detachTimer = null
+  _evictWarmPoolOverflow(now, reason = "lru-evict") {
+    const live = Array.from(this.sessions.values()).filter((s) => !s.dead)
+    const overflow = live.length - this._warmPoolMax
+    if (overflow <= 0) return 0
+    const evictable = live
+      .filter((s) => !this._isProtected(s, now))
+      .sort((a, b) => (a.lastActivityMs ?? 0) - (b.lastActivityMs ?? 0)) // 古い順
+    let evicted = 0
+    for (const s of evictable) {
+      if (evicted >= overflow) break
+      this._reapSession(s, now, reason)
+      evicted += 1
     }
+    return evicted
   }
 
   _require(stream_id) {
@@ -913,64 +970,49 @@ export class CodexStreamBridge extends EventEmitter {
   }
 
   /**
-   * 放棄セッションの reaper。claude-stream-bridge.mjs の gcDeadTerminals と同じ思想:
-   * 一定時間まったく通信 (browser 入力 / app-server 通知) が無いセッションの app-server を
-   * 停止して回収する。detach を送らず消えた端末や、codex エラーで turn/completed が来ず
-   * activeTurnId が固着したスタックターンは detach→TTL の graceful reap 経路に乗らないため、
-   * これが唯一の回収経路になる (プロセスリーク / 生成中固着の根治)。
-   *
-   * 進行中の正常なターンは app-server 通知で都度 touch されるので回収されない。
-   * main.mjs の state loop から claudeBridge.gcDeadTerminals と並べて定期実行する想定。
-   *
-   * この reaper は `detachRequested` を **意図的に参照しない**。detach を送れずに消えた
-   * ブラウザ (タブごとクラッシュ / 端末スリープ) は detachRequested が立たないまま残るため、
-   * ここでフラグを見ると回収不能になりリークする。「無通信が続いた事実」だけで回収する。
+   * Stage 5: セッションの周期 reconcile（state loop から ~5s 毎に実行）。以下を 1 パスで行う:
+   *   1. **stuck turn**: activeTurnId 固着だが app-server 通知が STUCK_TTL 途絶えた（ハング）→ reap
+   *      （healthy な長ターンは reasoning/output delta で touch されるため該当しない）。
+   *   2. **long idle**: 非 busy が idle TTL（既定 7 日）無活性 → reap（warm 保持の期限切れ）。
+   *   3. **LRU 上限**: 生存数が warmPoolMax（既定 5）を超えたら、非 protected の最終活性が
+   *      最も古いものから上限まで reap。
+   * busy（healthy running turn）は 1〜3 いずれの対象にもならない（走行中ターンを絶対に殺さない）。
    *
-   * 閲覧中の誤爆は keepalive で防ぐ (2026-07-17 に解消。旧: 開いたままでも 1h 無入力で
-   * 回収されていた)。frontend は Codex チャットを開いている間 codex.keepalive を定期送信し、
-   * keepalive() が lastActivityMs を touch する。ブラウザが閉じれば keepalive も止まるので
-   * この reaper は本来の orphan GC として正しく効く。CockpitTerminal.tsx の PTY keepalive
-   * (pty.resize で lastSeenAt を触る) と同じ構造。結果として TTL の意味は
-   * 「ブラウザ開 = 無期限 / 明示 detach = 5 分 / ブラウザ落ち = 1h reaper」に整理され、
-   * 「N 時間放置しても生きていてほしい」という数字合わせ自体が不要になった。
+   * 旧 `gcAbandonedSessions`（1h 無活性一律 reap）を置換。detach 済み warm セッションを 1h で
+   * 殺していた挙動を廃し、上限＋長 TTL に一本化した。main.mjs の state loop 呼び出しは
+   * 後方互換のため `gcAbandonedSessions` エイリアスを残す。
    *
-   * @param {number} [ttlMs] 無通信とみなす閾値 (テスト用に上書き可)。
    * @returns {number} 回収したセッション数。
    */
-  gcAbandonedSessions(ttlMs = ABANDONED_SESSION_TTL_MS) {
+  reconcileSessions() {
     const now = Date.now()
     let reaped = 0
+    // 1〜2: stuck turn / long idle。protected（healthy running turn）はスキップ。
     for (const session of Array.from(this.sessions.values())) {
       if (session.dead) continue
-      const last = session.lastActivityMs ?? 0
-      if (now - last < ttlMs) continue
-      this._clearDetachTimer(session)
-      session.dead = true
-      this.sessions.delete(session.stream_id)
-      try {
-        session.client.stop()
-      } catch (err) {
-        this.logger?.warn?.({ stream_id: session.stream_id, err: err?.message }, "gcAbandonedSessions: stop threw")
+      if (this._isProtected(session, now)) continue
+      const idle = now - (session.lastActivityMs ?? now)
+      if (session.activeTurnId && idle > this._stuckTurnTtlMs) {
+        this._reapSession(session, now, "stuck-turn")
+        reaped += 1
+      } else if (!session.activeTurnId && idle > this._detachTtlMs) {
+        this._reapSession(session, now, "idle-ttl")
+        reaped += 1
       }
-      reaped += 1
-      this.logger?.info?.(
-        { stream_id: session.stream_id, thread_id: session.threadId, idle_ms: now - last },
-        "codex abandoned session reaped (no activity past TTL)",
-      )
-      this.emit("exit", {
-        stream_id: session.stream_id,
-        thread_id: session.threadId,
-        code: 0,
-        reason: "idle-reaped",
-      })
     }
+    // 3: LRU 上限の超過分を退避（stuck/idle reap 後の生存数で判定）。
+    reaped += this._evictWarmPoolOverflow(now, "lru-evict")
     return reaped
   }
 
+  /** 後方互換エイリアス（main.mjs state loop が呼ぶ）。中身は reconcileSessions。 */
+  gcAbandonedSessions() {
+    return this.reconcileSessions()
+  }
+
   /** 全セッションを即座に終了する (agent shutdown 用。ターン完走は待たない)。 */
   shutdown() {
     for (const session of this.sessions.values()) {
-      this._clearDetachTimer(session)
       session.dead = true
       // hub-agent 再起動時にターン実行中のセッションを落とすと thread が汚染されうる
       // (exec 中の kill → output 欠落)。因果を後から辿れるよう必ず記録する。

package/src/main.mjs

@@ -4210,6 +4210,9 @@ async function dispatch(msg, ctx) {
             // consumers.py の per-stream relay は content-blind なので backend 側の
             // 変更は不要 (_AGENT_PER_STREAM_TYPES の codex.ready がそのまま運ぶ)。
             history: info.history || [],
+            // T06499: 巨大スレッドで末尾 N ターンに絞った場合 true。browser は
+            // 「以前の履歴は省略されています」バナーを出す (会話は resume 済みで継続可)。
+            history_truncated: info.historyTruncated === true,
             // 案C (権威的ターン状態): フロントは会話末尾からの推測 (deriveTurnActive
             // FromHistory) をやめ、Codex が明示する Thread.status で turnActive を決める。
             // resume 後は新プロセスで実行中ターンが無く thread_status='idle' が返るため、
@@ -4396,11 +4399,23 @@ async function dispatch(msg, ctx) {
         }
         try {
           const sessions = await ctx.codexBridge.listThreads({ cwd, limit })
+          // Stage 5 ③: 各 thread に「hub-agent 側で app-server が live か / busy か」を付す。
+          // rollout 由来の一覧（listThreads）は live 状態を知らないため、describeLiveSessions
+          // の thread_id → {live, busy} を併合する。browser は sidebar に live/reaped ドットを出す。
+          const liveByThread = new Map()
+          for (const s of ctx.codexBridge.describeLiveSessions(cwd)) {
+            if (s.thread_id) liveByThread.set(s.thread_id, { live: true, busy: !!s.busy })
+          }
+          const withLive = sessions.map((t) => ({
+            ...t,
+            live: liveByThread.get(t.thread_id)?.live === true,
+            busy: liveByThread.get(t.thread_id)?.busy === true,
+          }))
           ctx.client.send({
             type: "codex.sessions.response",
             stream_id,
             cwd,
-            sessions,
+            sessions: withLive,
           })
         } catch (err) {
           ctx.client.send({