@cocorograph/hub-agent 0.8.4 → 0.8.6

package/package.json

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

package/src/async-ttl-cache.mjs

@@ -0,0 +1,51 @@
+/**
+ * 読み取り専用スナップショット向けの短期 TTL + single-flight キャッシュ。
+ *
+ * - TTL 内は直前の成功値を即返す
+ * - TTL 切れ後に複数 caller が重なった場合も build は 1 本だけ実行する
+ * - build 失敗はキャッシュせず、次回 caller が再試行できる
+ * - clear() は進行中 build の呼び出し元も新世代の build へ合流し直す
+ */
+export class AsyncTtlCache {
+  constructor({ ttlMs, now = () => Date.now() }) {
+    this.ttlMs = Math.max(0, Number(ttlMs) || 0)
+    this.now = now
+    this.hasValue = false
+    this.value = undefined
+    this.expiresAt = 0
+    this.inFlight = null
+    this.generation = 0
+  }
+
+  async get(build) {
+    if (this.hasValue && this.now() < this.expiresAt) return this.value
+    if (this.inFlight) return this.inFlight
+
+    const generation = this.generation
+    const pending = Promise.resolve().then(build)
+    this.inFlight = pending
+    try {
+      const value = await pending
+      // build 中に mutation / state push が走った場合、旧値を最初の caller にも返さない。
+      // clear() が inFlight を外しているため、新世代の build を開始するか既存の新 build に
+      // 合流する。read-only snapshot 専用なので再実行は安全。
+      if (this.generation !== generation) return this.get(build)
+      this.value = value
+      this.hasValue = true
+      this.expiresAt = this.now() + this.ttlMs
+      return value
+    } finally {
+      if (this.inFlight === pending) this.inFlight = null
+    }
+  }
+
+  clear() {
+    this.generation += 1
+    this.hasValue = false
+    this.value = undefined
+    this.expiresAt = 0
+    // 旧 build 自体は安全に完走させるが、新 caller はそこへ合流させない。旧 build の
+    // finally は identity 比較により、新世代の inFlight を誤って消さない。
+    this.inFlight = null
+  }
+}

package/src/codex-stream-bridge.mjs

@@ -43,6 +43,7 @@
 import { EventEmitter } from "node:events"
 import { randomUUID } from "node:crypto"
 
+import { AsyncTtlCache } from "./async-ttl-cache.mjs"
 import { CodexAppServerClient } from "./codex-appserver-client.mjs"
 import {
   snapshotCodexDeliveryAudit,
@@ -323,6 +324,7 @@ export class CodexStreamBridge extends EventEmitter {
     listThreadsFromDisk,
     historyMaxItems,
     historyMaxBytes,
+    listThreadsCacheTtlMs,
   } = {}) {
     super()
     this.codexCmd = codexCmd
@@ -357,10 +359,12 @@ export class CodexStreamBridge extends EventEmitter {
     /** @type {Map<string, object>} stream_id -> session record */
     this.sessions = new Map()
     this._accountRateLimitsByProfile = new Map()
-    // Phase 3 (Read-plane): listThreads の single-flight。key(`cwd::limit`) -> in-flight Promise。
-    // codex.sessions.request を直列キューから外したため、同一 cwd への同時リクエストが
-    // app-server の同時 spawn (storm) を起こさないよう 1 本に畳む。
-    this._listThreadsInFlight = new Map()
+    // 複数 Cockpit タブ + pre-attach/ready の連続 request が、同じ cwd で rollout
+    // header 最大 800 件を短時間に何度も走査するのを防ぐ。thread picker の読み取り専用
+    // データなので数秒の鮮度差は許容し、実 turn/attach の正本には使わない。各 key の
+    // AsyncTtlCache が single-flight と、thread/start 中の世代切替をまとめて担う。
+    this._listThreadsCacheTtlMs = listThreadsCacheTtlMs ?? 5_000
+    this._listThreadsCache = new Map()
   }
 
   /**
@@ -576,6 +580,9 @@ export class CodexStreamBridge extends EventEmitter {
         ? await client.request("thread/resume", { ...startParams, threadId: resumeThreadId })
         : await client.request("thread/start", startParams)
       session.threadId = result?.thread?.id
+      // thread/start は一覧そのものを変更するため、pre-attach で得た短期キャッシュを破棄する。
+      // resume/reattach は既存 thread の再閲覧なのでキャッシュを維持し、ready 後の重複走査を防ぐ。
+      if (!resuming) this._invalidateListThreadsCacheForCwd(cwd)
       this.logger?.info?.(
         {
           stream_id,
@@ -836,13 +843,33 @@ export class CodexStreamBridge extends EventEmitter {
     // sessionsDir 未指定 (旧経路) のときだけ env 由来の値へフォールバックする。
     const readRoot = sessionsDir || process.env.CODEX_HOME || ""
     const key = `${readRoot}::${cwd || ""}::${limit ?? ""}`
-    const existing = this._listThreadsInFlight.get(key)
-    if (existing) return existing
-    const p = this._doListThreads({ cwd, limit, sessionsDir }).finally(() => {
-      this._listThreadsInFlight.delete(key)
-    })
-    this._listThreadsInFlight.set(key, p)
-    return p
+    let entry = this._listThreadsCache.get(key)
+    if (!entry) {
+      entry = {
+        cwd: cwd || "",
+        cache: new AsyncTtlCache({ ttlMs: this._listThreadsCacheTtlMs }),
+      }
+      this._listThreadsCache.set(key, entry)
+      this._pruneListThreadsCache()
+    }
+    return entry.cache.get(() => this._doListThreads({ cwd, limit, sessionsDir }))
+  }
+
+  _invalidateListThreadsCacheForCwd(cwd) {
+    const normalizedCwd = cwd || ""
+    for (const entry of this._listThreadsCache.values()) {
+      if (entry.cwd === normalizedCwd) entry.cache.clear()
+    }
+  }
+
+  _pruneListThreadsCache() {
+    if (this._listThreadsCache.size <= 256) return
+    for (const [key, entry] of this._listThreadsCache) {
+      if (this._listThreadsCache.size <= 256) break
+      // 走査中の entry を map から外すと、同じ key の次 caller が別走査を開始して
+      // single-flight を破る。完了済みの古い entry だけを先に落とす。
+      if (!entry.cache.inFlight) this._listThreadsCache.delete(key)
+    }
   }
 
   async _doListThreads({ cwd, limit, sessionsDir } = {}) {

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

@@ -47,6 +47,8 @@ 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 { AsyncTtlCache } from "./async-ttl-cache.mjs"
 import { PtyBridge } from "./pty-bridge.mjs"
 import { ClaudeStreamBridge } from "./claude-stream-bridge.mjs"
 import { CodexMcpControl } from "./codex-mcp-control.mjs"
@@ -91,6 +93,7 @@ import {
 } from "./claude-credentials.mjs"
 import {
   buildClaudeCmd,
+  buildWorktreeIndex,
   createSession as createTmuxSession,
   createWorktreeDir,
   execTmux,
@@ -337,6 +340,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 配列を読むだけで副作用が無く、
     // かつ「直列キュー前方の重い処理で再同期が遅延する」と送信待ちチップの固着が長引く
     // (再同期は固着を直すための経路なので、詰まりやすい経路に置いてはならない)。
@@ -1088,7 +1093,7 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
     })
   }
 
-  // Hub からのメッセージ dispatch は **直列実行** する。
+  // Hub からのメッセージ dispatch は、接続世代 + 機能レーン単位で直列実行する。
   //
   // `EventEmitter.emit` は async リスナーの完了を待たないため、`async (msg) =>
   // await dispatch(msg, ...)` の形だと複数 WS メッセージが連続して届いたとき
@@ -1103,50 +1108,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()
 
@@ -1735,6 +1719,11 @@ const lastTurnTextsCache = new Map()
  */
 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
 
@@ -1968,6 +1957,9 @@ async function startSessionEventWatcher({ client, logger, readinessTracker }) {
           "session.event push",
         )
       }
+      // 直前に作った一覧 snapshot がこの event より古い場合、次の poll で last_event を
+      // 逆戻りさせない。build 中なら AsyncTtlCache が新世代へ合流し直す。
+      tmuxSessionsSnapshotCache.clear()
       client.send({
         type: "session.event",
         session_name: sessionName,
@@ -2292,6 +2284,7 @@ export async function pushImmediateChatState({
     for (const s of states) {
       if (s.cwd !== cwd) continue
       if (cliKindForSessionName(s.session_name) !== cliKind) continue
+      tmuxSessionsSnapshotCache.clear()
       client.send({
         type: "session.state",
         session_name: s.session_name,
@@ -2398,6 +2391,7 @@ export function startStateLoop({ client, plugins, logger, intervalMs, claudeBrid
   // これで再接続直後の次 tick (≤intervalMs) に短縮する。初回接続時は空 Map の clear で no-op。
   const onReopen = () => {
     lastByName.clear()
+    tmuxSessionsSnapshotCache.clear()
   }
   client.on("open", onReopen)
 
@@ -2696,6 +2690,9 @@ export function startStateLoop({ client, plugins, logger, intervalMs, claudeBrid
             "session.state push",
           )
           }
+          // state push より古い一覧を後続 poll が返すと sidebar 行の status/context が
+          // 逆戻りするため、送信前に snapshot 世代を切り替える。
+          tmuxSessionsSnapshotCache.clear()
           client.send({
             type: "session.state",
             session_name: s.session_name,
@@ -2733,6 +2730,7 @@ export function startStateLoop({ client, plugins, logger, intervalMs, claudeBrid
             // の消滅はここが唯一の検知点。frontend が states/lastEvent を忘れてドットを
             // 'down' に倒せるよう、ローカル Map を forget する前に通知する。
             try {
+              tmuxSessionsSnapshotCache.clear()
               client.send({ type: "session.gone", session_name: name })
             } catch {
               /* ignore */
@@ -4452,6 +4450,7 @@ async function dispatch(msg, ctx) {
           ctx.claudeBridge?.shutdown()
           // tmux TUI セッションも旧アカウントのまま残さない: kill → 同名・同 cwd で再作成。
           const tmuxResult = await restartAllTmuxSessionsForProfileSwitch(ctx)
+          tmuxSessionsSnapshotCache.clear()
           // 切替先の config ディレクトリに認証情報が無ければ要ログイン (バッジ/案内用)。
           const hasCreds = isKeychainPlatform()
             ? await profileHasKeychainCredentials(target.configDir)
@@ -4591,6 +4590,7 @@ async function dispatch(msg, ctx) {
           // Codex セッションだけ撤去 (Claude セッションは残す = 独立切替)。
           const before = ctx.codexBridge?.sessions?.size ?? 0
           ctx.codexBridge?.shutdown()
+          tmuxSessionsSnapshotCache.clear()
           const hasCreds = await codexProfiles.hasCodexCredentials(target.configDir)
           const needsLogin = !hasCreds
           const isDefaultTarget = target.id === codexProfiles.DEFAULT_CODEX_PROFILE_ID
@@ -4724,48 +4724,42 @@ async function dispatch(msg, ctx) {
       }
       case "tmux.list_sessions": {
         try {
-          // boundSessions: 各行の context% (ドーナツ) を bound session の jsonl から引く
-          // (cwd dir 内の別セッション jsonl を最新と取り違える=メタ欠陥#1 の根治)。
-          // claudeBridge: TUI bind が無い SDK チャット cwd 向けの同根治フォールバック
-          // (2026-07 追加。tmux.mjs listSessions 参照)。
-          const sessions = await listTmuxSessions({
-            plugins: ctx.plugins,
-            logger: ctx.logger,
-            boundSessions: ctx.tuiReboundSessions,
-            claudeBridge: ctx.claudeBridge,
+          const snapshot = await tmuxSessionsSnapshotCache.get(async () => {
+            // worktree index は listSessions の親判定と stub 列挙で共用する。従来は同じ
+            // 全 workspace + git branch 走査を 1 応答内で 2 回直列実行していた。
+            const worktreeIndex = await buildWorktreeIndex()
+            // boundSessions: 各行の context% (ドーナツ) を bound session の jsonl から引く
+            // (cwd dir 内の別セッション jsonl を最新と取り違える=メタ欠陥#1 の根治)。
+            const sessions = await listTmuxSessions({
+              plugins: ctx.plugins,
+              logger: ctx.logger,
+              boundSessions: ctx.tuiReboundSessions,
+              claudeBridge: ctx.claudeBridge,
+              worktreeIndex,
+            })
+            const [lastEventByName, lastTextsByName] = await Promise.all([
+              readAllSessionEvents(),
+              readAllSessionLastTexts(sessions, ctx.getSessionStateSnapshot),
+            ])
+            const enriched = enrichTmuxSessionsForListResponse(
+              sessions,
+              lastEventByName,
+              ctx.getSessionStateSnapshot,
+              lastTextsByName,
+            )
+            const liveNames = new Set(enriched.map((s) => s.name))
+            let worktreeStubs = []
+            try {
+              worktreeStubs = await listWorktreeStubs(liveNames, { worktreeIndex })
+            } catch (err) {
+              ctx.logger?.warn?.({ err: err?.message }, "listWorktreeStubs failed")
+            }
+            return { sessions: enriched, worktree_stubs: worktreeStubs }
           })
-          // 各 session の最新 hook event を /tmp/cockpit_session_events/ から読んで
-          // レスポンスに含める (Phase 4: ハードリロード時の lastEvent 復元用)。
-          // 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 のリストを
-          // 同梱する。古い cockpit は worktree_stubs を無視するので互換 OK。
-          const liveNames = new Set(enriched.map((s) => s.name))
-          let worktreeStubs = []
-          try {
-            worktreeStubs = await listWorktreeStubs(liveNames)
-          } catch (err) {
-            ctx.logger?.warn?.({ err: err?.message }, "listWorktreeStubs failed")
-          }
           ctx.client.send({
             type: "tmux.sessions",
             request_id: msg.request_id,
-            sessions: enriched,
-            worktree_stubs: worktreeStubs,
+            ...snapshot,
           })
         } catch (err) {
           ctx.client.send({
@@ -4815,6 +4809,7 @@ async function dispatch(msg, ctx) {
               typeof msg.initial_prompt === "string" ? msg.initial_prompt : undefined,
             logger: ctx.logger,
           })
+          tmuxSessionsSnapshotCache.clear()
           ctx.client.send({
             type: "tmux.create_session.result",
             request_id: msg.request_id,
@@ -4885,6 +4880,7 @@ async function dispatch(msg, ctx) {
               typeof msg.initial_prompt === "string" ? msg.initial_prompt : undefined,
             logger: ctx.logger,
           })
+          tmuxSessionsSnapshotCache.clear()
           ctx.client.send({
             type: "worktree.create.result",
             request_id: msg.request_id,
@@ -4962,6 +4958,7 @@ async function dispatch(msg, ctx) {
         const force = msg.force === true
         try {
           const result = await removeWorktreeDir(name, { force })
+          if (result.dirty !== true) tmuxSessionsSnapshotCache.clear()
           ctx.client.send({
             type: "worktree.remove.result",
             request_id: msg.request_id,
@@ -4984,6 +4981,7 @@ async function dispatch(msg, ctx) {
       }
       case "tmux.kill_session": {
         await handleKillSession(msg, ctx)
+        tmuxSessionsSnapshotCache.clear()
         return
       }
       case "skills.request": {

package/src/tmux.mjs

@@ -174,7 +174,7 @@ export async function createWorktreeDir(parentDir, branch) {
  *
  * 移植元: D00000_cockpit/webapp/lib/workspaces.ts (findWorktrees)
  */
-async function buildWorktreeIndex() {
+export async function buildWorktreeIndex() {
   const out = new Map()
   const projectsBase = hubProjectsBase()
   let projects
@@ -240,8 +240,11 @@ async function buildWorktreeParentMap() {
  * worktree (`<wt>__codex`) が「未起動 stub」としても同時に列挙され、サイドバーに live 行と
  * stub 行が二重表示される事故を防ぐ。
  */
-export async function listWorktreeStubs(liveSessionNames) {
-  const idx = await buildWorktreeIndex()
+export async function listWorktreeStubs(liveSessionNames, opts = {}) {
+  const idx =
+    opts.worktreeIndex instanceof Map
+      ? opts.worktreeIndex
+      : await buildWorktreeIndex()
   const liveBaseNames = new Set()
   for (const n of liveSessionNames) liveBaseNames.add(baseSessionName(n))
   const stubs = []
@@ -649,7 +652,16 @@ export async function listSessions(opts = {}) {
   // pane 解析 (state.detectSessionState) はフォーマット変動に脆いので、
   // statusLine cache がある cwd では優先採用する。
   const [wtParentMap, sessionUsages] = await Promise.all([
-    buildWorktreeParentMap(),
+    opts.worktreeIndex instanceof Map
+      ? Promise.resolve(
+          new Map(
+            [...opts.worktreeIndex].map(([name, info]) => [
+              name,
+              info.parent_session_name,
+            ]),
+          ),
+        )
+      : buildWorktreeParentMap(),
     getSessionUsages().catch(() => []),
   ])
   // cwd → context_pct の lookup (同一 cwd で複数 session_id ある場合は最新 mtime 優先)