@cocorograph/hub-agent 0.7.73 → 0.7.75

package/package.json

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

package/src/claude-stream-bridge.mjs

@@ -1729,6 +1729,13 @@ export class ClaudeStreamBridge extends EventEmitter {
     this._mcpControlStarting = null
   }
 
+  /** _liveBySession の複合キー (T06271): cwd を含めることで、別 workspace の同一 session_id を
+   *  別エントリに分離し、resume/reattach が cwd 境界を越えないことを保証する。session_id は
+   *  本来ユニークだが、異常系 (別 cwd で同一 id) でも越境させないための機構キー。 */
+  _liveKeyFor(cwd, sessionId) {
+    return cwd && sessionId ? cwd + "\u0000" + sessionId : null
+  }
+
   /** 多端末共有: あるセッションに紐づく全端末 stream_id を sessions Map から外し、
    *  session_id 索引も掃除する。撤去 (reap / idle / shutdown) で 1 端末分だけ消すと
    *  他端末キーが Map に残って孤児化するため、まとめて消す。 */
@@ -1741,8 +1748,9 @@ export class ClaudeStreamBridge extends EventEmitter {
     if (this.sessions.get(session.stream_id) === session) {
       this.sessions.delete(session.stream_id)
     }
-    if (session.sessionId && this._liveBySession.get(session.sessionId) === session) {
-      this._liveBySession.delete(session.sessionId)
+    const curKey = this._liveKeyFor(session.cwd, session.sessionId)
+    if (curKey && this._liveBySession.get(curKey) === session) {
+      this._liveBySession.delete(curKey)
     }
     // SDK-P0-4 (2026-07-13): session_id 回転前に登録した旧キーも外す (現 sessionId しか見ないと
     // 旧 id → 死んだ session のエントリが残り、attach が孤児を引き当てる)。
@@ -1765,8 +1773,25 @@ export class ClaudeStreamBridge extends EventEmitter {
   stopSessionsFor({ cwd, session_id } = {}) {
     const victims = new Set()
     if (session_id) {
-      const s = this._liveBySession.get(session_id)
-      if (s) victims.add(s)
+      // 複合キー化 (T06271) で session_id 単独では引けないため values を走査して拾う。
+      // ⚠️ cwd 境界 (T06271 レビュー6): cwd 指定時は session_id 照合も **同 cwd に限定** する。
+      //    複合キー化後も別 cwd に同一 session_id の session が併存し得るため、全 cwd を union
+      //    すると A の cwd bind で B (別 cwd) の同一 R まで停止してしまう (実再現 stopped=2)。
+      const idMatches = []
+      for (const s of this._liveBySession.values()) {
+        if (s.sessionId !== session_id) continue
+        if (cwd && s.cwd !== cwd) continue
+        idMatches.push(s)
+      }
+      if (!cwd && idMatches.length > 1) {
+        // cwd 未指定で session_id が複数 cwd に一致 = どれを止めるべきか曖昧。推測停止しない。
+        this.logger?.warn?.(
+          { session_id, matches: idMatches.length },
+          "stopSessionsFor: session_id が複数 cwd に一致。cwd 未指定のため停止をスキップ (曖昧)",
+        )
+      } else {
+        for (const s of idMatches) victims.add(s)
+      }
     }
     if (cwd) {
       for (const s of this._liveBySession.values()) {
@@ -1827,12 +1852,19 @@ export class ClaudeStreamBridge extends EventEmitter {
     if (this.sessions.has(stream_id)) {
       throw new Error(`stream_id "${stream_id}" は既に attach 済みです`)
     }
+    // cwd を 1 回だけ解決し、reattach lookup / session 生成 / 索引登録で同じ値を使う
+    // (複合キーの整合性を保つため)。
+    const scwd = cwd || process.env.HOME || process.cwd()
     // 常駐化: resume_session_id が示すセッションが (走行中 / idle 問わず) まだ生存していれば、
     // 新規 query を起動せずそのセッションへ再アタッチする。これにより端末スリープ/再接続でも
     // ターンは落ちず、以降のイベントは新しい stream_id 経由でライブに流れる
     // (= 通常の生成中表示と同じ)。再接続前の確定分は browser の jsonl hydrate で復元する。
     if (resumeSessionId) {
-      const live = this._liveBySession.get(resumeSessionId)
+      // ⚠️ cwd 境界 (T06271): _liveBySession は **複合キー (cwd+session_id)** なので、別 cwd の
+      //    同一 session_id は別エントリに分離される。よって cwd=A の resume を cwd=B から
+      //    attach しても引き当たらず、越境 reattach が原理的に起きない (session_id は本来
+      //    ユニークだが異常系でも cwd を跨がない)。
+      const live = this._liveBySession.get(this._liveKeyFor(scwd, resumeSessionId))
       if (live && !live._closed) {
         // 多端末共有 (CHAT_SHARED_ENABLED): 旧 stream_id を Map から消さない。同一セッションを
         // 複数端末が購読する状態を作り、どの端末の input/permission/interrupt も解決できるように
@@ -1868,7 +1900,7 @@ export class ClaudeStreamBridge extends EventEmitter {
     }
     const session = new ClaudeStreamSession({
       stream_id,
-      cwd: cwd || process.env.HOME || process.cwd(),
+      cwd: scwd,
       model: model || null,
       permissionMode: permissionMode || null,
       maxTurns: typeof maxTurns === "number" ? maxTurns : null,
@@ -1894,14 +1926,17 @@ export class ClaudeStreamBridge extends EventEmitter {
         // 意図しない live session を引き当てる (+ Map リーク)。登録済みキーを覚えておき、
         // 回転を検知したら旧キーを外してから張り替える。
         if (session.sessionId) {
+          // 複合キー (cwd+session_id)。別 cwd の同一 session_id は別キーになるため、B の onEvent が
+          // A の索引を奪わない (T06271 レビュー5: cwd ガードだけでは onEvent の無条件 set が穴だった)。
+          const key = this._liveKeyFor(session.cwd, session.sessionId)
           const prevKey = session._liveKey
-          if (prevKey && prevKey !== session.sessionId) {
+          if (prevKey && prevKey !== key) {
             if (this._liveBySession.get(prevKey) === session) {
               this._liveBySession.delete(prevKey)
             }
           }
-          session._liveKey = session.sessionId
-          this._liveBySession.set(session.sessionId, session)
+          session._liveKey = key
+          this._liveBySession.set(key, session)
         }
       },
       onPermission: ({ tool_name, input, request_id }) => {
@@ -1955,6 +1990,18 @@ export class ClaudeStreamBridge extends EventEmitter {
       },
     })
     this.sessions.set(stream_id, session)
+    // ⚠️ resume 索引を attach 時に **同期登録** する (T06271 レビュー3 major①)。従来は onEvent
+    // (SDK が session_id を確定させた後) でしか _liveBySession に載せていなかったため、input 前に
+    // 同一 resumeSessionId で 2 回 attach すると「索引が空の窓」で上の reattach 判定 (1835) をすり抜け、
+    // 同じ session_id の別 session が 2 本でき、sendToStream が先頭へ推測注入していた。attach は
+    // get(reattach)→set まで await を挟まず同期なので、ここで登録すれば 2 本目の attach は必ず
+    // reattach 経路に入り重複が生じない。session_id が回転 (clear/compaction) したら onEvent が張り替える。
+    // ⚠️ 複合キー (cwd+session_id) で登録するため、別 cwd の同一 session_id を奪わない (T06271)。
+    if (resumeSessionId) {
+      const key = this._liveKeyFor(scwd, resumeSessionId)
+      session._liveKey = key
+      this._liveBySession.set(key, session)
+    }
     this.logger?.info(
       { stream_id, cwd: session.cwd, model: session.model, resume: !!resumeSessionId },
       "claude stream attached",
@@ -2303,6 +2350,61 @@ export class ClaudeStreamBridge extends EventEmitter {
     return true
   }
 
+  /**
+   * 指定 session_id のライブセッションへメッセージを直接注入する (sibling-inject の
+   * **明示宛先指定** 用、2026-07-19 / T06271)。sendToCwd は「cwd 内で最終活性が最新の
+   * もの」をヒューリスティックに選ぶため、同一 cwd に複数の生きた claude セッションが
+   * 同居すると意図しないセッション (詰まった巨大セッション等) へ誤爆する。呼び出し側が
+   * describeLiveSessions で得た session_id を明示すれば、この曖昧さを回避できる。
+   *
+   * ⚠️ セキュリティ (cwd 境界): 呼び出し元 sibling-inject.mjs のトークンは **cwd スコープ**
+   * (`verifySiblingToken(cwd, token)`) のため、cwd=A のトークンで cwd=B の session_id を
+   * 指定した越境注入を防ぐには、**このメソッド側で cwd 一致を必須化する**必要がある
+   * (session_id だけで全 sessions を走査すると、別 cwd のセッションへ注入できてしまう)。
+   * よって cwd と session_id の **両方** が一致した場合のみ注入する。
+   *
+   * ⚠️ 一意性 (T06271 レビュー3): session_id は「1 論理セッションに一意」なはずだが、resume
+   * 索引 (`_liveBySession`) を **attach 時に同期登録**するようにして初めて成立する不変条件。
+   * それでも競合の防御網として、同一 cwd で session_id が複数一致したら **推測せず ambiguous**
+   * を返す (codex の thread_id 重複と対称)。
+   *
+   * @param {string} cwd 呼び出し元がトークン検証した cwd (この cwd のセッションにのみ注入)
+   * @param {string} sessionId 宛先 session_id (describeLiveSessions の session_id)
+   * @param {string} text
+   * @returns {{status: "delivered", session: object} | {status: "not_found"} | {status: "ambiguous", candidates: object[]}}
+   */
+  sendToStream(cwd, sessionId, text) {
+    if (!cwd || !sessionId || !text) return { status: "not_found" }
+    const now = Date.now()
+    const seen = new Set()
+    const matches = []
+    for (const session of this.sessions.values()) {
+      if (seen.has(session)) continue
+      seen.add(session)
+      if (session.cwd !== cwd || session.sessionId !== sessionId) continue
+      matches.push(session)
+    }
+    if (matches.length === 0) return { status: "not_found" }
+    const describe = (s) => {
+      let at = 0
+      for (const t of s.lastActivityByStream?.values?.() ?? []) {
+        if (t > at) at = t
+      }
+      return { kind: "claude", cwd: s.cwd, session_id: s.sessionId, idle_ms: at ? now - at : -1 }
+    }
+    if (matches.length > 1) {
+      // 同一 session_id の別 session が複数 = resume 競合。推測せず ambiguous (誤爆防止)。
+      return { status: "ambiguous", candidates: matches.map(describe) }
+    }
+    matches[0].sendMessage({ role: "user", content: text }).catch((err) => {
+      this.logger?.error(
+        { session_id: sessionId, err: err?.message },
+        "sendToStream: sendMessage threw unexpectedly",
+      )
+    })
+    return { status: "delivered", session: describe(matches[0]) }
+  }
+
   /**
    * `mcpServerStatus()` の結果に、needs-auth キャッシュにあるが結果へ含まれない
    * サーバーを `needs-auth` として補完する。

package/src/codex-stream-bridge.mjs

@@ -61,35 +61,42 @@ function siblingEnvFor(cwd) {
   }
 }
 
-// ⚠️ 2026-07-17 の事故 (「Codex チャットが 5 分で消え ask-sibling が届かない」) の教訓:
-// この TTL は **detach 済み (= ブラウザが居なくなった) セッション専用** の猶予である。
-// 旧実装は (a) detach の有無を記録せず turn/completed のたびに無条件でタイマーを張り、
-// (b) タイマー発火時に activeTurnId を再チェックしなかったため、
-//   - ブラウザを開いたままでも「最後のターン完了から 5 分」で app-server が kill され、
-//   - その 5 分間に ask-sibling が新ターンを注入すると **exec 実行中に kill** され、
-//     rollout に output の無い custom_tool_call が残って thread が永久に汚染された
-//     (codex_core の `Custom tool call output is missing for call id: ...` が以後の
-//      全ターンで出続ける)。
-// 予約は detach 済みセッションに限り、発火時にも busy/再活性を再確認すること。
-// detach 後、非 busy なセッションを生かしておく猶予。claude 側 (7 日) と違い短くする:
-// この TTL は **in-memory reattach の猶予窓** を兼ねる。WS が切れて browser disconnect が
-// codex.detach を送っても、この TTL 内に **同じ attach_id で再接続** すれば _tryReattach が
-// その session を新 stream へ付け替えて拾える (fresh 直後 rollout 0件の会話も復元可)。TTL を
-// 超えて reap されたら、再接続は通常経路 (thread/resume は rollout 正本から復元、または fresh)
-// にフォールスルーする。7 日だと再接続チャーンのたびにプロセスが積み上がる (リーク) ため短命に
-// する。ターン実行中は TTL に
-// 関わらず完走まで絶対に落とさない (_maybeReapAfterIdle が busy 中は予約しない)。
-const IDLE_DETACH_TTL_MS = 5 * 60 * 1000
+// ── Stage 5 (2026-07-19): bounded warm pool + 長 idle TTL への再設計 ───────────
+// 旧設計: detach → **5 分** の per-session タイマーで reap（`_maybeReapAfterIdle`）＋
+// 1h の無活性 reaper（`gcAbandonedSessions`）。これは codex-review のように 1 ターンが
+// 数分〜数十分かかり、かつ **別 CLI 画面（claude チャット）から呼ぶため codex 画面が非
+// アクティブ = detach 済み**になる用途で、「ターン完了後 5 分の idle で reaped → 次の依頼が
+// 届かない」構造的ミスマッチを生んでいた（2026-07-19 調査）。
+//
+// 新設計: **周期 reconcile 一本化**（`reconcileSessions`、state loop から ~5s 毎）。
+//   - detach してもすぐ殺さず、**長 idle TTL（既定 7 日、claude softDetach と同思想）** で
+//     warm 保持する。
+//   - 際限ないプロセス蓄積は **LRU 件数上限（既定 5、マシン全体）** で防ぐ。6 個目が来たら
+//     最も使っていない **非 protected** セッションを 1 個 reap。旧「5 分で殺す」の代わりに
+//     「上限で天井を作る」ことで、TTL を長くしてもリークしない（T06500 の churn 削減も前提）。
+//   - **busy（healthy running turn）は絶対に reap しない**（TTL でも LRU でも）。
+//   - **stuck turn**（activeTurnId 固着だが app-server 通知が STUCK_TTL 途絶えた＝ハング）は
+//     protected から外れ、別途 reap 対象（プロセスリーク・固着の救済）。
+// これにより意味論は「**閲覧中＝無期限（keepalive で LRU 先頭維持）/ 直近 5 セッションは
+// detach しても 7 日 warm / 上限超過は LRU で 1 個 reap / busy は不可侵 / stuck は救済**」。
+
+// warm 保持の idle TTL（非 busy がこの時間 無活性なら reap の対象。上限内でも 7 日で頭打ち）。
+const IDLE_DETACH_TTL_MS =
+  Number(process.env.HUB_AGENT_CODEX_IDLE_DETACH_TTL_MS) || 7 * 24 * 60 * 60 * 1000
+
+// 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
 
-// 放棄セッションの reaper 閾値。claude-stream-bridge.mjs の gcDeadTerminals と同じ思想・
-// 同じ env (HUB_AGENT_DEAD_TERMINAL_TTL_MS、既定 1 時間)。detach を送らず消えた端末や、
-// codex エラーで turn/completed が来ず activeTurnId が固着したスタックセッションは、
-// detach→TTL(5分) の graceful reap 経路に乗らないため app-server が永久に残る (リーク)。
-// これを補い、「一定時間まったく通信 (browser 入力 / app-server 通知) が無い」セッションを
-// activeTurnId の有無に関わらず定期回収する。進行中の正常なターンは app-server 通知で
-// 都度 touch されるため回収されない (通知が途絶えたスタックターンのみ回収される)。
-const ABANDONED_SESSION_TTL_MS =
-  Number(process.env.HUB_AGENT_DEAD_TERMINAL_TTL_MS) || 60 * 60 * 1000
+// stuck turn 検出の閾値。activeTurnId が立っているのに app-server 通知がこの時間途絶えた
+// セッションは「ハングしたターン」とみなし protected から外して reap する（healthy な長ターンは
+// reasoning/output delta で都度 touch されるため該当しない）。旧 `HUB_AGENT_DEAD_TERMINAL_TTL_MS`
+// を後方互換で受ける。既定 1h。
+const STUCK_TURN_TTL_MS =
+  Number(process.env.HUB_AGENT_CODEX_STUCK_TURN_TTL_MS) ||
+  Number(process.env.HUB_AGENT_DEAD_TERMINAL_TTL_MS) ||
+  60 * 60 * 1000
 
 const CLIENT_INFO = { name: "cockpit-hub-agent", title: "Cockpit", version: "1.0.0" }
 
@@ -235,6 +242,8 @@ export class CodexStreamBridge extends EventEmitter {
     logger,
     clientFactory,
     detachTtlMs,
+    warmPoolMax,
+    stuckTurnTtlMs,
     rolloutPresence,
     historyMaxItems,
     historyMaxBytes,
@@ -243,8 +252,12 @@ export class CodexStreamBridge extends EventEmitter {
     this.codexCmd = codexCmd
     this.logger = logger
     this._clientFactory = clientFactory || ((opts) => new CodexAppServerClient(opts))
-    // テストから TTL を短縮できるよう注入可能にする (既定は 7 日)。
+    // Stage 5: warm 保持の idle TTL（既定 7 日）。テストから短縮できるよう注入可能。
     this._detachTtlMs = detachTtlMs ?? IDLE_DETACH_TTL_MS
+    // Stage 5: LRU warm pool 上限（既定 5）。テストから小さい値を注入可能。
+    this._warmPoolMax = warmPoolMax ?? WARM_POOL_MAX
+    // Stage 5: stuck turn 検出 TTL（既定 1h）。テストから短縮可能。
+    this._stuckTurnTtlMs = stuckTurnTtlMs ?? STUCK_TURN_TTL_MS
     // #4 失敗分類の rollout 存在チェック (tri-state。テストから注入可能)。
     this._rolloutPresence = rolloutPresence || codexRolloutPresence
     // T06499: 履歴 hydrate の上限 (テストから小さい値を注入可能)。
@@ -318,14 +331,15 @@ export class CodexStreamBridge extends EventEmitter {
       threadId: null,
       activeTurnId: null,
       pendingApprovals: new Map(), // request_id -> { turnId }
-      detachTimer: null,
-      // ブラウザから codex.detach を受け取った (= 画面の持ち主が居なくなった) か。
-      // アイドル TTL reap は **このフラグが立っているセッションだけ** が対象。
+      // ブラウザから codex.detach を受け取った (= 画面の持ち主が居なくなった) か。診断・ログ用。
+      // Stage 5: 回収の可否は detachRequested ではなく lastActivityMs（LRU）と activeTurnId
+      // （busy/stuck）で決める。detach してもすぐには殺さず warm 保持する。
       // ask-sibling 注入 (sendToCwd) は「新しい持ち主が付いた」とみなして false に戻す。
       detachRequested: false,
       dead: false,
-      // 放棄セッション reaper (gcAbandonedSessions) 用の最終活性時刻。browser 入力と
-      // app-server 通知 (ターン進捗) の両方で更新する。Date.now() は hub-agent 実行環境で利用可。
+      // Stage 5 reconcile（LRU / idle TTL / stuck）用の最終活性時刻。browser 入力と app-server
+      // 通知 (ターン進捗) の両方で更新する。LRU は「最終活性が最も古い非 protected」を退避する。
+      // Date.now() は hub-agent 実行環境で利用可。
       lastActivityMs: Date.now(),
       ready: null,
     }
@@ -389,6 +403,10 @@ export class CodexStreamBridge extends EventEmitter {
         },
         "codex session attached",
       )
+      // Stage 5: genuine attach で 1 プロセス増えたので、LRU 上限の超過分を即時退避する
+      // （次の reconnect まで ~5s 待たず、6 個目の app-server が居座るのを防ぐ）。新セッションは
+      // たった今 touch 済み = LRU 先頭なので退避対象にならず、最も古い非 protected が落ちる。
+      this._evictWarmPoolOverflow(Date.now(), "lru-evict-on-attach")
       return {
         resuming,
         threadId: session.threadId,
@@ -444,7 +462,6 @@ export class CodexStreamBridge extends EventEmitter {
     this.sessions.delete(originalStreamId)
     session.stream_id = newStreamId
     session.detachRequested = false
-    this._cancelIdleReap(session, "reattach")
     session.lastActivityMs = Date.now()
     this.sessions.set(newStreamId, session)
     this.logger?.info?.(
@@ -573,9 +590,8 @@ export class CodexStreamBridge extends EventEmitter {
       case "turn/completed":
         session.activeTurnId = null
         this._autoResolveStalePendingApprovals(session, msg.params?.turn?.id)
-        // ⚠️ detach 済みのときだけ再評価する。ブラウザが繋がったままのセッションは
-        // ターンが終わっても生かし続ける (_maybeReapAfterIdle 内でも二重に guard)。
-        this._maybeReapAfterIdle(session, "turn-completed-after-detach")
+        // Stage 5: turn 完了後の reap 予約は不要。以降 idle になれば周期 reconcile が
+        // 長 idle TTL / LRU で扱う（detach 済みでも 7 日 warm 保持）。
         break
       default:
         break
@@ -615,7 +631,6 @@ export class CodexStreamBridge extends EventEmitter {
   _onClientExit(session, info) {
     if (session.dead) return
     session.dead = true
-    this._clearDetachTimer(session)
     this.sessions.delete(session.stream_id)
     // app-server の終了は必ず記録する。ターン実行中の exit は「rollout に output 欠落の
     // custom_tool_call を残した可能性がある」= thread 汚染の予兆なので warn で出す
@@ -665,11 +680,9 @@ export class CodexStreamBridge extends EventEmitter {
    */
   async input({ stream_id, message, model, effort }) {
     const session = this._require(stream_id)
+    // Stage 5: _touch で lastActivityMs を更新 = LRU 先頭へ。ターン開始で activeTurnId が
+    // 立ち、reconcile は healthy busy を protected 扱いにするので実行中に kill されない。
     this._touch(session)
-    // TTL 待ちのセッションに新ターンを流す = まだ使われている。予約を解除しないと
-    // ターン実行中 (exec 中) に kill され、rollout に output 欠落の custom_tool_call が
-    // 残って thread が汚染される (2026-07-17 の事故)。
-    this._cancelIdleReap(session, "input")
     const input = userInputFromMessage(message)
     if (session.activeTurnId) {
       try {
@@ -718,7 +731,6 @@ export class CodexStreamBridge extends EventEmitter {
   async interrupt({ stream_id }) {
     const session = this._require(stream_id)
     this._touch(session)
-    this._cancelIdleReap(session, "interrupt")
     if (!session.activeTurnId) return
     await session.client.request("turn/interrupt", {
       threadId: session.threadId,
@@ -730,7 +742,6 @@ export class CodexStreamBridge extends EventEmitter {
   permissionReply({ stream_id, request_id, result }) {
     const session = this._require(stream_id)
     this._touch(session)
-    this._cancelIdleReap(session, "permission-reply")
     if (!session.pendingApprovals.has(request_id)) {
       this.logger?.warn?.({ stream_id, request_id }, "codex permissionReply: unknown request_id (ignored)")
       return
@@ -742,13 +753,9 @@ export class CodexStreamBridge extends EventEmitter {
   /**
    * ブラウザ閲覧中の生存シグナル (codex.keepalive)。frontend が Codex チャットを開いて
    * いる間だけ定期送信するため、これが届く = 「人が見ている」の観測可能な証跡になる。
-   * gcAbandonedSessions は lastActivityMs しか見ないので、touch するだけで
-   * 「開いたまま無入力でも 1h で殺される」ギャップが閉じる (TTL の数字を増やす必要は無い)。
-   *
-   * ⚠️ 意図的に `_cancelIdleReap` を **呼ばない**。detach 済みセッションの 5 分 TTL は
-   * 「ブラウザが去った」という別事実に基づく予約であり、detach と in-flight keepalive が
-   * 競合しても予約を解除しない (= 明示 detach は必ず 5 分で回収される) 方が意味論が明快。
-   * 閲覧を再開したブラウザは必ず attach を送り直すので、再養子はそちらの経路で足りる。
+   * Stage 5: touch で lastActivityMs を更新すると LRU 先頭に留まるため、**閲覧中のセッションは
+   * 上限超過の LRU 退避対象にならず、長 idle TTL でも殺されない**（= 実質無期限）。ブラウザを
+   * 閉じれば keepalive も止まり、以降は detach 済み warm として LRU / 7 日 idle TTL に従う。
    *
    * @returns {boolean} 生きているセッションを touch できたら true (未知 stream は false)。
    */
@@ -760,9 +767,9 @@ export class CodexStreamBridge extends EventEmitter {
   }
 
   /**
-   * グレースフル切断。ターン実行中は完走を待ち、非 busy ならアイドル TTL 後に
-   * プロセスを reap する (claude-stream-bridge.mjs の softDetach と同じ思想。
-   * Slice 2 は多端末共有非対応なので detach = そのまま TTL 予約でよい)。
+   * グレースフル切断（Stage 5）。**すぐには reap しない**。detachRequested を立てて
+   * warm 保持し、以降は周期 reconcile（LRU 上限 / 長 idle TTL / stuck）に委ねる。これにより
+   * 「別 CLI 画面へ切替えた瞬間 5 分で殺される」問題を解消し、直近 5 セッションは 7 日 warm に。
    */
   detach({ stream_id }) {
     const session = this.sessions.get(stream_id)
@@ -775,9 +782,8 @@ export class CodexStreamBridge extends EventEmitter {
         cwd: session.cwd,
         busy: !!session.activeTurnId,
       },
-      "codex detach requested by browser",
+      "codex detach requested by browser (kept warm; reconcile handles reap)",
     )
-    this._maybeReapAfterIdle(session, "detach")
   }
 
   /**
@@ -862,10 +868,11 @@ export class CodexStreamBridge extends EventEmitter {
       )
       return false
     }
-    // TTL 待ち (browser detach 済み) のセッションでも、ask-sibling が使うなら
-    // 「新しい持ち主が付いた」とみなして回収予約を解除する。これをしないと
-    // 注入したターンの実行中に kill され、thread が汚染される (2026-07-17)。
-    this._cancelIdleReap(best, "sendToCwd (ask-sibling injection)", { readopt: true })
+    // detach 済み warm セッションでも、ask-sibling が使うなら「新しい持ち主が付いた」とみなして
+    // detachRequested を解除し touch する（LRU 先頭へ）。this.input が改めて _touch するが、注入前に
+    // 明示しておく。ターン実行中は healthy busy = protected なので reconcile で kill されない。
+    best.detachRequested = false
+    this._touch(best)
     this.logger?.info?.(
       {
         cwd,
@@ -888,92 +895,144 @@ export class CodexStreamBridge extends EventEmitter {
   }
 
   /**
-   * detach 済み・非 busy なセッションに「アイドル TTL 後の回収」を予約する。
+   * 指定した id (stream_id もしくは thread_id) のライブセッションへ直接注入する
+   * (sibling-inject の **明示宛先指定** 用、2026-07-19 / T06271)。sendToCwd は cwd 内で
+   * 最終活性が最新のものを選ぶヒューリスティックのため、同一 cwd に複数の生きた codex
+   * セッションが同居すると誤爆する。呼び出し側が describeLiveSessions で得た id を明示
+   * すれば曖昧さを回避できる。
    *
-   * ⚠️ 予約は `detachRequested` が立っているセッションのみ。ブラウザが繋がったままの
-   * セッションを turn/completed 契機で殺してはいけない (2026-07-17 の事故)。
-   * @param {object} session
-   * @param {string} trigger 予約理由 (ログ用: 'detach' | 'turn-completed-after-detach')
+   * stream_id は WS 再接続 / in-memory reattach で付け替わる (不安定) 一方、thread_id は
+   * 会話に固定 (安定) なので、**両方を受け付け** どちらで指定しても解決できるようにする。
+   * Claude 版 `sendToStream` の対。
+   *
+   * ⚠️ セキュリティ (cwd 境界): 呼び出し元 sibling-inject.mjs のトークンは **cwd スコープ**
+   * のため、cwd=A のトークンで cwd=B の stream_id/thread_id を指定した越境注入を防ぐには、
+   * **このメソッド側で cwd 一致を必須化する** (id だけで全 sessions を走査すると別 cwd の
+   * セッションへ注入できてしまう)。cwd と id の **両方** が一致した場合のみ注入する。
+   *
+   * ⚠️ 一意性 (T06271 レビュー major③): stream_id は各 live app-server で一意だが、
+   * **thread_id は一意でない** — 同一 thread を複数回 resume/handover すると同じ thread_id を
+   * 持つ live セッションが同一 cwd に複数併存し得る。そのため:
+   *   1. まず stream_id の完全一致を優先 (常に一意に定まる)
+   *   2. stream_id で当たらなければ thread_id で照合し、**複数一致なら注入せず ambiguous を返す**
+   *      (Map 先頭を選ぶと明示指定が再び推測になるため)
+   *
+   * @param {string} cwd 呼び出し元がトークン検証した cwd (この cwd のセッションにのみ注入)
+   * @param {string} id 宛先 stream_id (一意・推奨) または thread_id
+   * @param {string} text
+   * @returns {{status: "delivered", session: object} | {status: "not_found"} | {status: "ambiguous", candidates: object[]}}
    */
-  _maybeReapAfterIdle(session, trigger = "detach") {
-    if (!session.detachRequested) return // ブラウザが居る → 回収対象外
-    if (session.activeTurnId) return // 完走まで待つ (turn/completed で再評価される)
-    this._clearDetachTimer(session)
-    session.detachTimer = setTimeout(() => {
-      if (session.dead) return
-      // 発火時の再確認: TTL 中に ask-sibling 注入 (sendToCwd) で再活性化した、または
-      // 新しいターンが走り出したセッションを **実行中に kill しない** (rollout に
-      // output 欠落の custom_tool_call を残さないため)。
-      if (!session.detachRequested) {
-        this.logger?.info?.(
-          { stream_id: session.stream_id, thread_id: session.threadId, cwd: session.cwd },
-          "codex idle reap canceled at fire time (session re-adopted)",
-        )
-        session.detachTimer = null
-        return
+  sendToStream(cwd, id, text) {
+    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) {
+        bySid = session
+        break // stream_id は一意なので即確定
       }
-      if (session.activeTurnId) {
-        this.logger?.info?.(
-          {
-            stream_id: session.stream_id,
-            thread_id: session.threadId,
-            cwd: session.cwd,
-            turn_id: session.activeTurnId,
-          },
-          "codex idle reap deferred (turn in progress; will re-arm on turn/completed)",
-        )
-        session.detachTimer = null
-        return
+      if (session.threadId === id) byThread.push(session)
+    }
+    let target = bySid
+    if (!target) {
+      if (byThread.length > 1) {
+        return { status: "ambiguous", candidates: byThread.map((s) => this._describe(s)) }
       }
-      this.logger?.info?.(
-        {
-          stream_id: session.stream_id,
-          thread_id: session.threadId,
-          cwd: session.cwd,
-          ttl_ms: this._detachTtlMs,
-          reason: "idle-detach-ttl",
-        },
-        "codex session reaped (detached and idle past TTL)",
-      )
+      target = byThread[0] || null
+    }
+    if (!target) return { status: "not_found" }
+    // detach 済み warm セッションでも、明示指定で使うなら「新しい持ち主が付いた」とみなす
+    // (sendToCwd と同じ扱い)。
+    target.detachRequested = false
+    this._touch(target)
+    this.input({ stream_id: target.stream_id, message: { role: "user", content: text } }).catch(
+      (err) => {
+        this.logger?.error(
+          { id, stream_id: target.stream_id, err: err?.message },
+          "sendToStream: input threw unexpectedly",
+        )
+      },
+    )
+    return { status: "delivered", session: this._describe(target) }
+  }
+
+  /** describeLiveSessions と同形の 1 セッション記述子 (sendToStream の結果整形に共用)。 */
+  _describe(session) {
+    return {
+      kind: "codex",
+      cwd: session.cwd,
+      stream_id: session.stream_id,
+      thread_id: session.threadId || null,
+      busy: !!session.activeTurnId,
+    }
+  }
+
+  /**
+   * Stage 5: セッションが「保護対象（reap 不可）」か。= **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) {
+    if (!session.activeTurnId) return false
+    return now - (session.lastActivityMs ?? now) <= this._stuckTurnTtlMs
+  }
+
+  /** 実際に app-server を止めてセッションを撤去し exit を emit する（reconcile 共通処理）。 */
+  _reapSession(session, now, reason) {
+    if (session.dead) return
+    session.dead = true
+    this.sessions.delete(session.stream_id)
+    try {
       session.client.stop()
-    }, this._detachTtlMs)
-    session.detachTimer.unref?.()
+    } catch (err) {
+      this.logger?.warn?.({ stream_id: session.stream_id, err: err?.message }, "codex reap: stop threw")
+    }
     this.logger?.info?.(
       {
         stream_id: session.stream_id,
         thread_id: session.threadId,
         cwd: session.cwd,
-        ttl_ms: this._detachTtlMs,
-        trigger,
+        reason,
+        idle_ms: now - (session.lastActivityMs ?? now),
+        live_after: this.sessions.size,
       },
-      "codex idle reap armed (browser detached)",
+      "codex session reaped",
     )
+    this.emit("exit", {
+      stream_id: session.stream_id,
+      thread_id: session.threadId,
+      code: 0,
+      reason: "idle-reaped",
+    })
   }
 
   /**
-   * 予約済みのアイドル回収を取り消す。ブラウザ入力 / ask-sibling 注入 / 承認応答など
-   * 「このセッションはまだ使われている」証跡が出たら必ず呼ぶ。
-   * @param {object} session
-   * @param {string} reason ログ用
-   * @param {boolean} readopt true なら detachRequested も解除 (新しい持ち主が付いた)
+   * Stage 5: LRU warm pool 上限の超過分を退避する。生存（非 dead）セッションが上限を超えたら、
+   * **非 protected の中で最終活性が最も古いもの**から順に上限まで reap する。protected（healthy
+   * running turn）は退避対象にしないため、全部が busy のときは一時的に上限を超えたまま許容する
+   * （走行中ターンを絶対に殺さない）。genuine attach 直後と reconcile の両方から呼ぶ。
+   * @param {number} now
+   * @returns {number} 退避した数
    */
-  _cancelIdleReap(session, reason, { readopt = false } = {}) {
-    const had = !!session.detachTimer
-    this._clearDetachTimer(session)
-    if (readopt) session.detachRequested = false
-    if (had) {
-      this.logger?.info?.(
-        { stream_id: session.stream_id, thread_id: session.threadId, cwd: session.cwd, reason },
-        "codex idle reap canceled (session active again)",
-      )
-    }
-  }
-
-  _clearDetachTimer(session) {
-    if (session.detachTimer) {
-      clearTimeout(session.detachTimer)
-      session.detachTimer = null
+  _evictWarmPoolOverflow(now, reason = "lru-evict") {
+    const live = Array.from(this.sessions.values()).filter((s) => !s.dead)
+    const overflow = live.length - this._warmPoolMax
+    if (overflow <= 0) return 0
+    const evictable = live
+      .filter((s) => !this._isProtected(s, now))
+      .sort((a, b) => (a.lastActivityMs ?? 0) - (b.lastActivityMs ?? 0)) // 古い順
+    let evicted = 0
+    for (const s of evictable) {
+      if (evicted >= overflow) break
+      this._reapSession(s, now, reason)
+      evicted += 1
     }
+    return evicted
   }
 
   _require(stream_id) {
@@ -985,64 +1044,49 @@ export class CodexStreamBridge extends EventEmitter {
   }
 
   /**
-   * 放棄セッションの reaper。claude-stream-bridge.mjs の gcDeadTerminals と同じ思想:
-   * 一定時間まったく通信 (browser 入力 / app-server 通知) が無いセッションの app-server を
-   * 停止して回収する。detach を送らず消えた端末や、codex エラーで turn/completed が来ず
-   * activeTurnId が固着したスタックターンは detach→TTL の graceful reap 経路に乗らないため、
-   * これが唯一の回収経路になる (プロセスリーク / 生成中固着の根治)。
+   * Stage 5: セッションの周期 reconcile（state loop から ~5s 毎に実行）。以下を 1 パスで行う:
+   *   1. **stuck turn**: activeTurnId 固着だが app-server 通知が STUCK_TTL 途絶えた（ハング）→ reap
+   *      （healthy な長ターンは reasoning/output delta で touch されるため該当しない）。
+   *   2. **long idle**: 非 busy が idle TTL（既定 7 日）無活性 → reap（warm 保持の期限切れ）。
+   *   3. **LRU 上限**: 生存数が warmPoolMax（既定 5）を超えたら、非 protected の最終活性が
+   *      最も古いものから上限まで reap。
+   * busy（healthy running turn）は 1〜3 いずれの対象にもならない（走行中ターンを絶対に殺さない）。
    *
-   * 進行中の正常なターンは app-server 通知で都度 touch されるので回収されない。
-   * main.mjs の state loop から claudeBridge.gcDeadTerminals と並べて定期実行する想定。
+   * 旧 `gcAbandonedSessions`（1h 無活性一律 reap）を置換。detach 済み warm セッションを 1h で
+   * 殺していた挙動を廃し、上限＋長 TTL に一本化した。main.mjs の state loop 呼び出しは
+   * 後方互換のため `gcAbandonedSessions` エイリアスを残す。
    *
-   * この reaper は `detachRequested` を **意図的に参照しない**。detach を送れずに消えた
-   * ブラウザ (タブごとクラッシュ / 端末スリープ) は detachRequested が立たないまま残るため、
-   * ここでフラグを見ると回収不能になりリークする。「無通信が続いた事実」だけで回収する。
-   *
-   * 閲覧中の誤爆は keepalive で防ぐ (2026-07-17 に解消。旧: 開いたままでも 1h 無入力で
-   * 回収されていた)。frontend は Codex チャットを開いている間 codex.keepalive を定期送信し、
-   * keepalive() が lastActivityMs を touch する。ブラウザが閉じれば keepalive も止まるので
-   * この reaper は本来の orphan GC として正しく効く。CockpitTerminal.tsx の PTY keepalive
-   * (pty.resize で lastSeenAt を触る) と同じ構造。結果として TTL の意味は
-   * 「ブラウザ開 = 無期限 / 明示 detach = 5 分 / ブラウザ落ち = 1h reaper」に整理され、
-   * 「N 時間放置しても生きていてほしい」という数字合わせ自体が不要になった。
-   *
-   * @param {number} [ttlMs] 無通信とみなす閾値 (テスト用に上書き可)。
    * @returns {number} 回収したセッション数。
    */
-  gcAbandonedSessions(ttlMs = ABANDONED_SESSION_TTL_MS) {
+  reconcileSessions() {
     const now = Date.now()
     let reaped = 0
+    // 1〜2: stuck turn / long idle。protected（healthy running turn）はスキップ。
     for (const session of Array.from(this.sessions.values())) {
       if (session.dead) continue
-      const last = session.lastActivityMs ?? 0
-      if (now - last < ttlMs) continue
-      this._clearDetachTimer(session)
-      session.dead = true
-      this.sessions.delete(session.stream_id)
-      try {
-        session.client.stop()
-      } catch (err) {
-        this.logger?.warn?.({ stream_id: session.stream_id, err: err?.message }, "gcAbandonedSessions: stop threw")
+      if (this._isProtected(session, now)) continue
+      const idle = now - (session.lastActivityMs ?? now)
+      if (session.activeTurnId && idle > this._stuckTurnTtlMs) {
+        this._reapSession(session, now, "stuck-turn")
+        reaped += 1
+      } else if (!session.activeTurnId && idle > this._detachTtlMs) {
+        this._reapSession(session, now, "idle-ttl")
+        reaped += 1
       }
-      reaped += 1
-      this.logger?.info?.(
-        { stream_id: session.stream_id, thread_id: session.threadId, idle_ms: now - last },
-        "codex abandoned session reaped (no activity past TTL)",
-      )
-      this.emit("exit", {
-        stream_id: session.stream_id,
-        thread_id: session.threadId,
-        code: 0,
-        reason: "idle-reaped",
-      })
     }
+    // 3: LRU 上限の超過分を退避（stuck/idle reap 後の生存数で判定）。
+    reaped += this._evictWarmPoolOverflow(now, "lru-evict")
     return reaped
   }
 
+  /** 後方互換エイリアス（main.mjs state loop が呼ぶ）。中身は reconcileSessions。 */
+  gcAbandonedSessions() {
+    return this.reconcileSessions()
+  }
+
   /** 全セッションを即座に終了する (agent shutdown 用。ターン完走は待たない)。 */
   shutdown() {
     for (const session of this.sessions.values()) {
-      this._clearDetachTimer(session)
       session.dead = true
       // hub-agent 再起動時にターン実行中のセッションを落とすと thread が汚染されうる
       // (exec 中の kill → output 欠落)。因果を後から辿れるよう必ず記録する。

package/src/main.mjs

@@ -4399,11 +4399,23 @@ async function dispatch(msg, ctx) {
         }
         try {
           const sessions = await ctx.codexBridge.listThreads({ cwd, limit })
+          // Stage 5 ③: 各 thread に「hub-agent 側で app-server が live か / busy か」を付す。
+          // rollout 由来の一覧（listThreads）は live 状態を知らないため、describeLiveSessions
+          // の thread_id → {live, busy} を併合する。browser は sidebar に live/reaped ドットを出す。
+          const liveByThread = new Map()
+          for (const s of ctx.codexBridge.describeLiveSessions(cwd)) {
+            if (s.thread_id) liveByThread.set(s.thread_id, { live: true, busy: !!s.busy })
+          }
+          const withLive = sessions.map((t) => ({
+            ...t,
+            live: liveByThread.get(t.thread_id)?.live === true,
+            busy: liveByThread.get(t.thread_id)?.busy === true,
+          }))
           ctx.client.send({
             type: "codex.sessions.response",
             stream_id,
             cwd,
-            sessions,
+            sessions: withLive,
           })
         } catch (err) {
           ctx.client.send({

package/src/sibling-inject.mjs

@@ -16,9 +16,17 @@
  * `src/sibling-token.mjs` の cwd スコープ capability トークンによる検証を必須とする。
  * トークンが一致しない要求は無視し (実行せず削除)、warn ログのみ残す。
  *
- * 契約: request file `<request_id>.json` = `{cwd, target_cli_kind, text, token}`。
+ * 契約: request file `<request_id>.json` は op で 3 形態 (2026-07-19 / T06271):
+ *   - 通常注入 (op 無し): `{cwd, target_cli_kind, text, token}`
+ *       cwd 内が 1 本なら注入、複数なら黙って推測せず `ambiguous_target` + 候補一覧。
+ *   - 明示注入: `{op:"inject", cwd, target_cli_kind, token, target_session_id, message}`
+ *       本文は **top-level text ではなく `message`** に入れる。これにより旧 hub-agent は
+ *       `!text` で `invalid_request` を返し (推測注入せず fail-closed)、明示宛先を解釈できる
+ *       新 agent だけが処理する (probe を挟まず単一リクエストで TOCTOU を排除)。
+ *       宛先は session_id(claude) / stream_id・thread_id(codex) を cwd 一致下に確定解決。
+ *   - 一覧: `{op:"list", cwd, target_cli_kind, token}` → `{ok, live_sessions}` (--list 用)。
  * 処理後は必ず削除し (成否問わず)、呼び出し側が待ち受けられるよう
- * `<request_id>.result.json` = `{ok, error?}` を書く。
+ * `<request_id>.result.json` = `{ok, error?, delivered_to?, candidates?, live_sessions?, hint?}` を書く。
  */
 
 import { watch } from "node:fs"
@@ -100,23 +108,104 @@ export class SiblingInjectBridge {
       return
     }
 
-    const { cwd, target_cli_kind, text, token } = body || {}
+    // 契約の 3 形態を op で判別する:
+    //   - op:"list"   → 候補列挙 (top-level text 無し)
+    //   - op:"inject" → 明示宛先 (target_session_id + message、top-level text は **持たない**)
+    //   - op 無し     → 通常 (cwd 最新、top-level text あり) ← 旧 agent と後方互換
+    // ⚠️ 明示宛先を「op:inject + message (top-level text 無し)」にするのが fail-closed の肝
+    //    (T06271 レビュー major①): 旧 hub-agent は `!text` で invalid_request を返すため、
+    //    未知フィールドを無視して sendToCwd 推測注入する事故が **単一リクエストで原理的に
+    //    起きない** (probe→注入の TOCTOU を排除)。
+    const { op, cwd, target_cli_kind, text, message, token, target_session_id } = body || {}
+    const isList = op === "list"
+    const isExplicit = op === "inject"
     let result
-    if (!cwd || !text || (target_cli_kind !== "claude" && target_cli_kind !== "codex")) {
+    const badKind = target_cli_kind !== "claude" && target_cli_kind !== "codex"
+    const badBody = isList
+      ? false
+      : isExplicit
+        ? !target_session_id || !message // 明示は id と message 必須 (空指定 fail-open を防ぐ)
+        : !text // 通常は top-level text 必須 (＝旧契約)
+    if (!cwd || badKind || badBody) {
       result = { ok: false, error: "invalid_request" }
     } else if (!verifySiblingToken(cwd, token)) {
       this.logger?.warn({ cwd, request_id }, "sibling-inject: token mismatch, request denied")
       result = { ok: false, error: "invalid_token" }
     } else {
       const bridge = target_cli_kind === "codex" ? this.codexBridge : this.claudeBridge
-      const sent = bridge?.sendToCwd?.(cwd, text) ?? false
-      result = sent
-        ? { ok: true }
-        : { ok: false, error: "no_live_session_for_cwd", ...this._diagnose(cwd, target_cli_kind) }
+      if (isList) {
+        // 宛先候補の列挙 (cockpit_orch.py --list 用)。この cwd の同種セッションを返す。
+        result = { ok: true, live_sessions: bridge?.describeLiveSessions?.(cwd) ?? [] }
+      } else if (isExplicit) {
+        // 明示宛先: session_id (claude) / stream_id|thread_id (codex) で cwd 一致下に確定解決。
+        // sendToStream は {status:"delivered"|"not_found"|"ambiguous"} を返す。
+        const r = bridge?.sendToStream?.(cwd, target_session_id, message) ?? { status: "not_found" }
+        if (r.status === "delivered") {
+          result = { ok: true, delivered_to: r.session }
+        } else if (r.status === "ambiguous") {
+          // 宛先 id が同一 cwd の複数 live セッションに一致し一意に定まらない。
+          // ⚠️ 解消手段は CLI で異なる (T06271 レビュー4 minor):
+          //   - codex: stream_id は一意なので stream_id で名指しできる
+          //   - claude: 一意な宛先指定子が無い (session_id は重複、stream_id は非公開) ため
+          //     --to では解消不能。Cockpit で該当チャットを開き直す / 再一覧を案内する
+          result = {
+            ok: false,
+            error: "ambiguous_target",
+            candidates: r.candidates,
+            live_sessions: r.candidates,
+            hint:
+              target_cli_kind === "codex"
+                ? `指定した id (${target_session_id}) はこの cwd で複数の live セッションに一致します。` +
+                  `stream_id で名指ししてください (--list で確認)。`
+                : `指定した session_id (${target_session_id}) がこの cwd で複数の live セッションに ` +
+                  `一致します。Claude は一意な宛先指定子が無いため --to では解消できません。Cockpit で` +
+                  `対象 cwd の Claude チャットを開き直して1本に整理してから再送してください` +
+                  `(通常は attach 時の重複解消で発生しません)。`,
+          }
+        } else {
+          result = {
+            ok: false,
+            error: "target_session_not_found",
+            target_session_id,
+            // ⚠️ _diagnose の hint は「対象 CLI 不在」前提で id 不一致 (別 cwd 指定含む) では矛盾
+            //    する ("claude は無い" と誤表示) ため、id 不一致専用の hint に差し替える。
+            live_sessions: this._diagnose(cwd, target_cli_kind).live_sessions,
+            hint:
+              `指定した宛先 id (${target_session_id}) はこの cwd (${cwd}) の生きた ` +
+              `${target_cli_kind} セッションに見つかりません (別 cwd の id は越境注入できません)。` +
+              `--list で候補を確認してください。`,
+          }
+        }
+      } else {
+        // 宛先省略 (通常): 同一 cwd の生きたセッション数で分岐。
+        //   0 本 → no_live_session / 1 本 → 注入 / 複数 → 黙って推測せず ambiguous_target。
+        const sameCwd = bridge?.describeLiveSessions?.(cwd) ?? []
+        if (sameCwd.length > 1) {
+          result = {
+            ok: false,
+            error: "ambiguous_target",
+            candidates: sameCwd,
+            live_sessions: sameCwd,
+          }
+        } else {
+          const sent = bridge?.sendToCwd?.(cwd, text) ?? false
+          result = sent
+            ? { ok: true, delivered_to: sameCwd[0] ?? null }
+            : { ok: false, error: "no_live_session_for_cwd", ...this._diagnose(cwd, target_cli_kind) }
+        }
+      }
     }
 
     this.logger?.[result.ok ? "info" : "warn"]?.(
-      { request_id, cwd, target_cli_kind, ...(result.ok ? {} : { error: result.error, live_sessions: result.live_sessions }) },
+      {
+        request_id,
+        cwd,
+        target_cli_kind,
+        op: op || "normal",
+        ...(result.ok
+          ? { delivered_to: result.delivered_to }
+          : { error: result.error, live_sessions: result.live_sessions }),
+      },
       result.ok ? "sibling-inject delivered" : "sibling-inject failed",
     )
     await this._writeResult(request_id, result)
@@ -136,22 +225,26 @@ export class SiblingInjectBridge {
    * ⚠️ ここに出るのは hub-agent が spawn した **チャットセッションのみ**。tmux 配下で
    * 動く TUI codex は ask-sibling の宛先にならないため、一覧が空でも「codex は画面上
    * 動いている」ことは普通に起きる。その旨を hint に明記する。
+   *
+   * ⚠️ セキュリティ (T06271 レビュー3 major②): 返す live_sessions は **この cwd のものだけ**に
+   * 限定する。呼び出し元トークンは cwd スコープなので、全 cwd の session id を返すと別
+   * workspace の cwd/セッション存在を漏らす (cwd scoped token での越境情報漏洩)。cwd 指定で
+   * describeLiveSessions を呼び、同一 cwd のみを材料にする。
    * @param {string} cwd
    * @param {string} targetKind
    */
   _diagnose(cwd, targetKind) {
-    const all = [
-      ...(this.claudeBridge?.describeLiveSessions?.() ?? []),
-      ...(this.codexBridge?.describeLiveSessions?.() ?? []),
+    const sameCwd = [
+      ...(this.claudeBridge?.describeLiveSessions?.(cwd) ?? []),
+      ...(this.codexBridge?.describeLiveSessions?.(cwd) ?? []),
     ]
-    const sameCwd = all.filter((s) => s.cwd === cwd)
     const hint = sameCwd.length
       ? `この cwd には ${sameCwd.map((s) => s.kind).join("/")} のチャットセッションはあるが ${targetKind} は無い。`
       : `この cwd には hub-agent 管理下のチャットセッションが 1 本も無い。` +
         `tmux の TUI codex は ask-sibling の宛先にならない (hub-agent が spawn した` +
         ` Cockpit のチャットセッションのみが対象)。Cockpit のブラウザで対象 cwd の` +
         ` ${targetKind} チャットを開き直してから再送すること。`
-    return { live_sessions: all, hint }
+    return { live_sessions: sameCwd, hint }
   }
 
   /** 結果ファイルを atomic write する (呼び出し側 CLI がポーリングする)。 */