@cocorograph/hub-agent 0.7.79 → 0.7.81

package/package.json

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

package/src/claude-stream-bridge.mjs

@@ -122,20 +122,20 @@ function readNeedsAuthCacheNames() {
   }
 }
 
-/** 多端末共有セッション (2026-05-30)。同じ Claude セッション (session_id) を複数端末で
- *  同時に開いて、どの端末でもライブ表示・入力・許可応答できるようにする。env
- *  HUB_AGENT_CHAT_SHARED="1" で有効化 (デフォルト無効 = 従来の「最後の端末だけが live」)。
+/** 多端末共有セッション (2026-05-30、T06542 で既定 ON 化・フラグ撤去)。同じ Claude セッション
+ *  (session_id) を複数端末で同時に開いて、どの端末でもライブ表示・入力・許可応答できる。
  *
- *  有効時の差分:
- *   - reattach で旧 stream_id を sessions Map から消さず、1 セッションに複数の端末
- *     stream_id を購読登録する (this.streamIds)。これにより旧端末からの input /
- *     permission.reply / interrupt も sessions.get(stream_id) で解決できる。
- *   - detach は購読端末の参照カウントを下げ、最後の 1 台が外れて初めて idle softDetach
- *     する (1 台閉じただけで走行中セッションを撤去しない)。
- *  配信のファンアウト自体は Hub backend が session_id 単位の group broadcast で行うため、
- *  agent 側はイベントに session_id を載せるだけでよい (既に emit 済み)。無効時は従来の
- *  単一 stream_id 挙動と完全に一致する (this.streamIds は未使用のまま)。 */
-const CHAT_SHARED_ENABLED = process.env.HUB_AGENT_CHAT_SHARED === "1"
+ *  挙動 (常時):
+ *   - reattach で旧 stream_id を sessions Map から消さず、1 セッションに複数の端末 stream_id を
+ *     購読登録する (this.streamIds)。これにより旧端末からの input / permission.reply / interrupt
+ *     も sessions.get(stream_id) で解決できる。
+ *   - detach は購読端末の参照カウントを下げ、最後の 1 台が外れて初めて idle softDetach する
+ *     (1 台閉じただけで走行中セッションを撤去しない)。
+ *  配信のファンアウト自体は Hub backend が session_id 単位の group broadcast で行うため、agent 側は
+ *  イベントに session_id を載せるだけでよい (既に emit 済み)。
+ *
+ *  ⚠️ 旧 env `HUB_AGENT_CHAT_SHARED` は撤去した (T06542)。以前フラグ OFF だと「最後の端末だけ
+ *  live」に退行し、環境間で挙動が割れる事故源だったため、単一挙動へ一本化した (Codex 側 案B と対称)。 */
 
 /** B11: 多端末共有時、一定期間 input/permission 等の活性が無い購読端末キーを死端末とみなして
  *  GC する閾値 (ミリ秒)。端末がクラッシュして claude.detach を送らず消えると streamIds /
@@ -145,6 +145,18 @@ const CHAT_SHARED_ENABLED = process.env.HUB_AGENT_CHAT_SHARED === "1"
 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 }。
  *
@@ -322,16 +334,24 @@ class ClaudeStreamSession {
     onTurnSettled,
   }) {
     this.stream_id = stream_id
-    /** 多端末共有: このセッションを購読中の全端末 stream_id。CHAT_SHARED_ENABLED 時のみ
-     *  参照され、reattach で増え detach で減る。最後の 1 台が外れると idle softDetach に入る。
+    /** 多端末共有 (T06542 で常時): このセッションを購読中の全端末 stream_id。reattach で増え
+     *  detach で減る。最後の 1 台が外れると idle softDetach に入る。
      *  this.stream_id は「最も新しく attach した端末」= legacy emit / primary 用に残す。 */
     this.streamIds = new Set([stream_id])
     /** B11: 購読端末ごとの最終アクティビティ時刻 (epoch ms)。attach / reattach / input /
-     *  permission 応答で更新する。CHAT_SHARED_ENABLED 時に「死端末 GC」が参照し、一定期間
-     *  無活動の購読端末キーを掃除する。これが無いと端末がクラッシュして claude.detach を
-     *  送らず消えると stream_id が streamIds/sessions に永久残留し、最後の 1 台が外れないと
-     *  idle softDetach が起動しないため死端末がセッションを永久に生かしてしまう。 */
+     *  permission 応答で更新する。「死端末 GC」(gcDeadTerminals) が参照し、一定期間 無活動の
+     *  購読端末キーを掃除する。これが無いと端末がクラッシュして claude.detach を送らず消えると
+     *  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())
     }
@@ -1866,12 +1889,9 @@ export class ClaudeStreamBridge extends EventEmitter {
       //    ユニークだが異常系でも cwd を跨がない)。
       const live = this._liveBySession.get(this._liveKeyFor(scwd, resumeSessionId))
       if (live && !live._closed) {
-        // 多端末共有 (CHAT_SHARED_ENABLED): 旧 stream_id を Map から消さない。同一セッションを
-        // 複数端末が購読する状態を作り、どの端末の input/permission/interrupt も解決できるように
-        // する。無効時は従来どおり旧 stream_id を撤去し「最後の 1 端末だけ live」に戻す。
-        if (!CHAT_SHARED_ENABLED) {
-          this.sessions.delete(live.stream_id)
-        }
+        // 多端末共有 (T06542 で常時): 旧 stream_id を Map から消さない。同一セッションを複数端末が
+        // 購読する状態を作り、どの端末の input/permission/interrupt も解決できるようにする
+        // (旧端末は reattach.streamIds に足され、backend が session group へ fan-out する)。
         // 改修5: 再アタッチ時に model/permission/maxThinkingTokens を引き継ぎ反映する。
         // browser はバッジ変更時に新しい値を載せた claude.attach を同一 resume で送る
         // ため、ここで適用すると常駐 query を維持したまま次ターンから切り替わる。
@@ -2052,6 +2072,11 @@ export class ClaudeStreamBridge extends EventEmitter {
       this.logger?.warn({ stream_id, request_id }, "claude.permission.reply but stream missing")
       return false
     }
+    // T06542 バグ修正: 許可応答も端末の活性シグナル。touch を呼ばないと「入力せず許可応答だけを
+    // 返し続ける端末」が lastActivityByStream 未更新のまま gcDeadTerminals(1h) に死端末として掃除され、
+    // 以降その端末からの入力/応答が stream_missing になる (session 定義コメント「permission 応答で
+    // 更新する」と実装が不一致だった)。多端末共有を常時 ON 化すると顕在化するためここで直す。
+    s.touch(stream_id)
     const decision = allow
       ? { behavior: "allow", updatedInput: updatedInput || {} }
       : { behavior: "deny", message: denyMessage || "denied by user" }
@@ -2550,46 +2575,53 @@ export class ClaudeStreamBridge extends EventEmitter {
   detach({ stream_id }) {
     const s = this.sessions.get(stream_id)
     if (!s) return false
-    // 多端末共有: この端末分の購読だけ外す。まだ他端末が見ているならセッションは生かし、
-    // softDetach (idle 撤去タイマー) には入らない。最後の 1 台が外れたときだけ従来の
-    // idle softDetach に進む。無効時は streamIds が常に 1 要素なので即 softDetach に落ちる。
-    if (CHAT_SHARED_ENABLED) {
-      s.streamIds.delete(stream_id)
-      s.lastActivityByStream.delete(stream_id) // B11: 活性記録も掃除
-      if (this.sessions.get(stream_id) === s) this.sessions.delete(stream_id)
-      if (s.streamIds.size > 0) {
-        // primary を生存端末へ寄せ替え (legacy emit / softDetach 撤去ログ用)。
-        // 末尾 (最も新しく購読した端末) を .at(-1) で明示的に選ぶ。
-        if (s.stream_id === stream_id) {
-          s.stream_id = Array.from(s.streamIds).at(-1)
-        }
-        return true
+    // 多端末共有 (T06542 で常時): この端末分の購読だけ外す。まだ他端末が見ているならセッションは
+    // 生かし、softDetach (idle 撤去タイマー) には入らない。最後の 1 台が外れたときだけ従来の
+    // idle softDetach に進む。
+    s.streamIds.delete(stream_id)
+    s.lastActivityByStream.delete(stream_id) // B11: 活性記録も掃除
+    if (this.sessions.get(stream_id) === s) this.sessions.delete(stream_id)
+    if (s.streamIds.size > 0) {
+      // primary を生存端末へ寄せ替え (legacy emit / softDetach 撤去ログ用)。
+      // 末尾 (最も新しく購読した端末) を .at(-1) で明示的に選ぶ。
+      if (s.stream_id === stream_id) {
+        s.stream_id = Array.from(s.streamIds).at(-1)
       }
+      return true
     }
     // 常駐化: 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 等の活性が無い購読端末) を
    *  GC する。端末がクラッシュして claude.detach を送らず消えた stream_id を掃除し、最後の
    *  1 台が外れたら通常の idle softDetach (走行中は完走を待つ) に進ませる。state loop など
-   *  既存の定期ループから呼ぶ想定。CHAT_SHARED_ENABLED 無効時は何もしない。
+   *  既存の定期ループから呼ぶ想定 (T06542 で常時有効)。
    *  @param {number} [ttlMs] 死端末とみなす無活性閾値 (テスト用に上書き可)。
    *  @returns {number} GC した端末キー数。 */
   gcDeadTerminals(ttlMs = DEAD_TERMINAL_TTL_MS) {
-    if (!CHAT_SHARED_ENABLED) return 0
     const now = Date.now()
     let removed = 0
     for (const session of new Set(this.sessions.values())) {
@@ -2614,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()