@cocorograph/hub-agent 0.8.3 → 0.8.5

package/package.json

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

package/src/claude-history.mjs

@@ -19,6 +19,7 @@ import path from "node:path"
 
 import {
   MASK_ENABLED,
+  SECRET_PLACEHOLDER,
   collectToolUseNames,
   maskMessageObject,
   redactSecrets,
@@ -541,6 +542,203 @@ async function extractLastTurnAtMs(filePath, fallbackMtimeMs = null) {
   }
 }
 
+/** サイドバー 1 行に載せる依頼 / 応答テキストの最大長。1 行 clamp 前提で少し余裕を持たせる。 */
+export const LAST_TURN_TEXT_MAX = 120
+
+/**
+ * message.content (string | block[]) から表示用テキストを連結する。
+ *
+ * tool_use / tool_result / thinking は「会話の主題」ではないので落とす。user 行の content が
+ * tool_result だけのケース (= ツール実行の戻り。ユーザーの発言ではない) は空文字になり、
+ * 呼び出し側がスキップして更に遡る。
+ */
+function contentToPlainText(content) {
+  if (typeof content === "string") return content
+  if (!Array.isArray(content)) return ""
+  const parts = []
+  for (const b of content) {
+    if (b && b.type === "text" && typeof b.text === "string") parts.push(b.text)
+  }
+  return parts.join("\n")
+}
+
+/**
+ * jsonl の末尾から「最後の実ユーザー依頼」と「最後のアシスタント応答」を 1 本ずつ抜く。
+ *
+ * ## なぜ必要か (2026-07-28)
+ * Cockpit サイドバーは各行に「何を依頼したか」を出す。しかし frontend は選択中 1 セッション
+ * 分のメッセージしか保持せず、backend にも全セッションの最新メッセージを返す API が無い。
+ * 既存の `ClaudeSessionSummary.preview` は **最初の** user 発言なので用途が違う。そこで
+ * agent 側で jsonl 末尾を読み、tmux.list_sessions の行に同梱して配信する。
+ *
+ * 実装は固定チャンクで**後方へ改行境界を探索**する tail scanner。1 行が
+ * `LAST_TURN_MAX_LINE` を超える巨大行 (tool_result / base64) は decode せず読み飛ばし、
+ * その手前の正常なターンまで遡る。総走査量は `LAST_TURN_MAX_SCAN`、読み飛ばせる行数は
+ * `LAST_TURN_MAX_SKIPPED_LINES` で頭打ちにして、poll ごとの I/O 集中を防ぐ。
+ * (旧実装の「窓を倍々に広げて巨大行ごと取り込む」方式は、単一行が上限を超えると窓内に
+ *  改行が 1 つも現れず、手前のターンごと取りこぼすため廃止した。)
+ *
+ * user 側は `normalizePreviewText` を通し、合成メッセージ / `/clear`・`/compact` の痕跡を
+ * 飛ばして「次の実発言」を拾う (= 一覧が全部 /clear で始まる問題を避ける)。
+ *
+ * @param {string} filePath
+ * @returns {Promise<{user: string, assistant: string}>} 見つからない側は ""
+ */
+/** 1 行の上限。これを超える行 (巨大 tool_result / base64) は decode せず読み飛ばす。 */
+export const LAST_TURN_MAX_LINE = 1024 * 1024
+/** 1 回の呼び出しで読む総バイト数の上限 (巨大行の読み飛ばしを含む I/O 予算)。 */
+export const LAST_TURN_MAX_SCAN = 8 * 1024 * 1024
+/** 読み飛ばしてよい巨大行の本数。超えたら諦める (poll ごとの I/O 集中を抑える)。 */
+export const LAST_TURN_MAX_SKIPPED_LINES = 8
+
+const NEWLINE_BYTE = 0x0a
+
+/** Buffer を改行 (0x0A) で分割して Buffer 配列にする。UTF-8 の継続バイトに 0x0A は現れない。 */
+function splitLinesBuf(buf) {
+  const out = []
+  let start = 0
+  for (let i = 0; i < buf.length; i++) {
+    if (buf[i] === NEWLINE_BYTE) {
+      out.push(buf.subarray(start, i))
+      start = i + 1
+    }
+  }
+  out.push(buf.subarray(start))
+  return out
+}
+
+/**
+ * preview テキストの秘匿情報を伏せる。**必ず切り詰めより前に、完全な本文へ適用する。**
+ *
+ * ⚠️ 順序が肝 (2026-07-28 のクロスレビューで実証された事故): 先に 80/120 文字へ切ると
+ * PEM の `-----END ... PRIVATE KEY-----` が落ち、`redactSecrets` の非貪欲マッチが不成立に
+ * なって **鍵の先頭断片がそのまま preview に出る**。マスク → 正規化 → 切り詰めの順にする。
+ *
+ * サイドバー配信は新設の露出面なので `MASK_ENABLED` に関係なく常にマスクする
+ * (120 文字のプレビューに秘匿情報が必要な場面は無い)。閉じていない PEM opener が残る
+ * ケースは、そこから先を保守的に全て伏せる。
+ */
+function maskPreviewText(raw) {
+  if (!raw) return ""
+  let out = redactSecrets(raw)
+  const openerAt = out.indexOf("-----BEGIN")
+  if (openerAt >= 0) out = out.slice(0, openerAt) + SECRET_PLACEHOLDER
+  return out
+}
+
+/** assistant テキスト用: マスク → 空白圧縮 → 切り詰め。 */
+function sanitizeAssistantText(raw) {
+  const masked = maskPreviewText(raw).trim()
+  if (!masked) return ""
+  return masked.replace(/\s+/g, " ").slice(0, LAST_TURN_TEXT_MAX)
+}
+
+/**
+ * 1 行 (JSON) から user / assistant テキストを取り出し、未取得の側だけを埋める。
+ * 既に埋まっている側は触らない (末尾に近い方を優先するため)。
+ */
+function takeTextsFromLine(line, user, assistant) {
+  if (!line) return { user, assistant }
+  let obj
+  try {
+    obj = JSON.parse(line)
+  } catch {
+    return { user, assistant }
+  }
+  if (!obj || !obj.message) return { user, assistant }
+  if (obj.type === "assistant" && !assistant) {
+    const t = sanitizeAssistantText(contentToPlainText(obj.message.content))
+    if (t) assistant = t
+    return { user, assistant }
+  }
+  if (obj.type === "user" && !user) {
+    // isMeta / isSidechain はハーネス注入や sub-agent の発言でユーザーの依頼ではない。
+    if (obj.isMeta === true || obj.isSidechain === true) return { user, assistant }
+    // マスクは正規化・切り詰めより前 (maskPreviewText の docstring 参照)。
+    const masked = maskPreviewText(contentToPlainText(obj.message.content))
+    // normalizePreviewText が null を返す行 (合成 / /clear / local-command) はスキップし、
+    // 更に過去へ遡って「実際に打った依頼」を探す。
+    const norm = normalizePreviewText(masked)
+    if (norm) user = norm.slice(0, LAST_TURN_TEXT_MAX)
+  }
+  return { user, assistant }
+}
+
+export async function extractLastTurnTexts(filePath) {
+  let handle
+  try {
+    handle = await open(filePath, "r")
+    const st = await handle.stat()
+    if (st.size <= 0) return { user: "", assistant: "" }
+
+    let pos = st.size // まだ読んでいない領域の右端 (exclusive)
+    let carry = null // 左端が未確定の行断片 (次のチャンクと連結して確定させる)
+    let skippingHugeLine = false // 上限超の行の途中を読み飛ばし中
+    let skipped = 0
+    let scanned = 0
+    let user = ""
+    let assistant = ""
+
+    // ⚠️ 「窓を倍々に広げて巨大行ごと取り込む」旧方式は、単一行が上限を超えると窓内に
+    // 改行が 1 つも現れず、その手前にある正常なターンまで丸ごと取りこぼした
+    // (4MB+1KB の tool_result で両方空になる事故)。固定チャンクで後方へ改行境界を
+    // 探索し、上限超の行は decode せず読み飛ばす方式に変える。
+    while (pos > 0 && scanned < LAST_TURN_MAX_SCAN) {
+      const len = Math.min(LAST_TURN_TAIL_CHUNK, pos)
+      pos -= len
+      const buf = Buffer.allocUnsafe(len)
+      const { bytesRead } = await handle.read(buf, 0, len, pos)
+      scanned += bytesRead
+      const chunk = buf.subarray(0, bytesRead)
+      const region = carry && carry.length ? Buffer.concat([chunk, carry]) : chunk
+      carry = null
+
+      const segs = splitLinesBuf(region)
+      let endIdx = segs.length // exclusive
+      if (skippingHugeLine) {
+        // 末尾 seg は読み飛ばし中の巨大行の続き → 捨てる。
+        endIdx -= 1
+        // 改行が 1 つでもあれば巨大行の左端に到達したので読み飛ばしを終える。
+        if (segs.length > 1) skippingHugeLine = false
+      }
+      let startIdx = 0
+      if (pos > 0) {
+        // 先頭 seg は左端未確定 → 次チャンクへ持ち越す。pos===0 なら完全な行。
+        carry = segs[0]
+        startIdx = 1
+      }
+
+      for (let i = endIdx - 1; i >= startIdx; i--) {
+        const lineBuf = segs[i]
+        if (lineBuf.length === 0) continue
+        if (lineBuf.length > LAST_TURN_MAX_LINE) {
+          skipped++
+          continue
+        }
+        const res = takeTextsFromLine(lineBuf.toString("utf-8"), user, assistant)
+        user = res.user
+        assistant = res.assistant
+        if (user && assistant) break
+      }
+      if (user && assistant) break
+      if (skipped > LAST_TURN_MAX_SKIPPED_LINES) break
+
+      if (carry && carry.length > LAST_TURN_MAX_LINE) {
+        // 単一行が上限超 → その行は諦め、更に左の改行まで decode せず読み飛ばす。
+        carry = null
+        skippingHugeLine = true
+        skipped++
+        if (skipped > LAST_TURN_MAX_SKIPPED_LINES) break
+      }
+    }
+    return { user, assistant }
+  } catch {
+    return { user: "", assistant: "" }
+  } finally {
+    await handle?.close()
+  }
+}
+
 /**
  * cwd 配下の全 jsonl ファイルから session 一覧を返す。
  * 各ファイルから session_id / 最終更新時刻 / サイズ / 最初の user message preview を抽出。

package/src/dispatch-scheduler.mjs

@@ -0,0 +1,238 @@
+/**
+ * Hub → agent の inbound dispatch を、接続世代と機能レーン単位で直列化する。
+ *
+ * 旧実装は全 message を 1 本の Promise chain に載せていたため、ある cwd の重い
+ * tmux/codex 処理が、無関係な cwd の claude.attach や reconnect の ready/sync まで
+ * 数分止める head-of-line blocking を起こしていた。
+ *
+ * 不変条件:
+ * - 同一 cwd・同一 CLI の chat 操作は受信順を維持する。
+ * - tmux/control と Claude/Codex、別 cwd 同士は互いに待たない。
+ * - ready / streams sync 等の接続ライフサイクルはキューを待たない。
+ * - WS 世代が変わったら、旧世代で未実行の操作を適用しない。
+ * - detach 済み stream の未実行 attach を適用しない。
+ */
+
+const LIFECYCLE_TYPES = new Set([
+  "ready",
+  "error",
+  "agent.streams.sync.response",
+  "bundle.sync.request",
+  "agent.shutdown",
+])
+
+const MAX_STREAM_LANE_KEYS = 4096
+
+export function isConnectionLifecycleMessage(type) {
+  return LIFECYCLE_TYPES.has(type)
+}
+
+function chatMode(type) {
+  if (typeof type !== "string") return null
+  if (type === "claude.attach" || type.startsWith("claude.")) return "claude"
+  if (type === "codex.attach" || type.startsWith("codex.")) return "codex"
+  return null
+}
+
+function globalMutationMode(type) {
+  if (type === "profile.switch" || type === "profile.add" || type === "profile.rename") {
+    return "claude"
+  }
+  if (
+    type === "codex.profile.switch" ||
+    type === "codex.profile.add" ||
+    type === "codex.profile.rename"
+  ) {
+    return "codex"
+  }
+  return null
+}
+
+function attachLaneKey(mode, msg) {
+  const cwd = typeof msg?.cwd === "string" ? msg.cwd.trim() : ""
+  if (cwd) return `${mode}:cwd:${cwd}`
+  const resumeId =
+    mode === "claude"
+      ? msg?.resume_session_id
+      : msg?.resume_thread_id || msg?.thread_id
+  if (typeof resumeId === "string" && resumeId) return `${mode}:resume:${resumeId}`
+  const streamId = typeof msg?.stream_id === "string" ? msg.stream_id : ""
+  return streamId ? `${mode}:stream:${streamId}` : `${mode}:control`
+}
+
+/**
+ * @param {{
+ *   run: (msg: object) => Promise<void>|void,
+ *   logger?: {debug?: Function, warn?: Function, error?: Function},
+ *   shouldBypass?: (type: string|undefined) => boolean,
+ * }} options
+ */
+export class DispatchScheduler {
+  constructor({ run, logger, shouldBypass }) {
+    if (typeof run !== "function") throw new TypeError("DispatchScheduler run is required")
+    this.run = run
+    this.logger = logger
+    this.shouldBypass = typeof shouldBypass === "function" ? shouldBypass : () => false
+    this.generation = 0
+    this.sequence = 0
+    this.laneTails = new Map()
+    this.streamLaneKeys = new Map()
+    this.detachedAtByStream = new Map()
+  }
+
+  /**
+   * WS close/open で世代を進める。既に走り始めた処理は止められないが、旧 tail を
+   * 新接続へ継承せず、まだ始まっていない旧世代 task は実行直前に drop する。
+   */
+  advanceGeneration(reason = "connection_changed") {
+    this.generation += 1
+    this.laneTails.clear()
+    this.streamLaneKeys.clear()
+    this.detachedAtByStream.clear()
+    this.logger?.debug?.(
+      { generation: this.generation, reason },
+      "dispatch generation advanced",
+    )
+    return this.generation
+  }
+
+  _rememberStreamLane(streamId, laneKey) {
+    const mode = laneKey.startsWith("codex:") ? "codex" : "claude"
+    const streamKey = streamId ? `${mode}:${streamId}` : ""
+    if (!streamKey) return
+    this.streamLaneKeys.set(streamKey, laneKey)
+    while (this.streamLaneKeys.size > MAX_STREAM_LANE_KEYS) {
+      const oldest = this.streamLaneKeys.keys().next().value
+      if (oldest == null) break
+      this.streamLaneKeys.delete(oldest)
+      this.detachedAtByStream.delete(oldest)
+    }
+  }
+
+  _rememberDetach(streamKey, sequence) {
+    if (!streamKey) return
+    this.detachedAtByStream.set(streamKey, sequence)
+    while (this.detachedAtByStream.size > MAX_STREAM_LANE_KEYS) {
+      const oldest = this.detachedAtByStream.keys().next().value
+      if (oldest == null) break
+      this.detachedAtByStream.delete(oldest)
+    }
+  }
+
+  _laneFor(msg) {
+    const type = msg?.type
+    const mutationMode = globalMutationMode(type)
+    if (mutationMode) return `${mutationMode}:global`
+
+    const mode = chatMode(type)
+    if (!mode) return "control"
+
+    const streamId = typeof msg?.stream_id === "string" ? msg.stream_id : ""
+    const streamKey = streamId ? `${mode}:${streamId}` : ""
+    if (type === `${mode}.attach`) {
+      const laneKey = attachLaneKey(mode, msg)
+      this._rememberStreamLane(streamId, laneKey)
+      return laneKey
+    }
+    if (streamKey && this.streamLaneKeys.has(streamKey)) {
+      return this.streamLaneKeys.get(streamKey)
+    }
+    const cwd = typeof msg?.cwd === "string" ? msg.cwd.trim() : ""
+    if (cwd) return `${mode}:cwd:${cwd}`
+    if (streamId) return `${mode}:stream:${streamId}`
+    // codex.profile.list 等の stream 非依存 read は main 側の read-only bypass
+    // に分類する。未知の stream 非依存メッセージは mode-wide control として扱う。
+    return `${mode}:global`
+  }
+
+  _previousFor(lane) {
+    const own = this.laneTails.get(lane)
+    const match = /^(claude|codex):(global|cwd:|resume:|stream:)/.exec(lane)
+    if (!match) return own || Promise.resolve()
+
+    const mode = match[1]
+    if (lane === `${mode}:global`) {
+      // プロファイル切替等の mode-wide mutation は、既に走っている同 CLI の
+      // attach/input が終わってから適用する。
+      const dependencies = []
+      for (const [key, tail] of this.laneTails) {
+        if (key.startsWith(`${mode}:`)) dependencies.push(tail)
+      }
+      return dependencies.length > 0 ? Promise.all(dependencies) : Promise.resolve()
+    }
+
+    // cwd/stream lane は、先行する profile mutation があればその完了も待つ。
+    const globalTail = this.laneTails.get(`${mode}:global`)
+    if (own && globalTail && own !== globalTail) return Promise.all([own, globalTail])
+    return own || globalTail || Promise.resolve()
+  }
+
+  _runNow(msg, lane = "bypass") {
+    return Promise.resolve().then(() => this.run(msg)).catch((err) => {
+      this.logger?.error?.(
+        { err: err?.message, type: msg?.type, lane },
+        "dispatch threw",
+      )
+    })
+  }
+
+  enqueue(msg) {
+    const type = msg?.type
+    const sequence = ++this.sequence
+    if (this.shouldBypass(type) || isConnectionLifecycleMessage(type)) {
+      return this._runNow(msg)
+    }
+
+    const streamId = typeof msg?.stream_id === "string" ? msg.stream_id : ""
+    const mode = chatMode(type)
+    const streamKey = mode && streamId ? `${mode}:${streamId}` : ""
+    const isDetach = type === "claude.detach" || type === "codex.detach"
+    if (isDetach && streamKey) {
+      // attach がまだ lane 内で待機中でも、その実行前に stale と判定できるよう
+      // detach の dispatch 完了を待たず受信時点の順序を記録する。真偽値だけだと
+      // detach より後に来た正規の再 attach まで落とすため、sequence で前後を区別する。
+      this._rememberDetach(streamKey, sequence)
+    }
+
+    const lane = this._laneFor(msg)
+    const generation = this.generation
+    const previous = this._previousFor(lane)
+    const task = previous
+      .then(async () => {
+        if (generation !== this.generation) {
+          this.logger?.debug?.(
+            { type, lane, queued_generation: generation, generation: this.generation },
+            "stale queued dispatch dropped after reconnect",
+          )
+          return
+        }
+        if (
+          (type === "claude.attach" || type === "codex.attach") &&
+          streamKey &&
+          (this.detachedAtByStream.get(streamKey) ?? -1) > sequence
+        ) {
+          this.logger?.debug?.(
+            { type, lane, stream_id: streamId },
+            "detached queued attach dropped",
+          )
+          return
+        }
+        await this.run(msg)
+      })
+      .catch((err) => {
+        this.logger?.error?.(
+          { err: err?.message, type, lane },
+          "dispatch threw in serial lane",
+        )
+      })
+      .finally(() => {
+        if (this.laneTails.get(lane) === task) this.laneTails.delete(lane)
+        if (isDetach && streamKey && generation === this.generation) {
+          this.streamLaneKeys.delete(streamKey)
+        }
+      })
+
+    this.laneTails.set(lane, task)
+    return task
+  }
+}

package/src/main.mjs

@@ -12,7 +12,15 @@
  */
 import { spawn as _childSpawn } from "node:child_process"
 import { existsSync, readFileSync, watch as fsWatch } from "node:fs"
-import { mkdir, readFile, readdir, rename, unlink, writeFile } from "node:fs/promises"
+import {
+  mkdir,
+  readFile,
+  readdir,
+  rename,
+  stat,
+  unlink,
+  writeFile,
+} from "node:fs/promises"
 import { randomUUID } from "node:crypto"
 import os from "node:os"
 import path from "node:path"
@@ -39,6 +47,7 @@ import {
 } from "./hub-bundle.mjs"
 import { loadPlugins, runHookBroadcast, runHookChain } from "./plugin-loader.mjs"
 import { WsClient } from "./ws-client.mjs"
+import { DispatchScheduler } from "./dispatch-scheduler.mjs"
 import { PtyBridge } from "./pty-bridge.mjs"
 import { ClaudeStreamBridge } from "./claude-stream-bridge.mjs"
 import { CodexMcpControl } from "./codex-mcp-control.mjs"
@@ -46,6 +55,7 @@ import { CodexStreamBridge, classifyCodexInputError } from "./codex-stream-bridg
 import { UploadManager } from "./claude-upload.mjs"
 import { requestSelfUninstall } from "./service-install.mjs"
 import {
+  extractLastTurnTexts,
   fetchSessionHistory,
   jsonlPath,
   listSessions,
@@ -328,6 +338,8 @@ export function isReadOnlyRpc(type) {
     type === "claude.history.request" ||
     type === "claude.sessions.request" ||
     type === "codex.sessions.request" ||
+    type === "profile.list" ||
+    type === "codex.profile.list" ||
     // T06603 (2026-07-25): キュー snapshot の pull。in-memory 配列を読むだけで副作用が無く、
     // かつ「直列キュー前方の重い処理で再同期が遅延する」と送信待ちチップの固着が長引く
     // (再同期は固着を直すための経路なので、詰まりやすい経路に置いてはならない)。
@@ -1079,7 +1091,7 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
     })
   }
 
-  // Hub からのメッセージ dispatch は **直列実行** する。
+  // Hub からのメッセージ dispatch は、接続世代 + 機能レーン単位で直列実行する。
   //
   // `EventEmitter.emit` は async リスナーの完了を待たないため、`async (msg) =>
   // await dispatch(msg, ...)` の形だと複数 WS メッセージが連続して届いたとき
@@ -1094,50 +1106,29 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
   // 結果として paste が tmux 内部状態 (copy mode 等) を抜ける前に届き、
   // claude TUI に正しく入らない事象が散発する。
   //
-  // Promise chain で前の dispatch 完了を待ってから次を始めることで、WS
-  // 受信順 = pane 反映順を保証する。pty 出力 (agent → browser) は別経路
-  // (`ptyBridge.on("output")`) なのでこの直列化の影響を受けない。
-  let dispatchChain = Promise.resolve()
-  client.on("message", (msg) => {
-    // B7: pty 出力データ (pty.data) と resize (pty.resize) は順序保証が不要で高頻度な
-    // 低レイテンシ経路。これらを直列キュー (dispatchChain) に通すと、1 件の tmux.exec 等
-    // のハングで pty 入出力まで全停止してしまう。安全側に「pty 出力データと resize のみ」
-    // を直列キューからバイパスして即時処理する。入力系 (claude.input)・制御系 (tmux.exec /
-    // permission / cancel→paste 等) は WS 受信順 = pane 反映順を守るため dispatchChain に残す。
-    if (isFastPathMessage(msg?.type)) {
-      Promise.resolve(
-        dispatch(msg, { ...ctx, client, ptyBridge, claudeBridge, codexBridge, codexMcpControl, uploadManager }),
-      ).catch((err) => {
-        logger.error(
-          { err: err.message, type: msg?.type },
-          "dispatch threw (bypassed pty fast-path)",
-        )
-      })
-      return
-    }
-    // Phase 3 (Read-plane): 読み取り専用 RPC (history/sessions) も直列キューから外して並行処理する。
-    // 直列キュー前方の重い処理 (codex app-server spawn 等) が claude.attach→ready を HoL blocking
-    // するのを防ぐ (view/spawn 分離)。純粋読み取りで順序依存が無いことは isReadOnlyRpc の説明参照。
-    if (isReadOnlyRpc(msg?.type)) {
-      Promise.resolve(
-        dispatch(msg, { ...ctx, client, ptyBridge, claudeBridge, codexBridge, codexMcpControl, uploadManager }),
-      ).catch((err) => {
-        logger.error(
-          { err: err.message, type: msg?.type },
-          "dispatch threw (bypassed read-only RPC lane)",
-        )
-      })
-      return
-    }
-    dispatchChain = dispatchChain
-      .then(() => dispatch(msg, { ...ctx, client, ptyBridge, claudeBridge, codexBridge, codexMcpControl, uploadManager }))
-      .catch((err) => {
-        logger.error(
-          { err: err.message, type: msg?.type },
-          "dispatch threw in serial queue",
-        )
-      })
+  // 旧来の global Promise chain は、ある cwd の tmux/codex 処理が別 cwd の
+  // claude.attach と reconnect ready/sync まで 60〜203 秒止める HoL blocking を
+  // 本番で起こした。DispatchScheduler は同一 cwd・同一 CLI の順序だけを維持し、
+  // tmux/control・Claude・Codex・別 cwd を独立レーンへ分離する。
+  const dispatchCtx = {
+    ...ctx,
+    client,
+    ptyBridge,
+    claudeBridge,
+    codexBridge,
+    codexMcpControl,
+    uploadManager,
+  }
+  const dispatchScheduler = new DispatchScheduler({
+    logger,
+    run: (msg) => dispatch(msg, dispatchCtx),
+    // pty fast-path / read-only RPC は従来どおり即時実行。接続 lifecycle は
+    // scheduler 自身が常に priority 扱いする。
+    shouldBypass: (type) => isFastPathMessage(type) || isReadOnlyRpc(type),
   })
+  client.on("close", () => dispatchScheduler.advanceGeneration("ws_close"))
+  client.on("open", () => dispatchScheduler.advanceGeneration("ws_open"))
+  client.on("message", (msg) => dispatchScheduler.enqueue(msg))
 
   client.connect()
 
@@ -1708,6 +1699,171 @@ 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()
+
+/** 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
+ * @returns {Promise<Map<string, {user: string, assistant: string}>>}
+ */
+export async function readAllSessionLastTexts(
+  sessions,
+  getSnap,
+  { extract = extractLastTurnTexts, statFn = stat, resolvePath = jsonlPath } = {},
+) {
+  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
+      const sessionId = snap.context_session_id
+      // パス要素として安全な形だけを通す (外部由来の値なので containment を局所保証)。
+      if (!isSafeSessionIdForPath(sessionId)) return
+      if (!s.cwd) return
+      const fp = resolvePath({ cwd: s.cwd, session_id: sessionId })
+      if (!fp) return
+      livePaths.add(fp)
+      const st = await statFn(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` 再配信 (取りこぼし回復) に使う。
@@ -1977,17 +2133,26 @@ 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,
 ) {
   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
@@ -4556,10 +4721,17 @@ async function dispatch(msg, ctx) {
           // fs.watch 由来の session.event push は揮発性のため、frontend が新規
           // マウントすると過去 event を取れず全グレー表示になる事象を解消する。
           const lastEventByName = await readAllSessionEvents()
+          // サイドバー行に「何を依頼したか」を出すため、各セッションの jsonl 末尾から
+          // 最新の依頼 / 応答テキストを読む (mtime キャッシュ付き)。失敗は空に落ちる。
+          const lastTextsByName = await readAllSessionLastTexts(
+            sessions,
+            ctx.getSessionStateSnapshot,
+          )
           const enriched = enrichTmuxSessionsForListResponse(
             sessions,
             lastEventByName,
             ctx.getSessionStateSnapshot,
+            lastTextsByName,
           )
           // cockpit (PR 1719) で未起動 worktree をサイドバーに可視化するために
           // filesystem 上は存在するが tmux session が無い worktree dir のリストを