@cocorograph/hub-agent 0.8.110 → 0.8.112

package/package.json

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

package/src/claude-history.mjs

@@ -714,7 +714,7 @@ export async function deleteSession({
 }
 
 /** 親の取得窓内の背景依頼だけに、直接の子 transcript を結合する。 */
-async function attachBackgroundSubagentHistory(filePath, { result, requests }) {
+async function attachBackgroundSubagentHistory(filePath, { result, requests }, timing) {
   if (requests.size === 0) return result
   const subagentsDir = path.join(filePath.slice(0, -".jsonl".length), "subagents")
   let names
@@ -730,6 +730,7 @@ async function attachBackgroundSubagentHistory(filePath, { result, requests }) {
       const meta = JSON.parse(await readFile(path.join(subagentsDir, name), "utf-8"))
       const toolUseId = meta?.toolUseId
       if (typeof toolUseId !== "string" || !toolUseId || !requests.has(toolUseId)) continue
+      if (timing) timing.subagent_files++
       const text = await readFile(path.join(subagentsDir, name.replace(/\.meta\.json$/, ".jsonl")), "utf-8")
       // 子は実行中にも読まれるので、追記途中の「未完の末尾行」だけは捨てて完成済みの行を残す。
       // ⚠️ 途中の行が壊れている場合は子ごと捨てる。壊れた行が tool_use だと、後続の tool_result を
@@ -760,6 +761,7 @@ async function attachBackgroundSubagentHistory(filePath, { result, requests }) {
       const index = requests.get(toolUseId)
       if (!children.has(index)) children.set(index, [])
       for (const event of events) children.get(index).push(event)
+      if (timing) timing.subagent_events += events.length
     } catch {
       // 不完全な meta / transcript は推定で紐付けず、その子だけスキップする。
     }
@@ -785,7 +787,27 @@ async function attachBackgroundSubagentHistory(filePath, { result, requests }) {
  * @param {{maxLines?: number, logger?: import('pino').Logger}} [opts]
  * @returns {Promise<{events: object[], total_lines: number, truncated: boolean}>}
  */
-export async function readSessionHistory(filePath, { maxLines = MAX_HISTORY_LINES, logger } = {}) {
+// timing は呼び出しごとの出力先。キャッシュと返却ペイロードには保存しない。
+export async function readSessionHistory(filePath, { maxLines = MAX_HISTORY_LINES, logger, timing } = {}) {
+  const started = performance.now()
+  if (timing) Object.assign(timing, { cache_hit: false, parent_ms: 0, subagent_ms: 0, subagent_files: 0, subagent_events: 0, tag_ms: 0 })
+  const attach = async (parent) => {
+    if (timing) timing.parent_ms = performance.now() - started
+    const subagentStarted = performance.now()
+    try {
+      return await attachBackgroundSubagentHistory(filePath, parent, timing)
+    } finally {
+      if (timing) timing.subagent_ms = performance.now() - subagentStarted
+    }
+  }
+  try {
+    return await readParentSessionHistory(filePath, { maxLines, logger, timing, attach })
+  } finally {
+    if (timing && timing.subagent_ms === 0) timing.parent_ms = performance.now() - started
+  }
+}
+
+async function readParentSessionHistory(filePath, { maxLines, logger, timing, attach }) {
   // stat は readFile よりずっと軽い (メタデータのみ)。mtimeMs+size が前回と同じなら
   // ファイル内容も同じとみなし、以降の readFile + 全行 parse をまるごとスキップする。
   let st
@@ -799,7 +821,10 @@ export async function readSessionHistory(filePath, { maxLines = MAX_HISTORY_LINE
     throw err
   }
   const cached = getHydrateCache(filePath, st.mtimeMs, st.size, maxLines)
-  if (cached) return attachBackgroundSubagentHistory(filePath, cached)
+  if (cached) {
+    if (timing) timing.cache_hit = true
+    return attach(cached)
+  }
 
   const readStarted = performance.now()
   let text
@@ -867,7 +892,7 @@ export async function readSessionHistory(filePath, { maxLines = MAX_HISTORY_LINE
   const result = { events, total_lines, truncated }
   const parent = { result, requests }
   setHydrateCache(filePath, st.mtimeMs, st.size, maxLines, parent)
-  return attachBackgroundSubagentHistory(filePath, parent)
+  return attach(parent)
 }
 
 /**
@@ -876,16 +901,22 @@ export async function readSessionHistory(filePath, { maxLines = MAX_HISTORY_LINE
  *
  * @param {{cwd: string, session_id: string, maxLines?: number, projectsRoot?: string, logger?: import('pino').Logger}} args
  */
-export async function fetchSessionHistory({ cwd, session_id, maxLines, projectsRoot, logger }) {
+export async function fetchSessionHistory({ cwd, session_id, maxLines, projectsRoot, logger, timing }) {
   if (!cwd || !session_id) {
     return { events: [], total_lines: 0, truncated: false, error: "missing_cwd_or_session_id" }
   }
   const filePath = jsonlPath({ cwd, session_id, projectsRoot })
   try {
-    const result = await readSessionHistory(filePath, { maxLines, logger })
+    const result = await readSessionHistory(filePath, { maxLines, logger, timing })
     // 連携カード種別 (Phase 2 永続化): 注入 user メッセージへ source を付け直す (hydrateCache は
     // filePath キーで cwd を持たないため、cwd を持つここでタグ付けする。クローンで cache 非破壊)。
-    const events = await tagHistoryInjectSources(result.events, cwd)
+    const tagStarted = performance.now()
+    let events
+    try {
+      events = await tagHistoryInjectSources(result.events, cwd)
+    } finally {
+      if (timing) timing.tag_ms = performance.now() - tagStarted
+    }
     return { ...result, events, file_path: filePath }
   } catch (err) {
     return {

package/src/dispatch-scheduler.mjs

@@ -43,7 +43,7 @@ const SLOW_DISPATCH_MS = 1000
  * 調査対象そのものなので、速かった場合も含めて毎回記録する
  * (速いことの記録が無いと「詰まっていない」を示せない)。
  */
-const ALWAYS_TIMED_TYPES = new Set(["chat.session.stop"])
+const ALWAYS_TIMED_TYPES = new Set(["chat.session.stop", "claude.attach"])
 
 export function isConnectionLifecycleMessage(type) {
   return LIFECYCLE_TYPES.has(type)
@@ -101,6 +101,15 @@ export function attachLaneKey(mode, msg, defaultCwd = "") {
   return streamId ? `${mode}:stream:${streamId}` : `${mode}:control`
 }
 
+/**
+ * ログに出すレーン名。内部キーは cwd・resume ID・stream ID を含むので、ログには種別だけを出す
+ * （直列化に使う内部キーそのものは変えない）。
+ */
+export function laneKindForLog(lane) {
+  const m = /^(claude|codex):(cwd|resume|stream):/.exec(typeof lane === "string" ? lane : "")
+  return m ? `${m[1]}:${m[2]}` : lane
+}
+
 /**
  * @param {{
  *   run: (msg: object) => Promise<void>|void,
@@ -261,14 +270,14 @@ export class DispatchScheduler {
         const runMs = Date.now() - startedAt
         if (shouldLogDispatchTiming(msg?.type, 0, runMs)) {
           this.logger?.info?.(
-            { type: msg?.type, lane, wait_ms: 0, run_ms: runMs },
+            { type: msg?.type, lane: laneKindForLog(lane), wait_ms: 0, run_ms: runMs },
             "dispatch timing",
           )
         }
       })
       .catch((err) => {
         this.logger?.error?.(
-          { err: err?.message, type: msg?.type, lane },
+          { err: err?.message, type: msg?.type, lane: laneKindForLog(lane) },
           "dispatch threw",
         )
       })
@@ -317,7 +326,7 @@ export class DispatchScheduler {
       .then(async () => {
         if (generation !== this.generation) {
           this.logger?.debug?.(
-            { type, lane, queued_generation: generation, generation: this.generation },
+            { type, lane: laneKindForLog(lane), queued_generation: generation, generation: this.generation },
             "stale queued dispatch dropped after reconnect",
           )
           return
@@ -328,7 +337,7 @@ export class DispatchScheduler {
           (this.detachedAtByStream.get(streamKey) ?? -1) > sequence
         ) {
           this.logger?.debug?.(
-            { type, lane, stream_id: streamId },
+            { type, lane: laneKindForLog(lane), stream_id: streamId },
             "detached queued attach dropped",
           )
           return
@@ -343,7 +352,7 @@ export class DispatchScheduler {
           const runMs = Date.now() - startedAt
           if (shouldLogDispatchTiming(type, waitMs, runMs)) {
             this.logger?.info?.(
-              { type, lane, wait_ms: waitMs, run_ms: runMs },
+              { type, lane: laneKindForLog(lane), wait_ms: waitMs, run_ms: runMs },
               "dispatch timing",
             )
           }
@@ -351,7 +360,7 @@ export class DispatchScheduler {
       })
       .catch((err) => {
         this.logger?.error?.(
-          { err: err?.message, type, lane },
+          { err: err?.message, type, lane: laneKindForLog(lane) },
           "dispatch threw in serial lane",
         )
       })

package/src/main.mjs

@@ -1,6 +1,6 @@
 import { performance } from "node:perf_hooks"
 import { createHash } from "node:crypto"
-import { logPhaseTiming, startEventLoopMetrics } from "./startup-metrics.mjs"
+import { logPhaseTiming, startEventLoopMetrics, readAttachEventLoopMetrics } from "./startup-metrics.mjs"
 import { startLogRotation } from "./log-rotation.mjs"
 /**
  * hub-agent daemon 本体。
@@ -2627,6 +2627,125 @@ export function handleClaudeChatInput(msg, ctx) {
   return p
 }
 
+export async function handleClaudeHistoryRequest(msg, ctx, {
+  resolveFn = resolveProjectsRoot,
+  fetchHistoryFn = fetchSessionHistory,
+} = {}) {
+  const timing = createHistoryDeliveryTiming()
+  let payload
+  let sendOk = false
+  try {
+    // Sprint G 0.6.1: ~/.claude/projects/<cwd-encoded>/<session_id>.jsonl を読んで
+    // 過去メッセージを返す。ChatView の re-mount 時の UI 復元用。
+    // stream_id は per-stream routing のため必須 (browser 側 stream に紐付ける)。
+    const stream_id = msg.stream_id
+    const cwd = msg.cwd || ""
+    const session_id = msg.session_id || ""
+    const maxLines = typeof msg.max_lines === "number" ? msg.max_lines : undefined
+    // Read-plane 案C ①: 読む projects/ は **リクエストの profile_id** から解決する
+    // (アカウント別に履歴がサイロ化されており、env 由来の active に頼ると切替中の
+    // in-flight read が別アカウントの履歴を返す)。profile_id 未指定は active へ縮退。
+    const epoch = typeof msg.epoch === "number" ? msg.epoch : undefined
+    const { projectsRoot, profileId } = await timeHistoryPhase(timing, "resolve_ms", () => resolveFn(msg.profile_id))
+    const result = await timeHistoryPhase(timing, "fetch_ms", () => fetchHistoryFn({
+      cwd,
+      session_id,
+      maxLines,
+      projectsRoot,
+      logger: ctx.logger,
+      timing,
+    }))
+    payload = result
+    // ⚠️ **観測窓を必ずどこかから読む**。タスク終端通知の封筒検査は、Claude CLI が
+    // ラッパー・タグ順・空白を変えると正当な通知まで落とし、**幽霊カードが静かに戻る**。
+    // 誰も読まないカウンタは「対策した気になるだけの飾り」になる (バンドル自己更新の
+    // 通知で発火率 0 の検査を残していた前例あり)。件数だけを出す (中身は伏せ字を
+    // 素通りするので絶対に出さない)。
+    const envelopeDrops = drainTaskNotificationEnvelopeDrops()
+    if (envelopeDrops > 0) {
+      try {
+        ctx.logger?.info?.(
+          { drops: envelopeDrops },
+          "history: task-notification の封筒検査で合成しなかった行があります (CLI の形式変更なら通知の復元が効かなくなります)",
+        )
+      } catch {
+        // ログ失敗でも応答を送る。
+      }
+    }
+    sendOk = ctx.client.send({
+      type: "claude.history.response",
+      stream_id,
+      session_id,
+      // SDK-P0-4 (2026-07-13): 要求時の cwd をエコーバックする。claude.sessions.response は
+      // 元から cwd を載せており frontend が cwd 照合で「別ワークスペース宛の遅延応答」を
+      // 捨てられるのに、history.response だけ cwd が無く照合材料が存在しなかった。
+      // その結果、無条件 hydrate → session_id 上書き → 購読スワップ → localStorage 汚染の
+      // 経路が残っていた (sessionScope.ts が stream_id 主軸で守るのは relay イベントのみ)。
+      cwd,
+      // 案C ②: epoch と解決済み profile を必ずエコーする。frontend の単一 read ゲートは
+      // この 2 つで「今の問いへの最新の答えか」を判定し、stale/逆順/別プロファイルを drop する。
+      epoch,
+      profile_id: profileId,
+      events: result.events,
+      total_lines: result.total_lines,
+      truncated: result.truncated,
+      error: result.error,
+    })
+  } finally {
+    logHistoryDelivery(ctx, "request", msg.stream_id, timing, payload, sendOk)
+  }
+}
+
+export function createHistoryDeliveryTiming() {
+  return {
+    started_at: Date.now(), started: performance.now(), resolve_ms: 0, fetch_ms: 0,
+    cache_hit: false, parent_ms: 0, subagent_ms: 0, subagent_files: 0,
+    subagent_events: 0, tag_ms: 0, has_error: false,
+  }
+}
+
+async function timeHistoryPhase(timing, field, run) {
+  const started = performance.now()
+  try {
+    return await run()
+  } catch (err) {
+    timing.has_error = true
+    throw err
+  } finally {
+    timing[field] = performance.now() - started
+  }
+}
+
+function logHistoryDelivery(ctx, via, stream_id, timing, payload, sendOk) {
+  try {
+    // 明示的な allowlist: 本文・パス・error 文字列をログへ流さない。
+    ctx.logger?.info?.({
+      via, stream_id, started_at: timing.started_at,
+      resolve_ms: timing.resolve_ms, fetch_ms: timing.fetch_ms,
+      cache_hit: timing.cache_hit, parent_ms: timing.parent_ms,
+      subagent_ms: timing.subagent_ms, subagent_files: timing.subagent_files,
+      subagent_events: timing.subagent_events, tag_ms: timing.tag_ms,
+      events: payload?.events?.length || 0, total_lines: payload?.total_lines || 0,
+      truncated: payload?.truncated === true, send_ok: Boolean(sendOk),
+      ws_buffered: ctx.client.bufferedAmount ?? null,
+      total_ms: performance.now() - timing.started,
+      has_error: Boolean(timing.has_error || payload?.error != null),
+    }, "claude history delivery timing")
+  } catch {
+    // 計測失敗で履歴配信を壊さない。
+  }
+}
+
+export function sendClaudeAttachHistory(ctx, stream_id, payload, timing) {
+  if (!payload) return
+  let sendOk = false
+  try {
+    sendOk = ctx.client.send({ ...payload, stream_id })
+  } finally {
+    logHistoryDelivery(ctx, "push", stream_id, timing, payload, sendOk)
+  }
+}
+
 /**
  * claude.attach の ready 直後にpushする履歴を組み立てる。
  * Browserからの claude.history.request 往復を省くため、resume時だけ先回りして読む。
@@ -2654,6 +2773,7 @@ export async function loadClaudeAttachHistory({
   logger,
   resolved,
   fetchHistoryFn = fetchSessionHistory,
+  timing = createHistoryDeliveryTiming(),
 }) {
   if (!cwd || !sessionId) return null
   const profileId = resolved?.profileId
@@ -2667,13 +2787,14 @@ export async function loadClaudeAttachHistory({
     const projectsRoot = resolved
       ? resolved.projectsRoot
       : await getActiveProjectsRoot()
-    const result = await fetchHistoryFn({
+    const result = await timeHistoryPhase(timing, "fetch_ms", () => fetchHistoryFn({
       cwd,
       session_id: sessionId,
       maxLines: 500,
       projectsRoot,
       logger,
-    })
+      timing,
+    }))
     return withProfile({
       type: "claude.history.response",
       session_id: sessionId,
@@ -2721,11 +2842,12 @@ export function buildAttachHistoryPromise({
   profileId,
   resolveFn = resolveProjectsRoot,
   loadFn = loadClaudeAttachHistory,
+  timing = createHistoryDeliveryTiming(),
 }) {
   if (!resumeSessionId) return Promise.resolve(null)
-  return resolveFn(profileId)
+  return timeHistoryPhase(timing, "resolve_ms", () => resolveFn(profileId))
     .then((resolved) =>
-      loadFn({ cwd, sessionId: resumeSessionId, logger, resolved }),
+      loadFn({ cwd, sessionId: resumeSessionId, logger, resolved, timing }),
     )
     .catch((err) => ({
       type: "claude.history.response",
@@ -3315,6 +3437,33 @@ export async function stopChatSessionsUnder(dir, ctx, reason = "worktree-remove"
   return stopped
 }
 
+// attach 一回につき一度だけ記録する。fields に本文・パス・セッション ID を持たせない。
+export function createClaudeAttachTiming(ctx, msg) {
+  const now = () => performance.now()
+  const started = now()
+  let logged = false
+  const fields = {
+    stream_id: msg.stream_id,
+    prepare_ms: null, attach_ms: null, to_ready_ms: null,
+    send_ok: null, ws_buffered: null,
+    resuming: false, has_resume_id: Boolean(msg.resume_session_id),
+  }
+  return {
+    now, started, fields,
+    log(outcome) {
+      if (logged) return
+      logged = true
+      try {
+        const loop = readAttachEventLoopMetrics()
+        fields.ws_buffered = ctx.client.bufferedAmount ?? null
+        ctx.logger?.info?.({ ...fields, ...loop, outcome }, "claude attach timing")
+      } catch {
+        // 計測失敗で attach / ready / error の配送を壊さない。
+      }
+    },
+  }
+}
+
 /**
  * DispatchScheduler から呼ばれる本番メッセージ入口。
  * export はハンドラ契約を subprocess なしで検証するテスト専用の公開面でもある。
@@ -3388,108 +3537,134 @@ export async function dispatch(msg, ctx) {
         ctx.client.completeStreamsSync?.(msg)
         return
       case "claude.attach": {
-        // Sprint G: stream-json モードで Claude Code を起動。
-        // stream_id は browser 採番のものをそのまま使う。
-        const stream_id = msg.stream_id
-        if (!ctx.claudeBridge) {
-          // SDK 未インストール時はその旨を即時 error で返す。browser 側は
-          // 「ターミナルモードで開いてください」と表示するなどの fallback を想定。
-          ctx.client.send({
-            type: "claude.error",
-            stream_id,
-            error: "stream_mode_unavailable: @anthropic-ai/claude-agent-sdk が agent にインストールされていません",
-          })
-          return
-        }
+        const timing = createClaudeAttachTiming(ctx, msg)
+        let outcome = "error"
         try {
-          // cwd は明示指定が無ければ agent.json の cwd → HOME の順で fallback
-          // (将来 cockpit から worktree path を指定する用)。
-          // model / permissionMode は agent.json の値も使えるよう fallback。
-          const cwdArg = msg.cwd || ctx.config?.claude_cwd || undefined
+          // Sprint G: stream-json モードで Claude Code を起動。
+          // stream_id は browser 採番のものをそのまま使う。
+          const stream_id = msg.stream_id
+          if (!ctx.claudeBridge) {
+            outcome = "unavailable"
+            // SDK 未インストール時はその旨を即時 error で返す。browser 側は
+            // 「ターミナルモードで開いてください」と表示するなどの fallback を想定。
+            ctx.client.send({
+              type: "claude.error",
+              stream_id,
+              error: "stream_mode_unavailable: @anthropic-ai/claude-agent-sdk が agent にインストールされていません",
+            })
+            return
+          }
           try {
-            await prepareChatWorkspace({
-              waitForSync: false,
+            // cwd は明示指定が無ければ agent.json の cwd → HOME の順で fallback
+            // (将来 cockpit から worktree path を指定する用)。
+            // model / permissionMode は agent.json の値も使えるよう fallback。
+            const cwdArg = msg.cwd || ctx.config?.claude_cwd || undefined
+            const prepareStarted = timing.now()
+            try {
+              try {
+                await prepareChatWorkspace({
+                  waitForSync: false,
+                  cwd: cwdArg || process.env.HOME || process.cwd(),
+                  cliKind: "claude",
+                  logger: ctx.logger,
+                })
+              } finally {
+                timing.fields.prepare_ms = Math.round(timing.now() - prepareStarted)
+              }
+            } catch (err) {
+              // Claude は attach で会話を登録するだけで、プロセス起動前に ready を返す。
+              // cwd が無くても live・配送対象に載るため、起動時の失敗に頼らず登録前に止める。
+              if (isCwdUnavailableError(err)) {
+                outcome = "workspace_missing"
+                ctx.client.send({ type: "claude.error", stream_id, error: `workspace_missing: ${err.message}` })
+                return
+              }
+              ctx.logger?.warn?.(
+                { cwd: cwdArg, err: err?.message || String(err) },
+                "claude.attach workspace preparation failed (attach continues)",
+              )
+            }
+            const resumeSessionId = msg.resume_session_id || null
+            // attachは同期処理なので、履歴I/Oを先に開始してreadyまでの待ちを重ねる。
+            // 新Browserはhistory_pushedを見て別requestを省略し、旧Browserは従来どおり
+            // requestしてもhydrateのuuid dedupで安全に収束する。
+            // 案C ①/major1/nit2/公開前 major: 履歴 push を attach/ready から独立させる。
+            // resolveProjectsRoot を attach の直列 await/try に載せない (解決失敗で attach ごと
+            // 落とさない・ready を遅らせない)。詳細は buildAttachHistoryPromise の doc 参照。
+            const historyTiming = createHistoryDeliveryTiming()
+            const historyPromise = buildAttachHistoryPromise({
+              timing: historyTiming,
+              resumeSessionId,
               cwd: cwdArg || process.env.HOME || process.cwd(),
-              cliKind: "claude",
               logger: ctx.logger,
+              profileId: msg.profile_id,
             })
-          } catch (err) {
-            // Claude は attach で会話を登録するだけで、プロセス起動前に ready を返す。
-            // cwd が無くても live・配送対象に載るため、起動時の失敗に頼らず登録前に止める。
-            if (isCwdUnavailableError(err)) {
-              ctx.client.send({ type: "claude.error", stream_id, error: `workspace_missing: ${err.message}` })
-              return
+            const attachStarted = timing.now()
+            let info
+            try {
+              info = ctx.claudeBridge.attach({
+                stream_id,
+                cwd: cwdArg,
+                ...resolveClaudeAttachOptions(ctx.config, msg),
+                resumeSessionId,
+              })
+            } finally {
+              timing.fields.attach_ms = Math.round(timing.now() - attachStarted)
+            }
+            timing.fields.resuming = info?.resuming === true
+            timing.fields.send_ok = false
+            const sendOk = ctx.client.send(buildClaudeReadyPayload(stream_id, info))
+            timing.fields.to_ready_ms = Math.round(timing.now() - timing.started)
+            timing.fields.send_ok = sendOk == null ? null : Boolean(sendOk)
+            timing.log("ready")
+            try {
+              if (resumeSessionId) {
+                void ctx.siblingInjectBridge
+                  ?.replayReviews?.("claude", cwdArg || process.env.HOME || process.cwd(), resumeSessionId)
+                  ?.catch((err) => ctx.logger?.warn?.({ err: err?.message }, "failed to replay review events"))
+              }
+            } catch (err) {
+              ctx.logger?.warn?.({ err: err?.message }, "failed to replay review events")
             }
-            ctx.logger?.warn?.(
-              { cwd: cwdArg, err: err?.message || String(err) },
-              "claude.attach workspace preparation failed (attach continues)",
-            )
-          }
-          const resumeSessionId = msg.resume_session_id || null
-          // attachは同期処理なので、履歴I/Oを先に開始してreadyまでの待ちを重ねる。
-          // 新Browserはhistory_pushedを見て別requestを省略し、旧Browserは従来どおり
-          // requestしてもhydrateのuuid dedupで安全に収束する。
-          // 案C ①/major1/nit2/公開前 major: 履歴 push を attach/ready から独立させる。
-          // resolveProjectsRoot を attach の直列 await/try に載せない (解決失敗で attach ごと
-          // 落とさない・ready を遅らせない)。詳細は buildAttachHistoryPromise の doc 参照。
-          const historyPromise = buildAttachHistoryPromise({
-            resumeSessionId,
-            cwd: cwdArg || process.env.HOME || process.cwd(),
-            logger: ctx.logger,
-            profileId: msg.profile_id,
-          })
-          const info = ctx.claudeBridge.attach({
-            stream_id,
-            cwd: cwdArg,
-            ...resolveClaudeAttachOptions(ctx.config, msg),
-            resumeSessionId,
-          })
-          ctx.client.send(buildClaudeReadyPayload(stream_id, info))
-          try {
             if (resumeSessionId) {
               void ctx.siblingInjectBridge
-                ?.replayReviews?.("claude", cwdArg || process.env.HOME || process.cwd(), resumeSessionId)
-                ?.catch((err) => ctx.logger?.warn?.({ err: err?.message }, "failed to replay review events"))
+                ?.replayDelegations(cwdArg || process.env.HOME || process.cwd(), resumeSessionId)
+                .catch((err) => {
+                  ctx.logger?.warn?.(
+                    { err: err?.message || String(err), stream_id, session_id: resumeSessionId },
+                    "failed to replay delegations after Claude attach",
+                  )
+                })
             }
-          } catch (err) {
-            ctx.logger?.warn?.({ err: err?.message }, "failed to replay review events")
-          }
-          if (resumeSessionId) {
-            void ctx.siblingInjectBridge
-              ?.replayDelegations(cwdArg || process.env.HOME || process.cwd(), resumeSessionId)
+            // dispatch全体はWSメッセージ順を守る直列キュー上にある。ここで履歴I/Oをawaitすると
+            // 同一接続のpermission/input等まで停止するため、readyの同期送信後は非同期でpushする。
+            void historyPromise
+              .then((pushedHistory) => {
+                sendClaudeAttachHistory(ctx, stream_id, pushedHistory, historyTiming)
+              })
               .catch((err) => {
                 ctx.logger?.warn?.(
-                  { err: err?.message || String(err), stream_id, session_id: resumeSessionId },
-                  "failed to replay delegations after Claude attach",
+                  { err: err?.message || String(err), stream_id },
+                  "failed to push Claude attach history",
                 )
               })
-          }
-          // dispatch全体はWSメッセージ順を守る直列キュー上にある。ここで履歴I/Oをawaitすると
-          // 同一接続のpermission/input等まで停止するため、readyの同期送信後は非同期でpushする。
-          void historyPromise
-            .then((pushedHistory) => {
-              if (pushedHistory) ctx.client.send({ ...pushedHistory, stream_id })
-            })
-            .catch((err) => {
-              ctx.logger?.warn?.(
-                { err: err?.message || String(err), stream_id },
-                "failed to push Claude attach history",
-              )
+            const session = ctx.claudeBridge.sessions?.get(stream_id)
+            const resolvedCwd = session?.cwd || cwdArg || process.env.HOME || process.cwd()
+            if (session && resumeSessionId) {
+              void loadResumeChatContext(session, "claude").catch(() => {})
+            }
+
+          } catch (err) {
+            ctx.client.send({
+              type: "claude.error",
+              stream_id,
+              error: err.message,
             })
-          const session = ctx.claudeBridge.sessions?.get(stream_id)
-          const resolvedCwd = session?.cwd || cwdArg || process.env.HOME || process.cwd()
-          if (session && resumeSessionId) {
-            void loadResumeChatContext(session, "claude").catch(() => {})
           }
-
-        } catch (err) {
-          ctx.client.send({
-            type: "claude.error",
-            stream_id,
-            error: err.message,
-          })
+          return
+        } finally {
+          timing.log(outcome)
         }
-        return
       }
       case "claude.session.options.set": {
         const result = ctx.claudeBridge?.setSessionOptions({
@@ -4137,56 +4312,7 @@ export async function dispatch(msg, ctx) {
         return
       }
       case "claude.history.request": {
-        // Sprint G 0.6.1: ~/.claude/projects/<cwd-encoded>/<session_id>.jsonl を読んで
-        // 過去メッセージを返す。ChatView の re-mount 時の UI 復元用。
-        // stream_id は per-stream routing のため必須 (browser 側 stream に紐付ける)。
-        const stream_id = msg.stream_id
-        const cwd = msg.cwd || ""
-        const session_id = msg.session_id || ""
-        const maxLines = typeof msg.max_lines === "number" ? msg.max_lines : undefined
-        // Read-plane 案C ①: 読む projects/ は **リクエストの profile_id** から解決する
-        // (アカウント別に履歴がサイロ化されており、env 由来の active に頼ると切替中の
-        // in-flight read が別アカウントの履歴を返す)。profile_id 未指定は active へ縮退。
-        const epoch = typeof msg.epoch === "number" ? msg.epoch : undefined
-        const { projectsRoot, profileId } = await resolveProjectsRoot(msg.profile_id)
-        const result = await fetchSessionHistory({
-          cwd,
-          session_id,
-          maxLines,
-          projectsRoot,
-          logger: ctx.logger,
-        })
-        // ⚠️ **観測窓を必ずどこかから読む**。タスク終端通知の封筒検査は、Claude CLI が
-        // ラッパー・タグ順・空白を変えると正当な通知まで落とし、**幽霊カードが静かに戻る**。
-        // 誰も読まないカウンタは「対策した気になるだけの飾り」になる (バンドル自己更新の
-        // 通知で発火率 0 の検査を残していた前例あり)。件数だけを出す (中身は伏せ字を
-        // 素通りするので絶対に出さない)。
-        const envelopeDrops = drainTaskNotificationEnvelopeDrops()
-        if (envelopeDrops > 0) {
-          ctx.logger?.info?.(
-            { drops: envelopeDrops },
-            "history: task-notification の封筒検査で合成しなかった行があります (CLI の形式変更なら通知の復元が効かなくなります)",
-          )
-        }
-        ctx.client.send({
-          type: "claude.history.response",
-          stream_id,
-          session_id,
-          // SDK-P0-4 (2026-07-13): 要求時の cwd をエコーバックする。claude.sessions.response は
-          // 元から cwd を載せており frontend が cwd 照合で「別ワークスペース宛の遅延応答」を
-          // 捨てられるのに、history.response だけ cwd が無く照合材料が存在しなかった。
-          // その結果、無条件 hydrate → session_id 上書き → 購読スワップ → localStorage 汚染の
-          // 経路が残っていた (sessionScope.ts が stream_id 主軸で守るのは relay イベントのみ)。
-          cwd,
-          // 案C ②: epoch と解決済み profile を必ずエコーする。frontend の単一 read ゲートは
-          // この 2 つで「今の問いへの最新の答えか」を判定し、stale/逆順/別プロファイルを drop する。
-          epoch,
-          profile_id: profileId,
-          events: result.events,
-          total_lines: result.total_lines,
-          truncated: result.truncated,
-          error: result.error,
-        })
+        await handleClaudeHistoryRequest(msg, ctx)
         return
       }
       case "claude.sessions.request": {

package/src/startup-metrics.mjs

@@ -4,6 +4,74 @@ import { monitorEventLoopDelay, performance } from "node:perf_hooks"
 // performance.now() はプロセス起動を原点とする単調時計。テストでは _setNowForTest で差し替える。
 let defaultNow = () => performance.now()
 
+// attach 用のイベントループ遅延。一定間隔のタイマーが予定よりどれだけ遅れたかを直接測る。
+// ⚠️ monitorEventLoopDelay は使わない: Node 24 では 1 回の長い停止を取りこぼす
+// （150ms 塞いでも max 22ms。2026-10-14 実測）。知りたいのはまさにその単発の停止なので測れない。
+const ATTACH_LOOP_TICK_MS = 20
+const ATTACH_LOOP_STALL_MS = 100
+
+/**
+ * タイマー遅延の集計（時計を差し込める状態機械）。read() ごとに区間を切る。
+ * - loop_delay_max_ms: 区間内に重なった遅延の最大。区間をまたぐ停止は区間内の部分だけを数える
+ *   （読み取り直後の区間に、前区間で報告済みの遅延を持ち越さない）
+ * - loop_stalls_100ms: 停止（遅延が stallMs 以上）の回数。1 回の停止は、stallMs に達したと最初に
+ *   分かった区間で 1 回だけ数える（読み取り時の進行中遅延で数えたら、後のタイマー発火では数えない）
+ * - loop_window_ms: 区間長
+ */
+export function createLoopLagSampler({ now = () => performance.now(), tickMs = ATTACH_LOOP_TICK_MS, stallMs = ATTACH_LOOP_STALL_MS } = {}) {
+  let lastTick = now()
+  let windowStart = lastTick
+  let maxLag = 0
+  let stalls = 0
+  // lastTick 以降に続いている停止を、既に回数へ数えたか。
+  let ongoingCounted = false
+  return {
+    tick() {
+      const t = now()
+      const lag = Math.max(0, t - lastTick - tickMs)
+      const inWindow = Math.min(lag, Math.max(0, t - windowStart))
+      if (inWindow > maxLag) maxLag = inWindow
+      if (lag >= stallMs && !ongoingCounted) stalls++
+      ongoingCounted = false
+      lastTick = t
+    },
+    read() {
+      const t = now()
+      const pending = Math.max(0, t - lastTick - tickMs)
+      const pendingInWindow = Math.min(pending, Math.max(0, t - windowStart))
+      let windowStalls = stalls
+      if (pending >= stallMs && !ongoingCounted) {
+        windowStalls++
+        ongoingCounted = true
+      }
+      const fields = {
+        loop_delay_max_ms: Math.round(Math.max(maxLag, pendingInWindow)),
+        loop_stalls_100ms: windowStalls,
+        loop_window_ms: Math.round(t - windowStart),
+      }
+      maxLag = 0
+      stalls = 0
+      windowStart = t
+      return fields
+    },
+  }
+}
+
+/** サンプラーを作り、タイマーで tick() を回す。計測のためにプロセスの終了を引き留めない。 */
+export function startLoopLagSampler({ now, tickMs = ATTACH_LOOP_TICK_MS, stallMs = ATTACH_LOOP_STALL_MS, setIntervalFn = setInterval } = {}) {
+  const sampler = createLoopLagSampler({ now, tickMs, stallMs })
+  const timer = setIntervalFn(() => sampler.tick(), tickMs)
+  timer?.unref?.()
+  return sampler
+}
+
+const attachLoopSampler = startLoopLagSampler()
+
+/** 前回読んでから今までのイベントループ遅延（最大・100ms 以上の停止回数・区間長）を返し、区間を切る。 */
+export function readAttachEventLoopMetrics() {
+  return attachLoopSampler.read()
+}
+
 /** テスト専用: 既定の時計を差し替える (省略で元に戻す)。直前の時計を返す。 */
 export function _setNowForTest(fn) {
   const prev = defaultNow

package/src/ws-client.mjs

@@ -111,6 +111,10 @@ function isEphemeralCodexDeltaEvent(obj) {
 }
 
 export class WsClient extends EventEmitter {
+  get bufferedAmount() {
+    return this.ws?.readyState === WebSocket.OPEN ? this.ws.bufferedAmount : null
+  }
+
   /**
    * @param {{ hub_url: string, agent_id: string, agent_token: string }} config
    * @param {{