@cocorograph/hub-agent 0.7.98 → 0.7.100

package/package.json

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

package/src/claude-stream-bridge.mjs

@@ -2442,27 +2442,62 @@ export class ClaudeStreamBridge extends EventEmitter {
    * @returns {Array<{kind: string, cwd: string, session_id: string|null, idle_ms: number}>}
    */
   describeLiveSessions(cwd) {
-    const now = Date.now()
+    return this._liveCandidatesForCwd(cwd, false).map(({ session, attached }) =>
+      this._describeCandidate(session, attached),
+    )
+  }
+
+  /**
+   * cwd 内の live セッション候補を `{session, attached}` の配列で返す共通スキャン。
+   * this.sessions (attached=browser 接続中) と _liveBySession (attached=false=soft-detached の warm)
+   * の **union** を走査し、両 Map に載り得る同一セッションは seen で重複排除する。attached は
+   * 「this.sessions に在籍しているか」で決める。
+   *
+   * ⚠️ describeLiveSessions(計数) と sendToCwd/sendToStream(配送) をこの同一集合に揃えることで、
+   * 従来「this.sessions のみ計数 / union 配送」の非対称が生んでいた undercount 由来のサイレント
+   * 誤配送 (detached-busy な旧セッションへ配送しつつ計数上は1本に見える TOCTOU) を排除する。
+   *
+   * @param {string} [cwd] 指定時はその cwd のみ
+   * @param {boolean} [requireSessionId=false] sessionId 未確定の fresh を除外するか
+   * @returns {Array<{session: object, attached: boolean}>}
+   */
+  _liveCandidatesForCwd(cwd, requireSessionId = false) {
     const out = []
     const seen = new Set()
-    for (const session of this.sessions.values()) {
-      if (seen.has(session)) continue
-      seen.add(session)
-      if (cwd && session.cwd !== cwd) continue
-      let at = 0
-      for (const t of session.lastActivityByStream?.values?.() ?? []) {
-        if (t > at) at = t
+    const collect = (iter, attached) => {
+      for (const session of iter) {
+        if (seen.has(session)) continue
+        // reap 済み (_closed) セッションは _liveBySession に残留し得るため除外する。union 走査で
+        // これを拾うと、reconcileWarmBounds で畳まれた古い session が宛先として復活してしまう。
+        if (session._closed) continue
+        if (cwd && session.cwd !== cwd) continue
+        if (requireSessionId && !session.sessionId) continue
+        seen.add(session)
+        out.push({ session, attached })
       }
-      out.push({
-        kind: "claude",
-        cwd: session.cwd,
-        session_id: session.sessionId || null,
-        idle_ms: at ? now - at : -1,
-      })
     }
+    // attached を先に走査して attached=true で登録、その後 warm を attached=false で補完する。
+    collect(this.sessions.values(), true)
+    collect(this._liveBySession.values(), false)
     return out
   }
 
+  /** describeLiveSessions と同形の 1 セッション記述子 (sendToCwd/sendToStream の結果整形に共用)。 */
+  _describeCandidate(session, attached) {
+    const now = Date.now()
+    let at = 0
+    for (const t of session.lastActivityByStream?.values?.() ?? []) {
+      if (t > at) at = t
+    }
+    return {
+      kind: "claude",
+      cwd: session.cwd,
+      session_id: session.sessionId || null,
+      idle_ms: at ? now - at : -1,
+      attached,
+    }
+  }
+
   /**
    * 指定 cwd で現在ライブな (browser 接続中、または detach 猶予内の) SDK チャット
    * session_id を返す。無ければ null。
@@ -2563,24 +2598,40 @@ export class ClaudeStreamBridge extends EventEmitter {
    * ⚠️ このメソッド自体は認証を行わない (呼び出し元の sibling-inject.mjs が
    * src/sibling-token.mjs の capability トークンで入力元を検証する前提)。
    *
+   * ⚠️ 宛先解決 (2026-07-23, 統一再設計 1-1): 従来の「最終活性が最も新しいものを選ぶ」
+   * ヒューリスティックを廃止し、**attached (前面=browser 接続中) 優先 + 曖昧は fail-safe** に
+   * 変更した。union 候補のうち attached があれば attached 層、無ければ warm 層から選び、層内が
+   * 1 本なら配送・複数なら推測せず ambiguous を返す。これにより「detached-busy な旧セッション A と
+   * 同 cwd の新規 attached B が併存するとき、計数上は B 1本に見えつつ配送は活性の新しい A に
+   * 落ちる」サイレント誤配送を、B (前面) への確定配送へ是正する (真に曖昧な稀ケースのみ
+   * ambiguous で fail-safe。誤配送はしない)。返り値は sendToStream と同形の status オブジェクト。
+   *
    * @param {string} cwd
    * @param {string} text
-   * @returns {boolean} 送信できたか (対象セッションが見つからなければ false)
+   * @returns {{status:"delivered", session:object} | {status:"not_found"} | {status:"ambiguous", candidates:object[]}}
    */
   sendToCwd(cwd, text) {
-    if (!cwd || !text) return false
-    // P5 (T06570): warm (soft-detached) セッションも対象にするため union 走査へ委譲する
-    // (従来は this.sessions のみで、detach 済みだが生きているセッションへ sibling-inject できず
-    // no_live_session_for_cwd になっていた)。sessionId 未確定の fresh も対象にするため false。
-    const best = this._liveSessionForCwd(cwd, false)
-    if (!best) return false
-    best.sendMessage({ role: "user", content: text }).catch((err) => {
+    if (!cwd || !text) return { status: "not_found" }
+    // sessionId 未確定の fresh も配送対象にするため requireSessionId=false。
+    const cands = this._liveCandidatesForCwd(cwd, false)
+    if (cands.length === 0) return { status: "not_found" }
+    const attached = cands.filter((c) => c.attached)
+    // attached があれば attached 層のみ、無ければ warm 層で解決する (前面優先)。
+    const tier = attached.length ? attached : cands
+    if (tier.length > 1) {
+      return {
+        status: "ambiguous",
+        candidates: tier.map((c) => this._describeCandidate(c.session, c.attached)),
+      }
+    }
+    const { session, attached: att } = tier[0]
+    session.sendMessage({ role: "user", content: text }).catch((err) => {
       this.logger?.error(
         { cwd, err: err?.message },
         "sendToCwd: sendMessage threw unexpectedly",
       )
     })
-    return true
+    return { status: "delivered", session: this._describeCandidate(session, att) }
   }
 
   /**
@@ -2608,34 +2659,28 @@ export class ClaudeStreamBridge extends EventEmitter {
    */
   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)
-    }
+    // union 走査 (2026-07-23, 統一再設計 1-1): warm (soft-detached) セッションも session_id
+    // ピンの対象にする。従来は this.sessions のみで、detach 済みだが生きているセッションを
+    // 明示 session_id で指しても not_found になっていた (describeLiveSessions/sendToCwd と非対称)。
+    const matches = this._liveCandidatesForCwd(cwd, false).filter(
+      (c) => c.session.sessionId === sessionId,
+    )
     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) }
+      return {
+        status: "ambiguous",
+        candidates: matches.map((c) => this._describeCandidate(c.session, c.attached)),
+      }
     }
-    matches[0].sendMessage({ role: "user", content: text }).catch((err) => {
+    const { session, attached } = matches[0]
+    session.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]) }
+    return { status: "delivered", session: this._describeCandidate(session, attached) }
   }
 
   /**

package/src/codex-stream-bridge.mjs

@@ -1407,19 +1407,30 @@ export class CodexStreamBridge extends EventEmitter {
    * ⚠️ このメソッド自体は認証を行わない (呼び出し元の sibling-inject.mjs が
    * src/sibling-token.mjs の capability トークンで入力元を検証する前提)。
    *
+   * ⚠️ 返り値 (2026-07-23, 統一再設計 1-1): claude 版と契約を揃えるため boolean から status
+   * オブジェクトへ変更した。codex は計数(describeLiveSessions)と配送が同一集合 (_liveSessions())
+   * を見るため claude のような undercount 由来のサイレント誤配送は構造的に起きず、宛先選定は
+   * 従来どおり「会話ターン境界時刻が最新」のヒューリスティックを維持する (挙動不変)。
+   *
    * @param {string} cwd
    * @param {string} text
-   * @returns {boolean} 送信できたか (対象セッションが見つからなければ false)
+   * @returns {{status:"delivered", session:object} | {status:"not_found"}}
    */
   sendToCwd(cwd, text) {
-    if (!cwd || !text) return false
+    if (!cwd || !text) return { status: "not_found" }
+    // 案B: distinct session で走査（多対一 Map の重複を除く）。
+    const cands = this._liveSessions().filter((s) => s.cwd === cwd)
+    // attached (前面=detach 未要求) 優先 (2026-07-23 統一再設計 1-1, cross-review 指摘4):
+    // detach 済み warm セッションが lastTurnAtMs 上たまたま新しくても、attached な現行セッションが
+    // あればそちらへ配送する (browser を離れた/畳まれかけの旧会話 ghost への誤配送を防ぐ)。
+    // claude と違い codex は同一 cwd に複数 attached が併存し得る (別スレッドの新会話 / ターン
+    // 実行中) ため fail-safe ambiguous にはせず、tier 内は会話ターン境界時刻が最新のものを選ぶ
+    // (閲覧 keepalive で動く lastActivityMs は使わない = 見ているだけの古い会話が本命を追い越さない)。
+    const attached = cands.filter((s) => !s.detachRequested)
+    const tier = attached.length ? attached : cands
     let best = null
     let bestAt = -1
-    // 案B: distinct session で走査（多対一 Map の重複を除く）。
-    for (const session of this._liveSessions()) {
-      if (session.cwd !== cwd) continue
-      // 宛先選定の「最新」は会話ターン境界時刻で判定する（閲覧 keepalive で動く
-      // lastActivityMs を使うと「見ているだけの古い会話」が本命を追い越す）。
+    for (const session of tier) {
       const at = session.lastTurnAtMs ?? session.lastActivityMs ?? 0
       if (at >= bestAt) {
         bestAt = at
@@ -1431,7 +1442,7 @@ export class CodexStreamBridge extends EventEmitter {
         { cwd, live_sessions: this.describeLiveSessions() },
         "codex sendToCwd: no live session for cwd (ask-sibling will fail)",
       )
-      return false
+      return { status: "not_found" }
     }
     // detach 済み warm セッションでも、ask-sibling が使うなら「新しい持ち主が付いた」とみなして
     // detachRequested を解除し touch する（LRU 先頭へ）。this.input が改めて _touch するが、注入前に
@@ -1456,7 +1467,7 @@ export class CodexStreamBridge extends EventEmitter {
         )
       },
     )
-    return true
+    return { status: "delivered", session: this._describe(best) }
   }
 
   /**

package/src/main.mjs

@@ -2861,9 +2861,12 @@ const STREAMS_SYNC_GRACE_MS = 45_000
  * Plan ε: `agent.streams.sync.response` を受けて backend ↔ agent の現存
  * stream_id を能動同期する。
  *
- * - local にあって backend にない → ptyBridge.detach で即時 kill (孤児)
- * - backend にあって local にない → backend に pty.error を通知 (browser に
- *   "pty 死んでます" を表示するため)
+ * - PTY: local にあって backend にない → ptyBridge.detach、逆差分 → pty.error
+ * - Claude/Codex: mode 別 snapshot から外れた古い subscriber を grace 付きで掃除
+ *
+ * active_stream_ids だけを全件 PTY とみなすと、正常な Claude/Codex に
+ * pty.error(stream_not_found_on_agent) を返して再 attach storm を誘発するため、
+ * 新 backend の active_streams を優先する。
  *
  * dispatch から呼ぶ用のヘルパーだが、テストから直接叩けるよう export している。
  */
@@ -2871,6 +2874,32 @@ export function handleStreamsSyncResponse(msg, ctx) {
   const activeIds = new Set(
     Array.isArray(msg?.active_stream_ids) ? msg.active_stream_ids : [],
   )
+  const activeByMode = { pty: new Set(), claude: new Set(), codex: new Set() }
+  const classifiedIds = new Set()
+  if (Array.isArray(msg?.active_streams)) {
+    for (const item of msg.active_streams) {
+      const streamId = item?.stream_id
+      const mode = item?.mode
+      const modeSet = activeByMode[mode]
+      if (typeof streamId !== "string" || !streamId || !(modeSet instanceof Set)) continue
+      modeSet.add(streamId)
+      classifiedIds.add(streamId)
+    }
+  }
+  // Blue-Green ローリング中に旧 BrowserConsumer の mode 無し応答が混ざった場合は
+  // typed snapshot を authoritative とみなさない。既知 chat stream だけ除外して
+  // legacy 互換を維持し、正常な Claude/Codex に ghost PTY error を返さない。
+  const haveCompleteModeSnapshot =
+    Array.isArray(msg?.active_streams)
+    && classifiedIds.size === activeIds.size
+    && Array.from(classifiedIds).every((id) => activeIds.has(id))
+  const knownChatIds = new Set([
+    ...Array.from(ctx.claudeBridge?.sessions?.keys?.() ?? []),
+    ...Array.from(ctx.codexBridge?.sessions?.keys?.() ?? []),
+  ])
+  const activePtyIds = haveCompleteModeSnapshot
+    ? activeByMode.pty
+    : new Set(Array.from(activeIds).filter((id) => !knownChatIds.has(id)))
   const localIds = new Set(ctx.ptyBridge.list())
   // churn 退化スナップショット保護 (ack_lost 根治 / 2026-06-17 根因 rank3)。
   // backend は browser 群へ _STREAMS_SYNC_TIMEOUT_S(0.5s) だけ問い合わせて active set を
@@ -2881,7 +2910,7 @@ export function handleStreamsSyncResponse(msg, ctx) {
   // 空 set は信用せず kill を一切行わない (真の孤児は 10min GC + maxStreams 上限が回収する)。
   const haveAuthoritativeActiveSet = activeIds.size > 0
   for (const sid of localIds) {
-    if (activeIds.has(sid)) continue
+    if (activePtyIds.has(sid)) continue
     if (!haveAuthoritativeActiveSet) continue
     // grace guard: 直近 STREAMS_SYNC_GRACE_MS 以内に touch (attach/write/resize/pty 出力) された
     // stream は「browser が再接続中で 0.5s 集計に間に合わなかっただけ」の可能性が高い。猶予内は
@@ -2901,7 +2930,7 @@ export function handleStreamsSyncResponse(msg, ctx) {
     )
     ctx.ptyBridge.detach({ stream_id: sid })
   }
-  for (const sid of activeIds) {
+  for (const sid of activePtyIds) {
     if (!localIds.has(sid)) {
       ctx.logger?.warn?.(
         { stream_id: sid, request_id: msg?.request_id },
@@ -2914,6 +2943,51 @@ export function handleStreamsSyncResponse(msg, ctx) {
       })
     }
   }
+
+  if (haveCompleteModeSnapshot) {
+    // reconnect 集計は browser ごとの復帰順で一時的に部分集合になり得る。
+    // 同じ mode の現役購読を1件も確認できない段階では、その mode 全体を掃除しない。
+    if (activeByMode.claude.size > 0) {
+      pruneInactiveChatSubscribers(
+        ctx.claudeBridge,
+        activeByMode.claude,
+        "claude",
+        ctx.logger,
+      )
+    }
+    if (activeByMode.codex.size > 0) {
+      pruneInactiveChatSubscribers(
+        ctx.codexBridge,
+        activeByMode.codex,
+        "codex",
+        ctx.logger,
+      )
+    }
+  }
+}
+
+/** backend の mode-aware snapshot に存在しない死 browser subscriber を除去する。
+ * 再接続が 0.5s 集計に間に合わなかった場合に備え、直近活性が grace 内の stream は保護する。 */
+export function pruneInactiveChatSubscribers(bridge, activeIds, mode, logger, now = Date.now()) {
+  if (!bridge?.sessions || typeof bridge.detach !== "function") return 0
+  let removed = 0
+  for (const session of new Set(bridge.sessions.values())) {
+    for (const streamId of Array.from(session?.streamIds ?? [])) {
+      if (activeIds.has(streamId)) continue
+      const lastSeen = session?.lastActivityByStream?.get?.(streamId) ?? 0
+      if (lastSeen > 0 && now - lastSeen < STREAMS_SYNC_GRACE_MS) continue
+      bridge.detach({ stream_id: streamId })
+      // Codex は live session の索引を最低1件残す不変条件があり、最後の1件では
+      // detachRequested を立てるだけで streamIds からは消さない。実際に消えた件だけ数える。
+      if (session.streamIds?.has?.(streamId)) continue
+      removed += 1
+      logger?.info?.(
+        { stream_id: streamId, mode, idle_ms: lastSeen > 0 ? now - lastSeen : null },
+        "inactive chat subscriber pruned after streams sync",
+      )
+    }
+  }
+  return removed
 }
 
 /**
@@ -3522,6 +3596,9 @@ async function dispatch(msg, ctx) {
         // 5s タイムアウトのような明示的な timer は持たず、再接続時に再度 request
         // が飛ぶので無害。
         handleStreamsSyncResponse(msg, ctx)
+        // buffered pty/control event は browser の購読集合が確定してから再送する。
+        // request_id は WsClient 側で現 reconnect 世代と照合され、古い応答は無視される。
+        ctx.client.completeStreamsSync?.(msg)
         return
       case "claude.attach": {
         // Sprint G: stream-json モードで Claude Code を起動。

package/src/sibling-inject.mjs

@@ -10,10 +10,15 @@
  * ファイル IPC 前例 (tui-permission-bridge.mjs 等、`/tmp/cockpit_*` + fs.watch +
  * atomic write) と同じパターンに揃える。
  *
- * ⚠️ セキュリティ設計 (2026-07-04 セッションでユーザー承認済み): この機構は
+ * ⚠️ セキュリティ設計 (2026-07-04 承認 / 2026-07-23 統一再設計 1-2 で緩和): この機構は
  * 「生きている自律エージェント (シェル/API/MCP ツールへのフルアクセス権を持つ)
  * へ外部プロセスから新規指示を注入する」という強い書き込み権限を持つため、
- * `src/sibling-token.mjs` の cwd スコープ capability トークンによる検証を必須とする。
+ * `src/sibling-token.mjs` の capability トークンによる検証を必須とする。
+ * 認可粒度は当初「ターゲット cwd 所有」だったが、claude↔claude / codex↔codex を含む
+ * クロス cwd 連携を可能にするため「**いずれかの cwd の有効トークン所有 (= 同一ユーザーの
+ * spawn 済みセッション)**」へ緩和した (`verifySiblingTokenAny`)。無認証プロセス (npm
+ * postinstall 等) はどの cwd のトークンも持たないため排除される核心は維持。ターゲット
+ * 解決は引き続き要求の cwd でスコープする (誤 cwd 着弾・別 workspace 情報漏洩を防ぐ)。
  * トークンが一致しない要求は無視し (実行せず削除)、warn ログのみ残す。
  *
  * 契約: request file `<request_id>.json` は op で 3 形態 (2026-07-19 / T06271):
@@ -25,6 +30,8 @@
  *       新 agent だけが処理する (probe を挟まず単一リクエストで TOCTOU を排除)。
  *       宛先は session_id(claude) / stream_id・thread_id(codex) を cwd 一致下に確定解決。
  *   - 一覧: `{op:"list", cwd, target_cli_kind, token}` → `{ok, live_sessions}` (--list 用)。
+ *   - 全一覧: `{op:"list-all", token}` → `{ok, live_sessions}` (全 cwd・両 CLI。クロス cwd
+ *       宛先探索用、2026-07-23。cwd/target_cli_kind 不要、token のみ必須)。
  * 処理後は必ず削除し (成否問わず)、呼び出し側が待ち受けられるよう
  * `<request_id>.result.json` = `{ok, error?, delivered_to?, candidates?, live_sessions?, hint?}` を書く。
  */
@@ -33,7 +40,7 @@ import { watch } from "node:fs"
 import { mkdir, readFile, writeFile, rename, unlink, readdir } from "node:fs/promises"
 import path from "node:path"
 
-import { verifySiblingToken } from "./sibling-token.mjs"
+import { verifySiblingTokenAny, siblingTokenCwd } from "./sibling-token.mjs"
 
 export const SIBLING_REQUESTS_DIR =
   process.env.COCKPIT_SIBLING_REQUESTS_DIR || "/tmp/cockpit_sibling_requests"
@@ -117,6 +124,7 @@ export class SiblingInjectBridge {
     //    未知フィールドを無視して sendToCwd 推測注入する事故が **単一リクエストで原理的に
     //    起きない** (probe→注入の TOCTOU を排除)。
     const { op, cwd, target_cli_kind, text, message, token, target_session_id } = body || {}
+    const isListAll = op === "list-all"
     const isList = op === "list"
     const isExplicit = op === "inject"
     let result
@@ -126,12 +134,47 @@ export class SiblingInjectBridge {
       : isExplicit
         ? !target_session_id || !message // 明示は id と message 必須 (空指定 fail-open を防ぐ)
         : !text // 通常は top-level text 必須 (＝旧契約)
-    if (!cwd || badKind || badBody) {
+    if (isListAll) {
+      // op:"list-all" (2026-07-23 統一再設計 1-2: クロス cwd 宛先探索): 全 cwd・両 CLI の
+      // ライブセッションを列挙する。cwd / target_cli_kind / 本文は不要 (token のみ必須)。
+      // 認可は verifySiblingTokenAny (同一ユーザーの spawn 済みセッションであれば全 cwd を
+      // 見渡せる。orchestrate リーダーが別プロジェクトの sub の宛先アドレスを得るため)。
+      if (!token) {
+        result = { ok: false, error: "invalid_request" }
+      } else if (!verifySiblingTokenAny(token)) {
+        this.logger?.warn({ request_id }, "sibling-inject: invalid sibling token (list-all)")
+        result = { ok: false, error: "invalid_token" }
+      } else {
+        result = {
+          ok: true,
+          live_sessions: [
+            ...(this.claudeBridge?.describeLiveSessions?.() ?? []),
+            ...(this.codexBridge?.describeLiveSessions?.() ?? []),
+          ],
+        }
+      }
+    } else 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")
+    } else if (!verifySiblingTokenAny(token)) {
+      // 2026-07-23 統一再設計 1-2: 認可を「ターゲット cwd 所有」→「いずれかの cwd の有効トークン
+      // 所有 (= 同一ユーザーの spawn 済みセッション)」へ緩和し、クロス cwd 連携を解禁する。
+      // cwd は引き続きターゲット解決のスコープとして使う (誤 cwd 着弾・情報漏洩は解決側で担保)。
+      this.logger?.warn({ cwd, request_id }, "sibling-inject: invalid sibling token, request denied")
       result = { ok: false, error: "invalid_token" }
     } else {
+      // クロス cwd 監査 (2026-07-23, cross-review round2 minor): 認可は同一ユーザーの any-cwd
+      // トークンで通るが、注入先の cwd がトークン発行元の cwd と異なる (= クロス cwd 注入) 場合は
+      // 「どの cwd のセッションから来たか」を info ログに残す (認可判定には使わない、追跡用)。
+      // op:list / list-all は非破壊なので対象外、注入系 (op:inject / 通常) のみ記録する。
+      if (!isList) {
+        const fromCwd = siblingTokenCwd(token)
+        if (fromCwd && fromCwd !== cwd) {
+          this.logger?.info?.(
+            { request_id, from_cwd: fromCwd, to_cwd: cwd, target_cli_kind, op: op || "normal" },
+            "sibling-inject: cross-cwd injection (audit)",
+          )
+        }
+      }
       const bridge = target_cli_kind === "codex" ? this.codexBridge : this.claudeBridge
       if (isList) {
         // 宛先候補の列挙 (cockpit_orch.py --list 用)。この cwd の同種セッションを返す。
@@ -177,21 +220,27 @@ export class SiblingInjectBridge {
           }
         }
       } else {
-        // 宛先省略 (通常): 同一 cwd の生きたセッション数で分岐。
-        //   0 本 → no_live_session / 1 本 → 注入 / 複数 → 黙って推測せず ambiguous_target。
-        const sameCwd = bridge?.describeLiveSessions?.(cwd) ?? []
-        if (sameCwd.length > 1) {
+        // 宛先省略 (通常): sendToCwd が union 候補から attached 優先で 1 本に確定解決する。
+        //   status:"delivered" → 注入 / "ambiguous" → 複数候補で fail-safe / "not_found" → 0 本。
+        //
+        // ⚠️ アトミック化 (2026-07-23, 統一再設計 1-1): 旧実装は describeLiveSessions.length の
+        //    計数ゲートと sendToCwd の配送を分離しており、warm セッションを取りこぼす計数
+        //    (claude: this.sessions のみ) をすり抜けて配送だけが warm へ落ちる TOCTOU
+        //    (サイレント誤配送 + delivered_to に実配送先でない sameCwd[0] を報告する成功偽装) が
+        //    あった。sendToCwd を status 返却にして解決と配送を 1 呼び出しに統合し、delivered_to は
+        //    **実配送先 (r.session)** を返す。
+        const r = bridge?.sendToCwd?.(cwd, text) ?? { status: "not_found" }
+        if (r.status === "delivered") {
+          result = { ok: true, delivered_to: r.session ?? null }
+        } else if (r.status === "ambiguous") {
           result = {
             ok: false,
             error: "ambiguous_target",
-            candidates: sameCwd,
-            live_sessions: sameCwd,
+            candidates: r.candidates,
+            live_sessions: r.candidates,
           }
         } 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) }
+          result = { ok: false, error: "no_live_session_for_cwd", ...this._diagnose(cwd, target_cli_kind) }
         }
       }
     }

package/src/sibling-token.mjs

@@ -56,6 +56,50 @@ export function verifySiblingToken(cwd, token) {
   return typeof expected === "string" && expected === token
 }
 
+/**
+ * 提示されたトークンが **いずれかの cwd** の有効な sibling トークンと一致するか検証する
+ * (2026-07-23, 統一再設計 1-2: クロス cwd 連携の認可緩和)。
+ *
+ * 従来の `verifySiblingToken(cwd, token)` は「ターゲット cwd 自身のトークン」を要求するため
+ * 同一 cwd 内の相互依頼しか通せなかった。claude↔claude / codex↔codex を含むクロス cwd 連携
+ * (orchestrate のリーダー→別プロジェクトのサブ等) を可能にするため、認可の粒度を
+ * 「**ターゲット cwd 所有**」から「**この hub-agent が spawn したいずれかのセッション所有**
+ * (= 同一ユーザー)」へ緩和する。
+ *
+ * ⚠️ トレードオフ (ユーザー承認済み 2026-07-23): 注入先の cwd 境界を越えられるようになるが、
+ * hub-agent は 1 ユーザー専用デーモンであり、全 cwd のセッションは同一ユーザー自身のもの
+ * なので信頼境界を跨がない。守るべき核心 = 「hub-agent が env にのみ渡したトークンを持たない
+ * 無認証プロセス (npm postinstall 等) の注入を防ぐ」は、**いずれかの cwd の有効トークン一致**を
+ * 必須にすることで維持される (無関係プロセスはどの cwd のトークンも持てない)。ターゲット
+ * セッションの解決自体は呼び出し側が渡す cwd で引き続きスコープされる (誤 cwd 着弾防止・
+ * 別 workspace の情報漏洩防止は sendToStream/_diagnose 側で担保)。
+ *
+ * @param {string} token
+ * @returns {boolean}
+ */
+export function verifySiblingTokenAny(token) {
+  if (!token || typeof token !== "string") return false
+  for (const expected of tokensByCwd.values()) {
+    if (expected === token) return true
+  }
+  return false
+}
+
+/**
+ * 提示されたトークンがどの cwd に発行されたものかを逆引きする (2026-07-23, クロス cwd 監査用)。
+ * 一致する cwd が無ければ null。verifySiblingTokenAny でクロス cwd 注入を許した際、
+ * 「どの cwd のセッションから来たか」を監査ログに残すために使う (認可の可否判定には使わない)。
+ * @param {string} token
+ * @returns {string|null}
+ */
+export function siblingTokenCwd(token) {
+  if (!token || typeof token !== "string") return null
+  for (const [cwd, expected] of tokensByCwd.entries()) {
+    if (expected === token) return cwd
+  }
+  return null
+}
+
 /** テスト用: トークンストアを全クリアする。 */
 export function _resetSiblingTokens() {
   tokensByCwd.clear()

package/src/ws-client.mjs

@@ -66,8 +66,9 @@ const PTY_BUFFER_MAX_AGE_MS = 30_000
 // `claude.jsonl.event ... "ws send skipped (not open)"` のドロップを観測)。
 //   - pty.input.ack: 喪失すると browser の pendingAcks が永久滞留し「送信待ち(未配信)」が
 //     消えない (S1/S3)。再接続 flush で遅れて届けば即解消する。
-//   - claude.jsonl.event / claude.event / session.event: 喪失すると新規セッションの
-//     楽観バブルが本物へ昇格できず「生成は始まったがバブルが出ない」(S5)。
+//   - claude/codex の event / ready / exit / error / permission / input ack,nack:
+//     喪失すると新規セッションの楽観バブルが本物へ昇格できず、再 attach も固着する。
+//   - claude.jsonl.event / session.event: TUI と一覧の確定状態を復元する。
 //   - pty.exit / pty.ready / pty.error: stream ライフサイクルの節目。落とすと browser の
 //     再 attach/復帰判断が狂う。
 // pty.data とは別バッファにするのは、高頻度な pty.data の洪水で低頻度な ack/event が
@@ -80,11 +81,29 @@ const BUFFERED_CTRL_TYPES = new Set([
   "pty.error",
   "claude.jsonl.event",
   "claude.event",
+  "claude.ready",
+  "claude.exit",
+  "claude.error",
+  "claude.permission.request",
+  "claude.permission.cancel",
+  "claude.input.ack",
+  "claude.input.nack",
+  "codex.event",
+  "codex.ready",
+  "codex.exit",
+  "codex.error",
+  "codex.permission.request",
+  "codex.input.ack",
+  "codex.input.nack",
   "session.event",
 ])
 // 制御/イベントバッファの上限。低頻度なので frames は小さめ、age は pty と揃える。
 const CTRL_BUFFER_MAX_FRAMES = 200
 const CTRL_BUFFER_MAX_AGE_MS = 30_000
+// reconnect 後の buffered event は backend が browser の active stream 集合を
+// 回収し終えるまで流さない。通常は 0.5s で応答する。旧 backend 互換のため 2s で
+// barrier を解除するが、通常時の送受信経路には一切待ちを追加しない。
+const STREAMS_SYNC_BARRIER_TIMEOUT_MS = 2_000
 
 /** SDK-P2 (2026-07-08): claude.event が「ephemeral な生成中 delta」かどうか。
  *  stream_event の content_block_delta (text_delta / thinking_delta) は高頻度で流れる
@@ -97,6 +116,12 @@ function isEphemeralDeltaEvent(obj) {
   return ev.event?.type === "content_block_delta"
 }
 
+/** Codex App Server の item/agentMessage/delta 等は再水和可能な高頻度delta。 */
+function isEphemeralCodexDeltaEvent(obj) {
+  const method = obj?.event?.method
+  return typeof method === "string" && method.toLowerCase().endsWith("/delta")
+}
+
 export class WsClient extends EventEmitter {
   /**
    * @param {{ hub_url: string, agent_id: string, agent_token: string }} config
@@ -149,6 +174,10 @@ export class WsClient extends EventEmitter {
     // 制御/イベント系 (ack / jsonl.event 等) の outbound buffer。pty.data とは別管理で、
     // 高頻度 pty.data の洪水に evict されないようにする (機構③)。entry: { obj, ts }
     this.ctrlOutboundBuffer = []
+    // reconnect 世代ごとの stream sync barrier。古い request_id の遅延応答で
+    // 現接続の buffer を flush しないよう request_id を照合する。
+    this.pendingStreamsSyncRequestId = null
+    this.streamsSyncBarrierTimer = null
     // 直前の close 原因が CF/origin の 5xx か。次回 backoff の下限を引き上げる。
     this.lastCloseWas5xx = false
     // 接続が STABLE_CONNECTION_MS 維持できたら backoff/5xx フラグをリセットする
@@ -190,6 +219,7 @@ export class WsClient extends EventEmitter {
     })
 
     ws.on("close", (code, reason) => {
+      this._clearStreamsSyncBarrier()
       this._clearStableReset()
       this._stopHeartbeat()
       this._stopBundleWatcher()
@@ -236,11 +266,8 @@ export class WsClient extends EventEmitter {
     // 1〜2 秒間隔の再接続ループに陥らない。
     this._armStableReset()
     this.logger?.info("ws open")
-    // 切断中に積んだ pty.data を flush。hello より先に送ると backend で stream
-    // 未登録のため unknown_stream error になる可能性があるが、hello の応答待ち
-    // 同期は backend が承認するため hello 送信後の同期 send_json で問題ない。
-    // ただし flush は hello 直後ではなく streams.sync.request の後に置く方が
-    // 安全 (sync 完了で stream_id がサーバに復元される想定)。
+    // 切断中に積んだ frame は hello 後も即時 flush しない。streams.sync.response で
+    // browser の購読集合が復元されたことを確認してから、現役 stream 宛だけ再送する。
     // hello 前に最新の bundle version / CLI 別ステータスを読み直す (再接続時の鮮度確保)
     this._refreshBundleVersion()
     this._refreshBundleStatus()
@@ -260,12 +287,12 @@ export class WsClient extends EventEmitter {
     // ptyBridge.list() と差分を取って kill する。request_id は uuid で
     // 重複排除。backend が古い (= Plan ε 未対応) なら "unknown_type" error が
     // 返るだけで動作には影響しない。
+    const streamsSyncRequestId = randomUUID()
     this._sendJson({
       type: "agent.streams.sync.request",
-      request_id: randomUUID(),
+      request_id: streamsSyncRequestId,
     })
-    this._flushPtyBuffer()
-    this._flushCtrlBuffer()
+    this._armStreamsSyncBarrier(streamsSyncRequestId)
     this._startHeartbeat()
     this._startBundleWatcher()
     this.emit("open")
@@ -278,8 +305,13 @@ export class WsClient extends EventEmitter {
    * buffer しない (warn のみ)。ack / event 系は 1 件ずつ意味を持つので別バッファに保持する。
    */
   send(obj) {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-      const type = obj?.type
+    const type = obj?.type
+    const wsOpen = this.ws?.readyState === WebSocket.OPEN
+    // sync barrier 中に新しく発生した frame も同じ buffer へ積み、切断中 frame より
+    // 先に送って時系列を逆転させない。heartbeat 等の非 buffer 制御系は通常どおり送る。
+    const holdForStreamsSync = Boolean(this.pendingStreamsSyncRequestId)
+      && (type === "pty.data" || BUFFERED_CTRL_TYPES.has(type))
+    if (!wsOpen || holdForStreamsSync) {
       if (type === "pty.data") {
         this._bufferPtyData(obj)
         return false
@@ -294,11 +326,16 @@ export class WsClient extends EventEmitter {
         if (type === "claude.event" && isEphemeralDeltaEvent(obj)) {
           return false
         }
+        if (type === "codex.event" && isEphemeralCodexDeltaEvent(obj)) {
+          return false
+        }
         this._bufferCtrl(obj)
         return false
       }
-      this.logger?.warn({ type }, "ws send skipped (not open)")
-      return false
+      if (!wsOpen) {
+        this.logger?.warn({ type }, "ws send skipped (not open)")
+        return false
+      }
     }
     return this._sendJson(obj)
   }
@@ -389,9 +426,55 @@ export class WsClient extends EventEmitter {
     )
   }
 
+  /** reconnect stream sync の完了通知。現接続の request_id と一致し、browser の
+   * active stream が1件以上復元されたときだけ buffered frame を flush する。
+   * @returns {boolean} 現在の barrier を解除した場合 true。 */
+  completeStreamsSync(msg) {
+    const requestId = msg?.request_id
+    if (!requestId || requestId !== this.pendingStreamsSyncRequestId) return false
+
+    const activeIds = new Set(
+      Array.isArray(msg?.active_stream_ids)
+        ? msg.active_stream_ids.filter((id) => typeof id === "string" && id)
+        : [],
+    )
+    // backend の 0.5s 集計窓では、browser がまだ再接続しておらず空 snapshot が
+    // 返ることがある。空を authoritative として flush/drop すると live stream の
+    // frame を失うため、2s compatibility timeout まで barrier を維持する。
+    if (activeIds.size === 0) return false
+    this._clearStreamsSyncBarrier()
+    this._flushPtyBuffer()
+    this._flushCtrlBuffer()
+    return true
+  }
+
+  _armStreamsSyncBarrier(requestId) {
+    this._clearStreamsSyncBarrier()
+    this.pendingStreamsSyncRequestId = requestId
+    this.streamsSyncBarrierTimer = setTimeout(() => {
+      if (this.pendingStreamsSyncRequestId !== requestId) return
+      this.pendingStreamsSyncRequestId = null
+      this.streamsSyncBarrierTimer = null
+      this.logger?.warn?.(
+        { request_id: requestId },
+        "streams sync barrier timed out; flushing buffered frames for legacy backend",
+      )
+      this._flushPtyBuffer()
+      this._flushCtrlBuffer()
+    }, STREAMS_SYNC_BARRIER_TIMEOUT_MS)
+    this.streamsSyncBarrierTimer.unref?.()
+  }
+
+  _clearStreamsSyncBarrier() {
+    if (this.streamsSyncBarrierTimer) clearTimeout(this.streamsSyncBarrierTimer)
+    this.streamsSyncBarrierTimer = null
+    this.pendingStreamsSyncRequestId = null
+  }
+
   /** Reconnect を止めて切断する。 */
   stop() {
     this.stopped = true
+    this._clearStreamsSyncBarrier()
     this._clearStableReset()
     this._stopHeartbeat()
     this._stopBundleWatcher()