@cocorograph/hub-agent 0.7.80 → 0.7.82

package/package.json

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

package/src/claude-stream-bridge.mjs

@@ -145,6 +145,18 @@ function readNeedsAuthCacheNames() {
 const DEAD_TERMINAL_TTL_MS =
   Number(process.env.HUB_AGENT_DEAD_TERMINAL_TTL_MS) || 60 * 60 * 1000
 
+/** 子⑤ (T06544): warm 保持を「各 cwd 1 本 × 同時 warm 保持する cwd 数 N（既定 20）」で有界化する
+ *  上限（codex-stream-bridge.mjs の WARM_CWD_MAX と対）。claude は従来 per-session の softDetach
+ *  タイマー（7 日）だけで件数上限が無かったため、多数の cwd を渡り歩くと warm セッション（= SDK
+ *  常駐 query プロセス）が N 個を超えて蓄積し得た。cwd 単位の LRU で最古 cwd から早期 reap する。
+ *  env HUB_AGENT_WARM_CWD_MAX で調整可能（codex と共有）。 */
+const WARM_CWD_MAX = Number(process.env.HUB_AGENT_WARM_CWD_MAX) || 20
+
+/** 子⑤ (T06544, codex-review round5 Finding 1): warm 境界の「最新 1 本を残す」判定で recency が
+ *  同一ミリ秒になったときのタイブレーク用の単調増加シーケンス（codex 側 CODEX_SESSION_SEQ と対）。
+ *  生成順が後 = 値が大きい = 新しいので、per-cwd=1 のタイでは必ず新しいセッションを残す。 */
+let CLAUDE_SESSION_SEQ = 0
+
 /**
  * モデル能力レジストリ (2026-07-11): モデル名 → { supportsEffort, supportsXhighEffort }。
  *
@@ -332,6 +344,14 @@ class ClaudeStreamSession {
      *  stream_id が streamIds/sessions に永久残留し、最後の 1 台が外れないと idle softDetach が
      *  起動しないため死端末がセッションを永久に生かしてしまう。 */
     this.lastActivityByStream = new Map([[stream_id, Date.now()]])
+    /** 子⑤ (T06544): session 単位の最終活性時刻。warm 境界（cwd-LRU）の recency 判定に使う。
+     *  lastActivityByStream は detach で端末キーごと削除されるため warm セッションでは空になり
+     *  recency を失う。これは touch() で更新し detach でリセットしないので、warm 化しても「最後に
+     *  使った時刻」が残り、最古 cwd から LRU reap できる。 */
+    this._lastActivityMs = Date.now()
+    /** 子⑤ round5 Finding 1: 生成順の単調増加シーケンス（warm 境界のタイブレーク用。値が大きい =
+     *  新しい）。recency 同値時に per-cwd=1 が新しいセッションを残せるようにする。 */
+    this._seq = CLAUDE_SESSION_SEQ += 1
     this.cwd = cwd
     this.model = model || null
     this.permissionMode = permissionMode || null
@@ -714,6 +734,9 @@ class ClaudeStreamSession {
 
   /** B11: 端末の最終アクティビティ時刻を更新する (死端末 GC の生存判定に使う)。 */
   touch(stream_id) {
+    // 子⑤: warm 境界の cwd-LRU 用に session 単位の最終活性も更新する（detach でリセットしないので
+    // warm 化しても最後の活性時刻が残る）。stream_id の購読有無に関わらず活性シグナルとして扱う。
+    this._lastActivityMs = Date.now()
     if (stream_id && this.streamIds.has(stream_id)) {
       this.lastActivityByStream.set(stream_id, Date.now())
     }
@@ -2569,17 +2592,27 @@ export class ClaudeStreamBridge extends EventEmitter {
     // 常駐化: browser 切断ではセッションを止めない (reap しない)。走行中ターンは完走し、
     // idle のまま IDLE_DETACH_TTL_MS 経過して初めて撤去する。TTL 内に再接続 (再アタッチ)
     // されればキャンセルされる。明示的に止めたい場合は interrupt()/明示終了を使う。
-    s.softDetach(IDLE_DETACH_TTL_MS, () => {
-      this._dropSessionMappings(s)
-      s.close()
+    this._softDetachSession(s)
+    return true
+  }
+
+  /** 子⑤ round5 Finding 3: session を直接 soft-detach（idle TTL で reap）する共通ヘルパー。
+   *  detach() と gcDeadTerminals() の「全端末離脱 → warm 保持」の唯一の入口。
+   *  ⚠️ gcDeadTerminals は死端末の stream_id を先に全削除するため、`this.detach({stream_id})` を
+   *  呼ぶと lookup が undefined を引いて no-op になり、session が「streamIds=0 / _detached=false /
+   *  idle timer 無し / _liveBySession だけに残る」孤児になっていた（20cwd 未満では warm-bounds でも
+   *  回収されない）。stream_id lookup を介さず session を直接 soft-detach することで孤児化を防ぐ。 */
+  _softDetachSession(session) {
+    session.softDetach(IDLE_DETACH_TTL_MS, () => {
+      this._dropSessionMappings(session)
+      session.close()
       this.emit("exit", {
-        stream_id: s.stream_id,
+        stream_id: session.stream_id,
         code: 0,
         reason: "idle-reaped",
-        session_id: s.sessionId,
+        session_id: session.sessionId,
       })
     })
-    return true
   }
 
   /** B11: 多端末共有時に「死端末」(一定期間 input/permission 等の活性が無い購読端末) を
@@ -2613,23 +2646,144 @@ export class ClaudeStreamBridge extends EventEmitter {
         )
       }
       // 全端末が死端末で空になったら、idle softDetach 経路に乗せる (走行中は完走を待つ)。
-      if (session.streamIds.size === 0) {
-        this.detach({ stream_id: session.stream_id })
+      // ⚠️ round5 Finding 3: 上のループで死端末キーを全削除済みのため this.detach({stream_id}) は
+      //    lookup 失敗で no-op になる。session を直接 soft-detach して孤児化を防ぐ。
+      if (session.streamIds.size === 0 && !session._detached && !session._closed) {
+        this._softDetachSession(session)
       }
     }
     return removed
   }
 
+  /** 子⑤ (T06544): warm 境界（cwd-LRU）用の session 単位 recency。attached 端末があればその最新
+   *  活性、warm（端末キーが無い softDetached 状態）なら session._lastActivityMs を使う。detach は
+   *  端末キーごと lastActivityByStream を消すため、warm セッションはこの session 単位の値でしか
+   *  「最後に使った時刻」を判定できない。 */
+  _sessionRecency(session) {
+    let at = session?._lastActivityMs ?? 0
+    for (const t of session?.lastActivityByStream?.values?.() ?? []) {
+      if (t > at) at = t
+    }
+    return at
+  }
+
+  /** 子⑤ round5 Finding 2 対応: warm 境界で reap してはいけない「in-flight」セッション。
+   *  走行中ターン（_busy）に加え、送信待ちの pending がある（現ターン完了時に drain される）
+   *  セッションも保護する（reap すると未処理入力が失われる）。 */
+  _isSessionProtected(session) {
+    if (!session) return false
+    if (session._busy) return true
+    return Array.isArray(session._pendingMessages) && session._pendingMessages.length > 0
+  }
+
+  /** 子⑤: warm 境界超過セッションを reap する（detach の softDetach onTimeout と同じ撤去処理）。 */
+  _reapForWarmBounds(session, reason) {
+    if (!session || session._closed) return
+    this._dropSessionMappings(session)
+    session.close()
+    this.emit("exit", {
+      stream_id: session.stream_id,
+      code: 0,
+      reason: "idle-reaped",
+      session_id: session.sessionId,
+    })
+    this.logger?.info(
+      { stream_id: session.stream_id, session_id: session.sessionId, cwd: session.cwd, reason },
+      "claude session reaped by warm bounds",
+    )
+  }
+
+  /**
+   * 子⑤ (T06544): warm 保持を「各 cwd 1 本 × 同時 warm 保持する cwd 数 N（既定 20）」で有界化する
+   * （codex-stream-bridge.mjs の `_reconcileWarmBounds` と対）。state loop から周期実行する。
+   *   Phase 1 (per-cwd=1): 同一 cwd に 2 本以上の live session があれば最終活性が最新の 1 本を残し、
+   *     残りの **非 busy** を reap する（WS 再接続は購読者追加=同一 session なので通常は発火せず、
+   *     別会話を同一 cwd で開始した等で 2 本目の SDK query ができたときだけ畳む）。
+   *   Phase 2 (N-cwd LRU): live session を持つ distinct cwd 数が上限を超えたら、cwd の最終活性が
+   *     最も古い cwd から、その cwd の非 busy session を reap して cwd 数を上限まで戻す。
+   * busy（走行中ターン）は Phase 1/2 いずれでも reap しない（完走を待つ）。warm セッションは
+   * this.sessions から外れ _liveBySession に残るため、両索引の union を dedup して走査する。
+   * @param {{ maxCwds?: number, now?: number }} [opts] テストから上限/時刻を注入可能。
+   * @returns {number} reap 数
+   */
+  reconcileWarmBounds({ maxCwds = WARM_CWD_MAX, now = Date.now() } = {}) {
+    void now // recency 比較は相対値のため now は将来の拡張用（署名の対称性維持）。
+    const liveSessions = () =>
+      Array.from(new Set([...this.sessions.values(), ...this._liveBySession.values()])).filter(
+        (s) => s && !s._closed,
+      )
+    let reaped = 0
+    // Phase 1: per-cwd=1。cwd ごとに最終活性が新しい順へ並べ、先頭（最新）以外の非 busy を reap。
+    const byCwd = new Map()
+    for (const s of 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) =>
+          this._sessionRecency(b) - this._sessionRecency(a) || (b._seq ?? 0) - (a._seq ?? 0),
+      )
+      for (let i = 1; i < list.length; i += 1) {
+        if (this._isSessionProtected(list[i])) continue // 走行中/pending は不可侵（一時的に >1 を許容）
+        this._reapForWarmBounds(list[i], "warm-bounds:per-cwd")
+        reaped += 1
+      }
+    }
+    // Phase 2: N-cwd LRU。per-cwd 畳み込み後の live から cwd 単位の recency / seq / protected 有無を集計。
+    const cwdInfo = new Map() // cwd -> { recency, seq, hasProtected, sessions: [] }
+    for (const s of liveSessions()) {
+      let info = cwdInfo.get(s.cwd)
+      if (!info) {
+        info = { recency: -Infinity, seq: -Infinity, hasProtected: false, sessions: [] }
+        cwdInfo.set(s.cwd, info)
+      }
+      const r = this._sessionRecency(s)
+      if (r > info.recency) info.recency = r
+      if ((s._seq ?? 0) > info.seq) info.seq = s._seq ?? 0 // round5 Finding 1: cwd タイブレーク用
+      if (this._isSessionProtected(s)) info.hasProtected = true
+      info.sessions.push(s)
+    }
+    const overflow = cwdInfo.size - maxCwds
+    if (overflow > 0) {
+      // protected（走行中/pending）を含む cwd は退避対象外（上限にカウントはするが reap しない）。
+      // 最古 recency の cwd から。recency 同値は seq（新しさ）で必ず新しい cwd を残す。
+      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) {
+          if (this._isSessionProtected(s)) continue
+          this._reapForWarmBounds(s, "warm-bounds:cwd-lru")
+          reaped += 1
+        }
+        cwdsEvicted += 1
+      }
+    }
+    return reaped
+  }
+
   /** 全セッションを強制停止 (agent shutdown 用。実行中ターンも中断する)。 */
   shutdown() {
-    for (const stream_id of Array.from(this.sessions.keys())) {
-      const s = this.sessions.get(stream_id)
-      if (!s) continue
+    // round6 Finding: this.sessions と _liveBySession の union を Set で dedup し、各 session を
+    // 1 回だけ close/exit する。
+    //   ① soft-detach 後に _liveBySession だけに残る warm session も確実に close する
+    //      （旧実装は this.sessions のみ走査 → warm は索引 clear だけで close されず idle timer が漏れた）。
+    //   ② 多端末共有（1 session を複数 stream key が指す）で close/exit が端末数ぶん重複発火するのを防ぐ。
+    const seen = new Set()
+    for (const s of [...this.sessions.values(), ...this._liveBySession.values()]) {
+      if (!s || seen.has(s)) continue
+      seen.add(s)
       s.close()
-      this.sessions.delete(stream_id)
-      this.emit("exit", { stream_id, code: 0, reason: "shutdown", session_id: s.sessionId })
+      this.emit("exit", { stream_id: s.stream_id, code: 0, reason: "shutdown", session_id: s.sessionId })
     }
-    // 常駐化: 再アタッチ索引も全消去 (プロセス終了時の後始末)。
+    // stream key 索引・再アタッチ索引を全消去 (プロセス終了時の後始末)。
+    this.sessions.clear()
     this._liveBySession.clear()
     // MCP control 専用 query も畳む。
     this._teardownMcpControlQuery()

package/src/codex-stream-bridge.mjs

@@ -88,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 な長ターンは
@@ -290,7 +301,7 @@ export class CodexStreamBridge extends EventEmitter {
     logger,
     clientFactory,
     detachTtlMs,
-    warmPoolMax,
+    warmCwdMax,
     stuckTurnTtlMs,
     deadTerminalTtlMs,
     turnStartTimeoutMs,
@@ -304,8 +315,9 @@ 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）。テストから短縮可能。
@@ -409,6 +421,9 @@ export class CodexStreamBridge extends EventEmitter {
       // 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台が外れたら
@@ -545,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,
@@ -1459,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
   }
@@ -1506,26 +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") {
-    // 案B: warm pool 上限は「distinct な生存 session 数」で判定する（購読端末数ではない）。
-    const live = this._liveSessions()
-    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
   }
@@ -1543,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 で
@@ -1572,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
   }
 

package/src/main.mjs

@@ -1515,6 +1515,230 @@ export function _resetContextWindowLearning() {
   lastAssistantModelByChatKey.clear()
 }
 
+/**
+ * session_event の「サイドバー並び順に効くか (sort_affecting)」判定用の per-session 状態。
+ * 「その session-run で実ユーザーターン (prompt_submit) を見たか」を持つ。
+ *
+ * ## なぜ必要か (2026-07-20 実測で確定した現象B の根治)
+ * 死んだ/寝ているセッションを開く=hub-agent が claude を respawn/resume すると、その
+ * 起動・resume の落ち着きで Stop フック (`stop`) や readiness (`ready`)、SessionStart
+ * (`session_start`) が near-now で発火する。frontend は session.event を種別問わず
+ * eventAt の sort key に使うため、ユーザーが 1 ターンも回していないのに「開いた/起こした
+ * だけ」でサイドバー最上位へ浮上していた。
+ *
+ * 対処療法 (フロントで focus 直後の bump を数秒抑制) ではなく、発火源で「ソート信号」と
+ * 「状態信号」を分離する: **並び順は実ユーザーターン (prompt_submit と、それに続く
+ * stop/ready) だけで動かす**。ライフサイクル (session_start/session_end) と、先行する
+ * prompt_submit の無い stop/ready (=起動/resume の落ち着き) は sort_affecting=false とし、
+ * frontend は status ドット用途にのみ使い eventAt は動かさない。
+ */
+const sawUserTurnByName = new Map()
+
+// session 単位で「最後に sort_affecting=true だった event の at」を保持する。
+// event ファイルは 1 session 1 ファイルの上書きで、最新が sort_affecting=false
+// (ready 等) だと直前の実ターン時刻が失われる。これを別途保持し poll (ハードリロード
+// 復元) で配信することで、リロード後に created 順へ退行する劣化を防ぐ (codex-review major#1)。
+const lastSortAffectingAtByName = new Map()
+
+// session 単位で「最後に処理した event の at」。fs.watch の pushFile は session 単位で
+// 直列化されず、古い prompt_submit の readFile が新しい session_start の後に完了して
+// sawUserTurn=true を復活させうる (out-of-order)。at 単調ガードで stale な状態更新を弾く
+// (codex-review major#2)。
+const lastEventAtByName = new Map()
+
+/**
+ * session-event の種別 (と「実ユーザーターンを見たか」) から sort_affecting を導出する純関数。
+ * - prompt_submit: 常に true (ユーザーがターンを開始した)
+ * - session_start / session_end: 常に false (ライフサイクル、ターンではない)
+ * - stop / ready / idle_hint: 直前に prompt_submit があった (sawUserTurn) ときだけ true
+ *   (=起動/resume の落ち着きで出た stop/ready は false)
+ * - 未知種別: 後方互換で true (並び順に効かせる)
+ * @param {string} event
+ * @param {boolean} sawUserTurn
+ * @returns {boolean}
+ */
+export function computeSortAffecting(event, sawUserTurn) {
+  if (event === "prompt_submit") return true
+  if (event === "session_start" || event === "session_end") return false
+  if (event === "stop" || event === "ready" || event === "idle_hint") {
+    return sawUserTurn === true
+  }
+  return true
+}
+
+/**
+ * session-event 種別に応じて sawUserTurnByName を更新する。
+ * - prompt_submit: 実ユーザーターン開始 → true
+ * - session_start / session_end: session-run の境界 → false にリセット
+ *   (次に実 prompt_submit を見るまで stop/ready は sort_affecting=false)
+ * その他の種別ではフラグを変えない (stop/ready は直前の prompt_submit 状態を引き継ぐ)。
+ * @param {string} name tmux session 名
+ * @param {string} event
+ */
+export function updateSawUserTurn(name, event) {
+  if (!name) return
+  if (event === "prompt_submit") sawUserTurnByName.set(name, true)
+  else if (event === "session_start" || event === "session_end") {
+    sawUserTurnByName.set(name, false)
+  }
+}
+
+/**
+ * session-event 1 件を sort_affecting 状態機械に取り込む。at 単調ガードで out-of-order な
+ * stale read を弾き (major#2)、sort_affecting を導出し、true なら sort 時刻を更新する (major#1)。
+ * @param {string} name tmux session 名
+ * @param {string} event 種別
+ * @param {number} at epoch ms
+ * @returns {{ sortAffecting: boolean, sortAffectingAt: number|undefined, stale: boolean }}
+ */
+export function ingestSessionEventForSort(name, event, at) {
+  const prevAt = lastEventAtByName.get(name) ?? 0
+  // stale (この session で処理済みの at より古い) read は状態を汚さない。arm や status は
+  // 呼び出し側で従来通り処理してよいが、sort へは一切効かせない。
+  if (typeof at === "number" && at < prevAt) {
+    return {
+      sortAffecting: false,
+      sortAffectingAt: lastSortAffectingAtByName.get(name),
+      stale: true,
+    }
+  }
+  if (typeof at === "number") lastEventAtByName.set(name, at)
+  updateSawUserTurn(name, event)
+  const sortAffecting = computeSortAffecting(event, sawUserTurnByName.get(name) === true)
+  // sort_affecting=true で前進したときだけ sort 時刻を更新し、sidecar に永続化する (major#1)。
+  // event ファイルは揮発 (最新イベントで上書き) のため、再起動後に「最後の実ターン時刻」を
+  // 復元できるよう別ファイルに残す。冪等な再取込 (at 同値) では書かない。
+  if (sortAffecting && typeof at === "number" && at > (lastSortAffectingAtByName.get(name) ?? 0)) {
+    lastSortAffectingAtByName.set(name, at)
+    writeSortAtSidecar(name, at) // fire-and-forget (エラーは握りつぶす)
+  }
+  return {
+    sortAffecting,
+    sortAffectingAt: lastSortAffectingAtByName.get(name),
+    stale: false,
+  }
+}
+
+/** poll (readAllSessionEvents) 用: この session の「最後に sort に効いた at」を返す (無ければ undefined)。 */
+export function getSortAffectingAt(name) {
+  return lastSortAffectingAtByName.get(name)
+}
+
+// sort 時刻 sidecar の接尾辞。`.json` にしない (readAllSessionEvents / pushFile が
+// `.endsWith(".json")` で event ファイルと誤認しないように)。
+const SORT_AT_SUFFIX = ".sortat"
+
+export function sortAtSidecarPath(name) {
+  return path.join(SESSION_EVENTS_DIR, `${name}${SORT_AT_SUFFIX}`)
+}
+
+// sidecar の write / delete を **session 単位で直列化** する op キュー。write と delete が
+// 双方 fire-and-forget だと「実ターン直後に kill → delete が先に走り (ENOENT)、その後 write の
+// rename が dead sidecar を復活」する競合が起きる (codex-review minor)。enqueue 順 = 実行順を
+// 保証すれば、ingest(write) → forget(delete) の順で delete が後になり sidecar は確実に消える。
+const sidecarOpTailByName = new Map()
+
+function enqueueSidecarOp(name, op) {
+  const prev = sidecarOpTailByName.get(name) ?? Promise.resolve()
+  const next = prev.then(op, op).catch(() => {})
+  sidecarOpTailByName.set(name, next)
+  // 末尾が settle したら Map エントリを掃除 (自分が最新末尾のときだけ; リーク防止)。
+  next.finally(() => {
+    if (sidecarOpTailByName.get(name) === next) sidecarOpTailByName.delete(name)
+  })
+  return next
+}
+
+/**
+ * 「最後の実ターン時刻」を sidecar に atomic 書き出す (major#1 の再起動永続化)。
+ * fire-and-forget だが session 単位で直列化する。event ファイルと別ファイルなので
+ * Python hook の上書きとは競合しない。
+ */
+export function writeSortAtSidecar(name, at) {
+  if (!name || /[/\\]/.test(name) || typeof at !== "number") return Promise.resolve()
+  return enqueueSidecarOp(name, async () => {
+    const fp = sortAtSidecarPath(name)
+    const tmp = `${fp}.tmp.${randomUUID()}`
+    try {
+      await mkdir(SESSION_EVENTS_DIR, { recursive: true })
+      await writeFile(tmp, JSON.stringify({ sort_at: at }))
+      await rename(tmp, fp)
+    } catch {
+      try {
+        await unlink(tmp)
+      } catch {
+        /* ignore */
+      }
+    }
+  })
+}
+
+/**
+ * forget 時に sidecar を消す (死名が再起動シードで復活しないように; codex-review minor)。
+ * write と同じ session 単位キューに載せ、先行 write の後に必ず delete が走るようにする。
+ */
+export function deleteSortAtSidecar(name) {
+  if (!name || /[/\\]/.test(name)) return Promise.resolve()
+  return enqueueSidecarOp(name, async () => {
+    try {
+      await unlink(sortAtSidecarPath(name))
+    } catch {
+      /* 無ければ無視 */
+    }
+  })
+}
+
+/**
+ * 起動時シード: sidecar から「最後の実ターン時刻」を復元する。揮発 event ファイルではなく
+ * sidecar を正本にすることで、最新イベントが session_start/resume 由来 (sort_affecting=false)
+ * でもその near-now at で現象B を再発させない (codex-review major#1 の再репро対策)。
+ */
+export async function seedSortAtFromSidecars() {
+  let files
+  try {
+    files = await readdir(SESSION_EVENTS_DIR)
+  } catch {
+    return
+  }
+  for (const f of files) {
+    if (!f.endsWith(SORT_AT_SUFFIX)) continue
+    const name = f.slice(0, -SORT_AT_SUFFIX.length)
+    try {
+      const data = JSON.parse(await readFile(path.join(SESSION_EVENTS_DIR, f), "utf-8"))
+      if (data && typeof data.sort_at === "number") seedSortAffectingAt(name, data.sort_at)
+    } catch {
+      /* 壊れた sidecar は無視 */
+    }
+  }
+}
+
+/**
+ * sort 時刻の初期値を設定する (sidecar シード専用)。既存値は上書きしない。
+ * @param {string} name
+ * @param {number} at
+ */
+export function seedSortAffectingAt(name, at) {
+  if (!name || typeof at !== "number") return
+  if (!lastSortAffectingAtByName.has(name)) lastSortAffectingAtByName.set(name, at)
+  if ((lastEventAtByName.get(name) ?? 0) < at) lastEventAtByName.set(name, at)
+}
+
+/** session 終了 (session.gone / kill / GC) 時に sort_affecting 状態を破棄する (リーク防止)。 */
+export function forgetSortAffectingState(name) {
+  if (!name) return
+  sawUserTurnByName.delete(name)
+  lastSortAffectingAtByName.delete(name)
+  lastEventAtByName.delete(name)
+  deleteSortAtSidecar(name) // 永続 sidecar も消す (再起動シードでの死名復活防止)
+}
+
+/** テスト用: sort_affecting 状態を全リセットする。 */
+export function _resetSawUserTurn() {
+  sawUserTurnByName.clear()
+  lastSortAffectingAtByName.clear()
+  lastEventAtByName.clear()
+}
+
 /**
  * sort 用の session-event ファイルをチャットのターン境界で書き出す
  * (`/tmp/cockpit_session_events/<tmux名>.json`)。bundle hook が TUI で書くものと
@@ -1565,6 +1789,15 @@ async function readAllSessionEvents() {
       out.set(sessionName, {
         event: data.event,
         at: typeof data.at === "number" ? data.at : Date.now(),
+        // ポーリング経路 (ハードリロード時の eventAt 復元) でも push 経路と同じ
+        // sort_affecting を frontend へ伝える。map (watcher が最新化) を参照する。
+        sort_affecting: computeSortAffecting(
+          data.event,
+          sawUserTurnByName.get(sessionName) === true,
+        ),
+        // major#1: 最新 event が sort_affecting=false でも、直前の実ターン時刻を
+        // frontend へ渡して created 順への退行を防ぐ。frontend はこの値で eventAt を復元する。
+        sort_affecting_at: getSortAffectingAt(sessionName),
       })
     } catch {
       // 一時欠如 / parse 失敗は無視
@@ -1641,6 +1874,11 @@ async function startSessionEventWatcher({ client, logger, readinessTracker }) {
           readinessTracker.arm(sessionName)
         }
       }
+      // sort_affecting 判定を状態機械へ委譲する: at 単調ガードで out-of-order な stale read を
+      // 弾き (major#2)、prompt_submit/session_start で状態遷移し、sort_affecting=true なら
+      // sort 時刻を更新する (major#1)。arm や status push は従来通り (stale でも status は最新化)。
+      const at = typeof data.at === "number" ? data.at : Date.now()
+      const { sortAffecting } = ingestSessionEventForSort(sessionName, data.event, at)
       // 計装 (2026-06-19, 既定 OFF=2026-06-20): ターン境界イベントと arm を記録する。常時 info は
       // ログ肥大の主因のため HUB_AGENT_STATE_TRACE=1 のときだけ出す(障害解析時に有効化)。
       if (STATE_TRACE) {
@@ -1649,6 +1887,7 @@ async function startSessionEventWatcher({ client, logger, readinessTracker }) {
             session_name: sessionName,
             event: data.event,
             armed: readinessTracker ? readinessTracker.isArmed(sessionName) : undefined,
+            sort_affecting: sortAffecting,
           },
           "session.event push",
         )
@@ -1657,13 +1896,20 @@ async function startSessionEventWatcher({ client, logger, readinessTracker }) {
         type: "session.event",
         session_name: sessionName,
         event: data.event,
-        at: typeof data.at === "number" ? data.at : Date.now(),
+        at,
+        // false=ライフサイクル/resume 落ち着き由来 → frontend は status のみ更新し並び順は動かさない。
+        sort_affecting: sortAffecting,
       })
     } catch {
       // 一時欠如 / parse 失敗等は無視 (次の変更で読み直す)
     }
   }
 
+  // major#1 再起動ケア: pushFile より前に、sidecar から「最後の実ターン時刻」をシードする。
+  // 揮発 event ファイル (最新イベントで上書き) からはシードしない。最新が session_start/resume
+  // 由来 (sort_affecting=false) の near-now at をシードすると現象B が再発するため (codex-review)。
+  await seedSortAtFromSidecars()
+
   // 起動時に既存ファイルを 1 回読んで初期 push (再起動後に取りこぼし防止)
   try {
     const files = await readdir(SESSION_EVENTS_DIR)
@@ -2072,6 +2318,14 @@ export function startStateLoop({ client, plugins, logger, intervalMs, claudeBrid
       } catch (err) {
         logger?.warn({ err: err?.message }, "gcDeadTerminals failed")
       }
+      // 子⑤ (T06544): claude 側 warm 境界（per-cwd=1 / N-cwd LRU）。従来 claude は per-session の
+      // softDetach タイマー（7 日）だけで件数上限が無かったため、多数の cwd を渡り歩くと warm な
+      // SDK 常駐 query が蓄積し得た。codex の reconcileSessions と対で cwd 単位に有界化する。
+      try {
+        claudeBridge?.reconcileWarmBounds?.()
+      } catch (err) {
+        logger?.warn({ err: err?.message }, "claude reconcileWarmBounds failed")
+      }
       // Codex 版 (claude の gcDeadTerminals と対): detach を送らず消えた / turn/completed が
       // 来ず activeTurnId が固着したスタックセッションの app-server を回収する (プロセス
       // リーク・生成中固着の根治)。進行中の正常ターンは app-server 通知で touch され残る。
@@ -2335,6 +2589,7 @@ export function startStateLoop({ client, plugins, logger, intervalMs, claudeBrid
             invalidateSessionCache(name) // capture/cwd/statusGate/spinnerFreeze/stability (state.mjs)
             stallTracker.forget(name) // StallTracker.byName
             readinessTracker?.forget?.(name) // ReadinessTracker.byName
+            forgetSortAffectingState(name) // sawUserTurn / sort_affecting_at / lastEventAt (リーク防止)
             lastByName.delete(name)
             outputFlowByName.delete(name)
             lastTurnAtByName.delete(name)
@@ -2889,6 +3144,7 @@ export async function handleKillSession(msg, ctx) {
     } catch {
       /* ignore */
     }
+    forgetSortAffectingState(name) // sort_affecting 状態のリーク防止 (kill 経路)
   }
 }
 
@@ -3893,6 +4149,9 @@ async function dispatch(msg, ctx) {
                 event: lastEvent.event,
                 at: lastEvent.at,
                 replay: true,
+                // この再配信は bind(=フォーカス) 契機の status 復旧専用。並び順は絶対に
+                // 動かさない (フォーカスで浮上させない現象B 根治の一部)。
+                sort_affecting: false,
               })
             }
           }