@cocorograph/hub-agent 0.8.89 → 0.8.91

package/package.json

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

package/src/claude-stream-bridge.mjs

@@ -203,13 +203,13 @@ const DEAD_TERMINAL_TTL_MS = readPositiveIntEnv(
  *  タイマー（7 日）だけで件数上限が無かったため、多数の cwd を渡り歩くと warm セッション（= SDK
  *  常駐 query プロセス）が N 個を超えて蓄積し得た。cwd 単位の LRU で最古 cwd から早期 reap する。
  *  env HUB_AGENT_WARM_CWD_MAX で調整可能（codex と共有）。 */
-const WARM_CWD_MAX = readPositiveIntEnv("HUB_AGENT_WARM_CWD_MAX", 20)
+export const WARM_CWD_MAX = readPositiveIntEnv("HUB_AGENT_WARM_CWD_MAX", 20)
 
 /** 1 cwd あたりの live セッション上限 K（既定 3）。旧仕様の per-cwd=1 を一般化したもの。
  *  「総量は増やさず配分の自由度だけ上げる」ため、総 live 上限 M（warm-bounds-total.mjs）と
  *  セットで効かせる。⚠️ 既存 env（HUB_AGENT_WARM_CWD_MAX = 同時 warm 保持する cwd 数 N）の
  *  意味は変えない。新しい上限は新しい env 名で足す（codex 側の WARM_PER_CWD_MAX と対）。 */
-const WARM_PER_CWD_MAX = readPositiveIntEnv("HUB_AGENT_WARM_PER_CWD_MAX", 3)
+export const WARM_PER_CWD_MAX = readPositiveIntEnv("HUB_AGENT_WARM_PER_CWD_MAX", 3)
 
 /** タスク実行中セッションを warm 境界の刈り取りから保護する際の**失効時間**（**鼓動が観測できる
  *  種別**用。既定 30 分）。「最後に生存を確認してから」の相対時間で、`task_progress` が届くたびに

package/src/dispatch-scheduler.mjs

@@ -43,7 +43,7 @@ const SLOW_DISPATCH_MS = 1000
  * 調査対象そのものなので、速かった場合も含めて毎回記録する
  * (速いことの記録が無いと「詰まっていない」を示せない)。
  */
-const ALWAYS_TIMED_TYPES = new Set(["tmux.kill_session"])
+const ALWAYS_TIMED_TYPES = new Set(["chat.session.stop"])
 
 export function isConnectionLifecycleMessage(type) {
   return LIFECYCLE_TYPES.has(type)
@@ -89,7 +89,7 @@ function globalMutationMode(type) {
 // stream レーンへ、個別停止 (cwd を持つ) が cwd レーンへ散り、直列化されないまま同時に走る。
 // scheduler へ設定も HOME も読ませず、補完後の既定 cwd を呼び出し側から mode 別に渡してもらう
 // (補完の規則は CLI 種別で違うため、mode を知らない scheduler 側では決められない)。
-function attachLaneKey(mode, msg, defaultCwd = "") {
+export function attachLaneKey(mode, msg, defaultCwd = "") {
   const cwd = (typeof msg?.cwd === "string" ? msg.cwd.trim() : "") || defaultCwd
   if (cwd) return `${mode}:cwd:${cwd}`
   const resumeId =
@@ -184,9 +184,10 @@ export class DispatchScheduler {
     const mutationMode = globalMutationMode(type)
     if (mutationMode) return `${mutationMode}:global`
 
-    // usage build は最大 25 秒かかり、同じ control lane の tmux.list_sessions が
+    // usage build は最大 25 秒かかり、同じ control lane の一覧要求 (当時は tmux.list_sessions) が
     // frontend の 10 秒打ち切りで捨てられていたため分離する (2026-09-04 本番計測)。
     if (type === "usage.request") return "usage"
+    if (type === "agent.sessions.restore") return "restore"
 
     if (type === "chat.session.stop") {
       if (msg.scope === "cwd") {
@@ -203,8 +204,7 @@ export class DispatchScheduler {
       }
       return "control"
     }
-    // chat.stop_all は全レーンに跨るため control に置く。その時点で live な会話だけを
-    // 止める契約であり、接続処理中のまだ live でない会話は対象外。sessions.request も control。
+    // chat.sessions.request は control。
     const mode = chatMode(type)
     if (!mode) return "control"
 
@@ -260,6 +260,22 @@ export class DispatchScheduler {
     })
   }
 
+  /**
+   * 指定レーンに処理を積み、結果（失敗も）を呼び出し元へ返す。
+   * ⚠️ 接続世代では破棄しない。唯一の利用者である会話復元は WS と無関係な bridge へ登録するので、
+   * 張り直しで待機中の行を黙って捨てると復元が途中で止まる（受付はプロセスあたり 1 回のため
+   * 送り直しでも戻らない）。旧世代の破棄は enqueue（WS 由来のメッセージ）だけの規則。
+   */
+  runInLane(lane, fn) {
+    const result = this._previousFor(lane).then(() => fn())
+    // 失敗した行が、後続の通常メッセージを止めないよう tail は成功で解決する。
+    const tail = result.catch(() => {}).finally(() => {
+      if (this.laneTails.get(lane) === tail) this.laneTails.delete(lane)
+    })
+    this.laneTails.set(lane, tail)
+    return result
+  }
+
   enqueue(msg) {
     const type = msg?.type
     const sequence = ++this.sequence

package/src/main.mjs

@@ -45,6 +45,7 @@ import {
 import { loadPlugins, runHookBroadcast } from "./plugin-loader.mjs"
 import { WsClient } from "./ws-client.mjs"
 import { DispatchScheduler } from "./dispatch-scheduler.mjs"
+import { noteRestoreStop, restoreSessions, sendBridgeMessage } from "./session-restore.mjs"
 import { AsyncTtlCache } from "./async-ttl-cache.mjs"
 import { ClaudeStreamBridge } from "./claude-stream-bridge.mjs"
 import { installClaudeDisplayMask } from "./claude-display-mask.mjs"
@@ -893,12 +894,12 @@ export async function startDaemon({ version, claudeSdk } = {}) {
         }
       }
       resolveChatContextPct(session, event)
-      client.send({ type: "claude.event", stream_id, session_id, 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 件採用)。
-      client.send({
+      sendBridgeMessage(client, {
         type: "claude.permission.request",
         stream_id,
         session_id,
@@ -915,7 +916,7 @@ export async function startDaemon({ version, claudeSdk } = {}) {
         // TUI 由来カードの撤去と同じ `claude.permission.cancel` 型を使う。
         for (const request_id of request_ids || []) {
           try {
-            client.send({
+            sendBridgeMessage(client, {
               type: "claude.permission.cancel",
               stream_id,
               session_id,
@@ -930,13 +931,13 @@ export async function startDaemon({ version, claudeSdk } = {}) {
       },
     )
     claudeBridge.on("exit", ({ stream_id, code, reason, session_id, cwd }) => {
-      client.send({ type: "claude.exit", stream_id, code, reason, session_id })
+      sendBridgeMessage(client, { type: "claude.exit", stream_id, code, reason, session_id })
     })
     claudeBridge.on("sessionoptions", (message) => {
-      client.send(buildClaudeSessionOptionsPayload(message))
+      sendBridgeMessage(client, buildClaudeSessionOptionsPayload(message))
     })
     claudeBridge.on("error", ({ stream_id, session_id, error }) => {
-      client.send({ type: "claude.error", stream_id, session_id, error })
+      sendBridgeMessage(client, { type: "claude.error", stream_id, session_id, error })
     })
   }
 
@@ -949,10 +950,10 @@ export async function startDaemon({ version, claudeSdk } = {}) {
       if (notification.method === "thread/tokenUsage/updated") {
         recordCodexLiveTokenUsage(producer_seq, notification.params?.tokenUsage)
       }
-      client.send({ type: "codex.event", stream_id, thread_id, event: notification })
+      sendBridgeMessage(client, { type: "codex.event", stream_id, thread_id, event: notification })
     })
     codexBridge.on("permission", ({ stream_id, thread_id, cwd, request_id, method, params }) => {
-      client.send({
+      sendBridgeMessage(client, {
         type: "codex.permission.request",
         stream_id,
         thread_id,
@@ -970,10 +971,10 @@ export async function startDaemon({ version, claudeSdk } = {}) {
       } catch {
         /* ignore */
       }
-      client.send({ type: "codex.exit", stream_id, thread_id, code, reason })
+      sendBridgeMessage(client, { type: "codex.exit", stream_id, thread_id, code, reason })
     })
     codexBridge.on("error", ({ stream_id, thread_id, error }) => {
-      client.send({ type: "codex.error", stream_id, thread_id, error })
+      sendBridgeMessage(client, { type: "codex.error", stream_id, thread_id, error })
     })
   }
 
@@ -991,6 +992,8 @@ export async function startDaemon({ version, claudeSdk } = {}) {
   // tmux/control・Claude・Codex・別 cwd を独立レーンへ分離する。
   const dispatchCtx = {
     ...ctx,
+    availableClis,
+    sessionRestoreState: { accepted: false },
     client,
     claudeBridge,
     codexBridge,
@@ -1008,6 +1011,7 @@ export async function startDaemon({ version, claudeSdk } = {}) {
     // 持たせず、解決済みの値だけを渡す。
     defaultCwd: (mode) => defaultLaneCwd(ctx.config, mode),
   })
+  dispatchCtx.dispatchScheduler = dispatchScheduler
   client.on("close", () => dispatchScheduler.advanceGeneration("ws_close"))
   client.on("open", () => dispatchScheduler.advanceGeneration("ws_open"))
   client.on("message", (msg) => dispatchScheduler.enqueue(msg))
@@ -3103,6 +3107,22 @@ export async function dispatch(msg, ctx) {
   const t = msg?.type || ""
   try {
     switch (t) {
+      case "agent.sessions.restore": {
+        const scheduler = ctx.dispatchScheduler
+        ctx.sessionRestoreState ??= { accepted: false }
+        await restoreSessions(msg, {
+          state: ctx.sessionRestoreState,
+          // 世代は行ごとに現在値を使う (張り直し後も新しい tail と直列化する)。
+          runInLane: scheduler && ((lane, fn) => scheduler.runInLane(lane, fn)),
+          claudeBridge: ctx.claudeBridge,
+          codexBridge: ctx.codexBridge,
+          available: (kind) => kind === "codex"
+            ? codexAvailableForDispatch(ctx)
+            : ctx.availableClis?.includes("claude") === true,
+          logger: ctx.logger,
+        })
+        return
+      }
       case "ready":
         ctx.logger.info({ msg }, "hub ready")
         await maybeSyncClaudeSettings(msg, ctx)
@@ -4364,14 +4384,18 @@ export async function dispatch(msg, ctx) {
       }
       case "chat.session.stop": {
         const result = { type: "chat.session.stop.result", request_id: msg.request_id, stopped: 0 }
+        // 復元中の未処理行を取り消す記録は、入力検証を通った停止だけに付ける（エラーを返す要求に
+        // 副作用を残さない）。停止件数 0 でも記録する（未登録の復元行を止めるため）。
         try {
           if (msg.scope === "cwd") {
             const cwd = typeof msg.cwd === "string" ? msg.cwd : ""
             if (msg.cli_kind !== "claude" && msg.cli_kind !== "codex") result.error = "unsupported cli_kind"
             else if (!cwd || !path.isAbsolute(cwd)) result.error = "cwd required"
             else if (msg.cli_kind === "claude") {
+              noteRestoreStop(ctx.sessionRestoreState, "claude", cwd)
               result.stopped = await ctx.claudeBridge.stopSessionsFor({ cwd, reason: "chat-stop" })
             } else {
+              noteRestoreStop(ctx.sessionRestoreState, "codex", cwd)
               result.stopped = await ctx.codexBridge.stopSessionsForCwd({ cwd, reason: "chat-stop" })
             }
             ctx.client.send(result)
@@ -4384,11 +4408,18 @@ export async function dispatch(msg, ctx) {
             else if (!/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(session_id)) {
               result.error = "invalid session_id"
             } else {
+              noteRestoreStop(ctx.sessionRestoreState, "claude", cwd)
               result.stopped = await ctx.claudeBridge.stopSessionForDeletion({ cwd, session_id, reason: "chat-stop" })
             }
           } else if (msg.cli_kind === "codex") {
             if (typeof msg.stream_id !== "string" || !msg.stream_id) result.error = "stream_id required"
-            else result.stopped = await ctx.codexBridge.stopSessionForStream({ stream_id: msg.stream_id, reason: "chat-stop" })
+            else {
+              // stream 停止は cwd を持たないので、停止対象の会話の cwd で記録する（無ければ記録しない:
+              // 存在しない stream の停止は未登録の復元行を指せない）。
+              const streamCwd = ctx.codexBridge.sessions?.get?.(msg.stream_id)?.cwd
+              if (streamCwd) noteRestoreStop(ctx.sessionRestoreState, "codex", streamCwd)
+              result.stopped = await ctx.codexBridge.stopSessionForStream({ stream_id: msg.stream_id, reason: "chat-stop" })
+            }
           } else {
             result.error = "unsupported cli_kind"
           }
@@ -4398,43 +4429,6 @@ export async function dispatch(msg, ctx) {
         ctx.client.send(result)
         return
       }
-      case "chat.stop_all": {
-        // exit に載る停止理由。bridge 側の既定 ("tui-bind-stop" / "explicit-stop") は
-        // それぞれ TUI 切替・個別停止の名前なので、全停止はここで明示して区別する。
-        const STOP_ALL_REASON = "chat-stop-all"
-        const result = { type: "chat.stop_all.result", request_id: msg.request_id, stopped: 0, failed: [] }
-        try {
-          const live = describeLiveSessionsUnion({ claudeBridge: ctx.claudeBridge, codexBridge: ctx.codexBridge })
-          const claudeCwds = new Set()
-          const codexStreams = new Set()
-          for (const session of live) {
-            let target
-            try {
-              if (session.kind === "claude") {
-                const cwd = session.cwd
-                if (claudeCwds.has(cwd)) continue
-                claudeCwds.add(cwd)
-                // ⚠️ reason を省くと stopSessionsFor の既定 "tui-bind-stop" が exit に載り、
-                // 画面から止めた会話が「tmux へ切り替えたせい」で消えたように見える。
-                target = { cwd, reason: STOP_ALL_REASON }
-                result.stopped += await ctx.claudeBridge.stopSessionsFor(target)
-              } else if (session.kind === "codex") {
-                const stream_id = session.stream_id
-                if (codexStreams.has(stream_id)) continue
-                codexStreams.add(stream_id)
-                target = { stream_id, reason: STOP_ALL_REASON }
-                result.stopped += await ctx.codexBridge.stopSessionForStream(target)
-              }
-            } catch (err) {
-              result.failed.push({ ...target, reason: err?.message || String(err) })
-            }
-          }
-        } catch (err) {
-          result.error = err?.message || String(err)
-        }
-        ctx.client.send(result)
-        return
-      }
       case "chat.sessions.request": {
         try {
           const snapshot = await buildChatSessionsSnapshot({

package/src/session-restore.mjs

@@ -0,0 +1,130 @@
+import { randomUUID } from "node:crypto"
+import { stat } from "node:fs/promises"
+import path from "node:path"
+import { chatRowSessionName } from "./chat-sessions-snapshot.mjs"
+import { WARM_CWD_MAX, WARM_PER_CWD_MAX } from "./claude-stream-bridge.mjs"
+import { WARM_TOTAL_MAX } from "./warm-bounds-total.mjs"
+import { describeLiveSessionsUnion } from "./live-sessions.mjs"
+import { attachLaneKey } from "./dispatch-scheduler.mjs"
+
+/** 復元専用の購読は browser に存在しない。detach 後の遅延イベントも送信しない。 */
+export function sendBridgeMessage(client, message) {
+  if (message.stream_id?.startsWith("restore:")) return
+  return client.send(message)
+}
+
+/**
+ * 復元中に届いた明示停止 (chat.session.stop) を記録する。未処理の復元行のうち、停止された
+ * cwd (cwd が無い停止は CLI 全体) の行を登録しないため。復元中以外は何もしない
+ * (停止記録は古い名簿にだけ効き、以後の通常 attach を妨げない)。
+ */
+export function noteRestoreStop(state, cliKind, cwd) {
+  if (!state?.stopped) return
+  state.stopped.add(`${cliKind}:${typeof cwd === "string" && cwd ? cwd : "*"}`)
+}
+
+/**
+ * state は接続ではなく agent の寿命に属する。最初の呼び出しで同期的に消費する。
+ * ⚠️ WS の張り直しでは中断しない。登録先の bridge は接続と無関係に生きているため、中断すると
+ * 受付状態と Hub の「接続ごとに 1 回」の送信がかみ合わず、復元が途中で止まる (2 巡目 blocker)。
+ */
+export async function restoreSessions(message, {
+  state, claudeBridge, codexBridge, available, logger,
+  runInLane = (_lane, fn) => fn(), statCwd = stat,
+}) {
+  if (state.accepted) {
+    logger?.info?.({}, "agent.sessions.restore ignored: already accepted")
+    return
+  }
+  state.accepted = true
+  const bridges = { claude: claudeBridge, codex: codexBridge }
+  const logSkip = (row, reason) => logger?.info?.({
+    cli_kind: row?.cli_kind, cwd: row?.cwd, session_id: row?.session_id, reason,
+  }, "agent.sessions.restore skipped")
+  if (!Array.isArray(message.sessions)) {
+    logSkip(null, "sessions must be an array")
+    return
+  }
+  const snapshot = () => describeLiveSessionsUnion({ claudeBridge, codexBridge }).map((s) => ({
+    cli_kind: s.kind, cwd: s.cwd, session_id: s.session_id || s.thread_id,
+  }))
+  const same = (a, b) => a.cli_kind === b.cli_kind && a.cwd === b.cwd && a.session_id === b.session_id
+  const fits = (row, live) => {
+    const bridge = bridges[row.cli_kind]
+    const cwdMax = row.cli_kind === "claude" ? WARM_CWD_MAX : bridge._warmCwdMax
+    const perCwdMax = row.cli_kind === "claude" ? WARM_PER_CWD_MAX : bridge._warmPerCwdMax
+    const own = live.filter((s) => s.cli_kind === row.cli_kind)
+    return live.length < WARM_TOTAL_MAX &&
+      own.filter((s) => s.cwd === row.cwd).length < perCwdMax &&
+      new Set([...own.map((s) => s.cwd), row.cwd]).size <= cwdMax
+  }
+  state.stopped = new Set()
+  const stoppedFor = (row) =>
+    state.stopped.has(`${row.cli_kind}:${row.cwd}`) || state.stopped.has(`${row.cli_kind}:*`)
+  const selected = []
+  const cwdStats = new Map()
+  try {
+    for (const row of message.sessions) {
+      const current = snapshot()
+      // 選別後に通常 attach で live になった行を二重に数えない。
+      const live = [...current, ...selected.filter((r) => !current.some((s) => same(s, r)))]
+      if (live.length >= WARM_TOTAL_MAX) break
+      try {
+        if (!row || !["claude", "codex"].includes(row.cli_kind)) throw new Error("unknown CLI")
+        if (!bridges[row.cli_kind] || !available(row.cli_kind)) throw new Error("CLI unavailable")
+        if (typeof row.session_id !== "string" || !row.session_id.trim()) throw new Error("empty session_id")
+        if (typeof row.cwd !== "string" || !path.isAbsolute(row.cwd)) throw new Error("cwd must be absolute")
+        if (row.session_name !== chatRowSessionName(row.cwd, row.cli_kind)) throw new Error("session_name mismatch")
+        if (live.some((s) => same(s, row))) continue
+        if (!fits(row, live)) { logSkip(row, "live limit"); continue }
+        if (!cwdStats.has(row.cwd)) cwdStats.set(row.cwd, Promise.resolve().then(() => statCwd(row.cwd)))
+        if (!(await cwdStats.get(row.cwd)).isDirectory()) throw new Error("cwd is not a directory")
+        selected.push(row)
+      } catch (err) {
+        logSkip(row, err.message)
+      }
+    }
+    // 名簿は新しい順。生成順・活動時刻を既存の回収規則に合わせる。
+    for (const row of selected.reverse()) {
+      await runInLane(attachLaneKey(row.cli_kind, row), async () => {
+        // 復元待ちの間に利用者が止めた会話を、後から復活させない。
+        if (stoppedFor(row)) { logSkip(row, "stopped during restore"); return }
+        // 待機中に worktree 削除が完了していることがある（削除中ガードは完了で解除される）。
+        // キャッシュを使わず取り直す。⚠️ この確認は live 再確認より前に置き、再確認から attach までの
+        // 間に await を挟まない（chat-session-starter.mjs と同じ順序。間に待ちがあると二重に作る）。
+        try {
+          if (!(await statCwd(row.cwd)).isDirectory()) throw new Error("not a directory")
+        } catch {
+          logSkip(row, "cwd missing at restore")
+          return
+        }
+        if (stoppedFor(row)) { logSkip(row, "stopped during restore"); return }
+        const bridge = bridges[row.cli_kind]
+        const live = snapshot()
+        if (live.some((s) => same(s, row))) return
+        if (!fits(row, live)) { logSkip(row, "live limit changed"); return }
+        const stream_id = `restore:${randomUUID()}`
+        try {
+          await bridge.attach({
+            stream_id, cwd: row.cwd,
+            ...(row.cli_kind === "claude"
+              ? { resumeSessionId: row.session_id }
+              : { resumeThreadId: row.session_id }),
+          })
+          logger?.info?.({ cli_kind: row.cli_kind, cwd: row.cwd, session_id: row.session_id },
+            "agent.sessions.restore registered")
+        } catch (err) {
+          logSkip(row, err.message)
+        } finally {
+          try {
+            bridge.detach({ stream_id })
+          } catch (err) {
+            logSkip(row, `detach failed: ${err.message}`)
+          }
+        }
+      })
+    }
+  } finally {
+    state.stopped = null
+  }
+}