@cocorograph/hub-agent 0.7.80 → 0.7.81

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocorograph/hub-agent",
-  "version": "0.7.80",
+  "version": "0.7.81",
   "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

@@ -2072,6 +2072,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 され残る。