@cocorograph/hub-agent 0.8.52 → 0.8.53

package/package.json

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

package/src/codex-stream-bridge.mjs

@@ -1003,6 +1003,10 @@ export class CodexStreamBridge extends EventEmitter {
       historyTruncated: false,
       historyStart: 0,
       historyTotal: 0,
+      // cold resume が確定した parent cursor の基準件数と、それ以降の root live 追記数。
+      // thread/read の短縮が「先頭 compaction」か「末尾反映待ち」かを区別する。
+      historyColdBaseTotal: 0,
+      historyLiveCursorAdditions: 0,
       // reattach 表示履歴には child item も含むが cursor は parent item だけを数える。
       // historyItems/historyCursorWeights は常に同長。weight は 1=parent / 0=child で、trim 時の
       // start 前進量を決める。ready の start/total はこの cursor 専用で配列 index ではない。
@@ -1010,6 +1014,9 @@ export class CodexStreamBridge extends EventEmitter {
       historyCursorWeights: [],
       historySnapshotCache: new AsyncTtlCache({ ttlMs: this._historySnapshotCacheTtlMs }),
       historySnapshotReleaseTimer: null,
+      historySnapshotBuildSeq: 0,
+      historySnapshotReturnedBuildSeq: 0,
+      historySnapshotFreshOperations: new Set(),
       historySnapshotComparable: false,
       historyAttachInProgress: true,
       historyItemArrivedDuringAttach: false,
@@ -1178,6 +1185,8 @@ export class CodexStreamBridge extends EventEmitter {
       session.historyTruncated = historyTruncated
       session.historyStart = flat.start
       session.historyTotal = flat.total
+      session.historyColdBaseTotal = flat.total
+      session.historyLiveCursorAdditions = 0
       session.historyCursorWeights = history.map(() => 1)
       session.historyAttachInProgress = false
       session.historySnapshotComparable = session.historyItemArrivedDuringAttach !== true
@@ -1248,7 +1257,7 @@ export class CodexStreamBridge extends EventEmitter {
     } catch (err) {
       this.sessions.delete(stream_id)
       this._settleAllPendingApprovals(session, { respond: false })
-      this._disposeHistorySnapshot(session)
+      this._disposeSessionHistory(session)
       client.stop()
       settleReady(null) // reattach 待ちへ「失敗」を通知 (reject しない)
       // 失敗も 1 行に落とす。**_classifyAttachFailure より前**に出す (分類は rollout の disk 走査を
@@ -1375,6 +1384,12 @@ export class CodexStreamBridge extends EventEmitter {
     const cursorWeight = countsForCursor ? 1 : 0
     session.historyCursorWeights.push(cursorWeight)
     session.historyTotal = (Number.isInteger(session.historyTotal) ? session.historyTotal : 0) + cursorWeight
+    if (cursorWeight === 1 && session.historyAttachInProgress !== true) {
+      session.historyLiveCursorAdditions =
+        (Number.isInteger(session.historyLiveCursorAdditions)
+          ? session.historyLiveCursorAdditions
+          : 0) + 1
+    }
     // 古い page は同じ snapshot 座標内なら順序が壊れないため cache は clear しない。
     // child 更新は parent thread/read snapshot にも無関係。TTL 後の再取得で自然に追随する。
     session.historyBytes += estimateItemBytes(entry)
@@ -1432,14 +1447,170 @@ export class CodexStreamBridge extends EventEmitter {
     session.historySnapshotCache?.clear?.()
   }
 
+  _abortFreshHistorySnapshot(session) {
+    if (!session) return
+    // clear() は進行中AsyncTtlCache buildを切り離して新世代buildを許すため、fresh operationも
+    // 一時的に複数並走し得る。finally deleteとの競合を避け、snapshot配列を全件abort→stopする。
+    const operations = [...(session.historySnapshotFreshOperations || [])]
+    for (const operation of operations) {
+      operation.abort?.()
+      try {
+        operation.stop?.()
+      } catch (error) {
+        this.logger?.warn?.(
+          {
+            error_code: codexHostCapabilityErrorCode(
+              error,
+              "CODEX_HISTORY_SNAPSHOT_STOP_FAILED",
+            ),
+          },
+          "codex history snapshot client stop failed",
+        )
+      }
+    }
+  }
+
+  _disposeSessionHistory(session) {
+    this._abortFreshHistorySnapshot(session)
+    this._disposeHistorySnapshot(session)
+  }
+
+  async _resumeFullHistorySnapshot(
+    session,
+    advertisedTotal,
+    requiredTotal,
+    liveItems,
+    coldBaseTotal,
+    additionsAtRequest,
+  ) {
+    const client = this._clientFactory({
+      cwd: session.cwd,
+      codexCmd: this.codexCmd,
+      logger: this.logger,
+      env: siblingEnvFor(session.cwd),
+    })
+    client.on("error", (error) => {
+      this.logger?.warn?.(
+        {
+          error_code: codexHostCapabilityErrorCode(
+            error,
+            "CODEX_HISTORY_SNAPSHOT_CLIENT_ERROR",
+          ),
+        },
+        "codex history snapshot client error",
+      )
+    })
+    const startedAt = Date.now()
+    let stopped = false
+    const stopClient = () => {
+      if (stopped) return
+      stopped = true
+      client.stop()
+    }
+    let rejectAbort
+    const aborted = new Promise((_, reject) => {
+      rejectAbort = reject
+    })
+    const abort = () => {
+      const error = new Error("stream_id is not attached")
+      error.code = "CODEX_HISTORY_SNAPSHOT_FALLBACK_ABORTED"
+      rejectAbort(error)
+    }
+    const operation = { client, abort, stop: stopClient }
+    session.historySnapshotFreshOperations.add(operation)
+    this.logger?.info?.(
+      {
+        thread_id: session.threadId,
+        advertised_total: advertisedTotal,
+        required_total: requiredTotal,
+        live_items: liveItems,
+        cold_base_total: coldBaseTotal,
+        additions_at_request: additionsAtRequest,
+      },
+      "codex history snapshot fallback started",
+    )
+    try {
+      const items = await Promise.race([
+        (async () => {
+          client.start()
+          await client.request("initialize", {
+            clientInfo: CLIENT_INFO,
+            capabilities: {
+              experimentalApi: true,
+              mcpServerOpenaiFormElicitation: true,
+            },
+          })
+          client.notify("initialized", {})
+          const result = await client.request("thread/resume", {
+            cwd: session.cwd,
+            threadId: session.threadId,
+          })
+          if (result?.thread?.id !== session.threadId) {
+            throw new Error("fresh thread/resume returned a different thread")
+          }
+          const resumedItems = flattenAllThreadItems(result.thread)
+          if (resumedItems.length < requiredTotal) {
+            throw new Error("fresh history snapshot is shorter than required prefix total")
+          }
+          return resumedItems
+        })(),
+        aborted,
+      ])
+      this.logger?.info?.(
+        {
+          thread_id: session.threadId,
+          advertised_total: advertisedTotal,
+          required_total: requiredTotal,
+          live_items: liveItems,
+          cold_base_total: coldBaseTotal,
+          additions_at_request: additionsAtRequest,
+          elapsed_ms: Date.now() - startedAt,
+        },
+        "codex history snapshot fallback completed",
+      )
+      return items
+    } catch (error) {
+      const isAborted = error?.code === "CODEX_HISTORY_SNAPSHOT_FALLBACK_ABORTED"
+      this.logger?.[isAborted ? "info" : "warn"]?.(
+        {
+          thread_id: session.threadId,
+          advertised_total: advertisedTotal,
+          required_total: requiredTotal,
+          live_items: liveItems,
+          cold_base_total: coldBaseTotal,
+          additions_at_request: additionsAtRequest,
+          elapsed_ms: Date.now() - startedAt,
+          error_code: codexHostCapabilityErrorCode(
+            error,
+            "CODEX_HISTORY_SNAPSHOT_FALLBACK_FAILED",
+          ),
+        },
+        isAborted
+          ? "codex history snapshot fallback aborted"
+          : "codex history snapshot fallback failed",
+      )
+      throw error
+    } finally {
+      stopClient()
+      session.historySnapshotFreshOperations.delete(operation)
+    }
+  }
+
   async _historySnapshot(session) {
     // この reader は既存の別責務の thread/read と統合しない。要求した root thread と応答の
     // thread id が一致することを、この履歴取得経路自身で必ず検証する。
     const cache = session.historySnapshotCache
-    const items = await cache.get(async () => {
+    const snapshot = await cache.get(async () => {
+      const buildSeq = (Number.isInteger(session.historySnapshotBuildSeq)
+        ? session.historySnapshotBuildSeq
+        : 0) + 1
+      session.historySnapshotBuildSeq = buildSeq
       // session破棄時の cache.clear() で進行中callerが新世代buildへ合流し直しても、停止済み
       // clientへ2本目のthread/readを送らない。
       if (session.dead) throw new Error("stream_id is not attached")
+      const additionsAtRequest = Number.isInteger(session.historyLiveCursorAdditions)
+        ? session.historyLiveCursorAdditions
+        : 0
       const result = await session.client.request("thread/read", {
         threadId: session.threadId,
         includeTurns: true,
@@ -1447,11 +1618,22 @@ export class CodexStreamBridge extends EventEmitter {
       if (result?.thread?.id !== session.threadId) {
         throw new Error("thread/read returned a different thread")
       }
-      const items = flattenAllThreadItems(result.thread)
+      if (session.dead) throw new Error("stream_id is not attached")
+      let items = flattenAllThreadItems(result.thread)
+      const coldBaseTotal = Number.isInteger(session.historyColdBaseTotal)
+        ? session.historyColdBaseTotal
+        : 0
+      const liveCursorAdditions = Number.isInteger(session.historyLiveCursorAdditions)
+        ? session.historyLiveCursorAdditions
+        : 0
+      const advertisedTotal = Math.max(
+        Number.isInteger(session.historyTotal) ? session.historyTotal : 0,
+        coldBaseTotal + liveCursorAdditions,
+      )
+      const knownPrefixAtRequest = coldBaseTotal + additionsAtRequest
       if (
         session.historySnapshotComparable === true &&
-        Number.isInteger(session.historyTotal) &&
-        items.length !== session.historyTotal
+        items.length !== advertisedTotal
       ) {
         this.logger?.warn?.(
           {
@@ -1462,14 +1644,50 @@ export class CodexStreamBridge extends EventEmitter {
           "codex history snapshot item count differs from live parent cursor",
         )
       }
+      let usedFresh = false
+      // read開始時点で既知だったroot cursor prefixより短い場合だけcompactionと判定する。
+      // read発行前に観測した加算はread応答に含まれる前提。await中のlive追加はknownPrefixへ
+      // 含めず末尾lagとして許容し、この前提が破れた可能性はfallbackログで観測する。
+      if (items.length < knownPrefixAtRequest) {
+        const requiredTotal = coldBaseTotal > 0 ? coldBaseTotal : knownPrefixAtRequest
+        items = await this._resumeFullHistorySnapshot(
+          session,
+          advertisedTotal,
+          requiredTotal,
+          items.length,
+          coldBaseTotal,
+          additionsAtRequest,
+        )
+        usedFresh = true
+        // このbridgeはthread/rollback・thread/forkを呼ばず単調threadだけを扱うため、fresh
+        // thread/resumeのitemsは先頭からのdurable prefix。fresh成功時だけbaseを単調に引上げ、
+        // 並行live追加は差分として残す。
+        session.historyColdBaseTotal = Math.max(
+          Number.isInteger(session.historyColdBaseTotal) ? session.historyColdBaseTotal : 0,
+          items.length,
+        )
+        const newBase = session.historyColdBaseTotal
+        session.historyLiveCursorAdditions = Math.max(
+          0,
+          (Number.isInteger(session.historyTotal) ? session.historyTotal : 0) - newBase,
+        )
+      }
+      if (session.dead) throw new Error("stream_id is not attached")
       session.historyTotal = Math.max(
         items.length,
         Number.isInteger(session.historyTotal) ? session.historyTotal : 0,
       )
-      return items
+      return { items, usedFresh, buildSeq }
     })
+    if (session.dead) throw new Error("stream_id is not attached")
+    session.historySnapshotReturnedBuildSeq = Math.max(
+      Number.isInteger(session.historySnapshotReturnedBuildSeq)
+        ? session.historySnapshotReturnedBuildSeq
+        : 0,
+      snapshot.buildSeq,
+    )
     this._scheduleHistorySnapshotRelease(session)
-    return items
+    return snapshot
   }
 
   /**
@@ -1493,19 +1711,23 @@ export class CodexStreamBridge extends EventEmitter {
     if (before > (Number.isInteger(session.historyTotal) ? session.historyTotal : 0)) {
       throw new Error("before exceeds live history total")
     }
-    let all = await this._historySnapshot(session)
-    // readyが広告した正当cursorへTTL snapshotが追いついていない場合だけ、このrequest内で最大1回
-    // 強制再buildする。再帰/loopは使わず、なお短ければerrorへ固定する。
-    if (before > all.length) {
+    const maxItems = this._historyLimits.maxItems
+    const pageLimit = limit == null ? maxItems : Math.min(maxItems, limit)
+    const seqAtCall = Number.isInteger(session.historySnapshotReturnedBuildSeq)
+      ? session.historySnapshotReturnedBuildSeq
+      : 0
+    let snapshot = await this._historySnapshot(session)
+    // readyが広告した正当cursorへlive-only snapshotが追いついていない場合だけ、このrequest内で
+    // 最大1回再buildする。fresh済みsnapshotは同一requestで2本目を起動せず即errorへ固定する。
+    const usedFreshDuringCall = snapshot.usedFresh === true && snapshot.buildSeq > seqAtCall
+    if (before > snapshot.items.length && !usedFreshDuringCall) {
       this._disposeHistorySnapshot(session)
-      all = await this._historySnapshot(session)
+      snapshot = await this._historySnapshot(session)
     }
-    if (before > all.length) {
+    if (before > snapshot.items.length) {
       throw new Error("before exceeds history snapshot total")
     }
-    const maxItems = this._historyLimits.maxItems
-    const pageLimit = limit == null ? maxItems : Math.min(maxItems, limit)
-    const page = pageThreadItems(all, {
+    const page = pageThreadItems(snapshot.items, {
       before,
       maxItems: pageLimit,
       maxBytes: this._historyLimits.maxBytes,
@@ -3174,7 +3396,7 @@ export class CodexStreamBridge extends EventEmitter {
     if (session.dead) return
     this._markRunningSubagentsKilled(session)
     session.dead = true
-    this._disposeHistorySnapshot(session)
+    this._disposeSessionHistory(session)
     // round3: app-server が死んだら barrier を解除し queue を reject する（promise 宙吊り防止）。
     this._settleTurnActiveWaiter(session)
     this._drainRejectQueue(session, { reason: "queue_dead" })
@@ -4209,7 +4431,7 @@ export class CodexStreamBridge extends EventEmitter {
     if (session.dead) return
     this._markRunningSubagentsKilled(session, now)
     session.dead = true
-    this._disposeHistorySnapshot(session)
+    this._disposeSessionHistory(session)
     // round3: reap した session の barrier を解除し queue を reject する（promise 宙吊り防止）。
     this._settleTurnActiveWaiter(session)
     this._drainRejectQueue(session, { reason: "queue_dead" })
@@ -4399,7 +4621,7 @@ export class CodexStreamBridge extends EventEmitter {
     for (const session of this._liveSessions()) {
       this._markRunningSubagentsKilled(session)
       session.dead = true
-      this._disposeHistorySnapshot(session)
+      this._disposeSessionHistory(session)
       // round3: shutdown で barrier を解除し queue 入力を reject（promise 宙吊り防止）。
       this._settleTurnActiveWaiter(session)
       this._drainRejectQueue(session, { reason: "queue_dead" })