@cocorograph/hub-agent 0.7.73 → 0.7.74

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocorograph/hub-agent",
-  "version": "0.7.73",
+  "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,35 +61,42 @@ 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
+// ── 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
 
-// 放棄セッションの 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
+// 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" }
 
@@ -235,6 +242,8 @@ export class CodexStreamBridge extends EventEmitter {
     logger,
     clientFactory,
     detachTtlMs,
+    warmPoolMax,
+    stuckTurnTtlMs,
     rolloutPresence,
     historyMaxItems,
     historyMaxBytes,
@@ -243,8 +252,12 @@ export class CodexStreamBridge extends EventEmitter {
     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 の上限 (テストから小さい値を注入可能)。
@@ -318,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,
     }
@@ -389,6 +403,10 @@ export class CodexStreamBridge extends EventEmitter {
         },
         "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,
@@ -444,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?.(
@@ -573,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
@@ -615,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 で出す
@@ -665,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 {
@@ -718,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,
@@ -730,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
@@ -742,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)。
    */
@@ -760,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)
@@ -775,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")
   }
 
   /**
@@ -862,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,
@@ -888,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) {
@@ -985,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 経路に乗らないため、
-   * これが唯一の回収経路になる (プロセスリーク / 生成中固着の根治)。
+   * 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 いずれの対象にもならない（走行中ターンを絶対に殺さない）。
    *
-   * 進行中の正常なターンは app-server 通知で都度 touch されるので回収されない。
-   * main.mjs の state loop から claudeBridge.gcDeadTerminals と並べて定期実行する想定。
+   * 旧 `gcAbandonedSessions`（1h 無活性一律 reap）を置換。detach 済み warm セッションを 1h で
+   * 殺していた挙動を廃し、上限＋長 TTL に一本化した。main.mjs の state loop 呼び出しは
+   * 後方互換のため `gcAbandonedSessions` エイリアスを残す。
    *
-   * この reaper は `detachRequested` を **意図的に参照しない**。detach を送れずに消えた
-   * ブラウザ (タブごとクラッシュ / 端末スリープ) は detachRequested が立たないまま残るため、
-   * ここでフラグを見ると回収不能になりリークする。「無通信が続いた事実」だけで回収する。
-   *
-   * 閲覧中の誤爆は 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 時間放置しても生きていてほしい」という数字合わせ自体が不要になった。
-   *
-   * @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

@@ -4399,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({