@cocorograph/hub-agent 0.8.111 → 0.8.112

package/package.json

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

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 本体。
@@ -3437,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 なしで検証するテスト専用の公開面でもある。
@@ -3510,110 +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 historyTiming = createHistoryDeliveryTiming()
-          const historyPromise = buildAttachHistoryPromise({
-            timing: historyTiming,
-            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) => {
-              sendClaudeAttachHistory(ctx, stream_id, pushedHistory, historyTiming)
-            })
-            .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({

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