@cocorograph/hub-agent 0.7.79 → 0.7.81

package/src/codex-stream-bridge.mjs

@@ -21,10 +21,14 @@
  *   (新 app-server を起動しない)。browser の WS 再接続で stream_id が変わっても、fresh 直後
  *   (rollout 0件) の会話も含めて復元できる。詳細は attach() の docstring 参照。
  *
+ * ## 多端末購読 (案B / T06542)
+ *   複数ブラウザタブでの **同時** 同一スレッド共有を実装済み (Claude の多端末共有と対称)。
+ *   session は購読集合 `streamIds` を持ち、reattach は「所有権付け替え」ではなく「購読者追加」。
+ *   どの購読端末からの input/permission も解決でき、配信は Hub backend が thread_id グループ
+ *   broadcast で行う (agent はイベントに thread_id を載せるだけ)。詳細は attach()/_tryReattach()/
+ *   detach()/gcDeadTerminals() の docstring 参照。旧 Slice 2 の「単一勝者のみ (同時共有は非対応)」は撤廃。
+ *
  * Slice 2 のスコープ外 (意図的に見送り、後続スライスで追加する):
- *   - 複数ブラウザタブでの **同時** 同一スレッド共有 (Claude の HUB_AGENT_CHAT_SHARED 相当)。
- *     in-memory reattach は「1 つの持ち主が WS を張り直す」ケース (単一勝者) であり、複数タブが
- *     同時に同一スレッドを操作する共有はまだ扱わない。
  *   - 画像/添付入力 (テキストのみ)。
  *   - acceptForSession や execpolicy/network amendment 等の高度な承認 decision
  *     (permissionReply は decision をそのまま素通しするので呼び出し側が組み立てる)。
@@ -84,10 +88,21 @@ function siblingEnvFor(cwd) {
 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
+// 子⑤ (T06544): warm 保持の上限を「マシン全体の総セッション数」から「各 cwd 1 本 × 同時 warm
+// 保持する cwd 数 N」へ再定義（親 T06539「1 cwd 1 本化」に整合）。旧 WARM_POOL_MAX（総数 LRU=5）は
+// 廃止し、境界を cwd 単位で定義する。1 セッション ≈ 120-140MB（node ラッパー + 本体 + MCP 子）
+// なので既定 20 cwd（~2.4-2.8GB 上限）。端末リソースで無理なら env で下げる。
+// 後方互換: 旧 HUB_AGENT_CODEX_WARM_POOL_MAX を設定していても新 cwd 上限として解釈する。
+const WARM_CWD_MAX =
+  Number(process.env.HUB_AGENT_WARM_CWD_MAX) ||
+  Number(process.env.HUB_AGENT_CODEX_WARM_POOL_MAX) ||
+  20
+
+// 子⑤ (T06544, codex-review round5 Finding 1): warm 境界の「最新 1 本を残す」判定で recency
+// (lastActivityMs) が同一ミリ秒になったときのタイブレーク用の単調増加シーケンス。生成順が後 =
+// 値が大きい = 新しいので、per-cwd=1 のタイでは **必ず新しく attach したセッションを残す**
+// （旧実装は安定ソートの挿入順で旧セッションが残り、新規 attach が即 reap される非決定性があった）。
+let CODEX_SESSION_SEQ = 0
 
 // stuck turn 検出の閾値。activeTurnId が立っているのに app-server 通知がこの時間途絶えた
 // セッションは「ハングしたターン」とみなし protected から外して reap する（healthy な長ターンは
@@ -98,6 +113,21 @@ const STUCK_TURN_TTL_MS =
   Number(process.env.HUB_AGENT_DEAD_TERMINAL_TTL_MS) ||
   60 * 60 * 1000
 
+// 案B (T06542): 死端末 GC の TTL。多端末購読で、応答を返さなくなった（クラッシュ / タブ強制終了で
+// codex.detach を送れなかった）購読端末を購読集合から掃除する閾値。claude-stream-bridge.mjs の
+// DEAD_TERMINAL_TTL_MS（既定 1h）と同型・同既定。stuck turn TTL とは別軸（あちらはターン固着、
+// こちらは端末の無応答）だが既定は揃える。
+const DEAD_TERMINAL_TTL_MS =
+  Number(process.env.HUB_AGENT_CODEX_DEAD_TERMINAL_TTL_MS) ||
+  Number(process.env.HUB_AGENT_DEAD_TERMINAL_TTL_MS) ||
+  60 * 60 * 1000
+
+// 案B (T06542, codex-review round3 major#2): turn/start RPC 成功後に turn/started 通知が来るのを待つ
+// 上限。これを超えたら「ターンが正しく始まらなかった」とみなし、pump が待機中の queue を reject して
+// 状態を解除する（turn/started/completed/exit が来ないケースで promise が永久宙吊りになるのを防ぐ）。
+const TURN_START_TIMEOUT_MS =
+  Number(process.env.HUB_AGENT_CODEX_TURN_START_TIMEOUT_MS) || 30 * 1000
+
 const CLIENT_INFO = { name: "cockpit-hub-agent", title: "Cockpit", version: "1.0.0" }
 
 // T06499 (2026-07-18): 巨大スレッドの resume ガード。長期運用したスレッドの rollout は
@@ -271,8 +301,10 @@ export class CodexStreamBridge extends EventEmitter {
     logger,
     clientFactory,
     detachTtlMs,
-    warmPoolMax,
+    warmCwdMax,
     stuckTurnTtlMs,
+    deadTerminalTtlMs,
+    turnStartTimeoutMs,
     rolloutPresence,
     historyMaxItems,
     historyMaxBytes,
@@ -283,10 +315,15 @@ export class CodexStreamBridge extends EventEmitter {
     this._clientFactory = clientFactory || ((opts) => new CodexAppServerClient(opts))
     // 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
+    // 子⑤ (T06544): 同時 warm 保持する cwd 数の上限（既定 20）。各 cwd は 1 本に畳む。
+    // テストから小さい値を注入可能。
+    this._warmCwdMax = warmCwdMax ?? WARM_CWD_MAX
     // Stage 5: stuck turn 検出 TTL（既定 1h）。テストから短縮可能。
     this._stuckTurnTtlMs = stuckTurnTtlMs ?? STUCK_TURN_TTL_MS
+    // 案B (T06542): 死端末 GC の TTL（既定 1h）。テストから短縮可能。
+    this._deadTerminalTtlMs = deadTerminalTtlMs ?? DEAD_TERMINAL_TTL_MS
+    // round3 major#2: turn/start 後に turn/started を待つ上限（既定 30s）。テストから短縮可能。
+    this._turnStartTimeoutMs = turnStartTimeoutMs ?? TURN_START_TIMEOUT_MS
     // #4 失敗分類の rollout 存在チェック (tri-state。テストから注入可能)。
     this._rolloutPresence = rolloutPresence || codexRolloutPresence
     // T06499: 履歴 hydrate の上限 (テストから小さい値を注入可能)。
@@ -381,8 +418,22 @@ export class CodexStreamBridge extends EventEmitter {
     // unhandled rejection を作らず、複数の reconnect が同じ promise を安全に await できる)。
     let settleReady
     const session = {
+      // primary stream_id: legacy な単一値 emit / ログ用。案B では最新購読端末へ寄せる
+      // (streamIds が真の購読者集合)。app-server 通知や emit は都度 session.stream_id を読む。
       stream_id,
+      // 子⑤ round5 Finding 1: 生成順の単調増加シーケンス（warm 境界のタイブレーク用。値が大きい =
+      // 新しい）。recency 同値時に per-cwd=1 が新しいセッションを残せるようにする。
+      seq: (CODEX_SESSION_SEQ += 1),
       cwd,
+      // 案B (T06542): 多端末購読集合。この live session を購読中の全端末 stream_id。reattach は
+      // 「所有権付け替え」ではなく「購読者追加」。detach で当該端末を外し、最後の1台が外れたら
+      // warm 保持（reconcile が LRU/idle TTL/stuck で reap）。sessions Map は各購読 stream_id →
+      // この session の多対一。distinct session 走査は必ず _liveSessions() で dedup する。
+      streamIds: new Set([stream_id]),
+      // 死端末 GC 用の端末別最終活性。browser→agent アクション（input/permission/interrupt/
+      // keepalive）で更新し、応答を返さなくなった購読端末を gcDeadTerminals が掃除する
+      // (claude-stream-bridge.mjs の lastActivityByStream と同型)。
+      lastActivityByStream: new Map([[stream_id, Date.now()]]),
       // #1 in-memory reattach のキー。attach 試行を跨いで安定 (WS 再接続で stream_id は変わる)。
       attachId: attachId || null,
       client,
@@ -393,6 +444,26 @@ export class CodexStreamBridge extends EventEmitter {
       // この session を引き当て _tryReattach の session.ready 合流に入り、二重 app-server を作らない。
       resumeThreadId: resumeThreadId || null,
       activeTurnId: null,
+      // 案B (T06542, codex-review round3 major#1): 同時入力を **session 単位の単一 FIFO + 単一 pump**で
+      // 直列化し、二重 turn/start・queue 追い越し・並行 steer を構造的に排除する。旧 turnStarting/
+      // pendingInputs の二重路 (queue 経路 + 直通経路) が overtaking と並行リトライ二重ターンの温床だった。
+      /** @type {Array<{input: object[], model?: string, effort?: string, resolve: Function,
+       *  reject: Function, retriedAsStart?: boolean}>} round3 major#1: **session 単位の単一 FIFO**。
+       *  全 input() はここに積まれ、単一 pump (_pumpInputs) が **1 件ずつ直列**に処理する。直通経路を
+       *  廃したので、drain 中の新規 input が queue を追い越したり、並行 turn/start・steer を発行して
+       *  二重ターンになる事故が起きない。各 promise は **実 delivery (turn/start か turn/steer の RPC)**で
+       *  settle する (main.mjs が codex.input.ack/nack を実配達に合わせて出せる)。 */
+      inputQueue: [],
+      /** round3 major#1: pump が走行中か (単一 pump を保証する singleflight フラグ)。 */
+      pumping: false,
+      /** @type {{resolve: Function, timer: any} | null} round3 major#2: turn/start 後に turn/started
+       *  (activeTurnId 確定) を待つ barrier の待機者。timeout 付きでハングを防ぐ。 */
+      _turnActiveWaiter: null,
+      /** round4 major#2: turn/started 通知ごとに +1 する世代カウンタ。pump は turn/start dispatch 前に
+       *  値を控え、応答後に「world が前進したか (turn が始まった/更に完了した)」を activeTurnId だけでなく
+       *  この前進でも判定する。fast-turn (start 応答と started+completed が同一 chunk で pump 再開前に
+       *  処理される) で activeTurnId=null に戻っていても、世代前進で検知して誤 timeout を防ぐ。 */
+      turnGeneration: 0,
       // request_id -> { turnId, method, params }。major#1: reattach で新 stream へ未応答の承認要求を
       // 再送できるよう、元の method/params も保持する (Claude の _permissionResolvers と同型)。
       pendingApprovals: new Map(),
@@ -489,10 +560,11 @@ 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")
+      // 子⑤ (T06544): genuine attach で 1 本増えたので warm 境界（per-cwd=1 / N-cwd LRU）を即時
+      // 適用する（次の reconnect まで ~5s 待たず、同一 cwd の重複や cwd 数超過が居座るのを防ぐ）。
+      // 新セッションはたった今 touch 済み = 各判定で最新なので退避対象にならず、最も古い非 protected
+      // が落ちる。
+      this._reconcileWarmBounds(Date.now(), "warm-bounds-on-attach")
       return {
         resuming,
         threadId: session.threadId,
@@ -579,32 +651,41 @@ export class CodexStreamBridge extends EventEmitter {
    * 付け替えられなければ null を返し、呼び出し側 attach() は通常経路へフォールスルーする。
    */
   async _tryReattach(session, newStreamId) {
-    // ⚠️ 付け替え前の stream_id を **await の前に capture** する (major #1: 同じ attach_id へ
-    // 複数 reconnect が session.ready 待ちで重なったとき、`session.stream_id` を await 後に
-    // 読むと勝者が既に付け替えた現在値を追ってしまい「別 stream へ移動済み」を検出できず、
-    // 敗者も成功してしまう。capture 値で CAS することで **単一勝者**にする)。
+    // 案B (T06542): reattach は「所有権付け替え」ではなく **購読者追加**。旧 stream を Map から
+    // 消さず、newStreamId を streamIds へ足して両方が同一 live session を購読する状態を作る
+    // (どの端末の input/permission/interrupt も解決でき、backend が thread group へ fan-out する)。
+    // これにより「2 本目の app-server を立てず、旧端末も生かしたまま」新端末を相乗りさせる。
     // 戻り値 status:
-    //   "reattached" - この呼び出しが session を newStreamId へ付け替えた (info 同梱)。
-    //   "superseded" - 別 reattach が勝って session を奪った (session は生きている)。呼び出し側は
-    //                  **通常経路に落とさず** 失敗させる (二重 thread を作らない)。
+    //   "reattached" - newStreamId を購読者として追加した (info 同梱)。
+    //   "superseded" - newStreamId が既に別 session を保持している異常時のみ (通常は起きない。
+    //                  attach() が :318 で has(stream_id) を弾くため)。呼び出し側は通常経路に
+    //                  落とさず失敗させる (二重 thread を作らない)。
     //   "unavailable"- session が死んだ / first の thread 確定に失敗 (ライブ session 無し)。
     //                  呼び出し側は通常経路へフォールスルーしてよい。
-    const originalStreamId = session.stream_id
     let threadId = session.threadId
     if (!threadId && session.ready) threadId = await session.ready
     // first の thread op が失敗 / session が死んだ = ライブ session はもう無い。
     if (!threadId || session.dead) return { status: "unavailable" }
-    // await 中に別 reattach が勝って session を移動した = concurrent の敗者。
-    if (this.sessions.get(originalStreamId) !== session) return { status: "superseded" }
-    if (this.sessions.has(newStreamId)) return { status: "superseded" } // 新 stream 側が別 session 保持 (異常)
-    this.sessions.delete(originalStreamId)
+    const existingForNew = this.sessions.get(newStreamId)
+    if (existingForNew && existingForNew !== session) return { status: "superseded" }
+    // 購読者追加: streamIds / 端末別活性 / Map を更新し、primary を最新端末へ寄せる
+    // (legacy 単一値 emit / ログ用。真の配信は backend の thread group fan-out が担う)。
+    const now = Date.now()
+    session.streamIds.add(newStreamId)
+    session.lastActivityByStream.set(newStreamId, now)
+    this.sessions.set(newStreamId, session)
     session.stream_id = newStreamId
     session.detachRequested = false
-    session.lastActivityMs = Date.now()
-    this.sessions.set(newStreamId, session)
+    session.lastActivityMs = now
     this.logger?.info?.(
-      { stream_id: newStreamId, thread_id: threadId, cwd: session.cwd, reattached: true },
-      "codex session reattached (in-memory)",
+      {
+        stream_id: newStreamId,
+        thread_id: threadId,
+        cwd: session.cwd,
+        reattached: true,
+        subscribers: session.streamIds.size,
+      },
+      "codex session reattached (multi-terminal subscribe)",
     )
     // major#1: 新 stream へ未応答の承認要求を再送する (Claude の _replayPendingPermissions と同型)。
     // 承認要求は app-server との in-flight callback で、履歴 hydrate には含まれない。旧 stream 宛に
@@ -719,9 +800,38 @@ export class CodexStreamBridge extends EventEmitter {
     })
   }
 
-  /** gcAbandonedSessions 用の最終活性更新。browser 入力 / app-server 通知の両方で呼ぶ。 */
-  _touch(session) {
-    if (session) session.lastActivityMs = Date.now()
+  /**
+   * reconcile 用の最終活性更新。browser 入力 / app-server 通知の両方で呼ぶ。
+   * 案B: stream_id を伴う browser→agent アクション（input/permission/interrupt/keepalive）では
+   * **端末別の活性（lastActivityByStream）も更新**し、gcDeadTerminals が「応答を返さない購読端末」
+   * だけを掃除できるようにする。app-server 通知（stream_id なし）は session 全体の活性のみ更新する。
+   */
+  _touch(session, stream_id) {
+    if (!session) return
+    const now = Date.now()
+    session.lastActivityMs = now
+    if (stream_id && session.streamIds?.has(stream_id)) {
+      session.lastActivityByStream.set(stream_id, now)
+    }
+  }
+
+  /**
+   * 案B: sessions Map は各購読 stream_id → session の多対一なので、distinct な live session を
+   * 走査するときは必ずこれで dedup する（同一 session を購読端末数ぶん重複カウントしない）。
+   * @returns {object[]} 非 dead な distinct session の配列
+   */
+  _liveSessions() {
+    return Array.from(new Set(this.sessions.values())).filter((s) => !s.dead)
+  }
+
+  /** 案B: この session を指す全購読 stream_id キーを sessions Map から外す（reap / exit 共通）。 */
+  _dropAllStreamKeys(session) {
+    const ids = session.streamIds ? Array.from(session.streamIds) : []
+    for (const sid of ids) {
+      if (this.sessions.get(sid) === session) this.sessions.delete(sid)
+    }
+    // primary が streamIds に含まれない異常時の保険。
+    if (this.sessions.get(session.stream_id) === session) this.sessions.delete(session.stream_id)
   }
 
   _onNotification(session, msg) {
@@ -733,11 +843,18 @@ export class CodexStreamBridge extends EventEmitter {
     switch (msg.method) {
       case "turn/started":
         session.activeTurnId = msg.params?.turn?.id || null
+        // round4 major#2: 世代を前進させる (pump が fast-turn を activeTurnId だけでなく世代前進でも検知)。
+        session.turnGeneration += 1
+        // round3 major#2: 起動確定 → pump の turn-active barrier を解除する (次 item が steer へ進む)。
+        this._settleTurnActiveWaiter(session)
         // 会話ターン境界で「新しさ」を更新（閲覧 keepalive では更新しない）。
         session.lastTurnAtMs = Date.now()
         break
       case "turn/completed":
         session.activeTurnId = null
+        // round3 major#2: turn/started を取りこぼしたまま turn/completed が来た異常時も barrier が
+        // 固着しないよう解除する (pump が次 item を fresh に turn/start できる)。
+        this._settleTurnActiveWaiter(session)
         session.lastTurnAtMs = Date.now()
         this._autoResolveStalePendingApprovals(session, msg.params?.turn?.id)
         // Stage 5: turn 完了後の reap 予約は不要。以降 idle になれば周期 reconcile が
@@ -810,7 +927,12 @@ export class CodexStreamBridge extends EventEmitter {
   _onClientExit(session, info) {
     if (session.dead) return
     session.dead = true
-    this.sessions.delete(session.stream_id)
+    // round3: app-server が死んだら barrier を解除し queue を reject する（promise 宙吊り防止）。
+    this._settleTurnActiveWaiter(session)
+    this._drainRejectQueue(session, { reason: "queue_dead" })
+    // 案B: app-server が死んだら全購読 stream_id キーを Map から外す（1 端末分だけでは
+    // 他の購読キーが dangling で残る）。
+    this._dropAllStreamKeys(session)
     // app-server の終了は必ず記録する。ターン実行中の exit は「rollout に output 欠落の
     // custom_tool_call を残した可能性がある」= thread 汚染の予兆なので warn で出す
     // (codex_core の `Custom tool call output is missing for call id: ...` の発生源)。
@@ -861,55 +983,177 @@ export class CodexStreamBridge extends EventEmitter {
     const session = this._require(stream_id)
     // Stage 5: _touch で lastActivityMs を更新 = LRU 先頭へ。ターン開始で activeTurnId が
     // 立ち、reconcile は healthy busy を protected 扱いにするので実行中に kill されない。
-    this._touch(session)
+    // 案B: stream_id を渡し端末別活性も更新（死端末 GC が入力継続端末を掃除しない）。
+    this._touch(session, stream_id)
     const input = userInputFromMessage(message)
-    if (session.activeTurnId) {
-      try {
-        await session.client.request("turn/steer", {
-          threadId: session.threadId,
-          expectedTurnId: session.activeTurnId,
-          input,
-        })
-        return
-      } catch (err) {
-        // S3 Codex 堅牢化 (2026-07-05): turn/steer が reject される最大の原因は
-        // expectedTurnId 不一致 (turn/completed 通知の取りこぼしで session.activeTurnId
-        // が古いまま残るケース) や request() タイムアウト。回復キューが無いと、以降の
-        // 入力が全て turn/steer として送られ続けて無反応になる (報告症状②の原因)。
-        // ここで activeTurnId を捨てて「busy ではない」扱いに戻し、同一メッセージを
-        // 1 回だけ turn/start として自動リトライすることで自己修復する。
-        session.activeTurnId = null
-        try {
-          const retryParams = { threadId: session.threadId, input }
-          if (model) retryParams.model = model
-          if (effort) retryParams.effort = effort
-          await session.client.request("turn/start", retryParams)
+    // round3 major#1: 全 input を **session 単位の単一 FIFO** に積み、単一 pump に処理させる。
+    // promise は pump が実 delivery で settle する (即 resolve しない)。
+    return new Promise((resolve, reject) => {
+      session.inputQueue.push({ input, model, effort, resolve, reject, retriedAsStart: false })
+      void this._pumpInputs(session)
+    })
+  }
+
+  /**
+   * round3 major#1 (案B / T06542): session 単位の単一 FIFO pump。**1 件ずつ直列**に処理し、
+   * 並行 turn/start・turn/steer や queue の追い越しを構造的に排除する (singleflight)。
+   *   - 非 busy (activeTurnId 無し): turn/start で新ターン。成功後、次を steer にするため
+   *     turn/started (activeTurnId 確定) を **timeout 付き**で待つ (round3 major#2: ハング防止)。
+   *   - busy (activeTurnId 有り): turn/steer で追い打ち。
+   *   - turn/steer 失敗 (expectedTurnId 不一致など): activeTurnId を捨て、同 item を **1 回だけ**
+   *     turn/start にフォールバックして自己修復する (旧 self-heal を FIFO 内で継続。並行はしない)。
+   * 各 item の promise は実 delivery の RPC 結果で settle する。
+   */
+  async _pumpInputs(session) {
+    if (session.pumping) return
+    session.pumping = true
+    try {
+      while (session.inputQueue.length > 0) {
+        if (session.dead) {
+          this._drainRejectQueue(session, { reason: "queue_dead" })
           return
-        } catch (retryErr) {
-          // 呼び出し元 (main.mjs の codex.input dispatch) が既存の .catch() で
-          // codex.error を送出する経路に reason を乗せて届ける (bridge 側で二重に
-          // 'error' イベントを emit すると frontend へ codex.error が二重送出される
-          // ため、ここでは throw のみに留める)。
-          const reason = "turn_mismatch_retry_failed"
-          throw Object.assign(
-            new Error(
-              `turn/steer failed (${err.message}) and turn/start retry also failed: ${retryErr.message}`,
-            ),
-            { reason, cause: retryErr },
-          )
         }
+        const item = session.inputQueue[0]
+        // round4 major#3: 試行種別 (steer/start) を **await の前に** 確定する。await 中に
+        // turn/completed が来て session.activeTurnId が null に戻ると、catch 時点の値では steer 試行が
+        // start と誤判定され、self-heal リトライがスキップされて item が誤 reject される。
+        const attemptedSteer = !!session.activeTurnId
+        try {
+          if (attemptedSteer) {
+            await session.client.request("turn/steer", {
+              threadId: session.threadId,
+              expectedTurnId: session.activeTurnId,
+              input: item.input,
+            })
+            session.inputQueue.shift()
+            item.resolve()
+          } else {
+            // round4 major#2: turn/start dispatch の **前に** 世代を控える。start 応答後に
+            // turn/started(+completed) が pump 再開前に処理されても、世代前進で「ターンが始まった」を
+            // 検知でき、誤 timeout しない。
+            const genBefore = session.turnGeneration
+            const params = { threadId: session.threadId, input: item.input }
+            if (item.model) params.model = item.model
+            if (item.effort) params.effort = item.effort
+            await session.client.request("turn/start", params)
+            session.inputQueue.shift()
+            item.resolve()
+            // 次の item を steer にするため turn/started (= 世代前進) を待つ。timeout でハングを防ぐ。
+            // timeout したら「ターンが正しく始まらなかった」とみなし残り queue を reject して打ち切る。
+            const becameActive = await this._waitTurnActive(session, genBefore)
+            if (!becameActive) {
+              this._drainRejectQueue(session, { reason: "turn_start_timeout" })
+              return
+            }
+          }
+        } catch (err) {
+          if (attemptedSteer && !item.retriedAsStart) {
+            // turn/steer 失敗 → 自己修復: activeTurnId を捨て、同 item を turn/start で 1 回だけリトライ
+            // (shift しない = 同 item を次ループの start 経路で再処理)。並行はしない (単一 pump)。
+            // 元の steer エラーを stash して、リトライも失敗したとき合成メッセージを作れるようにする。
+            session.activeTurnId = null
+            item.retriedAsStart = true
+            item.priorSteerError = err instanceof Error ? err : new Error(String(err))
+            continue
+          }
+          // start 失敗 or リトライ済み steer 失敗 → この item を reject。activeTurnId は捨てる
+          // (ターンは始まっていない/不明)。次の item は fresh に turn/start する。
+          session.inputQueue.shift()
+          session.activeTurnId = null
+          let e
+          if (item.retriedAsStart && item.priorSteerError) {
+            // steer→start リトライがともに失敗: 合成メッセージ + reason (main.mjs の classifyCodexInputError
+            // が reason を優先採用。従来の単一 input() 実装と同じ診断を保つ)。
+            e = Object.assign(
+              new Error(
+                `turn/steer failed (${item.priorSteerError.message}) and turn/start retry also failed: ${err instanceof Error ? err.message : String(err)}`,
+              ),
+              { reason: "turn_mismatch_retry_failed", cause: err },
+            )
+          } else {
+            e = err instanceof Error ? err : new Error(String(err))
+            if (!e.reason) e.reason = "start_error"
+          }
+          item.reject(e)
+        }
+      }
+    } finally {
+      session.pumping = false
+      // pumping=false 直後の enqueue 競合窓を拾い直す (取りこぼし防止)。再帰は 1 段のみ。
+      if (session.inputQueue.length > 0 && !session.dead) {
+        void this._pumpInputs(session)
+      }
+    }
+  }
+
+  /**
+   * round3 major#2 + round4 major#2: turn/start 後に「ターンが始まった」ことを timeout 付きで待つ
+   * barrier。activeTurnId が立っているか、または **turn/start dispatch 前に控えた世代 genBefore から
+   * 世代が前進している** (fast-turn で started+completed 済み) なら即 true を返し、誤 timeout しない。
+   * @param {object} session
+   * @param {number} [genBefore] turn/start dispatch 直前の session.turnGeneration
+   * @returns {Promise<boolean>} ターンが始まったら true、timeout したら false。
+   */
+  _waitTurnActive(session, genBefore = -1) {
+    if (session.activeTurnId || session.turnGeneration > genBefore) return Promise.resolve(true)
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        if (session._turnActiveWaiter && session._turnActiveWaiter.timer === timer) {
+          session._turnActiveWaiter = null
+        }
+        resolve(false)
+      }, this._turnStartTimeoutMs)
+      // minor (round4): 通知を出さない単体テスト等でプロセスを timeout 分保持しないよう unref する。
+      if (typeof timer.unref === "function") timer.unref()
+      // 既存 waiter があれば置換前に false 解決しておく (通常は無い)。
+      if (session._turnActiveWaiter) {
+        try {
+          clearTimeout(session._turnActiveWaiter.timer)
+        } catch {
+          /* noop */
+        }
+        session._turnActiveWaiter.resolve(false)
       }
+      session._turnActiveWaiter = { resolve: () => resolve(true), timer }
+    })
+  }
+
+  /** round3 major#2: turn/started / completed / exit / 死亡で待機中の barrier を解除する。 */
+  _settleTurnActiveWaiter(session) {
+    const w = session._turnActiveWaiter
+    if (!w) return
+    session._turnActiveWaiter = null
+    try {
+      clearTimeout(w.timer)
+    } catch {
+      /* noop */
+    }
+    w.resolve()
+  }
+
+  /**
+   * round3: FIFO の未処理 item を一括 reject する (session 死亡 / turn_start timeout で pump が
+   * 続行できないとき。ack も nack も返らない配達喪失を防ぐ)。
+   */
+  _drainRejectQueue(session, cause) {
+    if (!session || !Array.isArray(session.inputQueue) || session.inputQueue.length === 0) return
+    const pending = session.inputQueue
+    session.inputQueue = []
+    const reason = cause?.reason || "queue_dead"
+    for (const { reject } of pending) {
+      reject(
+        Object.assign(new Error("codex input dropped: turn could not be delivered"), {
+          reason,
+          cause,
+        }),
+      )
     }
-    const params = { threadId: session.threadId, input }
-    if (model) params.model = model
-    if (effort) params.effort = effort
-    await session.client.request("turn/start", params)
   }
 
   /** @returns {Promise<void>} */
   async interrupt({ stream_id }) {
     const session = this._require(stream_id)
-    this._touch(session)
+    this._touch(session, stream_id)
     if (!session.activeTurnId) return
     await session.client.request("turn/interrupt", {
       threadId: session.threadId,
@@ -920,7 +1164,8 @@ export class CodexStreamBridge extends EventEmitter {
   /** サーバー発の承認/入力要求への応答。result の shape は method ごとに呼び出し側が組み立てる。 */
   permissionReply({ stream_id, request_id, result }) {
     const session = this._require(stream_id)
-    this._touch(session)
+    // 案B エッジ②: 先着 1 応答で解決。stream_id を渡し応答端末の活性を更新（死端末 GC 対象外に）。
+    this._touch(session, stream_id)
     if (!session.pendingApprovals.has(request_id)) {
       this.logger?.warn?.({ stream_id, request_id }, "codex permissionReply: unknown request_id (ignored)")
       return
@@ -941,18 +1186,48 @@ export class CodexStreamBridge extends EventEmitter {
   keepalive({ stream_id }) {
     const session = this.sessions.get(stream_id)
     if (!session || session.dead) return false
-    this._touch(session)
+    this._touch(session, stream_id)
     return true
   }
 
   /**
-   * グレースフル切断（Stage 5）。**すぐには reap しない**。detachRequested を立てて
-   * warm 保持し、以降は周期 reconcile（LRU 上限 / 長 idle TTL / stuck）に委ねる。これにより
-   * 「別 CLI 画面へ切替えた瞬間 5 分で殺される」問題を解消し、直近 5 セッションは 7 日 warm に。
+   * グレースフル切断（Stage 5 + 案B T06542）。**すぐには reap しない**。
+   *
+   * 案B: detach は「この端末分の購読解除」。まだ他端末が購読していればセッションは生かし、
+   * detachRequested も立てない（別端末が見ているため warm ではなく現役）。最後の 1 台が外れた
+   * ときだけ detachRequested を立て warm 保持し、以降は周期 reconcile（LRU 上限 / 長 idle TTL /
+   * stuck）に委ねる。これにより「別 CLI 画面へ切替えた瞬間 5 分で殺される」問題を解消しつつ、
+   * 多端末購読中に 1 タブ閉じても残りの端末のライブ表示が切れない。
    */
   detach({ stream_id }) {
     const session = this.sessions.get(stream_id)
     if (!session || session.dead) return
+    // ⚠️ 不変条件（案B）: **live（非 dead）session は常に stream key を 1 つ以上持つ**。codex は
+    // claude と違い warm セッションの唯一の索引が this.sessions なので、最後の 1 端末分の key まで
+    // 消すと reconcile が到達できず（reap されずリーク）、_findLiveSessionByCwd の reattach 引き当ても
+    // 効かなくなる。よって「購読が 2 つ以上のときだけ実際に外す」。
+    if (session.streamIds.size > 1) {
+      // 他端末がまだ購読中: この端末分の購読解除のみ。セッションは残りの端末が生かす。
+      session.streamIds.delete(stream_id)
+      session.lastActivityByStream.delete(stream_id)
+      if (this.sessions.get(stream_id) === session) this.sessions.delete(stream_id)
+      // primary を生存端末へ寄せ替える（末尾＝最も新しく購読した端末を .at(-1) で明示選択）。
+      if (session.stream_id === stream_id) {
+        session.stream_id = Array.from(session.streamIds).at(-1)
+      }
+      this.logger?.info?.(
+        {
+          stream_id,
+          thread_id: session.threadId,
+          cwd: session.cwd,
+          remaining_subscribers: session.streamIds.size,
+        },
+        "codex terminal unsubscribed (session kept; other terminals still watching)",
+      )
+      return
+    }
+    // 最後の 1 台が外れた: key / streamIds は残したまま（reconcile 到達性のため）warm 保持し、
+    // detachRequested を立てる。以降は周期 reconcile（LRU 上限 / 長 idle TTL / stuck）が reap を判断する。
     session.detachRequested = true
     this.logger?.info?.(
       {
@@ -961,10 +1236,55 @@ export class CodexStreamBridge extends EventEmitter {
         cwd: session.cwd,
         busy: !!session.activeTurnId,
       },
-      "codex detach requested by browser (kept warm; reconcile handles reap)",
+      "codex detach requested by browser (last terminal; kept warm; reconcile handles reap)",
     )
   }
 
+  /**
+   * 案B (T06542): 死端末 GC。多端末購読で、クラッシュ / タブ強制終了で codex.detach を送れずに
+   * 消えた購読端末（一定期間 input/permission/interrupt/keepalive の活性が無い stream_id）を購読集合
+   * から掃除する。claude-stream-bridge.mjs の gcDeadTerminals と同型。複数端末が購読するセッション
+   * のみ対象（1 台しか居なければ reconcile の idle TTL / LRU に任せる）。全端末が死端末で空になったら
+   * detachRequested を立て warm 保持へ落とす。reconcileSessions の先頭から呼ばれる（main.mjs の
+   * state loop 経由）ほか、テストから直接も呼べる。
+   * @param {number} [ttlMs] 死端末とみなす無活性閾値（テスト用に上書き可）。
+   * @returns {number} GC した端末キー数。
+   */
+  gcDeadTerminals(ttlMs = this._deadTerminalTtlMs) {
+    const now = Date.now()
+    let removed = 0
+    for (const session of this._liveSessions()) {
+      // 複数端末が購読しているセッションのみ対象（1 台なら reconcile の idle TTL / LRU に任せる）。
+      if (session.streamIds.size <= 1) continue
+      for (const sid of Array.from(session.streamIds)) {
+        // ⚠️ 不変条件: live session は常に stream key を 1 つ以上残す（reconcile 到達性）。全端末が
+        // 死端末でも最後の 1 個は消さず、下で detachRequested を立てて idle TTL reap に委ねる。
+        if (session.streamIds.size <= 1) break
+        const last = session.lastActivityByStream.get(sid) ?? 0
+        if (now - last < ttlMs) continue
+        session.streamIds.delete(sid)
+        session.lastActivityByStream.delete(sid)
+        if (this.sessions.get(sid) === session) this.sessions.delete(sid)
+        removed += 1
+        if (session.stream_id === sid) {
+          session.stream_id = Array.from(session.streamIds).at(-1)
+        }
+        this.logger?.info?.(
+          { stream_id: sid, thread_id: session.threadId, cwd: session.cwd },
+          "codex dead terminal GC'd (no activity past TTL)",
+        )
+      }
+      // 生き残った最後の 1 端末も死端末（無活性が TTL 超過）なら warm 保持へ落とす
+      // （key は残したまま。reconcile が idle TTL / LRU で最終的に reap する）。
+      if (session.streamIds.size === 1) {
+        const [onlySid] = session.streamIds
+        const last = session.lastActivityByStream.get(onlySid) ?? 0
+        if (now - last >= ttlMs) session.detachRequested = true
+      }
+    }
+    return removed
+  }
+
   /**
    * 診断用: 生きているセッションの一覧 (sibling-inject の失敗理由に載せる / ログ用)。
    * 「TUI codex は hub-agent の管理外なので ask-sibling の宛先にならない」ことを
@@ -978,8 +1298,8 @@ export class CodexStreamBridge extends EventEmitter {
   describeLiveSessions(cwd) {
     const now = Date.now()
     const out = []
-    for (const session of this.sessions.values()) {
-      if (session.dead) continue
+    // 案B: sessions は多対一なので distinct session で走査する（購読端末数ぶん重複させない）。
+    for (const session of this._liveSessions()) {
       if (cwd && session.cwd !== cwd) continue
       out.push({
         kind: "codex",
@@ -1034,8 +1354,9 @@ export class CodexStreamBridge extends EventEmitter {
     if (!cwd || !text) return false
     let best = null
     let bestAt = -1
-    for (const session of this.sessions.values()) {
-      if (session.dead || session.cwd !== cwd) continue
+    // 案B: distinct session で走査（多対一 Map の重複を除く）。
+    for (const session of this._liveSessions()) {
+      if (session.cwd !== cwd) continue
       // 宛先選定の「最新」は会話ターン境界時刻で判定する（閲覧 keepalive で動く
       // lastActivityMs を使うと「見ているだけの古い会話」が本命を追い越す）。
       const at = session.lastTurnAtMs ?? session.lastActivityMs ?? 0
@@ -1109,9 +1430,11 @@ export class CodexStreamBridge extends EventEmitter {
     if (!cwd || !id || !text) return { status: "not_found" }
     let bySid = null
     const byThread = []
-    for (const session of this.sessions.values()) {
-      if (session.dead || session.cwd !== cwd) continue
-      if (session.stream_id === id) {
+    // 案B: distinct session で走査。id は **任意の購読 stream_id**（primary とは限らない）に
+    // 一致し得るので streamIds.has(id) で判定する（多端末購読の非 primary 端末も宛先にできる）。
+    for (const session of this._liveSessions()) {
+      if (session.cwd !== cwd) continue
+      if (session.streamIds.has(id)) {
         bySid = session
         break // stream_id は一意なので即確定
       }
@@ -1152,15 +1475,26 @@ export class CodexStreamBridge extends EventEmitter {
   }
 
   /**
-   * Stage 5: セッションが「保護対象（reap 不可）」か。= **healthy な running turn**。
-   * activeTurnId が立っており、かつ app-server 通知が STUCK_TTL 以内に届いている（＝生きている
-   * ターン）。activeTurnId が固着したまま通知が STUCK_TTL 途絶えたもの（stuck/ハング）は
-   * protected ではなく reap 対象にする（プロセスリーク・固着の救済）。
+   * Stage 5: セッションが「保護対象（reap 不可）」か。= **healthy な running turn**、
+   * または **in-flight な入力処理中**（codex-review round5 Finding 2 対応）。
+   * - in-flight: 単一 pump が走行中（`pumping`）／未処理 FIFO が残っている（`inputQueue`）／
+   *   turn/start RPC 送信後に turn/started を待っている（`_turnActiveWaiter`）状態。この間は
+   *   `activeTurnId` が未確定（null）でもターンが実際に始まりかけているので、per-cwd / N-cwd /
+   *   idle-TTL いずれでも reap してはいけない（別 attach が Phase 1 を発火した瞬間に処理中
+   *   セッションを殺す事故を防ぐ）。pump は turn/start timeout で必ず有限時間に畳まれるため、
+   *   ここで保護してもハング検出（stuck-turn）が効かなくなることはない。
+   * - healthy running turn: `activeTurnId` が立ち、app-server 通知が STUCK_TTL 以内に届いている。
+   *   activeTurnId 固着で通知が STUCK_TTL 途絶えたもの（stuck/ハング）は protected から外し reap
+   *   対象にする（プロセスリーク・固着の救済）。
    * @param {object} session
    * @param {number} now
    * @returns {boolean}
    */
   _isProtected(session, now) {
+    // in-flight 入力処理中（turn/start RPC 応答待ち等、activeTurnId 未確定でも処理中）を保護。
+    if (session.pumping) return true
+    if (Array.isArray(session.inputQueue) && session.inputQueue.length > 0) return true
+    if (session._turnActiveWaiter) return true
     if (!session.activeTurnId) return false
     return now - (session.lastActivityMs ?? now) <= this._stuckTurnTtlMs
   }
@@ -1169,7 +1503,11 @@ export class CodexStreamBridge extends EventEmitter {
   _reapSession(session, now, reason) {
     if (session.dead) return
     session.dead = true
-    this.sessions.delete(session.stream_id)
+    // round3: reap した session の barrier を解除し queue を reject する（promise 宙吊り防止）。
+    this._settleTurnActiveWaiter(session)
+    this._drainRejectQueue(session, { reason: "queue_dead" })
+    // 案B: 全購読 stream_id キーを Map から外す（primary 1 個だけ消すと dangling が残る）。
+    this._dropAllStreamKeys(session)
     try {
       session.client.stop()
     } catch (err) {
@@ -1182,7 +1520,7 @@ export class CodexStreamBridge extends EventEmitter {
         cwd: session.cwd,
         reason,
         idle_ms: now - (session.lastActivityMs ?? now),
-        live_after: this.sessions.size,
+        live_after: this._liveSessions().length,
       },
       "codex session reaped",
     )
@@ -1195,25 +1533,74 @@ export class CodexStreamBridge extends EventEmitter {
   }
 
   /**
-   * Stage 5: LRU warm pool 上限の超過分を退避する。生存（非 dead）セッションが上限を超えたら、
-   * **非 protected の中で最終活性が最も古いもの**から順に上限まで reap する。protected（healthy
-   * running turn）は退避対象にしないため、全部が busy のときは一時的に上限を超えたまま許容する
-   * （走行中ターンを絶対に殺さない）。genuine attach 直後と reconcile の両方から呼ぶ。
+   * 子⑤ (T06544): warm 保持を「各 cwd 1 本 × 同時 warm 保持する cwd 数 N（既定 20）」で有界化する。
+   * 旧 `_evictWarmPoolOverflow`（マシン全体の総セッション数 LRU=5）を置換し、境界を「総数」ではなく
+   * 「cwd 単位」で定義する（親 T06539「1 cwd 1 本化」に整合）。
+   *   Phase 1 (per-cwd=1): 同一 cwd に 2 本以上の live session があれば、最終活性が最新の 1 本を残し
+   *     残りの **非 protected** を reap する（WS 再接続や別スレッド開始で一時的に増えた重複を畳む）。
+   *   Phase 2 (N-cwd LRU): live session を持つ distinct cwd 数が warmCwdMax を超えたら、cwd の最終活性
+   *     が最も古い cwd から、その cwd の非 protected session を reap して cwd 数を上限まで戻す。
+   * protected（healthy running turn / stuck 未満）は Phase 1/2 いずれでも reap しない（busy 不可侵）。
+   * 全 cwd が busy 等で上限に収められないときは一時的に超過を許容する（走行中ターンを絶対に殺さない）。
+   * 多端末購読は 1 session に集約されるため（_liveSessions で dedup）、purely な多端末利用では
+   * per-cwd=1 は自動的に満たされ、Phase 1 は「同一 cwd に別 app-server が 2 本以上できたとき」だけ発火する。
+   * genuine attach 直後と reconcile の両方から呼ぶ。
    * @param {number} now
-   * @returns {number} 退避した数
+   * @returns {number} reap した数
    */
-  _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)) // 古い順
+  _reconcileWarmBounds(now, reason = "warm-bounds") {
     let evicted = 0
-    for (const s of evictable) {
-      if (evicted >= overflow) break
-      this._reapSession(s, now, reason)
-      evicted += 1
+    // Phase 1: per-cwd=1。cwd ごとに最終活性が新しい順へ並べ、先頭（最新）以外の非 protected を reap。
+    const byCwd = new Map()
+    for (const s of this._liveSessions()) {
+      const list = byCwd.get(s.cwd)
+      if (list) list.push(s)
+      else byCwd.set(s.cwd, [s])
+    }
+    for (const list of byCwd.values()) {
+      if (list.length <= 1) continue
+      // 新しい順。recency 同値は seq（生成順）で必ず新しい方を先頭（= 残す）にする（round5 Finding 1）。
+      list.sort(
+        (a, b) =>
+          (b.lastActivityMs ?? 0) - (a.lastActivityMs ?? 0) || (b.seq ?? 0) - (a.seq ?? 0),
+      )
+      for (let i = 1; i < list.length; i += 1) {
+        if (this._isProtected(list[i], now)) continue // busy は残す（一時的に >1 を許容）
+        this._reapSession(list[i], now, `${reason}:per-cwd`)
+        evicted += 1
+      }
+    }
+    // Phase 2: N-cwd LRU。per-cwd 畳み込み後の live から cwd 単位の recency と protected 有無を集計。
+    const cwdInfo = new Map() // cwd -> { recency, seq, hasProtected, sessions: [] }
+    for (const s of this._liveSessions()) {
+      let info = cwdInfo.get(s.cwd)
+      if (!info) {
+        info = { recency: -Infinity, seq: -Infinity, hasProtected: false, sessions: [] }
+        cwdInfo.set(s.cwd, info)
+      }
+      info.recency = Math.max(info.recency, s.lastActivityMs ?? 0)
+      info.seq = Math.max(info.seq, s.seq ?? 0) // round5 Finding 1: recency 同値の cwd タイブレーク用
+      if (this._isProtected(s, now)) info.hasProtected = true
+      info.sessions.push(s)
+    }
+    const overflow = cwdInfo.size - this._warmCwdMax
+    if (overflow > 0) {
+      // busy を含む cwd は退避対象外（上限にカウントはするが reap しない）。最古 recency の cwd から。
+      // recency 同値は seq（新しさ）で必ず新しい cwd を残す（古い方から evict）。
+      const evictableCwds = Array.from(cwdInfo.values())
+        .filter((info) => !info.hasProtected)
+        .sort((a, b) => a.recency - b.recency || a.seq - b.seq) // 古い順
+      let cwdsEvicted = 0
+      for (const info of evictableCwds) {
+        if (cwdsEvicted >= overflow) break
+        for (const s of info.sessions) {
+          // per-cwd 畳み込み後は各 cwd 1 本のはずだが、念のため非 protected のみ reap。
+          if (this._isProtected(s, now)) continue
+          this._reapSession(s, now, `${reason}:cwd-lru`)
+          evicted += 1
+        }
+        cwdsEvicted += 1
+      }
     }
     return evicted
   }
@@ -1231,8 +1618,8 @@ export class CodexStreamBridge extends EventEmitter {
    *   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。
+   *   3. **warm 境界**（子⑤ T06544）: `_reconcileWarmBounds` で「各 cwd 1 本 × 同時 warm cwd 数 N
+   *      （既定 20）」に有界化。同一 cwd の重複は最新 1 本へ畳み、cwd 数超過は最古 cwd から reap。
    * busy（healthy running turn）は 1〜3 いずれの対象にもならない（走行中ターンを絶対に殺さない）。
    *
    * 旧 `gcAbandonedSessions`（1h 無活性一律 reap）を置換。detach 済み warm セッションを 1h で
@@ -1244,9 +1631,12 @@ export class CodexStreamBridge extends EventEmitter {
   reconcileSessions() {
     const now = Date.now()
     let reaped = 0
+    // 案B: 0. 死端末 GC を先に回す（多端末購読で応答が途絶えた端末を購読集合から掃除）。これで
+    //    「全端末が死んで空になったセッション」が下の idle TTL 経路で正しく reap 対象になる。
+    this.gcDeadTerminals()
     // 1〜2: stuck turn / long idle。protected（healthy running turn）はスキップ。
-    for (const session of Array.from(this.sessions.values())) {
-      if (session.dead) continue
+    // 案B: distinct session で走査（多対一 Map の重複 reap を避ける）。
+    for (const session of this._liveSessions()) {
       if (this._isProtected(session, now)) continue
       const idle = now - (session.lastActivityMs ?? now)
       if (session.activeTurnId && idle > this._stuckTurnTtlMs) {
@@ -1257,8 +1647,8 @@ export class CodexStreamBridge extends EventEmitter {
         reaped += 1
       }
     }
-    // 3: LRU 上限の超過分を退避（stuck/idle reap 後の生存数で判定）。
-    reaped += this._evictWarmPoolOverflow(now, "lru-evict")
+    // 3: warm 境界（per-cwd=1 / N-cwd LRU）を適用（stuck/idle reap 後の生存数で判定）。
+    reaped += this._reconcileWarmBounds(now, "warm-bounds")
     return reaped
   }
 
@@ -1269,8 +1659,12 @@ export class CodexStreamBridge extends EventEmitter {
 
   /** 全セッションを即座に終了する (agent shutdown 用。ターン完走は待たない)。 */
   shutdown() {
-    for (const session of this.sessions.values()) {
+    // 案B: distinct session で走査（多対一 Map の重複 stop を避ける）。
+    for (const session of this._liveSessions()) {
       session.dead = true
+      // round3: shutdown で barrier を解除し queue 入力を reject（promise 宙吊り防止）。
+      this._settleTurnActiveWaiter(session)
+      this._drainRejectQueue(session, { reason: "queue_dead" })
       // hub-agent 再起動時にターン実行中のセッションを落とすと thread が汚染されうる
       // (exec 中の kill → output 欠落)。因果を後から辿れるよう必ず記録する。
       this.logger?.[session.activeTurnId ? "warn" : "info"]?.(