@cocorograph/hub-agent 0.8.107 → 0.8.109

package/package.json

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

package/src/claude-stream-bridge.mjs

@@ -66,10 +66,13 @@ function siblingEnvFor(cwd) {
 }
 
 /** browser 切断後、セッションを生かしたまま再接続を待つ idle TTL (ミリ秒)。これを過ぎ、
- *  かつ走行中でなければ撤去する。端末スリープ/長期離席後の再接続も吸収できるよう 7 日に
- *  設定 (放置セッションのメモリ蓄積は idle 時のみで小さい)。走行中ターンは TTL を過ぎても
- *  完走するまで絶対に撤去しない。明示終了 / 新規セッションでは即時撤去される。 */
-const IDLE_DETACH_TTL_MS = 7 * 24 * 60 * 60 * 1000
+ *  かつ実作業が無ければ撤去する。2026-10-06 の実測では使用済み chrome-devtools-mcp が
+ *  1 本 0.7〜2.5GB を保持し続け、swap は 26GB に達した。idle 中もメモリが小さいとは
+ *  限らないため、再接続の猶予を 3 時間に抑える。実作業中は TTL 後も再チェックする。 */
+export const IDLE_DETACH_TTL_MS = readPositiveIntEnv("HUB_AGENT_CLAUDE_IDLE_DETACH_TTL_MS", 3 * 60 * 60 * 1000)
+
+/** 無操作かつ実作業無しが 6 時間続いたら、セッションを残して常駐 query だけ畳む。 */
+export const IDLE_ATTACHED_TTL_MS = readPositiveIntEnv("HUB_AGENT_CLAUDE_IDLE_ATTACHED_TTL_MS", 6 * 60 * 60 * 1000)
 
 /** 改修2: チャット常駐query化のフラグ。env HUB_AGENT_CHAT_RESIDENT="0" で無効化し
  *  従来の「1メッセージ=1query」へ即ロールバックできる。デフォルト有効。 */
@@ -201,7 +204,7 @@ const DEAD_TERMINAL_TTL_MS = readPositiveIntEnv(
 
 /** 子⑤ (T06544): warm 保持を「各 cwd K 本 × 同時 warm 保持する cwd 数 N（既定 20）」で有界化する
  *  上限（codex-stream-bridge.mjs の WARM_CWD_MAX と対）。claude は従来 per-session の softDetach
- *  タイマー（7 日）だけで件数上限が無かったため、多数の cwd を渡り歩くと warm セッション（= SDK
+ *  タイマーだけで件数上限が無かったため、多数の cwd を渡り歩くと warm セッション（= SDK
  *  常駐 query プロセス）が N 個を超えて蓄積し得た。cwd 単位の LRU で最古 cwd から早期 reap する。
  *  env HUB_AGENT_WARM_CWD_MAX で調整可能（codex と共有）。 */
 export const WARM_CWD_MAX = readPositiveIntEnv("HUB_AGENT_WARM_CWD_MAX", 20)
@@ -483,6 +486,8 @@ export class ClaudeStreamSession {
      *  recency を失う。これは touch() で更新し detach でリセットしないので、warm 化しても「最後に
      *  使った時刻」が残り、最古 cwd から LRU reap できる。 */
     this._lastActivityMs = Date.now()
+    // 長いターンの終了直後に、入力時刻だけを見て idle 撤去しないための終了時刻。
+    this._lastTurnSettledMs = 0
     /** 子⑤ round5 Finding 1: 生成順の単調増加シーケンス（warm 境界のタイブレーク用。値が大きい =
      *  新しい）。recency 同値時に per-cwd=K が新しいセッションを残せるようにする。
      *  ⚠️ カウンタは **claude / codex 共通**（session-seq.mjs）。総 live 上限 M は両 CLI を合算して
@@ -702,6 +707,8 @@ export class ClaudeStreamSession {
      *  close()/shutdown() で子プロセスが残留する。per-message と同じく AbortController を
      *  options へ渡し、interrupt が reject したときと close() のときに最終手段として abort する。 */
     this._residentAbortController = null
+    this._foldedIdle = false
+    this._idleFoldAbortController = null
 
     /** jsonl ライブ追従 watcher (0.6.5)。外部 (tmux 等) の追記を拾う。 */
     this._watcher = null
@@ -1338,26 +1345,33 @@ export class ClaudeStreamSession {
   softDetach(ttlMs, onTimeout) {
     this._detached = true
     if (this._idleTimer) clearTimeout(this._idleTimer)
+    const detachedAt = Date.now()
+    const schedule = (remaining) => {
+      // Node.js のタイマー上限を超える TTL も、期限まで分割して待つ。
+      this._idleTimer = setTimeout(tick, Math.min(remaining, 2147483647))
+      this._idleTimer.unref?.()
+    }
     const tick = () => {
       // 再アタッチ済みなら撤去しない (reattach が _detached=false にする)
-      if (!this._detached) {
+      if (!this._detached || this._closed) {
         this._idleTimer = null
         return
       }
-      // 走行中ターンは完走を待ち TTL 後に再チェック (走行中は絶対に撤去しない)
-      if (this._busy) {
-        this._idleTimer = setTimeout(tick, ttlMs)
-        // idle TTL は最大 7 日。タイマー単独でイベントループを生かさない (unref)。
-        // 本番デーモンは WS 接続等で常駐するので reap は問題なく発火し、テスト/CLI
-        // など他に handle が無いプロセスは即座に終了できる。
-        this._idleTimer.unref?.()
+      const now = Date.now()
+      const remaining = Math.max(detachedAt, this._lastTurnSettledMs) + ttlMs - now
+      if (remaining > 0) {
+        schedule(remaining)
+        return
+      }
+      // 実作業中は再チェックするが、detach / ターン終了由来の期限自体は延ばさない。
+      if (this._busy || this._pendingMessages.length > 0 || this._hasLiveTask?.(now)) {
+        schedule(ttlMs)
         return
       }
       this._idleTimer = null
       onTimeout?.()
     }
-    this._idleTimer = setTimeout(tick, ttlMs)
-    this._idleTimer.unref?.()
+    schedule(ttlMs)
   }
 
   /**
@@ -1420,7 +1434,8 @@ export class ClaudeStreamSession {
       // pending へ退避し、現ターンの result 後に 1 件ずつ drain する。前ターン未完了のまま
       // 次を push すると SDK streaming-input で割り込み扱いになり得るため (公式 interrupt 警告)。
       // pending は queue_state で UI (送信待ちチップ) に出す (per-message と同じ体験)。
-      if (this._busy) {
+      if (this._busy || (this._foldedIdle && this._residentQuery)) {
+        // fold の abort が完了するまでの入力は finally の既存 resume/drain 経路へ渡す。
         this._enqueuePending(prompt, ultracode, inputId)
         this.logger?.info(
           { stream_id: this.stream_id, queued: this._pendingMessages.length },
@@ -1629,6 +1644,7 @@ export class ClaudeStreamSession {
           /* ignore */
         }
       }
+      this._lastTurnSettledMs = Date.now()
       this._busy = false
       if (aborted) {
         this.logger?.info({ stream_id: this.stream_id }, "claude turn aborted")
@@ -2157,6 +2173,7 @@ export class ClaudeStreamSession {
     // 中断直後の 1 ターンだけを帰属不明として扱い、それが確定したら次からは信頼に戻す。
     if (this._lastTurnTexts?.startedUncertain) this._turnTextsUncertain = false
     denyPending?.("turn ended")
+    this._lastTurnSettledMs = Date.now()
     this._busy = false
     // result の後に同一ターンの idle が遅れて届く場合がある。pending drain は同期的に
     // 次ターンの busy を立てるため、その idle を新ターンへ誤帰属させないよう先にガードする。
@@ -2180,6 +2197,9 @@ export class ClaudeStreamSession {
    *  (await するため async 化。idle ハンドラからは fire-and-forget で呼ばれる)。 */
   async _drainResidentPending() {
     if (this._closed) return
+    // fold 中の旧 query には渡さず、終了時の finally が resume して pending を拾う。
+    // 通常の interrupt 後の drain は従来どおり進める。
+    if (this._foldedIdle && this._residentQuery) return
     if (this._pendingMessages.length === 0) {
       // 症状1 自己修復 (2026-07-21): _drainPending と同旨。落ちた drain broadcast で送信待ち
       // チップが stale 残留するのを、ターン settle 毎の force 再表明で補正する (空 = count=0)。
@@ -2210,6 +2230,7 @@ export class ClaudeStreamSession {
         this._emitQueueState([next.text], { startedIds: [next.id] })
       else this._emitQueueState([], { force: true })
     } catch (err) {
+      this._lastTurnSettledMs = Date.now()
       this._busy = false
       this._pendingMessages.unshift(next)
       this.logger?.warn(
@@ -2286,6 +2307,7 @@ export class ClaudeStreamSession {
     try {
       const q = this.sdk.query({ prompt: this._inputQueue, options })
       this._residentQuery = q
+      this._foldedIdle = false
       for await (const msg of q) {
         let suppressEmit = false
         this._observeTurnTexts(msg)
@@ -2369,7 +2391,14 @@ export class ClaudeStreamSession {
         }
       }
     } catch (err) {
-      if (!this._closed) {
+      // run 固有の controller と照合する。fold フラグだけでは、再開後のエラーや
+      // abort と同時に起きた無関係なエラーまで握り潰してしまう。
+      const idleFoldAbort = this._idleFoldAbortController === myAbort && myAbort.signal.aborted && (
+        err?.name === "AbortError" || err?.code === "ABORT_ERR" ||
+        // SDK の abort 終了エラーは Error 派生で name が AbortError とは限らない。
+        err?.message === "Claude Code process aborted by user" || err?.message === "Operation aborted"
+      )
+      if (!this._closed && !idleFoldAbort) {
         try {
           this.onError?.(err)
         } catch {
@@ -2383,6 +2412,7 @@ export class ClaudeStreamSession {
       // generator になっていたことを検知できるようにするため。
       this._residentQueryReturned = true
       this._residentQuery = null
+      if (this._busy) this._lastTurnSettledMs = Date.now()
       this._busy = false
       denyPending("closed")
       // 常駐 query の終了。detached 後にここへ来たら reap する。
@@ -2503,6 +2533,7 @@ export class ClaudeStreamSession {
       //  いたが、中断ターンの in-flight イベントが _turnProgressed を立ててしまうため成立して
       //  いなかった)。
       this._turnSettled = true
+      if (this._busy) this._lastTurnSettledMs = Date.now()
       this._busy = false
       this._armStaleIdleGuard()
       // 孤児カード防止 (2026-07-10 監査): 中断したターンに紐づく未応答 permission は
@@ -2586,9 +2617,25 @@ export class ClaudeStreamSession {
     }
   }
 
+  /** idle の常駐プロセスだけを畳み、再接続と次入力用にセッションを保持する。 */
+  foldIdleResident() {
+    if (this._closed || !this._residentQuery || this._foldedIdle) return false
+    this._foldedIdle = true
+    // 既に別の理由で abort された run を idle fold のものとして扱わない。
+    if (!this._residentAbortController?.signal.aborted) {
+      this._idleFoldAbortController = this._residentAbortController
+    }
+    this._hardAbortResident()
+    this.logger?.info(
+      { stream_id: this.stream_id, session_id: this.sessionId, cwd: this.cwd, reason: "inactive" },
+      "claude idle resident query folded",
+    )
+    return true
+  }
+
   /** SDK-P0-4 (2026-07-13): 常駐 query の最終手段の強制終了。interrupt() (control request) が
-   *  失敗・無応答のときと close() から呼ぶ。AbortController を落とすと generator が終了し、
-   *  _runResidentQuery の finally が pending を resume 付きで再起動して取りこぼしを防ぐ。 */
+   *  失敗・無応答のときと close() / idle fold から呼ぶ。AbortController を落とすと generator が
+   *  終了し、finally が pending を resume 付きで再起動して取りこぼしを防ぐ。 */
   _hardAbortResident() {
     const ac = this._residentAbortController
     if (!ac || ac.signal?.aborted) return
@@ -2632,6 +2679,8 @@ export class ClaudeStreamSession {
    *  idle セッション (_residentQueryReturned=false) は生存中なので reattach 可。 */
   _isReattachable() {
     if (this._closed) return false
+    // 意図的に畳んだ常駐 query は、同じセッションで次入力から再開できる。
+    if (this._foldedIdle) return true
     if (this._residentQueryReturned && !this._residentQuery) return false
     return true
   }
@@ -2803,7 +2852,7 @@ export class ClaudeStreamBridge extends EventEmitter {
    *
    * TUI モードに切り替えた session は tmux ペインの対話 claude が write を担うため、
    * SDK セッションを生かしたままだと同一 cwd の jsonl を二重ホストして競合する
-   * (DESIGN.md C7)。soft-detach (7 日 resident) では止まらないので、ここで明示 close する。
+   * (DESIGN.md C7)。soft-detach (既定 3 時間 resident) では止まらないので、ここで明示 close する。
    *
    * ⚠️ `reason` は exit イベントにそのまま載る。既定の `tui-bind-stop` は上記 TUI bind 用の
    * 名前なので、**TUI 以外の理由で止めるときは必ず渡す**こと (既定のままだと、存在しない
@@ -4202,6 +4251,18 @@ export class ClaudeStreamBridge extends EventEmitter {
     return !!session._hasLiveTask?.(now)
   }
 
+  /** 購読数に関係なく、実作業が無く無操作 TTL を過ぎた常駐 query だけを畳む。 */
+  foldInactiveSessions(ttlMs = IDLE_ATTACHED_TTL_MS, now = Date.now()) {
+    let folded = 0
+    for (const { session } of this._liveCandidatesForCwd()) {
+      if (!session._residentQuery || this._hasSessionWork(session, now)) continue
+      const lastActive = Math.max(session._lastActivityMs ?? 0, session._lastTurnSettledMs ?? 0)
+      if (now - lastActive < ttlMs) continue
+      if (session.foldIdleResident()) folded += 1
+    }
+    return folded
+  }
+
   /**
    * daemon の deferred restart が待つべき実作業があるか。
    * 多端末 subscribe は warm 保持には必要だが作業ではないため、ここでは数えない。

package/src/hub-bundle.mjs

@@ -322,18 +322,50 @@ function _postInstallArgv(cmd, win) {
   return null
 }
 
+// stdout/stderr を継承した子プロセスの数。agent.log の回転はこの子の追記を保護できないため、
+// 0 でない間は回転を延期する (log-rotation.mjs)。
+let inheritedOutputChildren = 0
+
+export function hasInheritedOutputChild() {
+  return inheritedOutputChildren > 0
+}
+
 function runOnce(argv, { logger } = {}) {
   return new Promise((resolve, reject) => {
     const [bin, ...args] = argv
-    const child = spawn(bin, args, { stdio: "inherit" })
+    inheritedOutputChildren++
+    let released = false
+    const release = () => {
+      if (released) return
+      released = true
+      inheritedOutputChildren--
+    }
+    let child
+    try {
+      child = spawn(bin, args, { stdio: "inherit" })
+    } catch (err) {
+      release()
+      throw err
+    }
+    // spawn 失敗 (ENOENT 等) は exit が来ないことがある。error でも必ず settle させ、
+    // bundle 同期を未完了のまま残さない (resolve/reject は最初の 1 回だけ有効)。
+    // 診断ログは settle の後に出し、ログ書き込みの失敗 (ENOSPC 等) が settle を妨げないようにする。
+    const safeLog = (level, fields, message) => {
+      try { logger?.[level]?.(fields, message) } catch {}
+    }
+    child.once("error", (err) => {
+      release()
+      reject(err)
+      safeLog("warn", { cmd: argv.join(" "), error: err.message }, "hub-bundle post_install failed")
+    })
     child.on("exit", (code) => {
+      release()
       if (code === 0) {
-        logger?.info({ cmd: argv.join(" ") }, "hub-bundle post_install ok")
         resolve(code)
+        safeLog("info", { cmd: argv.join(" ") }, "hub-bundle post_install ok")
       } else {
-        const err = new Error(`post_install command failed (exit ${code}): ${argv.join(" ")}`)
-        logger?.warn({ cmd: argv.join(" "), code }, "hub-bundle post_install failed")
-        reject(err)
+        reject(new Error(`post_install command failed (exit ${code}): ${argv.join(" ")}`))
+        safeLog("warn", { cmd: argv.join(" "), code }, "hub-bundle post_install failed")
       }
     })
   })

package/src/log-rotation.mjs

@@ -0,0 +1,150 @@
+import { randomBytes } from "node:crypto"
+import { closeSync, fstatSync, ftruncateSync, openSync, readdirSync, readSync, renameSync, statSync, unlinkSync, writeSync } from "node:fs"
+import os from "node:os"
+import path from "node:path"
+
+export const DEFAULT_LOG_MAX_BYTES = 50 * 1024 * 1024
+export const LOG_CHECK_INTERVAL_MS = 10 * 60 * 1000
+// 回転は同期 I/O で常駐処理を止めるため、設定値で無制限に大きくさせない。
+export const MAX_LOG_MAX_BYTES = 512 * 1024 * 1024
+
+export function resolveLogMaxBytes(value = process.env.HUB_AGENT_LOG_MAX_BYTES) {
+  if (typeof value !== "string" || !/^\d+$/.test(value)) return DEFAULT_LOG_MAX_BYTES
+  const bytes = Number(value)
+  if (!Number.isSafeInteger(bytes) || bytes <= 0) return DEFAULT_LOG_MAX_BYTES
+  return Math.min(bytes, MAX_LOG_MAX_BYTES)
+}
+
+function sameFile(a, b) {
+  return a.dev === b.dev && a.ino === b.ino
+}
+
+// 削除判断に使うので、確実に居ないと分かる ESRCH のときだけ死亡扱いにする
+// (hub-bundle.mjs の _pidAlive はロック回収用で、EPERM 以外を死亡扱いにする別契約)。
+function processAlive(pid) {
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch (err) {
+    return err?.code !== "ESRCH"
+  }
+}
+
+/** 異常終了で残った一時ファイルを、作成したプロセスが既に居ない場合だけ消す。 */
+function removeStaleTemps(dir, prefix) {
+  for (const name of readdirSync(dir)) {
+    if (!name.startsWith(prefix)) continue
+    const pid = Number(name.slice(prefix.length).split("-")[0])
+    if (!Number.isSafeInteger(pid) || pid <= 0 || pid === process.pid || processAlive(pid)) continue
+    try { unlinkSync(path.join(dir, name)) } catch {}
+  }
+}
+
+/**
+ * logrotate の copytruncate と同じ方式。fd は launchd が開いたまま使うため rename はしない。
+ * 前提: この fd へ書く writer は同期 write だけ (main.mjs の pino は sync destination)。
+ * 同期区間の中でサイズ取得・コピー・truncate を行うので、同じプロセスの write とは競合しない。
+ * stdout を継承した子プロセスが動いている間は isDeferred で延期する。
+ */
+export function rotateLogIfNeeded(logger, {
+  fd = 1,
+  home = os.homedir(),
+  maxBytes = resolveLogMaxBytes(),
+  isDeferred = () => false,
+} = {}) {
+  try {
+    if (isDeferred()) return false
+    const before = fstatSync(fd)
+    if (!before.isFile()) return false
+    const logPath = path.join(home, ".hub", "agent.log")
+    let target
+    try {
+      target = statSync(logPath)
+    } catch (err) {
+      if (err.code === "ENOENT") return false
+      throw err
+    }
+    if (!sameFile(before, target) || before.size <= maxBytes) return false
+
+    const source = openSync(logPath, "r")
+    try {
+      if (!sameFile(before, fstatSync(source))) return false
+      // 上限値に比例してメモリを確保せず、末尾だけを小さな塊でコピーする。
+      const buffer = Buffer.alloc(64 * 1024)
+      let position = before.size - maxBytes
+      if (readSync(source, buffer, 0, 1, position - 1) !== 1) {
+        throw new Error("log changed before rotation")
+      }
+      let atLineStart = buffer[0] === 10
+      // 旧 .1 はコピー完了まで壊さない。一時ファイルを排他作成して rename で置き換える
+      // (unlink はリンク自体を消すだけで参照先を辿らない。wx は既存のリンクや FIFO を開かない)。
+      const backupPath = `${logPath}.1`
+      const tempPrefix = `${path.basename(backupPath)}.tmp-`
+      removeStaleTemps(path.dirname(logPath), tempPrefix)
+      const tempPath = path.join(
+        path.dirname(logPath),
+        `${tempPrefix}${process.pid}-${randomBytes(6).toString("hex")}`,
+      )
+      const backup = openSync(tempPath, "wx", 0o600)
+      let completed = false
+      let closeError = null
+      try {
+        while (position < before.size) {
+          const length = readSync(source, buffer, 0, Math.min(buffer.length, before.size - position), position)
+          if (length === 0) throw new Error("log changed during rotation")
+          position += length
+          let offset = 0
+          if (!atLineStart) {
+            const newline = buffer.subarray(0, length).indexOf(10)
+            if (newline === -1) continue
+            offset = newline + 1
+            atLineStart = true
+          }
+          while (offset < length) {
+            const written = writeSync(backup, buffer, offset, length - offset)
+            if (written === 0) throw new Error("log backup write made no progress")
+            offset += written
+          }
+        }
+        completed = true
+      } finally {
+        // close が失敗しても未確定の一時ファイルは消す (稼働中は残骸回収の対象外になるため)。
+        try {
+          closeSync(backup)
+        } catch (err) {
+          if (completed) {
+            completed = false
+            closeError = err
+          }
+        }
+        if (!completed) {
+          try { unlinkSync(tempPath) } catch {}
+        }
+      }
+      if (closeError) throw closeError
+      try {
+        renameSync(tempPath, backupPath)
+      } catch (err) {
+        try { unlinkSync(tempPath) } catch {}
+        throw err
+      }
+    } finally {
+      closeSync(source)
+    }
+    ftruncateSync(fd, 0)
+    logger?.info?.({ previousBytes: before.size, maxBytes }, "agent log rotated")
+    return true
+  } catch (err) {
+    // ログ出力自体の失敗も agent を停止させない。
+    try { logger?.warn?.({ error: err.message }, "agent log rotation failed") } catch {}
+    return false
+  }
+}
+
+export function startLogRotation(logger, { schedule = setInterval, ...options } = {}) {
+  const check = () => rotateLogIfNeeded(logger, options)
+  check()
+  const timer = schedule(check, LOG_CHECK_INTERVAL_MS)
+  timer.unref()
+  return timer
+}

package/src/main.mjs

@@ -1,6 +1,7 @@
 import { performance } from "node:perf_hooks"
 import { createHash } from "node:crypto"
 import { logPhaseTiming, startEventLoopMetrics } from "./startup-metrics.mjs"
+import { startLogRotation } from "./log-rotation.mjs"
 /**
  * hub-agent daemon 本体。
  *
@@ -37,6 +38,7 @@ import {
 import {
   codexTerminalSkipVersion,
   compareBundleVersions,
+  hasInheritedOutputChild,
   readCliBundleVersionSync,
   readCliInstalledVersionSync,
   readCodexApprovalStatusSync,
@@ -150,7 +152,10 @@ export function codexAvailableForDispatch(ctx) {
   return (ctx?._resolveCodexBinary || resolveCodexBinary)().available
 }
 
-const logger = pino({ name: "hub-agent" })
+// 同期書き込みにする。既定の非同期 destination は投入済み write の完了を待つ手段が無く
+// (minLength 0 の flush は即時 callback)、agent.log の copy+truncate 回転の間に完了した
+// write が消えるため。
+const logger = pino({ name: "hub-agent" }, pino.destination({ dest: 1, sync: true }))
 
 
 const BUNDLE_MANIFEST_PATH =
@@ -908,6 +913,7 @@ 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) {
@@ -1190,6 +1196,7 @@ export async function startDaemon({ version, claudeSdk } = {}) {
     client.stop()
     // 0.6.2 fix: watchdog を解放して event loop を抜けられるようにする
     clearInterval(keepaliveTimer)
+    clearInterval(logRotationTimer)
     process.exit(0)
   }
   restartCoordinator = new DeferredRestartCoordinator({
@@ -2152,10 +2159,15 @@ export function startStateLoop({ client, logger, intervalMs, claudeBridge, codex
       } catch (err) {
         logger?.warn({ err: err?.message }, "gcDeadTerminals failed")
       }
+      try {
+        claudeBridge?.foldInactiveSessions?.()
+      } catch (err) {
+        logger?.warn({ err: err?.message }, "claude foldInactiveSessions failed")
+      }
       // 子⑤ (T06544): claude 側 warm 境界（per-cwd=K / N-cwd LRU）。K は現行の既定 3
       // （**旧仕様**は per-cwd=1 で「各 cwd 1 本」だった。1 cwd で複数会話を同時に生かすため
       // 一般化し、総量は下の総 live 上限 M で押さえる）。従来 claude は per-session の softDetach
-      // タイマー（7 日）だけで件数上限が無かったため、多数の cwd を渡り歩くと warm な
+      // タイマーだけで件数上限が無かったため、多数の cwd を渡り歩くと warm な
       // SDK 常駐 query が蓄積し得た。codex の reconcileSessions と対で cwd 単位に有界化する。
       try {
         claudeBridge?.reconcileWarmBounds?.()