@cocorograph/hub-agent 0.7.78 → 0.7.80

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocorograph/hub-agent",
-  "version": "0.7.78",
+  "version": "0.7.80",
   "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 /
@@ -322,15 +322,15 @@ 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()]])
     this.cwd = cwd
     this.model = model || null
@@ -1866,12 +1866,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 +2049,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,21 +2552,19 @@ 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 内に再接続 (再アタッチ)
@@ -2585,11 +2585,10 @@ export class ClaudeStreamBridge extends EventEmitter {
   /** 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())) {

package/src/codex-stream-bridge.mjs

@@ -21,10 +21,14 @@
  *   (新 app-server を起動しない)。browser の WS 再接続で stream_id が変わっても、fresh 直後
  *   (rollout 0件) の会話も含めて復元できる。詳細は attach() の docstring 参照。
  *
+ * ## 多端末購読 (案B / T06542)
+ *   複数ブラウザタブでの **同時** 同一スレッド共有を実装済み (Claude の多端末共有と対称)。
+ *   session は購読集合 `streamIds` を持ち、reattach は「所有権付け替え」ではなく「購読者追加」。
+ *   どの購読端末からの input/permission も解決でき、配信は Hub backend が thread_id グループ
+ *   broadcast で行う (agent はイベントに thread_id を載せるだけ)。詳細は attach()/_tryReattach()/
+ *   detach()/gcDeadTerminals() の docstring 参照。旧 Slice 2 の「単一勝者のみ (同時共有は非対応)」は撤廃。
+ *
  * Slice 2 のスコープ外 (意図的に見送り、後続スライスで追加する):
- *   - 複数ブラウザタブでの **同時** 同一スレッド共有 (Claude の HUB_AGENT_CHAT_SHARED 相当)。
- *     in-memory reattach は「1 つの持ち主が WS を張り直す」ケース (単一勝者) であり、複数タブが
- *     同時に同一スレッドを操作する共有はまだ扱わない。
  *   - 画像/添付入力 (テキストのみ)。
  *   - acceptForSession や execpolicy/network amendment 等の高度な承認 decision
  *     (permissionReply は decision をそのまま素通しするので呼び出し側が組み立てる)。
@@ -98,6 +102,21 @@ const STUCK_TURN_TTL_MS =
   Number(process.env.HUB_AGENT_DEAD_TERMINAL_TTL_MS) ||
   60 * 60 * 1000
 
+// 案B (T06542): 死端末 GC の TTL。多端末購読で、応答を返さなくなった（クラッシュ / タブ強制終了で
+// codex.detach を送れなかった）購読端末を購読集合から掃除する閾値。claude-stream-bridge.mjs の
+// DEAD_TERMINAL_TTL_MS（既定 1h）と同型・同既定。stuck turn TTL とは別軸（あちらはターン固着、
+// こちらは端末の無応答）だが既定は揃える。
+const DEAD_TERMINAL_TTL_MS =
+  Number(process.env.HUB_AGENT_CODEX_DEAD_TERMINAL_TTL_MS) ||
+  Number(process.env.HUB_AGENT_DEAD_TERMINAL_TTL_MS) ||
+  60 * 60 * 1000
+
+// 案B (T06542, codex-review round3 major#2): turn/start RPC 成功後に turn/started 通知が来るのを待つ
+// 上限。これを超えたら「ターンが正しく始まらなかった」とみなし、pump が待機中の queue を reject して
+// 状態を解除する（turn/started/completed/exit が来ないケースで promise が永久宙吊りになるのを防ぐ）。
+const TURN_START_TIMEOUT_MS =
+  Number(process.env.HUB_AGENT_CODEX_TURN_START_TIMEOUT_MS) || 30 * 1000
+
 const CLIENT_INFO = { name: "cockpit-hub-agent", title: "Cockpit", version: "1.0.0" }
 
 // T06499 (2026-07-18): 巨大スレッドの resume ガード。長期運用したスレッドの rollout は
@@ -177,6 +196,15 @@ function flattenThreadItems(thread, { maxItems = HISTORY_MAX_ITEMS, maxBytes = H
   return { items: kept, truncated, total }
 }
 
+/** 履歴 item の概算 byte 数 (flattenThreadItems の budget 判定と同じ JSON 長ベース)。 */
+function estimateItemBytes(item) {
+  try {
+    return JSON.stringify(item)?.length || 0
+  } catch {
+    return 0
+  }
+}
+
 /**
  * resume 応答から Codex の「権威的なターン進行状態」を取り出す。
  *
@@ -264,6 +292,8 @@ export class CodexStreamBridge extends EventEmitter {
     detachTtlMs,
     warmPoolMax,
     stuckTurnTtlMs,
+    deadTerminalTtlMs,
+    turnStartTimeoutMs,
     rolloutPresence,
     historyMaxItems,
     historyMaxBytes,
@@ -278,6 +308,10 @@ export class CodexStreamBridge extends EventEmitter {
     this._warmPoolMax = warmPoolMax ?? WARM_POOL_MAX
     // Stage 5: stuck turn 検出 TTL（既定 1h）。テストから短縮可能。
     this._stuckTurnTtlMs = stuckTurnTtlMs ?? STUCK_TURN_TTL_MS
+    // 案B (T06542): 死端末 GC の TTL（既定 1h）。テストから短縮可能。
+    this._deadTerminalTtlMs = deadTerminalTtlMs ?? DEAD_TERMINAL_TTL_MS
+    // round3 major#2: turn/start 後に turn/started を待つ上限（既定 30s）。テストから短縮可能。
+    this._turnStartTimeoutMs = turnStartTimeoutMs ?? TURN_START_TIMEOUT_MS
     // #4 失敗分類の rollout 存在チェック (tri-state。テストから注入可能)。
     this._rolloutPresence = rolloutPresence || codexRolloutPresence
     // T06499: 履歴 hydrate の上限 (テストから小さい値を注入可能)。
@@ -332,6 +366,35 @@ export class CodexStreamBridge extends EventEmitter {
       }
     }
 
+    // T06541 案1: attach_id が無くても、同一 (cwd, resume_thread_id) のライブ session があれば
+    // in-memory reattach する。frontend は attach_id を送らないため上の attachId 経路は発火せず、
+    // これが実質のメイン reattach 経路になる。新プロセス thread/resume を起動せず所有権を付け替え、
+    // **蓄積済みの高忠実度履歴を返す**（frontend は remount で白紙化するため履歴が必要。reducer は
+    // uuid dedup で二重描画しない）。これにより症状⑦（生成中に移動→戻ると turn_active=false）が
+    // 解消し、停止/完了通知も同一プロセスに揃う。同一会話 (threadId 一致) のみ対象。
+    if (resumeThreadId) {
+      const existing = this._findLiveSessionByCwd(cwd, resumeThreadId)
+      if (existing && existing.stream_id !== stream_id) {
+        const r = await this._tryReattach(existing, stream_id)
+        if (r.status === "reattached") {
+          return {
+            ...r.info,
+            // 案1: reattach は履歴を返さない設計 (r.info.history=[]) だが、cwd reattach は remount
+            // 由来で表示がリセットされ得るため、live セッションが保持する高忠実度履歴を返す。
+            history: Array.isArray(existing.historyItems) ? existing.historyItems.slice() : [],
+            historyTruncated: existing.historyTruncated === true,
+          }
+        }
+        if (r.status === "superseded") {
+          const err = new Error("attach superseded by a concurrent reattach")
+          err.attachOperation = "reattach"
+          err.attachReason = "superseded"
+          throw err
+        }
+        // r.status === "unavailable" → 通常経路 (thread/resume) へフォールスルー。
+      }
+    }
+
     const client = this._clientFactory({
       cwd,
       codexCmd: this.codexCmd,
@@ -343,14 +406,52 @@ export class CodexStreamBridge extends EventEmitter {
     // unhandled rejection を作らず、複数の reconnect が同じ promise を安全に await できる)。
     let settleReady
     const session = {
+      // primary stream_id: legacy な単一値 emit / ログ用。案B では最新購読端末へ寄せる
+      // (streamIds が真の購読者集合)。app-server 通知や emit は都度 session.stream_id を読む。
       stream_id,
       cwd,
+      // 案B (T06542): 多端末購読集合。この live session を購読中の全端末 stream_id。reattach は
+      // 「所有権付け替え」ではなく「購読者追加」。detach で当該端末を外し、最後の1台が外れたら
+      // warm 保持（reconcile が LRU/idle TTL/stuck で reap）。sessions Map は各購読 stream_id →
+      // この session の多対一。distinct session 走査は必ず _liveSessions() で dedup する。
+      streamIds: new Set([stream_id]),
+      // 死端末 GC 用の端末別最終活性。browser→agent アクション（input/permission/interrupt/
+      // keepalive）で更新し、応答を返さなくなった購読端末を gcDeadTerminals が掃除する
+      // (claude-stream-bridge.mjs の lastActivityByStream と同型)。
+      lastActivityByStream: new Map([[stream_id, Date.now()]]),
       // #1 in-memory reattach のキー。attach 試行を跨いで安定 (WS 再接続で stream_id は変わる)。
       attachId: attachId || null,
       client,
       threadId: null,
+      // T06541 major#3: cwd reattach の in-flight 引き当てキー。thread/resume 完了まで threadId は
+      // null なので、並行 cold attach が「同一 (cwd, resumeThreadId)」を検出できるよう resume 対象の
+      // thread id を **client 生成前 (同期)** に持たせる。これで後続 attach は _findLiveSessionByCwd で
+      // この session を引き当て _tryReattach の session.ready 合流に入り、二重 app-server を作らない。
+      resumeThreadId: resumeThreadId || null,
       activeTurnId: null,
-      pendingApprovals: new Map(), // request_id -> { turnId }
+      // 案B (T06542, codex-review round3 major#1): 同時入力を **session 単位の単一 FIFO + 単一 pump**で
+      // 直列化し、二重 turn/start・queue 追い越し・並行 steer を構造的に排除する。旧 turnStarting/
+      // pendingInputs の二重路 (queue 経路 + 直通経路) が overtaking と並行リトライ二重ターンの温床だった。
+      /** @type {Array<{input: object[], model?: string, effort?: string, resolve: Function,
+       *  reject: Function, retriedAsStart?: boolean}>} round3 major#1: **session 単位の単一 FIFO**。
+       *  全 input() はここに積まれ、単一 pump (_pumpInputs) が **1 件ずつ直列**に処理する。直通経路を
+       *  廃したので、drain 中の新規 input が queue を追い越したり、並行 turn/start・steer を発行して
+       *  二重ターンになる事故が起きない。各 promise は **実 delivery (turn/start か turn/steer の RPC)**で
+       *  settle する (main.mjs が codex.input.ack/nack を実配達に合わせて出せる)。 */
+      inputQueue: [],
+      /** round3 major#1: pump が走行中か (単一 pump を保証する singleflight フラグ)。 */
+      pumping: false,
+      /** @type {{resolve: Function, timer: any} | null} round3 major#2: turn/start 後に turn/started
+       *  (activeTurnId 確定) を待つ barrier の待機者。timeout 付きでハングを防ぐ。 */
+      _turnActiveWaiter: null,
+      /** round4 major#2: turn/started 通知ごとに +1 する世代カウンタ。pump は turn/start dispatch 前に
+       *  値を控え、応答後に「world が前進したか (turn が始まった/更に完了した)」を activeTurnId だけでなく
+       *  この前進でも判定する。fast-turn (start 応答と started+completed が同一 chunk で pump 再開前に
+       *  処理される) で activeTurnId=null に戻っていても、世代前進で検知して誤 timeout を防ぐ。 */
+      turnGeneration: 0,
+      // request_id -> { turnId, method, params }。major#1: reattach で新 stream へ未応答の承認要求を
+      // 再送できるよう、元の method/params も保持する (Claude の _permissionResolvers と同型)。
+      pendingApprovals: new Map(),
       // ブラウザから codex.detach を受け取った (= 画面の持ち主が居なくなった) か。診断・ログ用。
       // Stage 5: 回収の可否は detachRequested ではなく lastActivityMs（LRU）と activeTurnId
       // （busy/stuck）で決める。detach してもすぐには殺さず warm 保持する。
@@ -368,6 +469,15 @@ export class CodexStreamBridge extends EventEmitter {
       // attach 時刻＝新規セッションは「たった今作った」で上位に来る（閲覧中の古い会話に負けない）。
       lastTurnAtMs: Date.now(),
       ready: null,
+      // T06541 案1（高忠実度履歴の蓄積）: cold attach 時の flatten 済み ThreadItem 履歴を
+      // 保持し、ライブ item/completed ごとに追記する。cwd reattach（新プロセスを立てない
+      // 復帰）時にこれを返すことで、frontend の remount 白紙化を防ぎつつ、rollout JSONL の
+      // 生データ（ツールカードが粗い）ではなく app-server 整形済みの高忠実度履歴を維持する。
+      historyItems: [],
+      historyTruncated: false,
+      // major#2: ライブ追記でも cold flatten と同じ「item 数＋概算 byte」二重上限を課すため、
+      // 蓄積済み履歴の概算 byte 合計を保持する (再計算を避け O(1) で trim 判定)。
+      historyBytes: 0,
     }
     session.ready = new Promise((resolve) => {
       settleReady = resolve
@@ -398,6 +508,12 @@ export class CodexStreamBridge extends EventEmitter {
         : { items: [], truncated: false, total: 0 }
       const history = flat.items
       const historyTruncated = flat.truncated
+      // T06541 案1: cold attach で得た高忠実度履歴をセッションに保持する。以降ライブ item
+      // 完了ごとに追記し、cwd reattach 時にこれを返す（新プロセス thread/resume を再実行しない）。
+      // major#2: byte 予算判定を O(1) にするため概算 byte 合計も持つ (flatten は既に byte 上限適用済み)。
+      session.historyItems = history.slice()
+      session.historyBytes = history.reduce((n, it) => n + estimateItemBytes(it), 0)
+      session.historyTruncated = historyTruncated
       // 案C: 権威的なターン状態を resume 応答から取り出してフロントへ渡す。
       // これによりフロントは会話末尾からの推測をやめ、Thread.status で turnActive を
       // 決められる (生成中スピナー固着バグの根治)。新規スレッドは常に idle 相当。
@@ -461,39 +577,105 @@ export class CodexStreamBridge extends EventEmitter {
     return null
   }
 
+  /**
+   * T06541: 同一 (cwd, threadId) のライブ session を返す (cwd ベース in-memory reattach 用)。
+   * frontend は attach_id を送らないため attachId 経路は発火せず、resume は毎回 thread/resume で
+   * 新プロセスを起動していた（別プロセスで生成中のターンを Thread.status で観測できず turn_active
+   * が false になる症状⑦の主機序）。resume_thread_id 一致で生きた session を引き当て所有権を付け替え
+   * れば、生成中ターン・停止・完了通知・高忠実度履歴が 1 本に揃う。
+   * ⚠️ **同一会話 (threadId 一致) のみ** を対象にし、別会話 (threadId 不一致) を誤って奪わない。
+   * major#3: thread/resume 完了前 (threadId=null) の in-flight session も、resume 対象 thread が
+   * 一致すれば引き当てる。これで並行 cold attach の後続が _tryReattach の session.ready 合流に入り、
+   * 同一 thread の app-server が二重生成されるのを防ぐ (Claude の同期索引登録と同じ「空の窓」対策)。
+   */
+  _findLiveSessionByCwd(cwd, threadId) {
+    if (!cwd || !threadId) return null
+    for (const s of this.sessions.values()) {
+      if (s.dead || s.cwd !== cwd) continue
+      // 確定済み thread 一致、または in-flight (未確定) で resume 対象が一致。
+      if (s.threadId === threadId) return s
+      if (s.threadId === null && s.resumeThreadId === threadId) return s
+    }
+    return null
+  }
+
+  /**
+   * T06541 案1: 完了 ThreadItem を高忠実度履歴 (session.historyItems) に追記する。
+   * 表示用バブル時刻 at_ms は completedAtMs (ms epoch) を採る（flattenThreadItems と同じ ms 単位。
+   * userMessage はライブでも completedAtMs=ターン冒頭で届くため整合する）。長い会話で無限成長させ
+   * ないよう cold flatten と同じ **item 数 (maxItems) ＋ 概算 byte 数 (maxBytes) の二重上限** を課し、
+   * 超過分は先頭 (最古) から捨て truncated を立てる (major#2: 巨大ツール出力で reattach payload が
+   * 肥大化し T06499 で防いだメモリ増・WS 転送・ブラウザフリーズが再発するのを防ぐ)。
+   */
+  _appendHistoryItem(session, item, completedAtMs) {
+    if (!session || !item || typeof item !== "object") return
+    if (!Array.isArray(session.historyItems)) session.historyItems = []
+    if (typeof session.historyBytes !== "number") session.historyBytes = 0
+    const entry = typeof completedAtMs === "number" ? { ...item, at_ms: completedAtMs } : item
+    session.historyItems.push(entry)
+    session.historyBytes += estimateItemBytes(entry)
+    const maxItems = this._historyLimits.maxItems
+    const maxBytes = this._historyLimits.maxBytes
+    // 末尾 1 件は必ず残す (flatten と同じ方針)。item 数超過 or byte 超過の間、先頭から捨てる。
+    while (
+      session.historyItems.length > 1 &&
+      ((typeof maxItems === "number" && session.historyItems.length > maxItems) ||
+        (typeof maxBytes === "number" && session.historyBytes > maxBytes))
+    ) {
+      const dropped = session.historyItems.shift()
+      session.historyBytes -= estimateItemBytes(dropped)
+      if (session.historyBytes < 0) session.historyBytes = 0
+      session.historyTruncated = true
+    }
+  }
+
   /**
    * 既存ライブ session を新 stream_id へ付け替える (in-memory reattach)。thread が未確定
    * (thread/start in-flight) なら session.ready を await する (成功=threadId / 失敗=null)。
    * 付け替えられなければ null を返し、呼び出し側 attach() は通常経路へフォールスルーする。
    */
   async _tryReattach(session, newStreamId) {
-    // ⚠️ 付け替え前の stream_id を **await の前に capture** する (major #1: 同じ attach_id へ
-    // 複数 reconnect が session.ready 待ちで重なったとき、`session.stream_id` を await 後に
-    // 読むと勝者が既に付け替えた現在値を追ってしまい「別 stream へ移動済み」を検出できず、
-    // 敗者も成功してしまう。capture 値で CAS することで **単一勝者**にする)。
+    // 案B (T06542): reattach は「所有権付け替え」ではなく **購読者追加**。旧 stream を Map から
+    // 消さず、newStreamId を streamIds へ足して両方が同一 live session を購読する状態を作る
+    // (どの端末の input/permission/interrupt も解決でき、backend が thread group へ fan-out する)。
+    // これにより「2 本目の app-server を立てず、旧端末も生かしたまま」新端末を相乗りさせる。
     // 戻り値 status:
-    //   "reattached" - この呼び出しが session を newStreamId へ付け替えた (info 同梱)。
-    //   "superseded" - 別 reattach が勝って session を奪った (session は生きている)。呼び出し側は
-    //                  **通常経路に落とさず** 失敗させる (二重 thread を作らない)。
+    //   "reattached" - newStreamId を購読者として追加した (info 同梱)。
+    //   "superseded" - newStreamId が既に別 session を保持している異常時のみ (通常は起きない。
+    //                  attach() が :318 で has(stream_id) を弾くため)。呼び出し側は通常経路に
+    //                  落とさず失敗させる (二重 thread を作らない)。
     //   "unavailable"- session が死んだ / first の thread 確定に失敗 (ライブ session 無し)。
     //                  呼び出し側は通常経路へフォールスルーしてよい。
-    const originalStreamId = session.stream_id
     let threadId = session.threadId
     if (!threadId && session.ready) threadId = await session.ready
     // first の thread op が失敗 / session が死んだ = ライブ session はもう無い。
     if (!threadId || session.dead) return { status: "unavailable" }
-    // await 中に別 reattach が勝って session を移動した = concurrent の敗者。
-    if (this.sessions.get(originalStreamId) !== session) return { status: "superseded" }
-    if (this.sessions.has(newStreamId)) return { status: "superseded" } // 新 stream 側が別 session 保持 (異常)
-    this.sessions.delete(originalStreamId)
+    const existingForNew = this.sessions.get(newStreamId)
+    if (existingForNew && existingForNew !== session) return { status: "superseded" }
+    // 購読者追加: streamIds / 端末別活性 / Map を更新し、primary を最新端末へ寄せる
+    // (legacy 単一値 emit / ログ用。真の配信は backend の thread group fan-out が担う)。
+    const now = Date.now()
+    session.streamIds.add(newStreamId)
+    session.lastActivityByStream.set(newStreamId, now)
+    this.sessions.set(newStreamId, session)
     session.stream_id = newStreamId
     session.detachRequested = false
-    session.lastActivityMs = Date.now()
-    this.sessions.set(newStreamId, session)
+    session.lastActivityMs = now
     this.logger?.info?.(
-      { stream_id: newStreamId, thread_id: threadId, cwd: session.cwd, reattached: true },
-      "codex session reattached (in-memory)",
+      {
+        stream_id: newStreamId,
+        thread_id: threadId,
+        cwd: session.cwd,
+        reattached: true,
+        subscribers: session.streamIds.size,
+      },
+      "codex session reattached (multi-terminal subscribe)",
     )
+    // major#1: 新 stream へ未応答の承認要求を再送する (Claude の _replayPendingPermissions と同型)。
+    // 承認要求は app-server との in-flight callback で、履歴 hydrate には含まれない。旧 stream 宛に
+    // 出したカードは remount/端末切替で失われ、応答が来ないとターンが永久 pending になる。新 stream へ
+    // 再 emit してカードを復元させる (frontend は request_id で重複排除するので二重化しない)。
+    this._replayPendingApprovals(session)
     // 履歴は返さない: reconnect では frontend が表示を保持している (resetDisplay=false) ため
     // 再 hydrate 不要。turnActive は session が保持する activeTurnId から権威的に決める。
     return {
@@ -602,9 +784,38 @@ export class CodexStreamBridge extends EventEmitter {
     })
   }
 
-  /** gcAbandonedSessions 用の最終活性更新。browser 入力 / app-server 通知の両方で呼ぶ。 */
-  _touch(session) {
-    if (session) session.lastActivityMs = Date.now()
+  /**
+   * reconcile 用の最終活性更新。browser 入力 / app-server 通知の両方で呼ぶ。
+   * 案B: stream_id を伴う browser→agent アクション（input/permission/interrupt/keepalive）では
+   * **端末別の活性（lastActivityByStream）も更新**し、gcDeadTerminals が「応答を返さない購読端末」
+   * だけを掃除できるようにする。app-server 通知（stream_id なし）は session 全体の活性のみ更新する。
+   */
+  _touch(session, stream_id) {
+    if (!session) return
+    const now = Date.now()
+    session.lastActivityMs = now
+    if (stream_id && session.streamIds?.has(stream_id)) {
+      session.lastActivityByStream.set(stream_id, now)
+    }
+  }
+
+  /**
+   * 案B: sessions Map は各購読 stream_id → session の多対一なので、distinct な live session を
+   * 走査するときは必ずこれで dedup する（同一 session を購読端末数ぶん重複カウントしない）。
+   * @returns {object[]} 非 dead な distinct session の配列
+   */
+  _liveSessions() {
+    return Array.from(new Set(this.sessions.values())).filter((s) => !s.dead)
+  }
+
+  /** 案B: この session を指す全購読 stream_id キーを sessions Map から外す（reap / exit 共通）。 */
+  _dropAllStreamKeys(session) {
+    const ids = session.streamIds ? Array.from(session.streamIds) : []
+    for (const sid of ids) {
+      if (this.sessions.get(sid) === session) this.sessions.delete(sid)
+    }
+    // primary が streamIds に含まれない異常時の保険。
+    if (this.sessions.get(session.stream_id) === session) this.sessions.delete(session.stream_id)
   }
 
   _onNotification(session, msg) {
@@ -616,16 +827,28 @@ export class CodexStreamBridge extends EventEmitter {
     switch (msg.method) {
       case "turn/started":
         session.activeTurnId = msg.params?.turn?.id || null
+        // round4 major#2: 世代を前進させる (pump が fast-turn を activeTurnId だけでなく世代前進でも検知)。
+        session.turnGeneration += 1
+        // round3 major#2: 起動確定 → pump の turn-active barrier を解除する (次 item が steer へ進む)。
+        this._settleTurnActiveWaiter(session)
         // 会話ターン境界で「新しさ」を更新（閲覧 keepalive では更新しない）。
         session.lastTurnAtMs = Date.now()
         break
       case "turn/completed":
         session.activeTurnId = null
+        // round3 major#2: turn/started を取りこぼしたまま turn/completed が来た異常時も barrier が
+        // 固着しないよう解除する (pump が次 item を fresh に turn/start できる)。
+        this._settleTurnActiveWaiter(session)
         session.lastTurnAtMs = Date.now()
         this._autoResolveStalePendingApprovals(session, msg.params?.turn?.id)
         // Stage 5: turn 完了後の reap 予約は不要。以降 idle になれば周期 reconcile が
         // 長 idle TTL / LRU で扱う（detach 済みでも 7 日 warm 保持）。
         break
+      case "item/completed":
+        // T06541 案1: 完了した ThreadItem を高忠実度履歴に追記する（cwd reattach で返す用）。
+        // ライブ表示は下の emit がそのまま担う（本 case は履歴蓄積を足すだけで emit は変えない）。
+        this._appendHistoryItem(session, msg.params?.item, msg.params?.completedAtMs)
+        break
       default:
         break
     }
@@ -639,7 +862,12 @@ export class CodexStreamBridge extends EventEmitter {
 
   _onServerRequest(session, msg) {
     const { stream_id } = session
-    session.pendingApprovals.set(msg.id, { turnId: session.activeTurnId })
+    // major#1: reattach 時に新 stream へ再送できるよう method/params も保持する。
+    session.pendingApprovals.set(msg.id, {
+      turnId: session.activeTurnId,
+      method: msg.method,
+      params: msg.params,
+    })
     this.emit("permission", {
       stream_id,
       thread_id: session.threadId,
@@ -650,6 +878,25 @@ export class CodexStreamBridge extends EventEmitter {
     })
   }
 
+  /**
+   * major#1: 未応答の承認要求を現在の stream へ再送する (reattach から呼ぶ)。Claude の
+   * _replayPendingPermissions と同型。frontend は request_id で重複排除するため、既に表示済みの
+   * 端末でも二重化しない。method/params は _onServerRequest 受信時に保存済み。
+   */
+  _replayPendingApprovals(session) {
+    if (!session || session.pendingApprovals.size === 0) return
+    for (const [request_id, info] of session.pendingApprovals) {
+      this.emit("permission", {
+        stream_id: session.stream_id,
+        thread_id: session.threadId,
+        cwd: session.cwd,
+        request_id,
+        method: info.method,
+        params: info.params,
+      })
+    }
+  }
+
   // ターン完了時、そのターンに紐づく未解決の承認要求は自動 decline する
   // (browser が応答する前にターンが打ち切られた/クラッシュ相当のケース。
   // claude-stream-bridge.mjs の「ターン終了時に未解決分は自動 deny」と同じ設計)。
@@ -664,7 +911,12 @@ export class CodexStreamBridge extends EventEmitter {
   _onClientExit(session, info) {
     if (session.dead) return
     session.dead = true
-    this.sessions.delete(session.stream_id)
+    // round3: app-server が死んだら barrier を解除し queue を reject する（promise 宙吊り防止）。
+    this._settleTurnActiveWaiter(session)
+    this._drainRejectQueue(session, { reason: "queue_dead" })
+    // 案B: app-server が死んだら全購読 stream_id キーを Map から外す（1 端末分だけでは
+    // 他の購読キーが dangling で残る）。
+    this._dropAllStreamKeys(session)
     // app-server の終了は必ず記録する。ターン実行中の exit は「rollout に output 欠落の
     // custom_tool_call を残した可能性がある」= thread 汚染の予兆なので warn で出す
     // (codex_core の `Custom tool call output is missing for call id: ...` の発生源)。
@@ -715,55 +967,177 @@ export class CodexStreamBridge extends EventEmitter {
     const session = this._require(stream_id)
     // Stage 5: _touch で lastActivityMs を更新 = LRU 先頭へ。ターン開始で activeTurnId が
     // 立ち、reconcile は healthy busy を protected 扱いにするので実行中に kill されない。
-    this._touch(session)
+    // 案B: stream_id を渡し端末別活性も更新（死端末 GC が入力継続端末を掃除しない）。
+    this._touch(session, stream_id)
     const input = userInputFromMessage(message)
-    if (session.activeTurnId) {
-      try {
-        await session.client.request("turn/steer", {
-          threadId: session.threadId,
-          expectedTurnId: session.activeTurnId,
-          input,
-        })
-        return
-      } catch (err) {
-        // S3 Codex 堅牢化 (2026-07-05): turn/steer が reject される最大の原因は
-        // expectedTurnId 不一致 (turn/completed 通知の取りこぼしで session.activeTurnId
-        // が古いまま残るケース) や request() タイムアウト。回復キューが無いと、以降の
-        // 入力が全て turn/steer として送られ続けて無反応になる (報告症状②の原因)。
-        // ここで activeTurnId を捨てて「busy ではない」扱いに戻し、同一メッセージを
-        // 1 回だけ turn/start として自動リトライすることで自己修復する。
-        session.activeTurnId = null
-        try {
-          const retryParams = { threadId: session.threadId, input }
-          if (model) retryParams.model = model
-          if (effort) retryParams.effort = effort
-          await session.client.request("turn/start", retryParams)
+    // round3 major#1: 全 input を **session 単位の単一 FIFO** に積み、単一 pump に処理させる。
+    // promise は pump が実 delivery で settle する (即 resolve しない)。
+    return new Promise((resolve, reject) => {
+      session.inputQueue.push({ input, model, effort, resolve, reject, retriedAsStart: false })
+      void this._pumpInputs(session)
+    })
+  }
+
+  /**
+   * round3 major#1 (案B / T06542): session 単位の単一 FIFO pump。**1 件ずつ直列**に処理し、
+   * 並行 turn/start・turn/steer や queue の追い越しを構造的に排除する (singleflight)。
+   *   - 非 busy (activeTurnId 無し): turn/start で新ターン。成功後、次を steer にするため
+   *     turn/started (activeTurnId 確定) を **timeout 付き**で待つ (round3 major#2: ハング防止)。
+   *   - busy (activeTurnId 有り): turn/steer で追い打ち。
+   *   - turn/steer 失敗 (expectedTurnId 不一致など): activeTurnId を捨て、同 item を **1 回だけ**
+   *     turn/start にフォールバックして自己修復する (旧 self-heal を FIFO 内で継続。並行はしない)。
+   * 各 item の promise は実 delivery の RPC 結果で settle する。
+   */
+  async _pumpInputs(session) {
+    if (session.pumping) return
+    session.pumping = true
+    try {
+      while (session.inputQueue.length > 0) {
+        if (session.dead) {
+          this._drainRejectQueue(session, { reason: "queue_dead" })
           return
-        } catch (retryErr) {
-          // 呼び出し元 (main.mjs の codex.input dispatch) が既存の .catch() で
-          // codex.error を送出する経路に reason を乗せて届ける (bridge 側で二重に
-          // 'error' イベントを emit すると frontend へ codex.error が二重送出される
-          // ため、ここでは throw のみに留める)。
-          const reason = "turn_mismatch_retry_failed"
-          throw Object.assign(
-            new Error(
-              `turn/steer failed (${err.message}) and turn/start retry also failed: ${retryErr.message}`,
-            ),
-            { reason, cause: retryErr },
-          )
         }
+        const item = session.inputQueue[0]
+        // round4 major#3: 試行種別 (steer/start) を **await の前に** 確定する。await 中に
+        // turn/completed が来て session.activeTurnId が null に戻ると、catch 時点の値では steer 試行が
+        // start と誤判定され、self-heal リトライがスキップされて item が誤 reject される。
+        const attemptedSteer = !!session.activeTurnId
+        try {
+          if (attemptedSteer) {
+            await session.client.request("turn/steer", {
+              threadId: session.threadId,
+              expectedTurnId: session.activeTurnId,
+              input: item.input,
+            })
+            session.inputQueue.shift()
+            item.resolve()
+          } else {
+            // round4 major#2: turn/start dispatch の **前に** 世代を控える。start 応答後に
+            // turn/started(+completed) が pump 再開前に処理されても、世代前進で「ターンが始まった」を
+            // 検知でき、誤 timeout しない。
+            const genBefore = session.turnGeneration
+            const params = { threadId: session.threadId, input: item.input }
+            if (item.model) params.model = item.model
+            if (item.effort) params.effort = item.effort
+            await session.client.request("turn/start", params)
+            session.inputQueue.shift()
+            item.resolve()
+            // 次の item を steer にするため turn/started (= 世代前進) を待つ。timeout でハングを防ぐ。
+            // timeout したら「ターンが正しく始まらなかった」とみなし残り queue を reject して打ち切る。
+            const becameActive = await this._waitTurnActive(session, genBefore)
+            if (!becameActive) {
+              this._drainRejectQueue(session, { reason: "turn_start_timeout" })
+              return
+            }
+          }
+        } catch (err) {
+          if (attemptedSteer && !item.retriedAsStart) {
+            // turn/steer 失敗 → 自己修復: activeTurnId を捨て、同 item を turn/start で 1 回だけリトライ
+            // (shift しない = 同 item を次ループの start 経路で再処理)。並行はしない (単一 pump)。
+            // 元の steer エラーを stash して、リトライも失敗したとき合成メッセージを作れるようにする。
+            session.activeTurnId = null
+            item.retriedAsStart = true
+            item.priorSteerError = err instanceof Error ? err : new Error(String(err))
+            continue
+          }
+          // start 失敗 or リトライ済み steer 失敗 → この item を reject。activeTurnId は捨てる
+          // (ターンは始まっていない/不明)。次の item は fresh に turn/start する。
+          session.inputQueue.shift()
+          session.activeTurnId = null
+          let e
+          if (item.retriedAsStart && item.priorSteerError) {
+            // steer→start リトライがともに失敗: 合成メッセージ + reason (main.mjs の classifyCodexInputError
+            // が reason を優先採用。従来の単一 input() 実装と同じ診断を保つ)。
+            e = Object.assign(
+              new Error(
+                `turn/steer failed (${item.priorSteerError.message}) and turn/start retry also failed: ${err instanceof Error ? err.message : String(err)}`,
+              ),
+              { reason: "turn_mismatch_retry_failed", cause: err },
+            )
+          } else {
+            e = err instanceof Error ? err : new Error(String(err))
+            if (!e.reason) e.reason = "start_error"
+          }
+          item.reject(e)
+        }
+      }
+    } finally {
+      session.pumping = false
+      // pumping=false 直後の enqueue 競合窓を拾い直す (取りこぼし防止)。再帰は 1 段のみ。
+      if (session.inputQueue.length > 0 && !session.dead) {
+        void this._pumpInputs(session)
+      }
+    }
+  }
+
+  /**
+   * round3 major#2 + round4 major#2: turn/start 後に「ターンが始まった」ことを timeout 付きで待つ
+   * barrier。activeTurnId が立っているか、または **turn/start dispatch 前に控えた世代 genBefore から
+   * 世代が前進している** (fast-turn で started+completed 済み) なら即 true を返し、誤 timeout しない。
+   * @param {object} session
+   * @param {number} [genBefore] turn/start dispatch 直前の session.turnGeneration
+   * @returns {Promise<boolean>} ターンが始まったら true、timeout したら false。
+   */
+  _waitTurnActive(session, genBefore = -1) {
+    if (session.activeTurnId || session.turnGeneration > genBefore) return Promise.resolve(true)
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        if (session._turnActiveWaiter && session._turnActiveWaiter.timer === timer) {
+          session._turnActiveWaiter = null
+        }
+        resolve(false)
+      }, this._turnStartTimeoutMs)
+      // minor (round4): 通知を出さない単体テスト等でプロセスを timeout 分保持しないよう unref する。
+      if (typeof timer.unref === "function") timer.unref()
+      // 既存 waiter があれば置換前に false 解決しておく (通常は無い)。
+      if (session._turnActiveWaiter) {
+        try {
+          clearTimeout(session._turnActiveWaiter.timer)
+        } catch {
+          /* noop */
+        }
+        session._turnActiveWaiter.resolve(false)
       }
+      session._turnActiveWaiter = { resolve: () => resolve(true), timer }
+    })
+  }
+
+  /** round3 major#2: turn/started / completed / exit / 死亡で待機中の barrier を解除する。 */
+  _settleTurnActiveWaiter(session) {
+    const w = session._turnActiveWaiter
+    if (!w) return
+    session._turnActiveWaiter = null
+    try {
+      clearTimeout(w.timer)
+    } catch {
+      /* noop */
+    }
+    w.resolve()
+  }
+
+  /**
+   * round3: FIFO の未処理 item を一括 reject する (session 死亡 / turn_start timeout で pump が
+   * 続行できないとき。ack も nack も返らない配達喪失を防ぐ)。
+   */
+  _drainRejectQueue(session, cause) {
+    if (!session || !Array.isArray(session.inputQueue) || session.inputQueue.length === 0) return
+    const pending = session.inputQueue
+    session.inputQueue = []
+    const reason = cause?.reason || "queue_dead"
+    for (const { reject } of pending) {
+      reject(
+        Object.assign(new Error("codex input dropped: turn could not be delivered"), {
+          reason,
+          cause,
+        }),
+      )
     }
-    const params = { threadId: session.threadId, input }
-    if (model) params.model = model
-    if (effort) params.effort = effort
-    await session.client.request("turn/start", params)
   }
 
   /** @returns {Promise<void>} */
   async interrupt({ stream_id }) {
     const session = this._require(stream_id)
-    this._touch(session)
+    this._touch(session, stream_id)
     if (!session.activeTurnId) return
     await session.client.request("turn/interrupt", {
       threadId: session.threadId,
@@ -774,7 +1148,8 @@ export class CodexStreamBridge extends EventEmitter {
   /** サーバー発の承認/入力要求への応答。result の shape は method ごとに呼び出し側が組み立てる。 */
   permissionReply({ stream_id, request_id, result }) {
     const session = this._require(stream_id)
-    this._touch(session)
+    // 案B エッジ②: 先着 1 応答で解決。stream_id を渡し応答端末の活性を更新（死端末 GC 対象外に）。
+    this._touch(session, stream_id)
     if (!session.pendingApprovals.has(request_id)) {
       this.logger?.warn?.({ stream_id, request_id }, "codex permissionReply: unknown request_id (ignored)")
       return
@@ -795,18 +1170,48 @@ export class CodexStreamBridge extends EventEmitter {
   keepalive({ stream_id }) {
     const session = this.sessions.get(stream_id)
     if (!session || session.dead) return false
-    this._touch(session)
+    this._touch(session, stream_id)
     return true
   }
 
   /**
-   * グレースフル切断（Stage 5）。**すぐには reap しない**。detachRequested を立てて
-   * warm 保持し、以降は周期 reconcile（LRU 上限 / 長 idle TTL / stuck）に委ねる。これにより
-   * 「別 CLI 画面へ切替えた瞬間 5 分で殺される」問題を解消し、直近 5 セッションは 7 日 warm に。
+   * グレースフル切断（Stage 5 + 案B T06542）。**すぐには reap しない**。
+   *
+   * 案B: detach は「この端末分の購読解除」。まだ他端末が購読していればセッションは生かし、
+   * detachRequested も立てない（別端末が見ているため warm ではなく現役）。最後の 1 台が外れた
+   * ときだけ detachRequested を立て warm 保持し、以降は周期 reconcile（LRU 上限 / 長 idle TTL /
+   * stuck）に委ねる。これにより「別 CLI 画面へ切替えた瞬間 5 分で殺される」問題を解消しつつ、
+   * 多端末購読中に 1 タブ閉じても残りの端末のライブ表示が切れない。
    */
   detach({ stream_id }) {
     const session = this.sessions.get(stream_id)
     if (!session || session.dead) return
+    // ⚠️ 不変条件（案B）: **live（非 dead）session は常に stream key を 1 つ以上持つ**。codex は
+    // claude と違い warm セッションの唯一の索引が this.sessions なので、最後の 1 端末分の key まで
+    // 消すと reconcile が到達できず（reap されずリーク）、_findLiveSessionByCwd の reattach 引き当ても
+    // 効かなくなる。よって「購読が 2 つ以上のときだけ実際に外す」。
+    if (session.streamIds.size > 1) {
+      // 他端末がまだ購読中: この端末分の購読解除のみ。セッションは残りの端末が生かす。
+      session.streamIds.delete(stream_id)
+      session.lastActivityByStream.delete(stream_id)
+      if (this.sessions.get(stream_id) === session) this.sessions.delete(stream_id)
+      // primary を生存端末へ寄せ替える（末尾＝最も新しく購読した端末を .at(-1) で明示選択）。
+      if (session.stream_id === stream_id) {
+        session.stream_id = Array.from(session.streamIds).at(-1)
+      }
+      this.logger?.info?.(
+        {
+          stream_id,
+          thread_id: session.threadId,
+          cwd: session.cwd,
+          remaining_subscribers: session.streamIds.size,
+        },
+        "codex terminal unsubscribed (session kept; other terminals still watching)",
+      )
+      return
+    }
+    // 最後の 1 台が外れた: key / streamIds は残したまま（reconcile 到達性のため）warm 保持し、
+    // detachRequested を立てる。以降は周期 reconcile（LRU 上限 / 長 idle TTL / stuck）が reap を判断する。
     session.detachRequested = true
     this.logger?.info?.(
       {
@@ -815,10 +1220,55 @@ export class CodexStreamBridge extends EventEmitter {
         cwd: session.cwd,
         busy: !!session.activeTurnId,
       },
-      "codex detach requested by browser (kept warm; reconcile handles reap)",
+      "codex detach requested by browser (last terminal; kept warm; reconcile handles reap)",
     )
   }
 
+  /**
+   * 案B (T06542): 死端末 GC。多端末購読で、クラッシュ / タブ強制終了で codex.detach を送れずに
+   * 消えた購読端末（一定期間 input/permission/interrupt/keepalive の活性が無い stream_id）を購読集合
+   * から掃除する。claude-stream-bridge.mjs の gcDeadTerminals と同型。複数端末が購読するセッション
+   * のみ対象（1 台しか居なければ reconcile の idle TTL / LRU に任せる）。全端末が死端末で空になったら
+   * detachRequested を立て warm 保持へ落とす。reconcileSessions の先頭から呼ばれる（main.mjs の
+   * state loop 経由）ほか、テストから直接も呼べる。
+   * @param {number} [ttlMs] 死端末とみなす無活性閾値（テスト用に上書き可）。
+   * @returns {number} GC した端末キー数。
+   */
+  gcDeadTerminals(ttlMs = this._deadTerminalTtlMs) {
+    const now = Date.now()
+    let removed = 0
+    for (const session of this._liveSessions()) {
+      // 複数端末が購読しているセッションのみ対象（1 台なら reconcile の idle TTL / LRU に任せる）。
+      if (session.streamIds.size <= 1) continue
+      for (const sid of Array.from(session.streamIds)) {
+        // ⚠️ 不変条件: live session は常に stream key を 1 つ以上残す（reconcile 到達性）。全端末が
+        // 死端末でも最後の 1 個は消さず、下で detachRequested を立てて idle TTL reap に委ねる。
+        if (session.streamIds.size <= 1) break
+        const last = session.lastActivityByStream.get(sid) ?? 0
+        if (now - last < ttlMs) continue
+        session.streamIds.delete(sid)
+        session.lastActivityByStream.delete(sid)
+        if (this.sessions.get(sid) === session) this.sessions.delete(sid)
+        removed += 1
+        if (session.stream_id === sid) {
+          session.stream_id = Array.from(session.streamIds).at(-1)
+        }
+        this.logger?.info?.(
+          { stream_id: sid, thread_id: session.threadId, cwd: session.cwd },
+          "codex dead terminal GC'd (no activity past TTL)",
+        )
+      }
+      // 生き残った最後の 1 端末も死端末（無活性が TTL 超過）なら warm 保持へ落とす
+      // （key は残したまま。reconcile が idle TTL / LRU で最終的に reap する）。
+      if (session.streamIds.size === 1) {
+        const [onlySid] = session.streamIds
+        const last = session.lastActivityByStream.get(onlySid) ?? 0
+        if (now - last >= ttlMs) session.detachRequested = true
+      }
+    }
+    return removed
+  }
+
   /**
    * 診断用: 生きているセッションの一覧 (sibling-inject の失敗理由に載せる / ログ用)。
    * 「TUI codex は hub-agent の管理外なので ask-sibling の宛先にならない」ことを
@@ -832,8 +1282,8 @@ export class CodexStreamBridge extends EventEmitter {
   describeLiveSessions(cwd) {
     const now = Date.now()
     const out = []
-    for (const session of this.sessions.values()) {
-      if (session.dead) continue
+    // 案B: sessions は多対一なので distinct session で走査する（購読端末数ぶん重複させない）。
+    for (const session of this._liveSessions()) {
       if (cwd && session.cwd !== cwd) continue
       out.push({
         kind: "codex",
@@ -888,8 +1338,9 @@ export class CodexStreamBridge extends EventEmitter {
     if (!cwd || !text) return false
     let best = null
     let bestAt = -1
-    for (const session of this.sessions.values()) {
-      if (session.dead || session.cwd !== cwd) continue
+    // 案B: distinct session で走査（多対一 Map の重複を除く）。
+    for (const session of this._liveSessions()) {
+      if (session.cwd !== cwd) continue
       // 宛先選定の「最新」は会話ターン境界時刻で判定する（閲覧 keepalive で動く
       // lastActivityMs を使うと「見ているだけの古い会話」が本命を追い越す）。
       const at = session.lastTurnAtMs ?? session.lastActivityMs ?? 0
@@ -963,9 +1414,11 @@ export class CodexStreamBridge extends EventEmitter {
     if (!cwd || !id || !text) return { status: "not_found" }
     let bySid = null
     const byThread = []
-    for (const session of this.sessions.values()) {
-      if (session.dead || session.cwd !== cwd) continue
-      if (session.stream_id === id) {
+    // 案B: distinct session で走査。id は **任意の購読 stream_id**（primary とは限らない）に
+    // 一致し得るので streamIds.has(id) で判定する（多端末購読の非 primary 端末も宛先にできる）。
+    for (const session of this._liveSessions()) {
+      if (session.cwd !== cwd) continue
+      if (session.streamIds.has(id)) {
         bySid = session
         break // stream_id は一意なので即確定
       }
@@ -1023,7 +1476,11 @@ export class CodexStreamBridge extends EventEmitter {
   _reapSession(session, now, reason) {
     if (session.dead) return
     session.dead = true
-    this.sessions.delete(session.stream_id)
+    // round3: reap した session の barrier を解除し queue を reject する（promise 宙吊り防止）。
+    this._settleTurnActiveWaiter(session)
+    this._drainRejectQueue(session, { reason: "queue_dead" })
+    // 案B: 全購読 stream_id キーを Map から外す（primary 1 個だけ消すと dangling が残る）。
+    this._dropAllStreamKeys(session)
     try {
       session.client.stop()
     } catch (err) {
@@ -1036,7 +1493,7 @@ export class CodexStreamBridge extends EventEmitter {
         cwd: session.cwd,
         reason,
         idle_ms: now - (session.lastActivityMs ?? now),
-        live_after: this.sessions.size,
+        live_after: this._liveSessions().length,
       },
       "codex session reaped",
     )
@@ -1057,7 +1514,8 @@ export class CodexStreamBridge extends EventEmitter {
    * @returns {number} 退避した数
    */
   _evictWarmPoolOverflow(now, reason = "lru-evict") {
-    const live = Array.from(this.sessions.values()).filter((s) => !s.dead)
+    // 案B: warm pool 上限は「distinct な生存 session 数」で判定する（購読端末数ではない）。
+    const live = this._liveSessions()
     const overflow = live.length - this._warmPoolMax
     if (overflow <= 0) return 0
     const evictable = live
@@ -1098,9 +1556,12 @@ export class CodexStreamBridge extends EventEmitter {
   reconcileSessions() {
     const now = Date.now()
     let reaped = 0
+    // 案B: 0. 死端末 GC を先に回す（多端末購読で応答が途絶えた端末を購読集合から掃除）。これで
+    //    「全端末が死んで空になったセッション」が下の idle TTL 経路で正しく reap 対象になる。
+    this.gcDeadTerminals()
     // 1〜2: stuck turn / long idle。protected（healthy running turn）はスキップ。
-    for (const session of Array.from(this.sessions.values())) {
-      if (session.dead) continue
+    // 案B: distinct session で走査（多対一 Map の重複 reap を避ける）。
+    for (const session of this._liveSessions()) {
       if (this._isProtected(session, now)) continue
       const idle = now - (session.lastActivityMs ?? now)
       if (session.activeTurnId && idle > this._stuckTurnTtlMs) {
@@ -1123,8 +1584,12 @@ export class CodexStreamBridge extends EventEmitter {
 
   /** 全セッションを即座に終了する (agent shutdown 用。ターン完走は待たない)。 */
   shutdown() {
-    for (const session of this.sessions.values()) {
+    // 案B: distinct session で走査（多対一 Map の重複 stop を避ける）。
+    for (const session of this._liveSessions()) {
       session.dead = true
+      // round3: shutdown で barrier を解除し queue 入力を reject（promise 宙吊り防止）。
+      this._settleTurnActiveWaiter(session)
+      this._drainRejectQueue(session, { reason: "queue_dead" })
       // hub-agent 再起動時にターン実行中のセッションを落とすと thread が汚染されうる
       // (exec 中の kill → output 欠落)。因果を後から辿れるよう必ず記録する。
       this.logger?.[session.activeTurnId ? "warn" : "info"]?.(

package/src/main.mjs

@@ -2064,9 +2064,9 @@ export function startStateLoop({ client, plugins, logger, intervalMs, claudeBrid
   const tick = async () => {
     if (stopped) return
     try {
-      // B11: 多端末共有時、クラッシュして detach を送らず消えた死端末を GC する
+      // B11: 多端末共有 (T06542 で常時) で、クラッシュして detach を送らず消えた死端末を GC する
       // (活性なし TTL 超過の購読端末キーを掃除し、最後の 1 台が外れたら idle softDetach へ)。
-      // CHAT_SHARED_ENABLED 無効時は no-op。例外は state loop 全体の try/catch が拾う。
+      // 例外は state loop 全体の try/catch が拾う。
       try {
         claudeBridge?.gcDeadTerminals?.()
       } catch (err) {
@@ -2559,6 +2559,13 @@ function makeSeenInputIdRegistry(max = SEEN_INPUT_IDS_MAX) {
 const seenClaudeChatInputIds = makeSeenInputIdRegistry()
 const seenCodexChatInputIds = makeSeenInputIdRegistry()
 
+// round4 major#1 (T06542): codex.input の **in-flight** dedup 用レジストリ (input_id -> Promise)。
+// `seen` は settle 後にしか登録されないため、frontend の ack watchdog (5s) が bridge の barrier/RPC
+// (turn/start→turn/started は数秒〜) より短く、同一 input_id が settle 前に再送されると bridge.input を
+// 二重に呼んで FIFO へ重複投入され、二重ターン/steer になる。処理中の input_id は再 dispatch せず既存
+// Promise へ合流させる (settle 時に元の .then/.catch が 1 回だけ ack/nack を出す)。
+const codexInflightByInputId = new Map()
+
 /**
  * input_id 付き pty.data (tracked 入力) の処理。write 成功で pty.input.ack を返し、
  * stream 不在なら pty.error を返して browser の再 attach → 再送に繋げる。
@@ -2697,13 +2704,19 @@ export function handleCodexChatInput(msg, ctx) {
     return undefined
   }
   if (input_id && seenCodexChatInputIds.has(input_id)) {
-    // 再送 (ack 喪失想定)。turn/start・turn/steer を再送出せず ack のみ返す
+    // 再送 (ack 喪失想定 / settle 済み)。turn/start・turn/steer を再送出せず ack のみ返す
     // (二重ターン実行を避ける。claude.input dedup と同じ考え方)。
     ctx.logger?.info?.({ stream_id, input_id }, "codex.input dedup (ack only)")
     ctx.client.send({ type: "codex.input.ack", stream_id, input_id })
     return undefined
   }
-  return ctx.codexBridge
+  if (input_id && codexInflightByInputId.has(input_id)) {
+    // round4 major#1: **処理中** の同一 input_id (watchdog の settle 前再送)。再 dispatch せず既存
+    // Promise へ合流する (元の .then/.catch が settle 時に 1 回だけ ack/nack を出すので二重投入しない)。
+    ctx.logger?.info?.({ stream_id, input_id }, "codex.input in-flight dedup (join, no re-dispatch)")
+    return codexInflightByInputId.get(input_id)
+  }
+  const p = ctx.codexBridge
     .input({
       stream_id,
       message: msg.message,
@@ -2735,6 +2748,12 @@ export function handleCodexChatInput(msg, ctx) {
         ...(err.reason ? { reason: err.reason } : {}),
       })
     })
+    .finally(() => {
+      // in-flight レジストリから外す (成功時は seen が以降の再送を dedup、失敗時は再送で正当にリトライ)。
+      if (input_id) codexInflightByInputId.delete(input_id)
+    })
+  if (input_id) codexInflightByInputId.set(input_id, p)
+  return p
 }
 
 /**

package/src/service-install.mjs

@@ -15,8 +15,6 @@ import path from "node:path"
 import { spawnSync } from "node:child_process"
 import { fileURLToPath } from "node:url"
 
-import { readConfig } from "./config.mjs"
-
 const PLIST_LABEL = "co.cocorograph.hub-agent"
 const SYSTEMD_UNIT_NAME = "hub-agent.service"
 // Windows(WSL) のログオン keep-alive タスク名 (install.ps1 の $TASK_NAME と一致)。
@@ -55,7 +53,7 @@ function escapeXmlText(s) {
     .replaceAll(">", ">")
 }
 
-function expandTemplate(text, hubAgentBin, opts = {}) {
+function expandTemplate(text, hubAgentBin) {
   // hub-agent デーモンの runtime 環境に必須な追加 env を、各プラットフォームの
   // 起動ファイル形式 (plist / systemd) に合わせて差し込むためのプレースホルダ展開。
   //
@@ -78,22 +76,8 @@ function expandTemplate(text, hubAgentBin, opts = {}) {
     systemdLine = `Environment=NODE_EXTRA_CA_CERTS=${nodeExtraCa}\n`
   }
 
-  // 多端末共有チャット (HUB_AGENT_CHAT_SHARED)。NODE_EXTRA_CA_CERTS と同じ仕組みで
-  // plist / systemd の EnvironmentVariables に焼き込む。値ソースは (a) installService
-  // が agent.json.chat_shared を読んで渡す opts.chatShared、または (b) install-service
-  // 実行時の process.env.HUB_AGENT_CHAT_SHARED。これにより agent 更新で install-service
-  // が plist を再生成しても、agent.json に chat_shared=true があればフラグが維持される
-  // (旧実装は手動 plist 追記が再生成で消える事故があった。2026-05-30)。
-  const chatShared =
-    opts.chatShared === true || process.env.HUB_AGENT_CHAT_SHARED === "1"
-  let chatPlistEntry = ""
-  let chatSystemdLine = ""
-  if (chatShared) {
-    chatPlistEntry =
-      `    <key>HUB_AGENT_CHAT_SHARED</key>\n` +
-      `    <string>1</string>\n`
-    chatSystemdLine = `Environment=HUB_AGENT_CHAT_SHARED=1\n`
-  }
+  // T06542: 多端末共有チャットは既定 ON 化しフラグ (HUB_AGENT_CHAT_SHARED) を撤去した。
+  // plist/systemd への env 焼き込みも不要になったため、テンプレートの placeholder ごと削除済み。
 
   return text
     .replaceAll("__HUB_AGENT_BIN__", hubAgentBin)
@@ -101,19 +85,6 @@ function expandTemplate(text, hubAgentBin, opts = {}) {
     .replaceAll("__PATH__", process.env.PATH || "/usr/local/bin:/usr/bin:/bin")
     .replaceAll("__NODE_EXTRA_CA_CERTS_PLIST_ENTRY__", plistEntry)
     .replaceAll("__NODE_EXTRA_CA_CERTS_SYSTEMD_LINE__", systemdLine)
-    .replaceAll("__HUB_AGENT_CHAT_SHARED_PLIST_ENTRY__", chatPlistEntry)
-    .replaceAll("__HUB_AGENT_CHAT_SHARED_SYSTEMD_LINE__", chatSystemdLine)
-}
-
-/** agent.json から多端末共有フラグ (chat_shared) を読む。読めなければ false。
- *  install-service 時に plist/systemd へ焼き込む値ソースに使う (env 併用は expandTemplate 側)。 */
-async function readChatSharedFromConfig() {
-  try {
-    const config = await readConfig()
-    return config?.chat_shared === true
-  } catch {
-    return false
-  }
 }
 
 async function ensureDir(p) {
@@ -290,12 +261,9 @@ export async function installService({ bin } = {}) {
   const hubAgentBin = bin || detectHubAgentBin()
   await ensureLogFile()
 
-  // agent.json の永続フラグを読み、テンプレ展開に渡す (再生成でも維持されるように)。
-  const chatShared = await readChatSharedFromConfig()
-
   if (process.platform === "darwin") {
     const tpl = await readTemplate("co.cocorograph.hub-agent.plist")
-    const expanded = expandTemplate(tpl, hubAgentBin, { chatShared })
+    const expanded = expandTemplate(tpl, hubAgentBin)
     const dest = macPlistPath()
     await ensureDir(path.dirname(dest))
     await fs.writeFile(dest, expanded, { mode: 0o644 })
@@ -317,7 +285,7 @@ export async function installService({ bin } = {}) {
 
   if (process.platform === "linux") {
     const tpl = await readTemplate("hub-agent.service")
-    const expanded = expandTemplate(tpl, hubAgentBin, { chatShared })
+    const expanded = expandTemplate(tpl, hubAgentBin)
     const dest = linuxUnitPath()
     await ensureDir(path.dirname(dest))
     await fs.writeFile(dest, expanded, { mode: 0o644 })

package/templates/co.cocorograph.hub-agent.plist

@@ -52,7 +52,7 @@
     <string>__PATH__</string>
     <key>HOME</key>
     <string>__HOME__</string>
-__NODE_EXTRA_CA_CERTS_PLIST_ENTRY____HUB_AGENT_CHAT_SHARED_PLIST_ENTRY__  </dict>
+__NODE_EXTRA_CA_CERTS_PLIST_ENTRY__  </dict>
 
   <!-- KeepAlive で過剰再起動した時に 10 秒スロットルする -->
   <key>ThrottleInterval</key>

package/templates/hub-agent.service

@@ -12,7 +12,7 @@ Type=simple
 # 行に、未 set なら空文字列に」展開する。
 Environment=PATH=__PATH__
 Environment=HOME=__HOME__
-__NODE_EXTRA_CA_CERTS_SYSTEMD_LINE____HUB_AGENT_CHAT_SHARED_SYSTEMD_LINE__WorkingDirectory=__HOME__
+__NODE_EXTRA_CA_CERTS_SYSTEMD_LINE__WorkingDirectory=__HOME__
 ExecStart=__HUB_AGENT_BIN__ start
 Restart=always
 RestartSec=10