@cocorograph/hub-agent 0.7.74 → 0.7.76

package/package.json

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

package/src/claude-history.mjs

@@ -73,6 +73,68 @@ export function clearHydrateCacheForTest() {
   hydrateCache.clear()
 }
 
+/**
+ * listSessions の並び順キー last_turn_at_ms を **cwd(dir) 単位** でキャッシュする。
+ *
+ * 背景 (finding 3): listSessions は Cockpit の閲覧ハートビート経路 (main.mjs) からも
+ * limit:1 で周期的に呼ばれる。毎回 cwd 配下の全 jsonl を stat→open→末尾 read すると、
+ * セッション数 N に比例した定期 I/O (最悪 64KB×N) が閲覧者ごとに走る。ほとんどのファイルは
+ * 会話が進んでいない (mtime/size 不変) ので、キャッシュヒット時はディスク読みを丸ごと省く。
+ *
+ * ⚠️ round2 finding: 単一グローバル LRU (上限 N 件) だと、1 dir のファイル数がその上限を
+ * 超えたとき「毎回同じ順で全件走査 → 先頭 miss が末尾側の既存エントリを順次追い出す」
+ * スキャン汚染で結局ほぼ全 miss になる (実環境に 1 dir 1996 件の履歴あり)。これを避けるため
+ * キャッシュを **dir → (filePath→{mtimeMs,size,lastTurnAtMs}) の 2 段**にし、LRU 退避は
+ * **dir 単位**でのみ行う。1 dir 内の全ファイルは同時に保持されるので、ファイル総数が
+ * どれだけ多くても 1 回の走査でキャッシュが自壊しない。dir 数を上限 (同時に見る cwd 数) で
+ * 縛るのでメモリも有界。dir 内は毎回の走査で「今存在するファイル」に prune する。
+ */
+const LAST_TURN_DIR_CACHE_MAX = 64 // 同時にキャッシュを保持する cwd(dir) 数の上限
+const lastTurnDirCache = new Map() // dir -> Map<filePath, {mtimeMs, size, lastTurnAtMs}>
+
+// テスト用: extractLastTurnAtMs の実 I/O 呼び出し回数 (キャッシュ有効性の回帰テスト用)。
+let extractCallCountForTest = 0
+export function getExtractCallCountForTest() {
+  return extractCallCountForTest
+}
+export function resetExtractCallCountForTest() {
+  extractCallCountForTest = 0
+}
+
+function getLastTurnDirMap(dir) {
+  let fileMap = lastTurnDirCache.get(dir)
+  if (fileMap) {
+    // LRU touch (再挿入で挿入順を更新)。
+    lastTurnDirCache.delete(dir)
+    lastTurnDirCache.set(dir, fileMap)
+    return fileMap
+  }
+  fileMap = new Map()
+  lastTurnDirCache.set(dir, fileMap)
+  while (lastTurnDirCache.size > LAST_TURN_DIR_CACHE_MAX) {
+    const oldest = lastTurnDirCache.keys().next().value
+    lastTurnDirCache.delete(oldest)
+  }
+  return fileMap
+}
+
+async function getLastTurnAtMsCached(fileMap, filePath, mtimeMs, size) {
+  const entry = fileMap.get(filePath)
+  if (entry && entry.mtimeMs === mtimeMs && entry.size === size) return entry.lastTurnAtMs
+  // extract に fallback を渡さず null を受ける。巨大最終行 (>4MB) 等で抽出不能のとき、
+  // mtime へ飛ばして再浮上させるのではなく **前回の last_turn_at_ms を維持** する (sticky。
+  // round2 minor 対応)。前回値も無ければ最後の手段として mtime。
+  const extracted = await extractLastTurnAtMs(filePath, null)
+  const lastTurnAtMs = extracted ?? entry?.lastTurnAtMs ?? mtimeMs
+  fileMap.set(filePath, { mtimeMs, size, lastTurnAtMs })
+  return lastTurnAtMs
+}
+
+/** テスト用: last_turn_at_ms キャッシュを全消去する。 */
+export function clearLastTurnCacheForTest() {
+  lastTurnDirCache.clear()
+}
+
 /**
  * jsonl の生 object を、Browser が SDK message として受け取れる表示用 shape に正規化する。
  * 余分な内部メタは落とし、表示・集計に必要なフィールドだけを superset で拾う。
@@ -318,6 +380,124 @@ async function extractPreview(filePath) {
   return ""
 }
 
+/**
+ * jsonl ファイルの「最後の会話ターン境界の時刻」(= 末尾メッセージに埋め込まれた timestamp) を
+ * ms epoch で返す。無ければ null。
+ *
+ * 背景 (症状⑨=実害): サイドバーの並び順はファイル mtime 降順だった (listSessions)。だが
+ * mtime は「会話への書き込み」以外の操作 (resume 時の jsonl 書き戻し・compact/summary の
+ * 全書き換え・ツールによる touch 等) でも bump するため、古いセッションを開いただけで最上位に
+ * 浮上する等の並び順ズレを起こす。会話の各行には ISO8601 の `timestamp` が埋め込まれており、
+ * これは resume 書き戻しでも歴史値として保存される (= 実際のターン発生時刻)。末尾行の
+ * timestamp を採れば「最後にターンが動いた時刻」で安定して並べられる。
+ *
+ * 末尾だけを読むため、ファイルサイズに関係なく最後の数十 KB だけを fd で読む
+ * (Claude jsonl は append-then-close なので末尾行は必ず完結している)。
+ *
+ * ⚠️ 2 つの落とし穴を回避している:
+ *  1. **巨大な最終行** (tool_result / 画像 base64 埋め込み等で 1 メッセージが 64KB 超も普通)。
+ *     固定窓だと最終行が窓境界で切れて JSON.parse できず取りこぼす。→ user/assistant の
+ *     message 行を拾えるまで窓を倍々に読み広げる (上限 MAX_READ)。
+ *  2. **非ターン行の timestamp** (message 後の `attachment` / `system` の stop_hook_summary /
+ *     turn_duration 等にも timestamp があり、会話ターン境界でない操作で時刻が進む)。
+ *     → 採用対象を `type in {user, assistant}` かつ `message` を持つ行に限定する。
+ *
+ * @param {string} filePath
+ * @param {number} fallbackMtimeMs stat 済みなら渡す (末尾に会話 message が無い時の保険)
+ * @returns {Promise<number|null>}
+ */
+const LAST_TURN_TAIL_CHUNK = 65536
+const LAST_TURN_MAX_READ = 4 * 1024 * 1024 // 4MB を超えて遡っても割に合わない → fallback
+
+/** テキスト中の「最後の user/assistant message 行」の timestamp(ms) を返す。無ければ null。 */
+function lastTurnTsFromText(text) {
+  const lines = text.split("\n")
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i]
+    if (!line) continue
+    let obj
+    try {
+      obj = JSON.parse(line)
+    } catch {
+      continue
+    }
+    // 会話ターン境界 = user/assistant の message 行のみ (finding 2)。
+    if ((obj?.type === "user" || obj?.type === "assistant") && obj.message) {
+      const ts = obj.timestamp
+      if (typeof ts === "string") {
+        const ms = Date.parse(ts)
+        if (!Number.isNaN(ms)) return ms
+      }
+    }
+  }
+  return null
+}
+
+/**
+ * 巨大行 (読み込み上限 4MB を超え、完全な行として parse できない) で正規 parse が空振り
+ * したときの最終手段: tail テキストから最後の `"timestamp":"<ISO>"` を正規表現で拾う
+ * (round2 minor / round3 対応)。
+ *
+ * Claude jsonl の各行はトップレベルに `"timestamp"` を持ち、これは message 本文の**後ろ**に
+ * 来る (= 行末側)。よって「最後の一致」を採ればトップレベルの timestamp をほぼ確実に拾える
+ * (message 本文内に稀に "timestamp" があっても、それより後ろのトップレベル側が勝つ)。
+ * 完全 parse で type を検証できない degraded path 専用。mtime 再浮上 (症状⑨) を避けるための
+ * 保守的 fallback として、この不確実性を許容する。
+ */
+const TIMESTAMP_FIELD_RE = /"timestamp":"([^"]+)"/g
+function regexLastTimestampMs(text) {
+  let m
+  let last = null
+  TIMESTAMP_FIELD_RE.lastIndex = 0
+  while ((m = TIMESTAMP_FIELD_RE.exec(text)) !== null) last = m[1]
+  if (last == null) return null
+  const ms = Date.parse(last)
+  return Number.isNaN(ms) ? null : ms
+}
+
+async function extractLastTurnAtMs(filePath, fallbackMtimeMs = null) {
+  extractCallCountForTest++
+  let handle
+  try {
+    handle = await open(filePath, "r")
+    const st = await handle.stat()
+    if (st.size <= 0) return fallbackMtimeMs
+    let readLen = Math.min(LAST_TURN_TAIL_CHUNK, st.size)
+    let hugeLineText = null // 上限まで読んでも完全行を parse できなかった巨大行の raw tail
+    for (;;) {
+      const start = st.size - readLen
+      const buf = Buffer.allocUnsafe(readLen)
+      const { bytesRead } = await handle.read(buf, 0, readLen, start)
+      const text = buf.toString("utf-8", 0, bytesRead)
+      // 窓の先頭が partial の可能性: start>0 なら最初の改行より前 (途中から始まる行) を捨て、
+      // 完全な行だけを対象にする。改行が無い (= 1 行が窓より大きい) 場合は下で窓拡張。
+      const nl = text.indexOf("\n")
+      const usable = start > 0 ? (nl >= 0 ? text.slice(nl + 1) : "") : text
+      const ms = lastTurnTsFromText(usable)
+      if (ms != null) return ms
+      // 見つからず、まだファイル先頭に届いておらず上限内なら窓を倍にして読み足す
+      // (巨大な最終行を完全に取り込むまで遡る。finding 1)。
+      if (start <= 0 || readLen >= LAST_TURN_MAX_READ) {
+        // 上限まで読んでも完全行が取れなかった (start>0 のまま budget 到達) = 巨大最終行。
+        // cold path (キャッシュ prev 値も無い) で mtime へ飛んで再浮上しないよう、
+        // raw tail から timestamp を正規表現で拾う degraded fallback を試みる。
+        if (start > 0 && readLen >= LAST_TURN_MAX_READ) hugeLineText = text
+        break
+      }
+      readLen = Math.min(readLen * 2, st.size, LAST_TURN_MAX_READ)
+    }
+    if (hugeLineText != null) {
+      const ms = regexLastTimestampMs(hugeLineText)
+      if (ms != null) return ms
+    }
+    return fallbackMtimeMs
+  } catch {
+    return fallbackMtimeMs
+  } finally {
+    await handle?.close()
+  }
+}
+
 /**
  * cwd 配下の全 jsonl ファイルから session 一覧を返す。
  * 各ファイルから session_id / 最終更新時刻 / サイズ / 最初の user message preview を抽出。
@@ -341,6 +521,9 @@ export async function listSessions({ cwd, projectsRoot, limit = 30, logger }) {
     logger?.warn({ err: err.message, dir }, "claude history list failed")
     return { sessions: [], error: err.message }
   }
+  // この dir 専用の last_turn_at_ms キャッシュ (dir 単位 LRU。スキャン汚染しない。finding 3/round2)。
+  const fileMap = getLastTurnDirMap(dir)
+  const seenPaths = new Set()
   const stats = []
   for (const f of files) {
     if (!f.endsWith(".jsonl")) continue
@@ -348,13 +531,32 @@ export async function listSessions({ cwd, projectsRoot, limit = 30, logger }) {
     const filePath = path.join(dir, f)
     try {
       const st = await stat(filePath)
-      stats.push({ session_id, file_path: filePath, mtime: st.mtimeMs, size_bytes: st.size })
+      seenPaths.add(filePath)
+      // last_turn_at_ms = jsonl 末尾メッセージの埋め込み timestamp (会話ターン境界)。
+      // サイドバーの並び順はこれを使う (mtime は resume 書き戻し等でも bump し、古い
+      // セッションを開いただけで浮上する症状⑨の原因になるため)。抽出不能なら前回値 sticky。
+      // (mtimeMs+size キャッシュ経由。ハートビート経路の周期呼び出しで全ファイルを毎回
+      //  読み直さない。finding 3)
+      const last_turn_at_ms = await getLastTurnAtMsCached(fileMap, filePath, st.mtimeMs, st.size)
+      stats.push({
+        session_id,
+        file_path: filePath,
+        mtime: st.mtimeMs,
+        last_turn_at_ms,
+        size_bytes: st.size,
+      })
     } catch {
       // ignore individual file stat errors
     }
   }
-  // 最新順 + limit 件に絞ってから preview 抽出 (全ファイル読みを避ける)
-  stats.sort((a, b) => b.mtime - a.mtime)
+  // 消えた jsonl (削除・rotate) のキャッシュエントリを掃除し、dir 内キャッシュを有界に保つ。
+  if (fileMap.size > seenPaths.size) {
+    for (const key of fileMap.keys()) {
+      if (!seenPaths.has(key)) fileMap.delete(key)
+    }
+  }
+  // 会話ターン境界の新しい順 + limit 件に絞ってから preview 抽出 (全ファイル読みを避ける)
+  stats.sort((a, b) => b.last_turn_at_ms - a.last_turn_at_ms)
   const top = stats.slice(0, limit)
   const sessions = []
   for (const s of top) {

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

@@ -535,10 +535,12 @@ export class CodexStreamBridge extends EventEmitter {
       const result = await client.request("thread/list", {
         cwd: cwd || undefined,
         limit: limit || undefined,
-        // recency_at は「読み込みも含めた実際の使用感」の並び順 (公式スキーマの説明:
-        // "Unix timestamp used for thread recency ordering")。updated_at だと最終書き込み
-        // のみで並ぶため、Claude 側の mtime (listSessions) と体感を揃えるならこちらが近い。
-        sortKey: "recency_at",
+        // ⚠️ updated_at を使う (recency_at ではない)。recency_at は「読み込み(=スレッドを
+        // 開くだけ)も含めた使用感」の並び順なので、古いスレッドを開いただけでサイドバー最上位
+        // に浮上してしまう (症状⑨=実害)。サイドバーは「会話への書き込み(=ターン境界)」で
+        // 並べたいので、最終書き込み時刻の updated_at を採用する。
+        // (Claude 側 listSessions も jsonl 内の最終メッセージ timestamp = ターン境界に揃えた)
+        sortKey: "updated_at",
         sortDirection: "desc",
       })
       const threads = Array.isArray(result?.data) ? result.data : []
@@ -546,10 +548,12 @@ export class CodexStreamBridge extends EventEmitter {
         thread_id: t.id,
         cwd: t.cwd || "",
         preview: typeof t.preview === "string" ? t.preview.slice(0, 80) : "",
-        // recencyAt 優先 (無ければ updatedAt) を ms へ変換。claude 側 ClaudeSessionSummary.mtime
-        // (ms epoch) と同じ単位に揃え、frontend が同じ並び替えロジックを使い回せるようにする。
+        // updatedAt 優先 (無ければ recencyAt fallback) を ms へ変換。claude 側
+        // ClaudeSessionSummary.mtime (ms epoch) と同じ単位に揃え、frontend が同じ並び替え
+        // ロジックを使い回せるようにする。並び順の source of truth は上の sortKey なので、
+        // ここは表示用の mtime も updatedAt を優先させて sortKey と一貫させる。
         updated_at_ms:
-          (typeof t.recencyAt === "number" ? t.recencyAt : t.updatedAt || 0) * 1000,
+          (typeof t.updatedAt === "number" ? t.updatedAt : t.recencyAt || 0) * 1000,
       }))
     } finally {
       client.stop()
@@ -894,6 +898,80 @@ export class CodexStreamBridge extends EventEmitter {
     return true
   }
 
+  /**
+   * 指定した id (stream_id もしくは thread_id) のライブセッションへ直接注入する
+   * (sibling-inject の **明示宛先指定** 用、2026-07-19 / T06271)。sendToCwd は cwd 内で
+   * 最終活性が最新のものを選ぶヒューリスティックのため、同一 cwd に複数の生きた codex
+   * セッションが同居すると誤爆する。呼び出し側が describeLiveSessions で得た id を明示
+   * すれば曖昧さを回避できる。
+   *
+   * 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[]}}
+   */
+  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.threadId === id) byThread.push(session)
+    }
+    let target = bySid
+    if (!target) {
+      if (byThread.length > 1) {
+        return { status: "ambiguous", candidates: byThread.map((s) => this._describe(s)) }
+      }
+      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 以内に届いている（＝生きている

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 がポーリングする)。 */