@cocorograph/hub-agent 0.8.111 → 0.8.113

package/package.json

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

package/src/codex-profiles.mjs

@@ -29,6 +29,7 @@ import path from "node:path"
 import os from "node:os"
 
 import { paths as hubPaths, ensureConfigDir } from "./config.mjs"
+import { fileSignature, keepRuntimeActive } from "./registry-cache.mjs"
 
 /** 既定 (プライマリ) プロファイルの ID。 */
 export const DEFAULT_CODEX_PROFILE_ID = "default"
@@ -94,6 +95,9 @@ export function registryPath() {
 
 let _cache = null
 
+/** 稼働中の active（env へ反映済みのもの）。keepRuntimeActive の docstring 参照。 */
+let _runtimeActive = null
+
 /** チルダ展開。 */
 function resolveDir(dir) {
   if (!dir) return defaultCodexDir()
@@ -106,13 +110,19 @@ function resolveDir(dir) {
  * レジストリを読み込む。存在しなければ既定プロファイルのみの仮想レジストリを返す。
  * @returns {Promise<{activeId: string, profiles: Array<{id:string,label:string,configDir:string}>}>}
  */
-export async function loadRegistry() {
-  if (_cache) return _cache
+async function readRegistry() {
+  // ⚠️ profiles.mjs と同じく、キャッシュはファイルの状態と組で持つ（手動編集を即時反映する）。
+  const signature = await fileSignature(registryPath())
+  if (_cache && _cache.signature === signature) return _cache.registry
   let parsed = null
   try {
     const raw = await fs.readFile(registryPath(), "utf-8")
     parsed = JSON.parse(raw)
   } catch (err) {
+    // 手編集の途中（保存前の truncate・書きかけ）で壊れた JSON を読んだときは、直前に
+    // 正しく読めた内容を使い続ける（署名は更新しないので、次の呼び出しで読み直す）。
+    // 壊れたまま再起動した場合は、従来どおり起動時に失敗する。
+    if (err instanceof SyntaxError && _cache) return _cache.registry
     if (err.code !== "ENOENT") throw err
   }
 
@@ -143,8 +153,27 @@ export async function loadRegistry() {
     }
   }
 
-  _cache = { activeId, profiles }
-  return _cache
+  const registry = { activeId, profiles }
+  _runtimeActive = keepRuntimeActive(registry, _runtimeActive)
+  _cache = { signature, registry }
+  return registry
+}
+
+/**
+ * レジストリを読み込む（readRegistry の docstring 参照）。
+ *
+ * ⚠️ 読み込みが失敗した時点で稼働中の active がまだ決まっていなければ、既定に固定する。
+ * 起動時に失敗すると main.mjs は既定のディレクトリで env を組むので、あとでファイルが
+ * 直ったときにファイル上の activeId を「稼働中の active」と誤認しないため。stat・パース・
+ * 正規化のどこで失敗しても同じに扱う。固定済みなら（稼働後の失敗では）変えない。
+ */
+export async function loadRegistry() {
+  try {
+    return await readRegistry()
+  } catch (err) {
+    if (!_runtimeActive) _runtimeActive = makeDefaultCodexProfile()
+    throw err
+  }
 }
 
 /** レジストリを永続化する。default は profiles[] に含めず defaultLabel / activeId だけ保存。 */
@@ -237,6 +266,10 @@ export async function setActiveProfile(id) {
   if (!target) throw new Error(`unknown codex profile: ${id}`)
   reg.activeId = id
   await saveRegistry(reg)
+  // 保存と並行して読み直した結果が旧 active のままキャッシュされないよう、ここで捨てる
+  // （同期で続けて書くので、以後に完了する読み直しは新しい active を使う）。
+  _runtimeActive = { ...target }
+  _cache = null
   return target
 }
 
@@ -406,4 +439,5 @@ export async function provisionProfile(configDir) {
 /** テスト用: モジュールキャッシュを破棄する。 */
 export function _clearCache() {
   _cache = null
+  _runtimeActive = null
 }

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 本体。
@@ -912,27 +912,37 @@ export function wireBridgeEvents(client, { claudeBridge, codexBridge }) {
   }
 }
 
-export async function startDaemon({ version, claudeSdk } = {}) {
-  const logRotationTimer = startLogRotation(logger, { isDeferred: hasInheritedOutputChild })
-  startEventLoopMetrics(logger)
-  const config = await readConfig()
-  if (!config) {
-    throw new Error(
-      "~/.hub/agent.json が見つかりません。`hub-agent enroll <token>` を先に実行してください。",
-    )
-  }
+/**
+ * 起動時の env を組む（シェル補完 → Claude / Codex プロファイルの env 反映）。
+ *
+ * launchd / systemd 起動では .zshrc 等の対話シェル設定が読まれず、~/.claude.json の
+ * MCP 定義が参照する環境変数 (例: Authorization: Bearer ${WRI_MCP_TOKEN}) が解決
+ * できない。ユーザーのログインシェル env + dotenv 層を 1 回解決して process.env を
+ * 補完する。spawn される全 Claude query が継承し、MCP トークンを出どころ
+ * (Keychain / シェル変数 / .env) を問わず引き継げる。WHY: ナレッジ/インフラ/cockpit-mcp-reauth
+ *
+ * ⚠️ プロファイルの env はシェル補完の**後**に反映する。補完は「欠けているキー」を足すので、
+ * 既定プロファイルで CLAUDE_CONFIG_DIR / CODEX_HOME を消したあとに補完すると、シェルに
+ * 書かれた値が戻り、一覧（既定）と実行（シェルの値）が食い違う。
+ * ⚠️ プロファイルを読めなかったときも既定の env を反映する（継承した値を残すと、一覧は
+ * 既定・実行は継承先になる）。profiles.mjs / codex-profiles.mjs の loadRegistry は、この
+ * 失敗時に稼働中の active を既定として固定する。
+ *
+ * @param {object} p
+ * @param {import('pino').Logger} p.logger
+ * @param {object} [p.deps] テスト用の差し替え（hydrate / getClaudeProfile / getCodexProfile）
+ */
+export async function applyStartupEnv({ logger, deps = {} }) {
+  const hydrate = deps.hydrate || hydrateProcessEnvFromShell
+  const getClaudeProfile = deps.getClaudeProfile || getActiveProfile
+  const getCodexProfile = deps.getCodexProfile || codexProfiles.getActiveProfile
 
-  const plugins = await loadPlugins(logger)
-  // ctx と dispatchCtx の shallow copy を跨いで共有する lifecycle 正本。
-  const lifecycle = { restartPending: false, shutdownStarted: false }
-  const ctx = { logger, config, plugins, lifecycle }
+  await hydrate({ logger })
 
-  // 起動時: 保存済み active プロファイルの CLAUDE_CONFIG_DIR を反映してから
-  // Claude SDK を初期化する。profiles.json が無ければ既定 (~/.claude) のまま。
   try {
-    const activeProfile = await getActiveProfile()
-    applyActiveProfileEnv(activeProfile, logger)
+    applyActiveProfileEnv(await getClaudeProfile(), logger)
   } catch (err) {
+    applyActiveProfileEnv(null, logger)
     logger.warn(
       { err: err.message },
       "failed to apply active claude profile; falling back to default ~/.claude",
@@ -941,22 +951,32 @@ export async function startDaemon({ version, claudeSdk } = {}) {
 
   // 同様に active Codex プロファイルの CODEX_HOME を反映する (独立切替)。
   try {
-    const activeCodex = await codexProfiles.getActiveProfile()
-    applyActiveCodexEnv(activeCodex, logger)
+    applyActiveCodexEnv(await getCodexProfile(), logger)
   } catch (err) {
+    applyActiveCodexEnv(null, logger)
     logger.warn(
       { err: err.message },
       "failed to apply active codex profile; falling back to default ~/.codex",
     )
   }
+}
 
-  // launchd / systemd 起動では .zshrc 等の対話シェル設定が読まれず、~/.claude.json の
-  // MCP 定義が参照する環境変数 (例: Authorization: Bearer ${WRI_MCP_TOKEN}) が解決
-  // できない。ユーザーのログインシェル env + dotenv 層を 1 回解決して process.env を
-  // 補完する。spawn される全 Claude query が継承し、MCP トークンを出どころ
-  // (Keychain / シェル変数 / .env) を問わず引き継げる。
-  // WHY: ナレッジ/インフラ/cockpit-mcp-reauth
-  await hydrateProcessEnvFromShell({ logger })
+export async function startDaemon({ version, claudeSdk } = {}) {
+  const logRotationTimer = startLogRotation(logger, { isDeferred: hasInheritedOutputChild })
+  startEventLoopMetrics(logger)
+  const config = await readConfig()
+  if (!config) {
+    throw new Error(
+      "~/.hub/agent.json が見つかりません。`hub-agent enroll <token>` を先に実行してください。",
+    )
+  }
+
+  const plugins = await loadPlugins(logger)
+  // ctx と dispatchCtx の shallow copy を跨いで共有する lifecycle 正本。
+  const lifecycle = { restartPending: false, shutdownStarted: false }
+  const ctx = { logger, config, plugins, lifecycle }
+
+  await applyStartupEnv({ logger })
 
   await runHookBroadcast(plugins, "onAgentStart", ctx)
 
@@ -3437,6 +3457,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 +3557,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/profiles.mjs

@@ -32,6 +32,7 @@ import path from "node:path"
 import os from "node:os"
 
 import { paths as hubPaths, ensureConfigDir } from "./config.mjs"
+import { fileSignature, keepRuntimeActive } from "./registry-cache.mjs"
 
 /** 既定 (プライマリ) プロファイルの ID。 */
 export const DEFAULT_PROFILE_ID = "default"
@@ -56,9 +57,13 @@ export function registryPath() {
 }
 
 /** モジュール内キャッシュ (頻繁に呼ばれる getActiveConfigDir のため)。
- *  setActiveProfile / 書き込み系で必ず無効化する。 */
+ *  `{ signature, registry }`。signature がファイルの現状と一致するときだけ使う
+ *  （手動編集の即時反映）。setActiveProfile / 書き込み系でも念のため無効化する。 */
 let _cache = null
 
+/** 稼働中の active（env へ反映済みのもの）。keepRuntimeActive の docstring 参照。 */
+let _runtimeActive = null
+
 /** チルダ展開 (`~` / `~/...` を home 起点に解決)。それ以外は path.resolve。 */
 function resolveDir(dir) {
   if (!dir) return defaultConfigDir()
@@ -73,13 +78,22 @@ function resolveDir(dir) {
  *
  * @returns {Promise<{activeId: string, profiles: Array<{id:string,label:string,configDir:string}>}>}
  */
-export async function loadRegistry() {
-  if (_cache) return _cache
+async function readRegistry() {
+  // ⚠️ キャッシュは「読んだ時点のファイルの状態」と組で持ち、毎回 stat して変わっていたら
+  // 読み直す。起動時に読んだ内容を使い続けると、稼働中に ~/.hub/profiles.json を手で
+  // 作成・編集しても agent を再起動するまで反映されなかった（初期登録で再起動が 2 回要った）。
+  // stat は極小ファイル 1 回分なので、頻繁に呼ばれる getActiveConfigDir でも負荷は無視できる。
+  const signature = await fileSignature(registryPath())
+  if (_cache && _cache.signature === signature) return _cache.registry
   let parsed = null
   try {
     const raw = await fs.readFile(registryPath(), "utf-8")
     parsed = JSON.parse(raw)
   } catch (err) {
+    // 手編集の途中（保存前の truncate・書きかけ）で壊れた JSON を読んだときは、直前に
+    // 正しく読めた内容を使い続ける（署名は更新しないので、次の呼び出しで読み直す）。
+    // 壊れたまま再起動した場合は、従来どおり起動時に失敗する。
+    if (err instanceof SyntaxError && _cache) return _cache.registry
     if (err.code !== "ENOENT") throw err
   }
 
@@ -112,8 +126,27 @@ export async function loadRegistry() {
     }
   }
 
-  _cache = { activeId, profiles }
-  return _cache
+  const registry = { activeId, profiles }
+  _runtimeActive = keepRuntimeActive(registry, _runtimeActive)
+  _cache = { signature, registry }
+  return registry
+}
+
+/**
+ * レジストリを読み込む（readRegistry の docstring 参照）。
+ *
+ * ⚠️ 読み込みが失敗した時点で稼働中の active がまだ決まっていなければ、既定に固定する。
+ * 起動時に失敗すると main.mjs は既定のディレクトリで env を組むので、あとでファイルが
+ * 直ったときにファイル上の activeId を「稼働中の active」と誤認しないため。stat・パース・
+ * 正規化のどこで失敗しても同じに扱う。固定済みなら（稼働後の失敗では）変えない。
+ */
+export async function loadRegistry() {
+  try {
+    return await readRegistry()
+  } catch (err) {
+    if (!_runtimeActive) _runtimeActive = makeDefaultProfile()
+    throw err
+  }
 }
 
 /** レジストリを永続化する。default は profiles[] に含めず、追加分と activeId / defaultLabel だけ保存。 */
@@ -215,6 +248,10 @@ export async function setActiveProfile(id) {
   if (!target) throw new Error(`unknown profile: ${id}`)
   reg.activeId = id
   await saveRegistry(reg)
+  // 保存と並行して読み直した結果が旧 active のままキャッシュされないよう、ここで捨てる
+  // （同期で続けて書くので、以後に完了する読み直しは新しい active を使う）。
+  _runtimeActive = { ...target }
+  _cache = null
   return target
 }
 
@@ -537,4 +574,5 @@ async function isBrokenSymlink(p) {
 /** テスト用: モジュールキャッシュを破棄する。 */
 export function _clearCache() {
   _cache = null
+  _runtimeActive = null
 }

package/src/registry-cache.mjs

@@ -0,0 +1,47 @@
+import { promises as fs } from "node:fs"
+
+/**
+ * ファイルの現在の状態を表す文字列を返す（読み込み結果をキャッシュするときの照合キー）。
+ *
+ * パス・inode・サイズ・mtime・ctime の組で、どれかが変われば別物として扱う
+ * （同じミリ秒内の同サイズ書き換えも ctime / inode で拾う。エディタの「別名保存 → rename」も
+ * inode で拾う）。ファイルが無ければ `<path>:absent`。ENOENT 以外の失敗はそのまま投げる。
+ *
+ * @param {string} p 絶対パス
+ * @returns {Promise<string>}
+ */
+export async function fileSignature(p) {
+  try {
+    const st = await fs.stat(p)
+    return `${p}:${st.ino}:${st.size}:${st.mtimeMs}:${st.ctimeMs}`
+  } catch (err) {
+    if (err.code === "ENOENT") return `${p}:absent`
+    throw err
+  }
+}
+
+/**
+ * 稼働中に使っている active プロファイルを、読み直したレジストリへ当て直す。
+ *
+ * ⚠️ active は「env（CLAUDE_CONFIG_DIR / CODEX_HOME）に反映済みのもの」をプロセスが持ち続ける。
+ * ファイルを読み直すたびに activeId や active の configDir を手編集どおりに変えると、一覧は
+ * 新しい active を表示するのに、子プロセスは起動時の env を継承して古いアカウントで動く
+ * （表示と実行が食い違う）。env の反映と既存セッションの停止は UI の切替経路（main.mjs の
+ * profile.switch / codex.profile.switch）だけが行うので、稼働中の active の変更もその経路に限る。
+ * active への手編集（activeId の変更・active の configDir 変更・active の削除）は再起動で反映される。
+ *
+ * @param {{activeId:string, profiles:Array<{id:string,label:string,configDir:string}>}} registry 読み直した結果（破壊的に更新する）
+ * @param {{id:string,label:string,configDir:string}|null} pinned 稼働中の active（初回は null）
+ * @returns {{id:string,label:string,configDir:string}} 以後保持する active
+ */
+export function keepRuntimeActive(registry, pinned) {
+  if (!pinned) {
+    const active = registry.profiles.find((p) => p.id === registry.activeId) || registry.profiles[0]
+    return { ...active }
+  }
+  const hit = registry.profiles.find((p) => p.id === pinned.id)
+  if (!hit) registry.profiles.push({ ...pinned })
+  else if (hit.configDir !== pinned.configDir) hit.configDir = pinned.configDir
+  registry.activeId = pinned.id
+  return pinned
+}

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