@cocorograph/hub-agent 0.8.8 → 0.8.10

package/package.json

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

package/src/claude-history.mjs

@@ -664,7 +664,13 @@ function takeTextsFromLine(line, user, assistant) {
   return { user, assistant }
 }
 
-export async function extractLastTurnTexts(filePath) {
+/**
+ * @param {string} filePath 対象 jsonl
+ * @param {{ isInjected?: (text: string) => Promise<boolean> | boolean }} [opts]
+ *   注入と判定した user ターンは、そのターンの assistant も含めて飛ばす。
+ */
+export async function extractLastTurnTexts(filePath, opts = {}) {
+  const isInjected = typeof opts.isInjected === "function" ? opts.isInjected : null
   let handle
   try {
     handle = await open(filePath, "r")
@@ -716,11 +722,26 @@ export async function extractLastTurnTexts(filePath) {
           continue
         }
         const res = takeTextsFromLine(lineBuf.toString("utf-8"), user, assistant)
+        if (isInjected && res.user && !user) {
+          let injected = false
+          try {
+            injected = (await isInjected(res.user)) === true
+          } catch {
+            // 注入判定の障害で通常の依頼まで消さない。
+          }
+          if (injected) {
+            // 後方走査中の assistant はこの注入 user より後ろ、つまり同じ注入ターンの
+            // 応答候補。依頼だけでなく応答も捨てて、更に前の自分のターンを探す。
+            user = ""
+            assistant = ""
+            continue
+          }
+        }
         user = res.user
         assistant = res.assistant
-        if (user && assistant) break
+        if (isInjected ? Boolean(user) : user && assistant) break
       }
-      if (user && assistant) break
+      if (isInjected ? Boolean(user) : user && assistant) break
       if (skipped > LAST_TURN_MAX_SKIPPED_LINES) break
 
       if (carry && carry.length > LAST_TURN_MAX_LINE) {

package/src/codex-stream-bridge.mjs

@@ -43,6 +43,8 @@
 import { EventEmitter } from "node:events"
 import { randomUUID } from "node:crypto"
 
+import { recordInjectSourcePersistent } from "./inject-source-store.mjs"
+
 import { AsyncTtlCache } from "./async-ttl-cache.mjs"
 import { CodexAppServerClient } from "./codex-appserver-client.mjs"
 import {
@@ -1947,6 +1949,9 @@ export class CodexStreamBridge extends EventEmitter {
         reason: delivery?.reason || "echo_timeout",
       }
     }
+    // Claude と同じ永続ストアへ記録し、hub-agent 再起動後に rollout を読む場合も
+    // peer / orchestrator 注入を通常の user 依頼として表示しない。
+    recordInjectSourcePersistent(session.cwd, text, source).catch(() => {})
     // rollout は内部形式・flush 遅延の影響を受けるため primary oracle にしない。echo delivered を
     // 返した後、注入前 offset + threadId + 本文 hash で非同期監査し、結果だけを構造化ログへ残す。
     void this._deliveryAuditVerify(durableAudit)

package/src/main.mjs

@@ -17,7 +17,6 @@ import {
   readFile,
   readdir,
   rename,
-  stat,
   unlink,
   writeFile,
 } from "node:fs/promises"
@@ -56,13 +55,12 @@ import { CodexStreamBridge, classifyCodexInputError } from "./codex-stream-bridg
 import { UploadManager } from "./claude-upload.mjs"
 import { requestSelfUninstall } from "./service-install.mjs"
 import {
-  extractLastTurnTexts,
   fetchSessionHistory,
-  jsonlPath,
   listSessions,
 } from "./claude-history.mjs"
 import { listAgents } from "./agents.mjs"
 import { listSkills } from "./skills.mjs"
+import { readSidebarMessageSnapshot } from "./sidebar-message-snapshot.mjs"
 import {
   capturePane,
   detectPermissionModeFromText,
@@ -342,6 +340,7 @@ export function isReadOnlyRpc(type) {
     type === "codex.sessions.request" ||
     type === "profile.list" ||
     type === "codex.profile.list" ||
+    type === "chat.sidebar_snapshot.request" ||
     // T06603 (2026-07-25): キュー snapshot の pull。in-memory 配列を読むだけで副作用が無く、
     // かつ「直列キュー前方の重い処理で再同期が遅延する」と送信待ちチップの固着が長引く
     // (再同期は固着を直すための経路なので、詰まりやすい経路に置いてはならない)。
@@ -1442,23 +1441,25 @@ const lastSortAffectingAtByName = new Map()
 const lastEventAtByName = new Map()
 
 /**
- * session-event の種別 (と「実ユーザーターンを見たか」) から sort_affecting を導出する純関数。
- * - prompt_submit: 常に true (ユーザーがターンを開始した)
- * - session_start / session_end: 常に false (ライフサイクル、ターンではない)
- * - stop / ready / idle_hint: 直前に prompt_submit があった (sawUserTurn) ときだけ true
- *   (=起動/resume の落ち着きで出た stop/ready は false)
- * - 未知種別: 後方互換で true (並び順に効かせる)
+ * session-event の種別から sort_affecting を導出する純関数。
+ *
+ * **並び順が動くのはユーザーがメッセージを送った瞬間 (prompt_submit) だけ**。
+ * ターン終了 (stop) やアイドル系はソートに効かせない。
+ *
+ * ⚠️ 旧仕様は stop/ready/idle_hint を「直前に prompt_submit があれば sort_affecting」に
+ * していたため、**ターンが終わるたびにサイドバーの行が並び替わり、レイアウトシフトが起きた**
+ * (2026-07-29 ユーザー報告)。並び順の意味を「最後に人間が送った順」に一本化するため、
+ * ターン終了はソートへ影響させない (状態表示＝ドット側は従来どおり別軸で更新される)。
+ *
+ * - prompt_submit: true (ユーザーがターンを開始した = 並び順の唯一の発火源)
+ * - それ以外 (stop / ready / idle_hint / session_start / session_end / 未知種別): false
+ *
  * @param {string} event
- * @param {boolean} sawUserTurn
+ * @param {boolean} _sawUserTurn 後方互換で受けるが未使用 (ターン終了を効かせないため)
  * @returns {boolean}
  */
-export function computeSortAffecting(event, sawUserTurn) {
-  if (event === "prompt_submit") return true
-  if (event === "session_start" || event === "session_end") return false
-  if (event === "stop" || event === "ready" || event === "idle_hint") {
-    return sawUserTurn === true
-  }
-  return true
+export function computeSortAffecting(event, _sawUserTurn) {
+  return event === "prompt_submit"
 }
 
 /**
@@ -1701,219 +1702,11 @@ async function readAllSessionEvents() {
   return out
 }
 
-/**
- * jsonl 末尾テキストのキャッシュ。key = jsonl path、value = `{version, texts}`。
- * version の構成は `lastTurnTextsVersion()` が正本 (ここに具体値を書くとドリフトする)。
- *
- * tmux.list_sessions は数秒間隔で回るため、毎回全セッションの jsonl 末尾を読むと I/O が
- * 積み上がる。会話が進めば必ず version が変わるので、version 一致なら前回値を使い回す。
- */
-const lastTurnTextsCache = new Map()
-
-/**
- * path 単位の in-flight 共有。複数ブラウザが同時に poll しても同じ jsonl を重複抽出しない。
- * key = jsonl path、value = `{version, promise}`。
- *
- * ⚠️ version を必ず持たせる。「どの版の抽出か」が分からないと、合流した caller が自分の
- * 観測版で結果を保存してしまい、古いテキストが恒久的に cache hit する (major#1 参照)。
- */
-const lastTurnTextsInFlight = new Map()
-
 // 複数 Cockpit タブは各自 8 秒 poll を持つため、位相がずれると agent は同じ
 // tmux/worktree/jsonl スナップショットを数秒おきに再構築してしまう。5 秒だけ成功値を
 // 共有し、同時要求は single-flight に畳む。create/kill/worktree 変更時は明示 clear する。
 const tmuxSessionsSnapshotCache = new AsyncTtlCache({ ttlMs: 5_000 })
 
-/** cold cache 時に全セッションを一斉に読まないための同時実行上限。 */
-const LAST_TEXTS_CONCURRENCY = 4
-
-/** テスト用: module-global なキャッシュのテスト間汚染を防ぐ。 */
-export function clearLastTurnTextsCacheForTest() {
-  lastTurnTextsCache.clear()
-  lastTurnTextsInFlight.clear()
-}
-
-/** GC: tmux から消えたセッションの jsonl は追跡しない (Map の線形増加を防ぐ)。 */
-function pruneLastTurnTextsCache(livePaths) {
-  if (lastTurnTextsCache.size <= livePaths.size) return
-  for (const k of lastTurnTextsCache.keys()) {
-    if (!livePaths.has(k)) lastTurnTextsCache.delete(k)
-  }
-}
-
-/**
- * jsonl の版 (キャッシュ無効化キー)。
- *
- * mtime だけだと、分解能の粗い FS や「同一 ms 内の追記」で古いテキストを再利用しうる
- * (同リポの hydrate / last-turn キャッシュも mtime+size を使っている)。size と ctime も
- * 混ぜて、append / atomic replace の双方を検出できるようにする。
- */
-function lastTurnTextsVersion(st) {
-  return `${st.mtimeMs}:${st.size}:${st.ctimeMs}`
-}
-
-/**
- * `context_session_id` を jsonl のパス要素として使ってよいか検証する。
- *
- * この値は SDK resume 経路では browser → backend → agent と外部を通ってくるため、
- * `../` を含むと cwd の project dir の外を指しうる。新設の自動読み取り面なので、
- * パス要素として安全な形だけを通す (実在の Claude session id は UUID だが、将来の
- * 形式変更で壊れないよう「危険な形の排除」に留める)。
- */
-function isSafeSessionIdForPath(id) {
-  if (!id || typeof id !== "string") return false
-  if (id.length > 200) return false
-  if (id === "." || id === "..") return false
-  // パス区切り / NUL / 制御文字 / ドット始まりを排除。
-  if (/[/\\\0]/.test(id)) return false
-  // eslint-disable-next-line no-control-regex
-  if (/[\x00-\x1f]/.test(id)) return false
-  if (id.startsWith(".")) return false
-  // 未 bind のプレースホルダ (jsonl がまだ存在しない)。
-  if (id.startsWith("fresh:") || id.startsWith("unbound:")) return false
-  return true
-}
-
-/**
- * 各 tmux session の「最後の依頼 / 最後の応答」テキストを jsonl 末尾から読む。
- *
- * Cockpit サイドバーが行ごとに「何を依頼したか」を出すためのデータ源 (2026-07-28)。
- * frontend は選択中 1 セッションしかメッセージを保持しないため、一覧用は agent 側で
- * 供給するしかない。会話 ID は state loop の snapshot (`context_session_id`) を使う。
- *
- * 対象は **claude 行のみ**。codex はスレッド保存形式が異なるため対象外 (将来対応)。
- * `fresh:<request_id>` は jsonl 未生成のプレースホルダなのでスキップする。
- *
- * @param {Array} sessions listTmuxSessions の素の行 (name / cwd を使う)
- * @param {((name: string) => object | null) | undefined} getSnap state loop の getSnapshot
- * @param {object} [options] I/O と session ID 解決の注入点
- * @param {((session: object) => string | null) | undefined} [options.resolveFallbackSessionId]
- *        snapshot の context_session_id が再起動後の `unbound:*` のとき、TUI bind / live
- *        Claude bridge から同じ cwd の会話 ID を復元する。戻り値にも containment 検査を行う。
- * @returns {Promise<Map<string, {user: string, assistant: string}>>}
- */
-export async function readAllSessionLastTexts(
-  sessions,
-  getSnap,
-  {
-    extract = extractLastTurnTexts,
-    statFn = stat,
-    resolvePath = jsonlPath,
-    resolveFallbackSessionId,
-  } = {},
-) {
-  const out = new Map()
-  if (!getSnap) return out
-  const livePaths = new Set()
-
-  const readOne = async (s) => {
-    try {
-      const snap = getSnap(s.name)
-      if (!snap || snap.cli_kind !== "claude") return
-      let sessionId = snap.context_session_id
-      let usedFallback = false
-      // hub-agent 再起動で in-memory の TUI bind が消えると、state loop の snapshot は
-      // `unbound:<session>` へ落ちる。一方、Claude bridge の warm/live session は cwd
-      // から同じ会話 ID を復元できる。ここでフォールバックしないと、再起動後に全行の
-      // 「最後の依頼 / 応答」だけが消え、次に chat signal が fresh になるまで戻らない。
-      //
-      // snapshot が安全な実 ID を持つ場合は必ずそちらを優先し、fallback は placeholder /
-      // 危険値の場合だけ使う。fallback も同じ containment 検査を通してから path 化する。
-      if (!isSafeSessionIdForPath(sessionId) && resolveFallbackSessionId) {
-        sessionId = resolveFallbackSessionId(s)
-        usedFallback = true
-      }
-      // パス要素として安全な形だけを通す (外部由来の値なので containment を局所保証)。
-      if (!isSafeSessionIdForPath(sessionId)) return
-      if (!s.cwd) return
-      let fp = resolvePath({ cwd: s.cwd, session_id: sessionId })
-      if (!fp) return
-      let st
-      try {
-        st = await statFn(fp)
-      } catch {
-        // 再起動直後は snapshot に構文上は安全でも既に失効した session ID が残ることがある。
-        // 0.8.7 は unbound/fresh だけを live session へ切り替えていたため、この場合は stat
-        // 失敗を外側 catch が握りつぶし、サイドバーの依頼/応答だけが空のままになった。
-        // primary path が読めない場合に限って、現在の cwd-scoped live session ID を再解決する。
-        // snapshot path が実在する通常系では従来どおり snapshot を優先する。
-        if (usedFallback || !resolveFallbackSessionId) return
-        const fallbackId = resolveFallbackSessionId(s)
-        if (!isSafeSessionIdForPath(fallbackId) || fallbackId === sessionId) return
-        const fallbackPath = resolvePath({ cwd: s.cwd, session_id: fallbackId })
-        if (!fallbackPath) return
-        try {
-          st = await statFn(fallbackPath)
-        } catch {
-          return
-        }
-        sessionId = fallbackId
-        fp = fallbackPath
-        usedFallback = true
-      }
-      livePaths.add(fp)
-      const version = lastTurnTextsVersion(st)
-      const cached = lastTurnTextsCache.get(fp)
-      if (cached && cached.version === version) {
-        out.set(s.name, cached.texts)
-        return
-      }
-      // 同一 path への同時抽出は 1 本に畳む (複数ブラウザの同時 poll 対策)。
-      //
-      // ⚠️ in-flight には「どの版の抽出か」を必ず持たせる (2026-07-28 クロスレビュー major#1)。
-      // path だけで共有し、合流した caller が自分の観測版で結果を保存すると、
-      // 「V1 の抽出中に V2 へ追記 → V2 を観測した caller が V1 の結果を {version: V2} で
-      // 保存」となり、以降ファイルが動かない限り古いテキストが恒久的に cache hit する。
-      let pending = lastTurnTextsInFlight.get(fp)
-      if (!pending) {
-        const entry = { version, promise: null }
-        entry.promise = extract(fp).finally(() => {
-          // 世代交代後に古い finally が新しい in-flight を消さないよう、
-          // Map の現在値が自分自身のときだけ削除する。
-          if (lastTurnTextsInFlight.get(fp) === entry) lastTurnTextsInFlight.delete(fp)
-        })
-        lastTurnTextsInFlight.set(fp, entry)
-        pending = entry
-      }
-      const texts = await pending.promise
-      out.set(s.name, texts)
-      // cache に載せてよいのは「その抽出を開始した版」の caller だけ。別版を観測して
-      // 合流した caller は表示にのみ使い、cache は汚さない (次回 poll で必ず再抽出)。
-      if (pending.version === version) {
-        // 抽出中に追記されていた場合、読んだ内容は既に古い可能性がある。開始時と同じ版の
-        // ままだったときだけ cache する (追記中の結果を恒久 hit させないための回帰ガード)。
-        let unchanged = false
-        try {
-          unchanged = lastTurnTextsVersion(await statFn(fp)) === version
-        } catch {
-          unchanged = false
-        }
-        if (unchanged) lastTurnTextsCache.set(fp, { version, texts })
-      }
-    } catch {
-      // jsonl 不在 / 権限 / parse 失敗は「テキスト無し」に落とすだけ (一覧は出す)
-    }
-  }
-
-  // cold cache で数十セッションが一斉に上限走査に入ると I/O が集中するため、
-  // 素の Promise.all ではなく固定並列度で流す。
-  const queue = sessions.slice()
-  const workers = Array.from(
-    { length: Math.min(LAST_TEXTS_CONCURRENCY, queue.length) },
-    async () => {
-      for (;;) {
-        const s = queue.shift()
-        if (!s) return
-        await readOne(s)
-      }
-    },
-  )
-  await Promise.all(workers)
-
-  pruneLastTurnTextsCache(livePaths)
-  return out
-}
-
 /**
  * 単一 session の最新 session-event をファイル正本から読む。無ければ null。
  * claude.tui.bind 時の `stop` 再配信 (取りこぼし回復) に使う。
@@ -2186,26 +1979,13 @@ const STALL_WARN_MS = Number(process.env.HUB_AGENT_STALL_WARN_MS ?? 90000)
  * @param {Map<string, object>} lastEventByName session_name → 最新 hook event
  * @param {((name: string) => object | null) | undefined} getSnap state loop の getSnapshot
  *        accessor。undefined のときは 4 信号を一切付与しない(snapshot 経路 OFF と等価)
- * @param {Map<string, {user: string, assistant: string}> | undefined} lastTextsByName
- *        session_name → jsonl 末尾の依頼/応答テキスト (サイドバー行の内容表示用)。
- *        undefined / 未収録なら該当フィールドを載せない(古い cockpit は無視するので互換)
  */
-export function enrichTmuxSessionsForListResponse(
-  sessions,
-  lastEventByName,
-  getSnap,
-  lastTextsByName,
-) {
+export function enrichTmuxSessionsForListResponse(sessions, lastEventByName, getSnap) {
   return sessions.map((s) => {
     const base = {
       ...s,
       last_event: lastEventByName.get(s.name) || null,
     }
-    // サイドバー行に出す「何を依頼したか / 何が返ったか」。空文字は載せない
-    // (frontend 側で「未取得」と「本当に空」を区別する必要が無いため)。
-    const texts = lastTextsByName?.get(s.name)
-    if (texts?.user) base.last_user_text = texts.user
-    if (texts?.assistant) base.last_assistant_text = texts.assistant
     if (!getSnap) return base
     const snap = getSnap(s.name)
     if (!snap) return base
@@ -2420,6 +2200,9 @@ export function decideTurnActiveSource({
 export function startStateLoop({ client, plugins, logger, intervalMs, claudeBridge, codexBridge, readinessTracker, boundSessions }) {
   const lastByName = new Map() // session_name → {status, context_pct}
   const lastTurnAtByName = new Map() // session_name → 最後に event ファイル化した turnAt
+  // session_name → 最後に書いた chat 由来 event 種別。エッジ駆動 (種別遷移時のみ書く) にして
+  // 生成中の prompt_submit 連打を防ぐ (並行生成でサイドバーが揺れる原因)。
+  const lastChatEventByName = new Map()
   // (i) session_name → {sig, changedAt}: 出力領域署名の最終変化時刻 (出力フロー検知用)。
   const outputFlowByName = new Map()
   // 権威的 stall 判定 (arm 非依存・cap 非依存)。state loop が観測する signal だけで turn の開閉と
@@ -2495,19 +2278,27 @@ export function startStateLoop({ client, plugins, logger, intervalMs, claudeBrid
         let status = overlay.status
         let contextPct = overlay.contextPct
         if (chat) {
-          // チャットのターン境界 (turnAt 前進) を sort 用 session-event に橋渡し。
+          // チャットのターン境界を sort / 状態用 session-event に橋渡しする。
           // tmux ペインが動かず bundle hook が発火しないため、ここで代替発火する。
+          //
+          // ⚠️ **エッジ駆動** (種別が変わったときだけ書く)。旧実装は turnAt が前進するたびに
+          // 書いており、turnAt は assistant イベント毎に前進するため **生成中ずっと
+          // prompt_submit を書き続けていた**。並行生成中のセッション同士が assistant の
+          // 到着順で入れ替わり、サイドバーが揺れる原因になる (2026-07-29)。
+          // 種別遷移でのみ書けば、prompt_submit は生成開始の 1 回だけになる。
+          //
+          // 確認待ち (inputPending) は専用 event "input_required"、生成中は "prompt_submit"、
+          // それ以外は "stop"。並び順に効くのは computeSortAffecting により prompt_submit だけ。
+          const ev = chat.inputPending
+            ? "input_required"
+            : chat.status === "processing"
+              ? "prompt_submit"
+              : "stop"
           const prevTurnAt = lastTurnAtByName.get(s.session_name) || 0
-          if (chat.turnAt > prevTurnAt) {
+          const prevEv = lastChatEventByName.get(s.session_name)
+          if (chat.turnAt > prevTurnAt && ev !== prevEv) {
             lastTurnAtByName.set(s.session_name, chat.turnAt)
-            // 確認待ち (inputPending) は専用 event "input_required" を書き、サイドバーの
-            // 「確認待ち」ドット & 通知に橋渡しする。それ以外は従来通り processing →
-            // prompt_submit / それ以外 → stop。
-            const ev = chat.inputPending
-              ? "input_required"
-              : chat.status === "processing"
-                ? "prompt_submit"
-                : "stop"
+            lastChatEventByName.set(s.session_name, ev)
             writeSessionEventFile(s.session_name, ev, chat.turnAt).catch(() => {})
           }
         }
@@ -4780,23 +4571,11 @@ async function dispatch(msg, ctx) {
               claudeBridge: ctx.claudeBridge,
               worktreeIndex,
             })
-            const [lastEventByName, lastTextsByName] = await Promise.all([
-              readAllSessionEvents(),
-              readAllSessionLastTexts(sessions, ctx.getSessionStateSnapshot, {
-                resolveFallbackSessionId: (session) =>
-                  resolveStateLoopBoundSessionId(
-                    ctx.tuiReboundSessions,
-                    session.name,
-                    session.cwd,
-                    ctx.claudeBridge,
-                  ),
-              }),
-            ])
+            const lastEventByName = await readAllSessionEvents()
             const enriched = enrichTmuxSessionsForListResponse(
               sessions,
               lastEventByName,
               ctx.getSessionStateSnapshot,
-              lastTextsByName,
             )
             const liveNames = new Set(enriched.map((s) => s.name))
             let worktreeStubs = []
@@ -4823,6 +4602,29 @@ async function dispatch(msg, ctx) {
         }
         return
       }
+      case "chat.sidebar_snapshot.request": {
+        try {
+          const messages = await readSidebarMessageSnapshot(msg.targets, {
+            liveCodexSession: (target) => {
+              const live = ctx.codexBridge?.liveSessionForCwd?.(target.cwd)
+              return live?.threadId === target.conversationId ? live : null
+            },
+          })
+          ctx.client.send({
+            type: "chat.sidebar_snapshot.response",
+            request_id: msg.request_id,
+            messages,
+          })
+        } catch (err) {
+          ctx.client.send({
+            type: "chat.sidebar_snapshot.response",
+            request_id: msg.request_id,
+            messages: [],
+            error: err?.message || String(err),
+          })
+        }
+        return
+      }
       case "tmux.create_session": {
         const name = (msg.session_name || "").trim()
         const cwd = (msg.cwd || process.env.HOME || "/").trim()

package/src/sidebar-message-snapshot.mjs

@@ -0,0 +1,362 @@
+import { open, readdir, realpath, stat } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+
+import { extractLastTurnTexts, jsonlPath, LAST_TURN_TEXT_MAX } from "./claude-history.mjs"
+import { resolveProjectsRoot } from "./profiles.mjs"
+import * as codexProfiles from "./codex-profiles.mjs"
+import { lookupInjectSource } from "./inject-source-store.mjs"
+import { SECRET_PLACEHOLDER, redactSecrets } from "./tool-result-mask.mjs"
+
+const MAX_TARGETS = 100
+const READ_CONCURRENCY = 8
+const TAIL_CHUNK = 64 * 1024
+const MAX_SCAN = 8 * 1024 * 1024
+const MAX_LINE = 1024 * 1024
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+
+const textCache = new Map()
+const textInFlight = new Map()
+const rolloutPathCache = new Map()
+
+function sanitizeText(value) {
+  if (typeof value !== "string" || !value.trim()) return ""
+  let masked = redactSecrets(value)
+  const openerAt = masked.indexOf("-----BEGIN")
+  if (openerAt >= 0) masked = masked.slice(0, openerAt) + SECRET_PLACEHOLDER
+  return masked.trim().replace(/\s+/g, " ").slice(0, LAST_TURN_TEXT_MAX)
+}
+
+function itemText(item) {
+  const content = item?.content
+  if (typeof content === "string") return content
+  if (!Array.isArray(content)) return ""
+  return content
+    .map((block) =>
+      block && typeof block === "object" && typeof block.text === "string"
+        ? block.text
+        : "",
+    )
+    .join("\n")
+}
+
+export async function textsFromCodexItems(items, { isInjected } = {}) {
+  let assistant = ""
+  if (!Array.isArray(items)) return { user: "", assistant }
+  for (let i = items.length - 1; i >= 0; i--) {
+    const item = items[i]
+    if (item?.type === "agentMessage" && !assistant) {
+      assistant = sanitizeText(itemText(item))
+      continue
+    }
+    if (item?.type !== "userMessage") continue
+    const user = sanitizeText(itemText(item))
+    if (!user) continue
+    let injected = item.source === "peer" || item.source === "orchestrator"
+    if (!injected && typeof isInjected === "function") {
+      try {
+        injected = (await isInjected(user)) === true
+      } catch {
+        // 判定不能なら通常入力として残す。
+      }
+    }
+    if (injected) {
+      assistant = ""
+      continue
+    }
+    return { user, assistant }
+  }
+  return { user: "", assistant }
+}
+
+function codexLineMessage(line) {
+  if (!line) return null
+  let obj
+  try {
+    obj = JSON.parse(line)
+  } catch {
+    return null
+  }
+  if (obj?.type !== "event_msg" || !obj.payload) return null
+  if (obj.payload.type === "agent_message") {
+    return { role: "assistant", text: sanitizeText(obj.payload.message) }
+  }
+  if (obj.payload.type === "user_message") {
+    return { role: "user", text: sanitizeText(obj.payload.message) }
+  }
+  return null
+}
+
+export async function extractCodexLastTurnTexts(filePath, { isInjected } = {}) {
+  let assistant = ""
+  let handle
+  try {
+    handle = await open(filePath, "r")
+    const fileStat = await handle.stat()
+    let pos = fileStat.size
+    let carry = null
+    let scanned = 0
+    while (pos > 0 && scanned < MAX_SCAN) {
+      const len = Math.min(TAIL_CHUNK, pos, MAX_SCAN - scanned)
+      pos -= len
+      const buf = Buffer.allocUnsafe(len)
+      const { bytesRead } = await handle.read(buf, 0, len, pos)
+      scanned += bytesRead
+      const region = carry?.length
+        ? Buffer.concat([buf.subarray(0, bytesRead), carry])
+        : buf.subarray(0, bytesRead)
+      const parts = []
+      let start = 0
+      for (let i = 0; i < region.length; i++) {
+        if (region[i] === 0x0a) {
+          parts.push(region.subarray(start, i))
+          start = i + 1
+        }
+      }
+      parts.push(region.subarray(start))
+      carry = pos > 0 ? parts.shift() : null
+      if (carry?.length > MAX_LINE) carry = null
+
+      for (let i = parts.length - 1; i >= 0; i--) {
+        if (parts[i].length === 0 || parts[i].length > MAX_LINE) continue
+        const message = codexLineMessage(parts[i].toString("utf8"))
+        if (!message?.text) continue
+        if (message.role === "assistant") {
+          if (!assistant) assistant = message.text
+          continue
+        }
+        let injected = false
+        if (typeof isInjected === "function") {
+          try {
+            injected = (await isInjected(message.text)) === true
+          } catch {
+            // 判定不能なら通常入力として残す。
+          }
+        }
+        if (injected) {
+          assistant = ""
+          continue
+        }
+        return { user: message.text, assistant }
+      }
+    }
+    return { user: "", assistant }
+  } catch {
+    return { user: "", assistant: "" }
+  } finally {
+    await handle?.close().catch(() => {})
+  }
+}
+
+async function findCodexRolloutFile(threadId, sessionsDir) {
+  if (!UUID_RE.test(threadId) || !sessionsDir) return null
+  const cacheKey = `${sessionsDir}\0${threadId}`
+  const cached = rolloutPathCache.get(cacheKey)
+  if (cached) {
+    try {
+      await stat(cached)
+      return cached
+    } catch {
+      rolloutPathCache.delete(cacheKey)
+    }
+  }
+  const suffix = `-${threadId}.jsonl`
+  const years = await readdir(sessionsDir).catch(() => [])
+  for (const year of years.filter((v) => /^\d{4}$/.test(v)).sort().reverse()) {
+    const yearDir = path.join(sessionsDir, year)
+    const months = await readdir(yearDir).catch(() => [])
+    for (const month of months.sort().reverse()) {
+      const monthDir = path.join(yearDir, month)
+      const days = await readdir(monthDir).catch(() => [])
+      for (const day of days.sort().reverse()) {
+        const dayDir = path.join(monthDir, day)
+        const files = await readdir(dayDir).catch(() => [])
+        const match = files.find((file) => file.endsWith(suffix))
+        if (!match) continue
+        const found = path.join(dayDir, match)
+        rolloutPathCache.set(cacheKey, found)
+        return found
+      }
+    }
+  }
+  return null
+}
+
+async function readCached(filePath, extract, { maxAgeMs = Infinity } = {}) {
+  if (!filePath) return { user: "", assistant: "" }
+  let fileStat
+  try {
+    fileStat = await stat(filePath)
+  } catch {
+    return { user: "", assistant: "" }
+  }
+  const version = `${fileStat.mtimeMs}:${fileStat.size}:${fileStat.ctimeMs}`
+  const cached = textCache.get(filePath)
+  if (
+    cached &&
+    cached.version === version &&
+    Date.now() - cached.checkedAt < maxAgeMs
+  ) {
+    return cached.texts
+  }
+
+  // 複数タブの同時 snapshot は同じ版の抽出 1 本へ畳む。版が違う要求は古い
+  // in-flight に合流させず、追記後の本文を独立して読む。
+  const inFlightKey = `${filePath}\0${version}`
+  let pending = textInFlight.get(inFlightKey)
+  if (!pending) {
+    pending = extract(filePath).finally(() => {
+      textInFlight.delete(inFlightKey)
+    })
+    textInFlight.set(inFlightKey, pending)
+  }
+  const texts = await pending
+
+  // 抽出中に追記・置換された結果を開始時の版としてキャッシュしない。
+  try {
+    const after = await stat(filePath)
+    const afterVersion = `${after.mtimeMs}:${after.size}:${after.ctimeMs}`
+    if (afterVersion === version) {
+      textCache.set(filePath, {
+        version,
+        checkedAt: Date.now(),
+        texts,
+      })
+    }
+  } catch {
+    // 読み終えた直後の削除は今回結果だけ返し、cache には残さない。
+  }
+  while (textCache.size > 512) textCache.delete(textCache.keys().next().value)
+  return texts
+}
+
+function normalizedTarget(raw) {
+  if (!raw || typeof raw !== "object") return null
+  const sessionName = typeof raw.session_name === "string" ? raw.session_name.trim() : ""
+  const cwd = typeof raw.cwd === "string" ? raw.cwd.trim() : ""
+  const cliKind = raw.cli_kind === "codex" ? "codex" : raw.cli_kind === "claude" ? "claude" : ""
+  const conversationId =
+    typeof raw.conversation_id === "string" ? raw.conversation_id.trim() : ""
+  const profileId = typeof raw.profile_id === "string" ? raw.profile_id.trim() : undefined
+  if (!sessionName || !cwd || !cliKind || !UUID_RE.test(conversationId)) return null
+  return { sessionName, cwd, cliKind, conversationId, profileId }
+}
+
+async function defaultIsAllowedCwd(cwd) {
+  const configuredBase = process.env.HUB_PROJECTS_BASE || path.join(os.homedir(), "hub", "projects")
+  try {
+    const [resolvedCwd, resolvedBase] = await Promise.all([realpath(cwd), realpath(configuredBase)])
+    if (!resolvedCwd.startsWith(`${resolvedBase}${path.sep}`)) return false
+    const parts = path.relative(resolvedBase, resolvedCwd).split(path.sep)
+    return (
+      parts.length === 1 ||
+      (parts.length === 4 && parts[1] === ".claude" && parts[2] === "worktrees")
+    )
+  } catch {
+    return false
+  }
+}
+
+export async function readSidebarMessageSnapshot(
+  targets,
+  {
+    resolveClaudeRoot = resolveProjectsRoot,
+    resolveCodexRoot = codexProfiles.resolveSessionsDir,
+    liveCodexSession,
+    isAllowedCwd = defaultIsAllowedCwd,
+    lookupInjected = lookupInjectSource,
+    extractClaude = extractLastTurnTexts,
+    extractCodex = extractCodexLastTurnTexts,
+  } = {},
+) {
+  const safeTargets = (Array.isArray(targets) ? targets : [])
+    .slice(0, MAX_TARGETS)
+    .map(normalizedTarget)
+    .filter(Boolean)
+
+  const readTarget = async (target) => {
+    try {
+      if (!(await isAllowedCwd(target.cwd))) throw new Error("cwd outside workspace roots")
+      const isInjected = async (text) =>
+        Boolean(await lookupInjected(target.cwd, text))
+      let texts = { user: "", assistant: "" }
+      if (target.cliKind === "claude") {
+        const { projectsRoot, profileId } = await resolveClaudeRoot(target.profileId)
+        const filePath = jsonlPath({
+          cwd: target.cwd,
+          session_id: target.conversationId,
+          projectsRoot,
+        })
+        texts = await readCached(
+          filePath,
+          (fp) => extractClaude(fp, { isInjected }),
+          { maxAgeMs: 2_000 },
+        )
+        return {
+          session_name: target.sessionName,
+          cli_kind: "claude",
+          conversation_id: target.conversationId,
+          profile_id: profileId,
+          ...(texts.user ? { user: texts.user } : {}),
+          ...(texts.assistant ? { assistant: texts.assistant } : {}),
+        }
+      }
+
+      const live = liveCodexSession?.(target)
+      if (live && live.threadId === target.conversationId) {
+        texts = await textsFromCodexItems(live.historyItems, { isInjected })
+      }
+      const { sessionsDir, profileId } = await resolveCodexRoot(target.profileId)
+      if (!texts.user || !texts.assistant) {
+        const filePath = await findCodexRolloutFile(target.conversationId, sessionsDir)
+        const diskTexts = await readCached(
+          filePath,
+          (fp) => extractCodex(fp, { isInjected }),
+          { maxAgeMs: 2_000 },
+        )
+        texts = {
+          user: texts.user || diskTexts.user,
+          // live に user があるのに assistant が無い = 生成中。前ターンの disk assistant
+          // で埋めると別ターン混在になるため、disk は live user 自体が無いときだけ使う。
+          assistant: texts.user ? texts.assistant : diskTexts.assistant,
+        }
+      }
+      return {
+        session_name: target.sessionName,
+        cli_kind: "codex",
+        conversation_id: target.conversationId,
+        profile_id: profileId,
+        ...(texts.user ? { user: texts.user } : {}),
+        ...(texts.assistant ? { assistant: texts.assistant } : {}),
+      }
+    } catch {
+      // 1 件の profile / 履歴 I/O 失敗で、他セッションの表示まで消さない。
+      return {
+        session_name: target.sessionName,
+        cli_kind: target.cliKind,
+        conversation_id: target.conversationId,
+      }
+    }
+  }
+
+  const messages = new Array(safeTargets.length)
+  let cursor = 0
+  const workers = Array.from(
+    { length: Math.min(READ_CONCURRENCY, safeTargets.length) },
+    async () => {
+      for (;;) {
+        const index = cursor++
+        if (index >= safeTargets.length) return
+        messages[index] = await readTarget(safeTargets[index])
+      }
+    },
+  )
+  await Promise.all(workers)
+  return messages
+}
+
+export function _resetSidebarMessageSnapshotCachesForTest() {
+  textCache.clear()
+  textInFlight.clear()
+  rolloutPathCache.clear()
+}