@cocorograph/hub-agent 0.8.93 → 0.8.95

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocorograph/hub-agent",
-  "version": "0.8.93",
+  "version": "0.8.95",
   "description": "Hub Hosted Cockpit のローカル常駐 agent。Hub と outbound WSS で接続し、ローカルの Claude / Codex チャットと tmux セッションを中継する。",
   "type": "module",
   "license": "UNLICENSED",

package/src/agents.mjs

@@ -1,3 +1,5 @@
+import { performance } from "node:perf_hooks"
+import { logPhaseTiming } from "./startup-metrics.mjs"
 /**
  * Claude Code の subagent (`~/.claude/agents/<category>/<name>.md`) を集計する。
  *
@@ -28,13 +30,19 @@ function parseH1(text) {
   return { title: "", description: "" }
 }
 
-export async function listAgents() {
+export async function listAgents({ logger } = {}) {
+  const started = performance.now()
+  let scanned_files = 0
+  const finish = (agents) => {
+    logPhaseTiming(logger, "agents list timing", { total_ms: performance.now() - started, count: agents.length, scanned_files })
+    return agents
+  }
   const agents = []
   let categories
   try {
     categories = await fs.readdir(AGENTS_DIR)
   } catch {
-    return []
+    return finish([])
   }
   for (const cat of categories) {
     if (cat.startsWith(".") || cat.startsWith("_")) continue
@@ -55,6 +63,7 @@ export async function listAgents() {
     for (const f of files) {
       if (!f.endsWith(".md")) continue
       if (f.startsWith("_")) continue
+      scanned_files += 1
       const fp = path.join(catPath, f)
       try {
         const text = await fs.readFile(fp, "utf-8")
@@ -75,5 +84,5 @@ export async function listAgents() {
   agents.sort(
     (a, b) => a.category.localeCompare(b.category) || a.name.localeCompare(b.name),
   )
-  return agents
+  return finish(agents)
 }

package/src/claude-history.mjs

@@ -1,3 +1,5 @@
+import { performance } from "node:perf_hooks"
+import { logPhaseTiming } from "./startup-metrics.mjs"
 import { maskTurnText, sanitizeTurnText, truncateTurnText } from "./last-turn-texts.mjs"
 /**
  * Claude Code のローカル会話履歴 (`~/.claude/projects/<cwd-encoded>/<session-id>.jsonl`)
@@ -715,6 +717,7 @@ export async function readSessionHistory(filePath, { maxLines = MAX_HISTORY_LINE
   const cached = getHydrateCache(filePath, st.mtimeMs, st.size, maxLines)
   if (cached) return cached
 
+  const readStarted = performance.now()
   let text
   try {
     text = await readFile(filePath, "utf-8")
@@ -725,6 +728,7 @@ export async function readSessionHistory(filePath, { maxLines = MAX_HISTORY_LINE
     logger?.warn({ err: err.message, filePath }, "claude history read failed")
     throw err
   }
+  const parseStarted = performance.now()
   // 末尾 newline は捨てる
   const lines = text.split("\n").filter((l) => l.length > 0)
   const total_lines = lines.length
@@ -761,6 +765,11 @@ export async function readSessionHistory(filePath, { maxLines = MAX_HISTORY_LINE
     if (MASK_ENABLED) event = maskMessageObject(event, toolNames)
     events.push(event)
   }
+  const finished = performance.now()
+  logPhaseTiming(logger, "claude history read timing", {
+    file_bytes: st.size, lines: total_lines,
+    read_ms: parseStarted - readStarted, parse_ms: finished - parseStarted, total_ms: finished - readStarted,
+  })
   const result = { events, total_lines, truncated }
   setHydrateCache(filePath, st.mtimeMs, st.size, maxLines, result)
   return result
@@ -1215,7 +1224,13 @@ export async function extractLastTurnTexts(filePath, opts = {}) {
  * @param {{cwd: string, projectsRoot?: string, limit?: number, logger?: import('pino').Logger}} args
  */
 export async function listSessions({ cwd, projectsRoot, limit = 30, logger }) {
-  if (!cwd) return { sessions: [] }
+  const started = performance.now()
+  let scanned_files = 0
+  const finish = (result) => {
+    logPhaseTiming(logger, "claude sessions timing", { total_ms: performance.now() - started, count: result.sessions.length, scanned_files })
+    return result
+  }
+  if (!cwd) return finish({ sessions: [] })
   const dir = path.join(
     projectsRoot || path.join(os.homedir(), ".claude", "projects"),
     encodeCwdToDirName(cwd),
@@ -1224,9 +1239,9 @@ export async function listSessions({ cwd, projectsRoot, limit = 30, logger }) {
   try {
     files = await readdir(dir)
   } catch (err) {
-    if (err.code === "ENOENT") return { sessions: [] }
+    if (err.code === "ENOENT") return finish({ sessions: [] })
     logger?.warn({ err: err.message, dir }, "claude history list failed")
-    return { sessions: [], error: err.message }
+    return finish({ sessions: [], error: err.message })
   }
   // この dir 専用の last_turn_at_ms キャッシュ (dir 単位 LRU。スキャン汚染しない。finding 3/round2)。
   const fileMap = getLastTurnDirMap(dir)
@@ -1234,6 +1249,7 @@ export async function listSessions({ cwd, projectsRoot, limit = 30, logger }) {
   const stats = []
   for (const f of files) {
     if (!f.endsWith(".jsonl")) continue
+    scanned_files += 1
     const session_id = f.slice(0, -".jsonl".length)
     const filePath = path.join(dir, f)
     try {
@@ -1271,7 +1287,7 @@ export async function listSessions({ cwd, projectsRoot, limit = 30, logger }) {
     const title = await extractTitleCached(fileMap, s.file_path, s.size_bytes, s.mtime)
     sessions.push({ ...s, preview, ...(title === undefined ? {} : { title }) })
   }
-  return { sessions }
+  return finish({ sessions })
 }
 
 /**

package/src/claude-stream-bridge.mjs

@@ -2736,6 +2736,8 @@ export class ClaudeStreamBridge extends EventEmitter {
     this._mcpControlStarting = null
     /** listSupportedCommands() の短命キャッシュ {at:ms, commands:SlashCommand[]} (T06117)。 */
     this._supportedCommandsCache = null
+    /** listSupportedCommands() の取得中 Promise (同時呼び出しの相乗り用)。 */
+    this._supportedCommandsInflight = null
   }
 
   /** _liveBySession の複合キー (T06271): cwd を含めることで、別 workspace の同一 session_id を
@@ -3274,6 +3276,8 @@ export class ClaudeStreamBridge extends EventEmitter {
             // control query が死んだらキャッシュも破棄する。次回アクセスで新しい
             // query から取り直す (別 query の init スナップショットに更新される)。
             this._supportedCommandsCache = null
+            // 死んだ query への取得に後続の要求を相乗りさせない。
+            this._supportedCommandsInflight = null
           }
         }
       })()
@@ -3317,6 +3321,9 @@ export class ClaudeStreamBridge extends EventEmitter {
     // reload / shutdown 後も古いキャッシュが残り続け、listSupportedCommands が新しい
     // query を起動せず stale を返し続ける (ライフタイムキャッシュの永続化バグ)。
     this._supportedCommandsCache = null
+    // 畳んだ query への取得中 Promise も捨てる。残すと reload 後の要求が旧 query の取得へ
+    // 相乗りし、新しい query を起動しない。旧取得の結果は _loadSupportedCommands 側で捨てる。
+    this._supportedCommandsInflight = null
     try {
       input?.close()
     } catch {
@@ -3404,6 +3411,21 @@ export class ClaudeStreamBridge extends EventEmitter {
     // ライフタイムキャッシュ: 存在すれば (init スナップショット + commands_changed で
     // 反映済みの最新) をそのまま返す。再取得しない (上記 ⚠️)。
     if (this._supportedCommandsCache) return this._supportedCommandsCache.commands
+    // 取得中の呼び出しがあれば相乗りする。再接続直後は開いているタブの数だけ skills.request が
+    // 同時に届き、キャッシュが空のうちは全員が supportedCommands() を別々に叩いていた
+    // (2026-09-23 実測: 再接続直後に skills 15 件・agents 14 件が同時着)。
+    if (this._supportedCommandsInflight) return this._supportedCommandsInflight
+    const inflight = this._loadSupportedCommands()
+    this._supportedCommandsInflight = inflight
+    try {
+      return await inflight
+    } finally {
+      if (this._supportedCommandsInflight === inflight) this._supportedCommandsInflight = null
+    }
+  }
+
+  /** listSupportedCommands の取得本体 (相乗りの外側から 1 回だけ呼ばれる)。 */
+  async _loadSupportedCommands() {
     try {
       const q = await this._ensureMcpControlQuery()
       this._armMcpControlIdle()
@@ -3412,6 +3434,9 @@ export class ClaudeStreamBridge extends EventEmitter {
         return null
       }
       const commands = await q.supportedCommands()
+      // 取得中に query が畳まれた (idle / reload / shutdown) なら、旧 query の一覧を
+      // キャッシュへ書き戻さない。呼び出し側は null で FS 走査へフォールバックする。
+      if (this._mcpControlQuery !== q) return null
       const arr = Array.isArray(commands) ? commands : []
       // commands_changed が先に届いてキャッシュを埋めていたら、その最新を尊重する
       // (init スナップショットで上書きしない)。

package/src/dispatch-scheduler.mjs

@@ -252,12 +252,26 @@ export class DispatchScheduler {
   }
 
   _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",
-      )
-    })
+    // 順番待ちが無い経路なので wait_ms は常に 0。本体が遅いときだけ記録する
+    // (skills/agents 等の読み取りをここへ移したとき、効果を測れなくならないように)。
+    const startedAt = Date.now()
+    return Promise.resolve()
+      .then(() => this.run(msg))
+      .finally(() => {
+        const runMs = Date.now() - startedAt
+        if (shouldLogDispatchTiming(msg?.type, 0, runMs)) {
+          this.logger?.info?.(
+            { type: msg?.type, lane, wait_ms: 0, run_ms: runMs },
+            "dispatch timing",
+          )
+        }
+      })
+      .catch((err) => {
+        this.logger?.error?.(
+          { err: err?.message, type: msg?.type, lane },
+          "dispatch threw",
+        )
+      })
   }
 
   /**

package/src/main.mjs

@@ -1,3 +1,6 @@
+import { performance } from "node:perf_hooks"
+import { createHash } from "node:crypto"
+import { logPhaseTiming, startEventLoopMetrics } from "./startup-metrics.mjs"
 /**
  * hub-agent daemon 本体。
  *
@@ -230,6 +233,9 @@ async function loadClaudeSdk(logger) {
 /** アカウント利用量取得の時間制限 (ms)。超えたらレーンを解放して次へ進む。 */
 export const ACCOUNT_USAGE_TIMEOUT_MS = 8_000
 
+/** Codex アカウント利用制限の取得待ちの上限 (ms)。 */
+export const CODEX_RATE_LIMITS_TIMEOUT_MS = 8_000
+
 /**
  * `promise` に時間制限を設ける。制限を超えたら `null` で解決し `onTimeout` を呼ぶ。
  *
@@ -323,10 +329,75 @@ export function isReadOnlyRpc(type) {
     // T06603 (2026-07-25): キュー snapshot の pull。in-memory 配列を読むだけで副作用が無く、
     // かつ「直列キュー前方の重い処理で再同期が遅延する」と送信待ちチップの固着が長引く
     // (再同期は固着を直すための経路なので、詰まりやすい経路に置いてはならない)。
-    type === "claude.queue.request"
+    type === "claude.queue.request" ||
+    // 2026-09-23: 一覧の読み取り (FS 走査と SDK のコマンド一覧) だけで状態を変えず、request_id で
+    // 相関する。再接続直後はタブの数だけ同時に届き (実測 29 件)、control レーンで 1 件ずつ
+    // 並べていたため最後の 1 件が約 3 秒待っていた。同一要求は coalesceInflight で相乗りする。
+    type === "skills.request" ||
+    type === "agents.request"
   )
 }
 
+const coalesceCounts = new WeakMap()
+
+/**
+ * 同じ key の処理が実行中なら、その Promise を返して相乗りさせる (完了後は保持しない)。
+ * 結果をキャッシュするのではなく「同時に来た同一要求を 1 回の処理にまとめる」だけなので、
+ * 完了後に来た要求は必ず取り直す (一覧が古くならない)。
+ *
+ * @template T
+ * @param {Map<string, Promise<T>>} inflight
+ * @param {string} key
+ * @param {() => Promise<T>} fn
+ * @param {(counts: {joined: number}) => void} [onComplete] 計測用。返却値は変更しない。
+ * @returns {Promise<T>}
+ */
+export function coalesceInflight(inflight, key, fn, onComplete) {
+  const running = inflight.get(key)
+  if (running) {
+    const counts = coalesceCounts.get(running)
+    if (counts) counts.joined += 1
+    return running
+  }
+  const promise = Promise.resolve().then(fn)
+  inflight.set(key, promise)
+  const counts = { joined: 1 }
+  coalesceCounts.set(promise, counts)
+  const clear = () => {
+    if (inflight.get(key) === promise) inflight.delete(key)
+    // 計測用の通知は結果に影響させない (ここで投げると未処理 rejection になる)。
+    try {
+      onComplete?.(counts)
+    } catch {
+      // 無視する
+    }
+  }
+  promise.then(clear, clear)
+  return promise
+}
+
+/**
+ * 起動時に SDK のコマンド一覧を先に取りに行く (startDaemon から呼ぶ)。完了を待たない。
+ * claude CLI が無い端末・SDK が無い端末では query を起動しない。
+ *
+ * @param {{ listSupportedCommands?: () => Promise<unknown> } | null} claudeBridge
+ * @param {string[]} availableClis
+ * @returns {boolean} 取得を開始したら true
+ */
+export function prewarmSupportedCommands(claudeBridge, availableClis) {
+  if (!claudeBridge?.listSupportedCommands || !availableClis.includes("claude")) return false
+  void claudeBridge.listSupportedCommands()
+  return true
+}
+
+/** skills.request / agents.request の実行中の処理 (coalesceInflight 用)。 */
+const listRequestsInflight = new Map()
+
+/** skills.request の相乗りの単位。結果は CLI 種別と session_name で変わる。 */
+export function skillsRequestKey(cliKind, sessionName) {
+  return `skills\u0000${cliKind}\u0000${sessionName || ""}`
+}
+
 /**
  * active プロファイルの configDir を process.env.CLAUDE_CONFIG_DIR へ反映する。
  * 既定 (`~/.claude`) のときは変数を消して従来挙動 (Claude Code の既定パス) に戻す。
@@ -726,7 +797,115 @@ export class DeferredRestartCoordinator {
   }
 }
 
+/**
+ * bridge のイベントを Hub へ転送する listener を登録する。
+ * ⚠️ 送信は必ず sendBridgeMessage を通す。会話の再点灯 (agent.sessions.restore) で使う
+ * `restore:` 購読は browser に存在しないため、ここで捨てないと Hub へ幽霊 stream が流れる。
+ * 起動処理から切り出してあるのは、この配線そのものをテストから通すため。
+ */
+export function wireBridgeEvents(client, { claudeBridge, codexBridge }) {
+  // stream-json モード (Sprint G): Claude Code を SDK 経由で起動し、stream イベントを
+  // そのまま browser に転送する。SDK 未インストール時は claudeBridge=null で全 attach が
+  // claude.error を返す経路に分岐 (dispatch 側で判定)。
+  if (claudeBridge) {
+    claudeBridge.on("event", ({ stream_id, session_id, cwd, session, event }) => {
+      // SDK の rate_limit_event を捕捉して usage の 5h/7d 実値に反映する
+      // (チャットモードでは statusLine が更新されないため、これが live 値の唯一の源)。
+      if (event?.type === "rate_limit_event" && event.rate_limit_info) {
+        try {
+          recordChatRateLimit(event.rate_limit_info)
+        } catch {
+          /* ignore */
+        }
+      }
+      resolveChatContextPct(session, event)
+      sendBridgeMessage(client, { type: "claude.event", stream_id, session_id, event })
+    })
+    claudeBridge.on("permission", ({ stream_id, session_id, cwd, request_id, tool_name, input }) => {
+      // 多端末共有: session_id を載せて backend が session group へ broadcast できるように
+      // する (全端末に許可ダイアログ → 先着 1 件採用)。
+      sendBridgeMessage(client, {
+        type: "claude.permission.request",
+        stream_id,
+        session_id,
+        request_id,
+        tool_name,
+        input,
+      })
+    })
+    claudeBridge.on(
+      "permissioncancel",
+      ({ stream_id, session_id, cwd, request_ids, reason }) => {
+        // SDK チャットの未応答 permission をターン終了/中断/close で内部 deny したとき、
+        // browser に残っている承認カードを撤去する (孤児カード防止, 2026-07-10 監査)。
+        // TUI 由来カードの撤去と同じ `claude.permission.cancel` 型を使う。
+        for (const request_id of request_ids || []) {
+          try {
+            sendBridgeMessage(client, {
+              type: "claude.permission.cancel",
+              stream_id,
+              session_id,
+              cwd,
+              request_id,
+              reason,
+            })
+          } catch {
+            /* ignore */
+          }
+        }
+      },
+    )
+    claudeBridge.on("exit", ({ stream_id, code, reason, session_id, cwd }) => {
+      sendBridgeMessage(client, { type: "claude.exit", stream_id, code, reason, session_id })
+    })
+    claudeBridge.on("sessionoptions", (message) => {
+      sendBridgeMessage(client, buildClaudeSessionOptionsPayload(message))
+    })
+    claudeBridge.on("error", ({ stream_id, session_id, error }) => {
+      sendBridgeMessage(client, { type: "claude.error", stream_id, session_id, error })
+    })
+  }
+
+  // codex 版 (Slice 3): codex-stream-bridge.mjs の生 notification/permission/exit/error を
+  // browser にそのまま転送する。claudeBridge と同じ「素通し」方針 (codex-stream-bridge.mjs
+  // 冒頭コメント参照)。claude 版にある rate_limit/MCP control query 相当の処理は無い
+  // (codex 側にまだ存在しない/後続スライス)。live usage だけを producer 単位で記録する。
+  if (codexBridge) {
+    codexBridge.on("event", ({ stream_id, producer_seq, thread_id, cwd, notification }) => {
+      if (notification.method === "thread/tokenUsage/updated") {
+        recordCodexLiveTokenUsage(producer_seq, notification.params?.tokenUsage)
+      }
+      sendBridgeMessage(client, { type: "codex.event", stream_id, thread_id, event: notification })
+    })
+    codexBridge.on("permission", ({ stream_id, thread_id, cwd, request_id, method, params }) => {
+      sendBridgeMessage(client, {
+        type: "codex.permission.request",
+        stream_id,
+        thread_id,
+        request_id,
+        method,
+        params,
+      })
+    })
+    codexBridge.on("exit", ({ stream_id, producer_seq, thread_id, code, reason, cwd }) => {
+      // T06407 増分2: この producer(session.seq) の live tokenUsage スロットを破棄する。
+      // seq は immutable なので、reattach で stream_id が付け替わっても alias slot / Map リークは
+      // 生じない (stream_id キー時代の major#1 を解消)。
+      try {
+        forgetCodexLiveTokenUsage(producer_seq)
+      } catch {
+        /* ignore */
+      }
+      sendBridgeMessage(client, { type: "codex.exit", stream_id, thread_id, code, reason })
+    })
+    codexBridge.on("error", ({ stream_id, thread_id, error }) => {
+      sendBridgeMessage(client, { type: "codex.error", stream_id, thread_id, error })
+    })
+  }
+}
+
 export async function startDaemon({ version, claudeSdk } = {}) {
+  startEventLoopMetrics(logger)
   const config = await readConfig()
   if (!config) {
     throw new Error(
@@ -804,6 +983,13 @@ export async function startDaemon({ version, claudeSdk } = {}) {
     ? new ClaudeStreamBridge({ sdk: resolvedSdk, logger })
     : null
 
+  // 起動直後の skills 一覧を待たせないよう、SDK のコマンド一覧を先に取りに行く。取得には
+  // control query の起動が要り、初回は 1.5〜3 秒かかる (2026-09-23 実測: 本日の再起動 7 回とも
+  // 再接続直後の最初の skills.request が 1.5〜3.1 秒)。再接続で一斉に届く要求はこの取得に
+  // 相乗りする (listSupportedCommands の in-flight)。失敗しても null を返すだけで、要求時に
+  // FS 走査へフォールバックする。claude CLI が無い端末では query を起動しない。
+  prewarmSupportedCommands(claudeBridge, availableClis)
+
   // codex app-server ベースの chat ブリッジ。resolver は各 spawn 時に再評価するため、
   // daemon 起動時に一時的に unavailable でも bridge 自体は保持する。
   const codexBridge = new CodexStreamBridge({ logger })
@@ -879,104 +1065,7 @@ export async function startDaemon({ version, claudeSdk } = {}) {
     logger.warn({ err: err.message }, "ws client error (will retry via close handler)")
   })
 
-  // stream-json モード (Sprint G): Claude Code を SDK 経由で起動し、stream イベントを
-  // そのまま browser に転送する。SDK 未インストール時は claudeBridge=null で全 attach が
-  // claude.error を返す経路に分岐 (dispatch 側で判定)。
-  if (claudeBridge) {
-    claudeBridge.on("event", ({ stream_id, session_id, cwd, session, event }) => {
-      // SDK の rate_limit_event を捕捉して usage の 5h/7d 実値に反映する
-      // (チャットモードでは statusLine が更新されないため、これが live 値の唯一の源)。
-      if (event?.type === "rate_limit_event" && event.rate_limit_info) {
-        try {
-          recordChatRateLimit(event.rate_limit_info)
-        } catch {
-          /* ignore */
-        }
-      }
-      resolveChatContextPct(session, event)
-      sendBridgeMessage(client, { type: "claude.event", stream_id, session_id, event })
-    })
-    claudeBridge.on("permission", ({ stream_id, session_id, cwd, request_id, tool_name, input }) => {
-      // 多端末共有: session_id を載せて backend が session group へ broadcast できるように
-      // する (全端末に許可ダイアログ → 先着 1 件採用)。
-      sendBridgeMessage(client, {
-        type: "claude.permission.request",
-        stream_id,
-        session_id,
-        request_id,
-        tool_name,
-        input,
-      })
-    })
-    claudeBridge.on(
-      "permissioncancel",
-      ({ stream_id, session_id, cwd, request_ids, reason }) => {
-        // SDK チャットの未応答 permission をターン終了/中断/close で内部 deny したとき、
-        // browser に残っている承認カードを撤去する (孤児カード防止, 2026-07-10 監査)。
-        // TUI 由来カードの撤去と同じ `claude.permission.cancel` 型を使う。
-        for (const request_id of request_ids || []) {
-          try {
-            sendBridgeMessage(client, {
-              type: "claude.permission.cancel",
-              stream_id,
-              session_id,
-              cwd,
-              request_id,
-              reason,
-            })
-          } catch {
-            /* ignore */
-          }
-        }
-      },
-    )
-    claudeBridge.on("exit", ({ stream_id, code, reason, session_id, cwd }) => {
-      sendBridgeMessage(client, { type: "claude.exit", stream_id, code, reason, session_id })
-    })
-    claudeBridge.on("sessionoptions", (message) => {
-      sendBridgeMessage(client, buildClaudeSessionOptionsPayload(message))
-    })
-    claudeBridge.on("error", ({ stream_id, session_id, error }) => {
-      sendBridgeMessage(client, { type: "claude.error", stream_id, session_id, error })
-    })
-  }
-
-  // codex 版 (Slice 3): codex-stream-bridge.mjs の生 notification/permission/exit/error を
-  // browser にそのまま転送する。claudeBridge と同じ「素通し」方針 (codex-stream-bridge.mjs
-  // 冒頭コメント参照)。claude 版にある rate_limit/MCP control query 相当の処理は無い
-  // (codex 側にまだ存在しない/後続スライス)。live usage だけを producer 単位で記録する。
-  if (codexBridge) {
-    codexBridge.on("event", ({ stream_id, producer_seq, thread_id, cwd, notification }) => {
-      if (notification.method === "thread/tokenUsage/updated") {
-        recordCodexLiveTokenUsage(producer_seq, notification.params?.tokenUsage)
-      }
-      sendBridgeMessage(client, { type: "codex.event", stream_id, thread_id, event: notification })
-    })
-    codexBridge.on("permission", ({ stream_id, thread_id, cwd, request_id, method, params }) => {
-      sendBridgeMessage(client, {
-        type: "codex.permission.request",
-        stream_id,
-        thread_id,
-        request_id,
-        method,
-        params,
-      })
-    })
-    codexBridge.on("exit", ({ stream_id, producer_seq, thread_id, code, reason, cwd }) => {
-      // T06407 増分2: この producer(session.seq) の live tokenUsage スロットを破棄する。
-      // seq は immutable なので、reattach で stream_id が付け替わっても alias slot / Map リークは
-      // 生じない (stream_id キー時代の major#1 を解消)。
-      try {
-        forgetCodexLiveTokenUsage(producer_seq)
-      } catch {
-        /* ignore */
-      }
-      sendBridgeMessage(client, { type: "codex.exit", stream_id, thread_id, code, reason })
-    })
-    codexBridge.on("error", ({ stream_id, thread_id, error }) => {
-      sendBridgeMessage(client, { type: "codex.error", stream_id, thread_id, error })
-    })
-  }
+  wireBridgeEvents(client, { claudeBridge, codexBridge })
 
   // Hub からのメッセージ dispatch は、接続世代 + 機能レーン単位で直列実行する。
   //
@@ -2751,135 +2840,163 @@ export async function buildUsagePayload(ctx) {
   let localUsageMs = 0
   let codexRateLimitsMs = 0
 
-  const credentialsStartedAt = Date.now()
-  const activeClaudeProfile = await getActiveProfile()
-  const claudeHasCredentials = isKeychainPlatform()
-    ? await profileHasKeychainCredentials(activeClaudeProfile.configDir)
-    : await hasFileCredentialsCached(activeClaudeProfile.configDir)
-  credentialsMs = Date.now() - credentialsStartedAt
-
-  // 5h/7d の本命ソース: SDK control request (アカウント全体、session 非依存)。
-  // statusLine が rate_limits を出さなくなった環境 (2026-07 時点の Claude CLI) でも
-  // ここでライブ更新できる。frontend の usage.request ポーリング (既定 60s) 頻度に
-  // 相乗りするだけで十分な鮮度が保てるため、専用タイマーは設けない。EXPERIMENTAL
-  // API の失敗は getAccountUsage 内で握りつぶし null を返す (recordChatUsageSnapshot
-  // は no-op) ので、既存の statusLine/transcript フォールバックは無傷で残る。
-  if (ctx.claudeBridge) {
-    const accountUsageStartedAt = Date.now()
-    try {
-      // ⚠️ getAccountUsage は SDK のサブプロセスを spawn する。**時間制限が無いと
-      // 返ってこないときに usage レーンが止まり、後続の usage.request (60 秒周期) が
-      // 無期限に詰まる**。2026-09-04 までは control レーン (tmux.list_sessions や
-      // セッション停止が並ぶ) に乗っていて head-of-line blocking を起こしていたため
-      // dispatch-scheduler の _laneFor で専用 "usage" レーンへ分離した。同種の詰まりで
-      // cold p95 40〜54 秒を計測した記録が isReadOnlyRpc の注記にある。
-      // 時間切れは握りつぶさず warn で残す (これ自体が「詰まりの実測値」になる)。
-      const acct = await withDeadline(
-        ctx.claudeBridge.getAccountUsage(),
-        ACCOUNT_USAGE_TIMEOUT_MS,
-        () =>
-          ctx.logger?.warn?.(
-            { timeout_ms: ACCOUNT_USAGE_TIMEOUT_MS },
-            "account usage timed out (dispatch lane released)",
-          ),
-      )
-      if (acct) recordChatUsageSnapshot(acct, Date.now(), activeClaudeProfile.id)
-    } catch (err) {
-      ctx.logger?.debug?.({ err: err?.message }, "account usage snapshot skipped")
+  // 各 provider は独立して取得する。Claude 内は snapshot → ローカル集計の順を保つ。
+  async function buildClaudeUsage() {
+    const credentialsStartedAt = Date.now()
+    const activeClaudeProfile = await getActiveProfile()
+    const claudeHasCredentials = isKeychainPlatform()
+      ? await profileHasKeychainCredentials(activeClaudeProfile.configDir)
+      : await hasFileCredentialsCached(activeClaudeProfile.configDir)
+    credentialsMs = Date.now() - credentialsStartedAt
+
+    // 5h/7d の本命ソース: SDK control request (アカウント全体、session 非依存)。
+    // statusLine が rate_limits を出さなくなった環境 (2026-07 時点の Claude CLI) でも
+    // ここでライブ更新できる。frontend の usage.request ポーリング (既定 60s) 頻度に
+    // 相乗りするだけで十分な鮮度が保てるため、専用タイマーは設けない。EXPERIMENTAL
+    // API の失敗は getAccountUsage 内で握りつぶし null を返す (recordChatUsageSnapshot
+    // は no-op) ので、既存の statusLine/transcript フォールバックは無傷で残る。
+    if (ctx.claudeBridge) {
+      const accountUsageStartedAt = Date.now()
+      try {
+        // ⚠️ getAccountUsage は SDK のサブプロセスを spawn する。**時間制限が無いと
+        // 返ってこないときに usage レーンが止まり、後続の usage.request (60 秒周期) が
+        // 無期限に詰まる**。2026-09-04 までは control レーン (tmux.list_sessions や
+        // セッション停止が並ぶ) に乗っていて head-of-line blocking を起こしていたため
+        // dispatch-scheduler の _laneFor で専用 "usage" レーンへ分離した。同種の詰まりで
+        // cold p95 40〜54 秒を計測した記録が isReadOnlyRpc の注記にある。
+        // 時間切れは握りつぶさず warn で残す (これ自体が「詰まりの実測値」になる)。
+        const acct = await withDeadline(
+          ctx.claudeBridge.getAccountUsage(),
+          ACCOUNT_USAGE_TIMEOUT_MS,
+          () =>
+            ctx.logger?.warn?.(
+              { timeout_ms: ACCOUNT_USAGE_TIMEOUT_MS },
+              "account usage timed out (dispatch lane released)",
+            ),
+        )
+        if (acct) recordChatUsageSnapshot(acct, Date.now(), activeClaudeProfile.id)
+      } catch (err) {
+        ctx.logger?.debug?.({ err: err?.message }, "account usage snapshot skipped")
+      }
+      accountUsageMs = Date.now() - accountUsageStartedAt
     }
-    accountUsageMs = Date.now() - accountUsageStartedAt
-  }
 
-  const localUsageStartedAt = Date.now()
-  let [usage, sessions] = await Promise.all([
-    getUsage({ profileId: activeClaudeProfile.id }),
-    getSessionUsages(),
-  ])
-  localUsageMs = Date.now() - localUsageStartedAt
-  // 未ログインで残ったローカル transcript/cache をアカウント利用量として見せない。
-  if (!claudeHasCredentials) {
-    usage = null
-    sessions = []
+    const localUsageStartedAt = Date.now()
+    let [usage, sessions] = await Promise.all([
+      getUsage({ profileId: activeClaudeProfile.id }),
+      getSessionUsages(),
+    ])
+    localUsageMs = Date.now() - localUsageStartedAt
+    // 未ログインで残ったローカル transcript/cache をアカウント利用量として見せない。
+    if (!claudeHasCredentials) {
+      usage = null
+      sessions = []
+    }
+    return { usage, sessions }
   }
 
-  // Codex 版 (Stream B3, 2026-07-03): rollout jsonl の token_count イベントから
-  // 5h/7d + context% を取る。⚠️ Codex の 5h/7d は ChatGPT/OpenAI サブスクリプション
-  // の残量であり、上の `usage` (Claude/Anthropic サブスクリプション) とは別契約の
-  // 別数値のため、`usage` にマージせず独立フィールド `codexUsage`/`codexSessions`
-  // として返す (frontend 側でどちらのアカウントの残量か混同しないため)。
-  let codexUsage = null
-  let codexContextCwd = null
-  let codexSessions = []
-  const activeCodexProfile = await codexProfiles.getActiveProfile()
-  const codexHasCredentials = await codexProfiles.hasCodexCredentials(activeCodexProfile.configDir)
-  if (ctx.codexBridge && codexHasCredentials) {
-    try {
-      // キャッシュは従来の cwd / アカウントデータだけを作る。
-      // 代表会話の値は handleUsageRequest の送信直前に付ける。
-      const cwds = new Set()
-      for (const s of ctx.codexBridge.sessions.values()) {
-        if (s.threadId && s.cwd) cwds.add(s.cwd)
-      }
-      const liveCodex = []
-      for (const cwd of cwds) {
-        const authoritative = ctx.codexBridge.liveSessionForCwd?.(cwd)
-        if (authoritative?.threadId) {
-          liveCodex.push({
-            sessionId: authoritative.threadId,
-            cwd: authoritative.cwd,
-            threadId: authoritative.threadId,
-            producerSeq: authoritative.seq,
+  async function buildCodexUsage() {
+    // Codex 版 (Stream B3, 2026-07-03): rollout jsonl の token_count イベントから
+    // 5h/7d + context% を取る。⚠️ Codex の 5h/7d は ChatGPT/OpenAI サブスクリプション
+    // の残量であり、上の `usage` (Claude/Anthropic サブスクリプション) とは別契約の
+    // 別数値のため、`usage` にマージせず独立フィールド `codexUsage`/`codexSessions`
+    // として返す (frontend 側でどちらのアカウントの残量か混同しないため)。
+    let codexUsage = null
+    let codexContextCwd = null
+    let codexSessions = []
+    const activeCodexProfile = await codexProfiles.getActiveProfile()
+    const codexHasCredentials = await codexProfiles.hasCodexCredentials(activeCodexProfile.configDir)
+    if (ctx.codexBridge && codexHasCredentials) {
+      try {
+        // キャッシュは従来の cwd / アカウントデータだけを作る。
+        // 代表会話の値は handleUsageRequest の送信直前に付ける。
+        const cwds = new Set()
+        for (const s of ctx.codexBridge.sessions.values()) {
+          if (s.threadId && s.cwd) cwds.add(s.cwd)
+        }
+        const liveCodex = []
+        for (const cwd of cwds) {
+          const authoritative = ctx.codexBridge.liveSessionForCwd?.(cwd)
+          if (authoritative?.threadId) {
+            liveCodex.push({
+              sessionId: authoritative.threadId,
+              cwd: authoritative.cwd,
+              threadId: authoritative.threadId,
+              producerSeq: authoritative.seq,
+            })
+          }
+        }
+        if (liveCodex.length > 0) {
+          // 5h/7d はアカウント全体の値 (どの live session から読んでも同じ契約の残量)
+          // なので、代表として最初の 1 件から取る (context% はその producer の live を使う)。
+          codexContextCwd = liveCodex[0].cwd
+          codexUsage = await codexUsageForThread(liveCodex[0].threadId, {
+            producerSeq: liveCodex[0].producerSeq,
           })
+          codexSessions = await codexSessionUsages(liveCodex)
+          // ⚠️ codex-review round2 major#2: codexSessionUsages の rollout I/O 中に cwd の
+          // 権威 producer が別 session へ移りうる。await 後に各 cwd の現権威 seq を再検証し、
+          // 集計に使った producer が現権威でない entry は破棄する (古い producer の context を
+          // codexCtxByCwd へ出さない)。破棄した cwd は frontend が state loop の
+          // live.context_pct (毎 tick 権威を同期解決=TOCTOU 無し) にフォールバックする。
+          const seqForCwd = (cwd) => ctx.codexBridge.liveSessionForCwd?.(cwd)?.seq
+          const producerByCwd = new Map(liveCodex.map((e) => [e.cwd, e.producerSeq]))
+          codexSessions = filterCodexSessionsByAuthority(
+            codexSessions,
+            producerByCwd,
+            seqForCwd,
+          )
+          // codex-review round3 minor#1: 集約 codexUsage.context は代表 producer
+          // (liveCodex[0]) の値。await 中に代表が権威を失っていたら旧 context を出さない
+          // (context だけ null 化。5h/7d は account-wide なので保持する)。
+          if (codexUsage && seqForCwd(liveCodex[0].cwd) !== liveCodex[0].producerSeq) {
+            codexUsage = { ...codexUsage, context: null }
+          }
         }
-      }
-      if (liveCodex.length > 0) {
-        // 5h/7d はアカウント全体の値 (どの live session から読んでも同じ契約の残量)
-        // なので、代表として最初の 1 件から取る (context% はその producer の live を使う)。
-        codexContextCwd = liveCodex[0].cwd
-        codexUsage = await codexUsageForThread(liveCodex[0].threadId, {
-          producerSeq: liveCodex[0].producerSeq,
-        })
-        codexSessions = await codexSessionUsages(liveCodex)
-        // ⚠️ codex-review round2 major#2: codexSessionUsages の rollout I/O 中に cwd の
-        // 権威 producer が別 session へ移りうる。await 後に各 cwd の現権威 seq を再検証し、
-        // 集計に使った producer が現権威でない entry は破棄する (古い producer の context を
-        // codexCtxByCwd へ出さない)。破棄した cwd は frontend が state loop の
-        // live.context_pct (毎 tick 権威を同期解決=TOCTOU 無し) にフォールバックする。
-        const seqForCwd = (cwd) => ctx.codexBridge.liveSessionForCwd?.(cwd)?.seq
-        const producerByCwd = new Map(liveCodex.map((e) => [e.cwd, e.producerSeq]))
-        codexSessions = filterCodexSessionsByAuthority(
-          codexSessions,
-          producerByCwd,
-          seqForCwd,
-        )
-        // codex-review round3 minor#1: 集約 codexUsage.context は代表 producer
-        // (liveCodex[0]) の値。await 中に代表が権威を失っていたら旧 context を出さない
-        // (context だけ null 化。5h/7d は account-wide なので保持する)。
-        if (codexUsage && seqForCwd(liveCodex[0].cwd) !== liveCodex[0].producerSeq) {
-          codexUsage = { ...codexUsage, context: null }
+        // ライブ session の有無にかかわらず、起動直後の account RPC を優先する。
+        // rollout は context の補助だけにし、5h/7d はプロファイル固有の最新実値にする。
+        const codexRateLimitsStartedAt = Date.now()
+        let rateLimits
+        try {
+          // 取得自体は止めず、完了値は bridge 内のキャッシュで次回に再利用する。
+          rateLimits = await withDeadline(
+            ctx.codexBridge.readAccountRateLimits({ profileId: activeCodexProfile.id }),
+            CODEX_RATE_LIMITS_TIMEOUT_MS,
+            () => ctx.logger?.warn?.(
+              { timeout_ms: CODEX_RATE_LIMITS_TIMEOUT_MS },
+              "codex account rate limits timed out (dispatch lane released)",
+            ),
+          )
+        } finally {
+          codexRateLimitsMs = Date.now() - codexRateLimitsStartedAt
         }
+        const accountUsage = codexUsageFromAccountRateLimits(rateLimits)
+        if (accountUsage) {
+          codexUsage = { ...accountUsage, context: codexUsage?.context ?? null }
+          recordAccountUsageSnapshot("codex", activeCodexProfile.id, codexUsage)
+        }
+      } catch (err) {
+        ctx.logger?.debug?.({ err: err?.message }, "codex usage snapshot skipped")
       }
-      // ライブ session の有無にかかわらず、起動直後の account RPC を優先する。
-      // rollout は context の補助だけにし、5h/7d はプロファイル固有の最新実値にする。
-      const codexRateLimitsStartedAt = Date.now()
-      const rateLimits = await ctx.codexBridge.readAccountRateLimits({
-        profileId: activeCodexProfile.id,
-      })
-      codexRateLimitsMs = Date.now() - codexRateLimitsStartedAt
-      const accountUsage = codexUsageFromAccountRateLimits(rateLimits)
-      if (accountUsage) {
-        codexUsage = { ...accountUsage, context: codexUsage?.context ?? null }
-        recordAccountUsageSnapshot("codex", activeCodexProfile.id, codexUsage)
-      }
-    } catch (err) {
-      ctx.logger?.debug?.({ err: err?.message }, "codex usage snapshot skipped")
     }
+    // Agent 再起動後や一時的な account RPC 失敗時も、同一 profile の最終取得値だけを
+    // 表示する。未ログインならここへ到達せず、表示も完全に隠す。
+    if (codexHasCredentials && !codexUsage) {
+      codexUsage = await readAccountUsageSnapshot("codex", activeCodexProfile.id)
+    }
+    return { codexUsage, codexSessions, codexContextCwd }
   }
-  // Agent 再起動後や一時的な account RPC 失敗時も、同一 profile の最終取得値だけを
-  // 表示する。未ログインならここへ到達せず、表示も完全に隠す。
-  if (codexHasCredentials && !codexUsage) {
-    codexUsage = await readAccountUsageSnapshot("codex", activeCodexProfile.id)
-  }
+
+  const [{ usage, sessions }, { codexUsage, codexSessions, codexContextCwd }] = await Promise.all([
+    buildClaudeUsage().catch((err) => {
+      ctx.logger?.debug?.({ err: err?.message }, "claude usage build skipped")
+      return { usage: null, sessions: [] }
+    }),
+    buildCodexUsage().catch((err) => {
+      ctx.logger?.debug?.({ err: err?.message }, "codex usage build skipped")
+      return { codexUsage: null, codexSessions: [], codexContextCwd: null }
+    }),
+  ])
 
   return {
     payload: { usage, sessions, codexUsage, codexSessions },
@@ -4576,18 +4693,42 @@ export async function dispatch(msg, ctx) {
           // 添えれば Codex 向け skills (~/.codex/skills/) を返す。未指定は
           // 従来どおり claude 向け。
           const skillsCliKind = msg.cli_kind === "codex" ? "codex" : "claude"
-          // T06117: claude は SDK supportedCommands() を権威に一覧を作る (組込 +
-          // グローバル skill + plugin/dynamic を FS 走査の取りこぼしなく反映)。
-          // 取れなければ null で listSkills が FS 走査へフォールバックする。
-          let sdkCommands = null
-          if (skillsCliKind === "claude" && ctx.claudeBridge?.listSupportedCommands) {
-            sdkCommands = await ctx.claudeBridge.listSupportedCommands()
-          }
-          const skills = await listSkills({
-            sessionName: msg.session_name,
-            cliKind: skillsCliKind,
-            sdkCommands,
-          })
+          const timing = { sdk_wait_ms: 0, list_skills_ms: 0 }
+          let started
+          const skills = await coalesceInflight(
+            listRequestsInflight,
+            skillsRequestKey(skillsCliKind, msg.session_name),
+            async () => {
+              // T06117: claude は SDK supportedCommands() を権威に一覧を作る (組込 +
+              // グローバル skill + plugin/dynamic を FS 走査の取りこぼしなく反映)。
+              // 取れなければ null で listSkills が FS 走査へフォールバックする。
+              started = performance.now()
+              let sdkCommands = null
+              if (skillsCliKind === "claude" && ctx.claudeBridge?.listSupportedCommands) {
+                try {
+                  sdkCommands = await ctx.claudeBridge.listSupportedCommands()
+                } finally {
+                  timing.sdk_wait_ms = performance.now() - started
+                }
+              }
+              timing.sdk_wait_ms = performance.now() - started
+              const listStarted = performance.now()
+              try {
+                return await listSkills({
+                  sessionName: msg.session_name,
+                  cliKind: skillsCliKind,
+                  sdkCommands,
+                  timing,
+                })
+              } finally {
+                timing.list_skills_ms = performance.now() - listStarted
+              }
+            },
+            ({ joined }) => logPhaseTiming(ctx.logger, "skills request timing", {
+              coalesce_key_hash: createHash("sha256").update(skillsRequestKey(skillsCliKind, msg.session_name)).digest("hex"),
+              joined, ...timing, total_ms: performance.now() - started,
+            }),
+          )
           ctx.client.send({
             type: "skills.response",
             request_id: msg.request_id,
@@ -4607,7 +4748,8 @@ export async function dispatch(msg, ctx) {
       }
       case "agents.request": {
         try {
-          const agents = await listAgents()
+          // 引数を持たない要求なので、実行中の取得があれば全員で結果を共有する。
+          const agents = await coalesceInflight(listRequestsInflight, "agents", () => listAgents({ logger: ctx.logger }))
           ctx.client.send({
             type: "agents.response",
             request_id: msg.request_id,

package/src/skills.mjs

@@ -1,3 +1,4 @@
+import { performance } from "node:perf_hooks"
 /**
  * Claude Code の skill / slash command を集計する (Sprint H)。
  *
@@ -160,17 +161,20 @@ export async function listSkills(opts = {}) {
   // FS の frontmatter から name でオーバーレイし、control query の cwd 外にある
   // project-local skill は FS 走査で補完する。
   if (cliKind === "claude" && Array.isArray(opts.sdkCommands)) {
-    return await listSkillsFromSdk(opts.sdkCommands, sessionName, projectsRoot)
+    return await listSkillsFromSdk(opts.sdkCommands, sessionName, projectsRoot, opts.timing)
   }
 
   // フォールバック経路: SDK 未取得 / Codex は従来どおり FS 走査 + 組込ハードコード。
   const out = []
   out.push(...(cliKind === "codex" ? CODEX_BUILT_IN_COMMANDS : BUILT_IN_COMMANDS))
+  const globalStarted = performance.now()
   out.push(...(await loadSkillsDir(skillsDirFor(cliKind), "skill")))
   if (cliKind === "claude") {
     out.push(...(await loadCommandsDir(GLOBAL_COMMANDS_DIR, "command")))
   }
 
+  if (opts.timing) opts.timing.global_scan_ms = performance.now() - globalStarted
+  const projectStarted = performance.now()
   if (sessionName && /^D\d{5}_/.test(sessionName)) {
     const projectDirName = cliKind === "codex" ? ".codex" : ".claude"
     const projectDir = path.join(projectsRoot, sessionName, projectDirName)
@@ -180,6 +184,8 @@ export async function listSkills(opts = {}) {
     }
   }
 
+  if (opts.timing) opts.timing.project_scan_ms = performance.now() - projectStarted
+
   // 同名は最初を採用、名前順 sort
   const seen = new Set()
   const deduped = out.filter((s) => {
@@ -218,7 +224,7 @@ export function sourceFromCommandSuffix(desc) {
  * - control query の cwd 外にある project-local skill/command を FS 走査で補完
  * - 同名 dedup / 名前順 sort
  */
-async function listSkillsFromSdk(sdkCommands, sessionName, projectsRoot) {
+async function listSkillsFromSdk(sdkCommands, sessionName, projectsRoot, timing) {
   const entries = []
   const seen = new Set()
   for (const c of sdkCommands) {
@@ -232,10 +238,13 @@ async function listSkillsFromSdk(sdkCommands, sessionName, projectsRoot) {
   }
 
   // label_ja オーバーレイ用の FS 走査 (global) + project-local の補完材料。
+  const globalStarted = performance.now()
   const globalLabelSources = [
     ...(await loadSkillsDir(GLOBAL_SKILLS_DIR, "skill")),
     ...(await loadCommandsDir(GLOBAL_COMMANDS_DIR, "command")),
   ]
+  if (timing) timing.global_scan_ms = performance.now() - globalStarted
+  const projectStarted = performance.now()
   let projectEntries = []
   if (sessionName && /^D\d{5}_/.test(sessionName)) {
     const projectDir = path.join(projectsRoot, sessionName, ".claude")
@@ -245,6 +254,7 @@ async function listSkillsFromSdk(sdkCommands, sessionName, projectsRoot) {
     ]
   }
 
+  if (timing) timing.project_scan_ms = performance.now() - projectStarted
   const labelMap = new Map()
   for (const s of [...globalLabelSources, ...projectEntries]) {
     if (s.label) labelMap.set(s.name, s.label)

package/src/startup-metrics.mjs

@@ -0,0 +1,52 @@
+import { monitorEventLoopDelay, performance } from "node:perf_hooks"
+
+// performance.now() はプロセス起動を原点とする単調時計。テストでは _setNowForTest で差し替える。
+let defaultNow = () => performance.now()
+
+/** テスト専用: 既定の時計を差し替える (省略で元に戻す)。直前の時計を返す。 */
+export function _setNowForTest(fn) {
+  const prev = defaultNow
+  defaultNow = fn ?? (() => performance.now())
+  return prev
+}
+
+export function isStartupWindow(now = defaultNow) {
+  return now() <= 60_000
+}
+
+/**
+ * 計測ログを出す。⚠️ 計測は処理結果に影響させない: logger が例外を投げても外へ出さない
+ * (呼び出し元の処理・キャッシュ・Promise の完了通知を壊さないため)。
+ */
+export function logPhaseTiming(logger, msg, fields, now = defaultNow) {
+  try {
+    if (isStartupWindow(now) || fields.total_ms >= 500) logger?.info?.(fields, msg)
+  } catch {
+    // 計測ログの失敗は無視する
+  }
+}
+
+export function startEventLoopMetrics(logger, {
+  now = defaultNow,
+  monitor = monitorEventLoopDelay,
+  schedule = setTimeout,
+} = {}) {
+  const histogram = monitor({ resolution: 20 })
+  histogram.enable()
+  for (const deadline of [10_000, 30_000, 60_000]) {
+    schedule(() => {
+      try {
+        logger?.info?.({
+          since_start_ms: now(),
+          p50_ms: histogram.percentile(50) / 1e6,
+          p99_ms: histogram.percentile(99) / 1e6,
+          max_ms: histogram.max / 1e6,
+        }, "startup event loop delay")
+      } catch {
+        // 計測ログの失敗は無視する
+      } finally {
+        if (deadline === 60_000) histogram.disable()
+      }
+    }, Math.max(0, deadline - now())).unref()
+  }
+}