@cocorograph/hub-agent 0.8.9 → 0.8.11

package/src/codex-stream-bridge.mjs

@@ -8,7 +8,7 @@
  *
  * Claude 側との対応 (詳細は main.mjs の codex.* dispatch = Slice 3 で配線):
  *   claude.attach            → attach()   (initialize → thread/start か thread/resume)
- *   claude.input              → input()    (turn/start、ターン中は turn/steer)
+ *   claude.input              → input()    (idle は turn/start、生成中は次ターン FIFO)
  *   claude.interrupt          → interrupt() (turn/interrupt)
  *   claude.detach              → detach()   (TTL 付き graceful close)
  *   (codex 固有)               → keepalive() (閲覧中の生存シグナル。pty.resize 相当)
@@ -43,6 +43,8 @@
 import { EventEmitter } from "node:events"
 import { randomUUID } from "node:crypto"
 
+import { recordInjectSourcePersistent } from "./inject-source-store.mjs"
+
 import { AsyncTtlCache } from "./async-ttl-cache.mjs"
 import { CodexAppServerClient } from "./codex-appserver-client.mjs"
 import {
@@ -134,6 +136,10 @@ const DEAD_TERMINAL_TTL_MS =
 const TURN_START_TIMEOUT_MS =
   Number(process.env.HUB_AGENT_CODEX_TURN_START_TIMEOUT_MS) || 30 * 1000
 
+// browser が ack を取りこぼしても queue snapshot から受理済みと再確認できるよう、
+// 直近 input_id を bounded ring で保持する (Claude queue_state.accepted と同じ契約)。
+const ACCEPTED_INPUT_ID_RING_MAX = 256
+
 // sibling-inject の turn RPC が成功した後、app-server が同じ userMessage を
 // item/completed で echo するまで待つ上限。RPC accepted と userMessage delivered を
 // 分離し、旧 stream / 初期化競合で rollout に残らない入力を成功扱いしない。
@@ -253,9 +259,8 @@ export function deriveResumeTurnState(thread) {
   const lastTurnStatus = typeof lastTurn?.status === "string" ? lastTurn.status : null
   // 権威シグナル: スレッドが active のときだけ「ターン実行中」。fresh resume は idle。
   const turnActive = threadStatus === "active"
-  // active かつ最後のターンが inProgress のときのみ activeTurnId を復元する
-  // (input() が turn/steer へ正しく分岐できるように)。それ以外は null のまま
-  // = 次の入力は turn/start になり、固着しない。
+  // active かつ最後のターンが inProgress のときのみ activeTurnId を復元する。
+  // 通常入力はこの ID がある間は次ターン FIFO で待ち、一致する completed 後に start する。
   const activeTurnId =
     turnActive && lastTurnStatus === "inProgress" && typeof lastTurn?.id === "string"
       ? lastTurn.id
@@ -267,10 +272,9 @@ export function deriveResumeTurnState(thread) {
  * 配達保証 (S2, 2026-07-05): `input()` が reject したエラーを `codex.input.nack` の
  * `reason` へ分類する。
  *
- * S3 Codex 堅牢化 (同日マージ) 以降、`CodexAppServerClient.request()` のタイムアウトや
- * `CodexStreamBridge.input()` の turn/steer→turn/start 自動リトライ失敗は、reject する
- * Error に権威ある `.reason` (`'timeout'` / `'turn_mismatch_retry_failed'`) を直接
- * 付与するようになった。付与されていればそれを最優先で採用し (main.mjs が組み立てる
+ * `CodexAppServerClient.request()` のタイムアウト等、bridge が判断できる失敗は reject する
+ * Error に権威ある `.reason` を直接付与する。付与されていればそれを最優先で採用し
+ * (main.mjs が組み立てる
  * `codex.error.reason` と同じ値になり、frontend 側の分岐を一致させられる)、付与されて
  * いない場合 (例: `_require()` の「セッション不在」) のみメッセージ文言からの
  * ベストエフォート分類にフォールバックする。
@@ -479,19 +483,20 @@ export class CodexStreamBridge extends EventEmitter {
       // この session を引き当て _tryReattach の session.ready 合流に入り、二重 app-server を作らない。
       resumeThreadId: resumeThreadId || null,
       activeTurnId: null,
-      // 案B (T06542, codex-review round3 major#1): 同時入力を **session 単位の単一 FIFO + 単一 pump**で
-      // 直列化し、二重 turn/start・queue 追い越し・並行 steer を構造的に排除する。旧 turnStarting/
-      // pendingInputs の二重路 (queue 経路 + 直通経路) が overtaking と並行リトライ二重ターンの温床だった。
+      // 通常入力は session 単位の次ターン FIFO。activeTurnId がある間は App Server へ
+      // turn/steer せずここで待ち、対象 turn/completed 後に 1 件ずつ turn/start する。
       /** @type {Array<{input: object[], model?: string, effort?: string, resolve: Function,
-       *  reject: Function, retriedAsStart?: boolean, deliveryId?: string,
-       *  sourceStreamId?: string}>} round3 major#1: **session 単位の単一 FIFO**。
-       *  全 input() はここに積まれ、単一 pump (_pumpInputs) が **1 件ずつ直列**に処理する。直通経路を
-       *  廃したので、drain 中の新規 input が queue を追い越したり、並行 turn/start・steer を発行して
-       *  二重ターンになる事故が起きない。各 promise は **実 delivery (turn/start か turn/steer の RPC)**で
-       *  settle する (main.mjs が codex.input.ack/nack を実配達に合わせて出せる)。 */
+       *  reject: Function, deliveryId?: string, inputId?: string, text: string,
+       *  sourceStreamId?: string, acceptedAsQueued?: boolean}>} */
       inputQueue: [],
       /** round3 major#1: pump が走行中か (単一 pump を保証する singleflight フラグ)。 */
       pumping: false,
+      /** turn/start RPC を送出中の item。queue snapshot では pending から除外する。 */
+      dispatchingInput: null,
+      /** queue_state の session 内単調増加版番号。generation は session.seq を使う。 */
+      queueStateSeq: 0,
+      /** ack 喪失からの自己回復用、受理済み browser input_id の bounded ring。 */
+      acceptedInputIds: [],
       /** @type {{resolve: Function, timer: any} | null} round3 major#2: turn/start 後に turn/started
        *  (activeTurnId 確定) を待つ barrier の待機者。timeout 付きでハングを防ぐ。 */
       _turnActiveWaiter: null,
@@ -941,6 +946,82 @@ export class CodexStreamBridge extends EventEmitter {
     return Array.from(new Set(this.sessions.values())).filter((s) => !s.dead)
   }
 
+  _recordAcceptedInput(session, inputId) {
+    if (!session || typeof inputId !== "string" || !inputId) return
+    const ids = session.acceptedInputIds || (session.acceptedInputIds = [])
+    const at = ids.indexOf(inputId)
+    if (at !== -1) ids.splice(at, 1)
+    ids.push(inputId)
+    if (ids.length > ACCEPTED_INPUT_ID_RING_MAX) {
+      ids.splice(0, ids.length - ACCEPTED_INPUT_ID_RING_MAX)
+    }
+  }
+
+  _pendingInputItems(session) {
+    if (!session || !Array.isArray(session.inputQueue)) return []
+    return session.inputQueue.filter((item) => item !== session.dispatchingInput)
+  }
+
+  /** Claude の queue_state と同じ payload を Codex notification 上へ載せる。 */
+  queueState(stream_id) {
+    const session = this._require(stream_id)
+    const pending = this._pendingInputItems(session)
+    return {
+      type: "queue_state",
+      pending: pending.length,
+      messages: pending.map((item) => item.text),
+      items: pending.map((item) => ({ id: item.inputId || item.deliveryId || "", text: item.text })),
+      seq: session.queueStateSeq || 0,
+      generation: session.seq,
+      accepted: [...(session.acceptedInputIds || [])],
+    }
+  }
+
+  /** 次ターン FIFO に残っている browser 入力を id 指定で取り消す。
+   * dispatchingInput は既に turn/start RPC 中なので対象外（実行開始済みとして扱う）。 */
+  cancelQueued({ stream_id, id }) {
+    const session = this._require(stream_id)
+    if (!id) return false
+    const index = session.inputQueue.findIndex(
+      (item) =>
+        (item?.inputId === id || item?.deliveryId === id) &&
+        item !== session.dispatchingInput,
+    )
+    if (index < 0) {
+      this._emitQueueState(session)
+      return false
+    }
+    const [item] = session.inputQueue.splice(index, 1)
+    if (!item.acceptedAsQueued) {
+      const err = Object.assign(new Error("codex queued input cancelled"), {
+        reason: "cancelled",
+      })
+      item.reject(err)
+    }
+    this._emitQueueState(session)
+    return true
+  }
+
+  _emitQueueState(session, startedItem = null) {
+    if (!session || session.dead) return
+    session.queueStateSeq = (session.queueStateSeq || 0) + 1
+    const snapshot = this.queueState(session.stream_id)
+    if (startedItem?.text) {
+      snapshot.started = [startedItem.text]
+      snapshot.startedIds = [startedItem.inputId || startedItem.deliveryId || null]
+    } else {
+      snapshot.started = []
+      snapshot.startedIds = []
+    }
+    this.emit("event", {
+      stream_id: session.stream_id,
+      producer_seq: session.seq,
+      thread_id: session.threadId,
+      cwd: session.cwd,
+      notification: { method: "cockpit/queue_state", params: snapshot },
+    })
+  }
+
   /** 連携カード種別 + 配達確認: 注入本文 → entry を session の FIFO に控える。sendToCwd/
    *  sendToStream が input() を呼ぶ直前に記録し、直後の userMessage echo を
    *  _tagInjectSourceOnItem が拾う。entry 自体が delivery promise の handle であり、
@@ -1118,7 +1199,27 @@ export class CodexStreamBridge extends EventEmitter {
         )
         break
       case "turn/completed":
-        session.activeTurnId = null
+        {
+          const completedTurnId = msg.params?.turn?.id || null
+          // App Server の対象 turn と現在の権威 activeTurnId が一致したときだけ idle 化する。
+          // 遅延した別 turn の completed で現ターンを落として FIFO を早期排出しない。
+          if (
+            session.activeTurnId &&
+            completedTurnId !== session.activeTurnId
+          ) {
+            this.logger?.warn?.(
+              {
+                stream_id: session.stream_id,
+                thread_id: session.threadId,
+                active_turn_id: session.activeTurnId,
+                completed_turn_id: completedTurnId,
+              },
+              "ignored stale codex turn/completed",
+            )
+            break
+          }
+          session.activeTurnId = null
+        }
         // round3 major#2: turn/started を取りこぼしたまま turn/completed が来た異常時も barrier が
         // 固着しないよう解除する (pump が次 item を fresh に turn/start できる)。
         this._settleTurnActiveWaiter(session)
@@ -1136,6 +1237,8 @@ export class CodexStreamBridge extends EventEmitter {
         )
         // Stage 5: turn 完了後の reap 予約は不要。以降 idle になれば周期 reconcile が
         // 長 idle TTL / LRU で扱う（detach 済みでも 7 日 warm 保持）。
+        // 通常送信 FIFO は matching turn/completed だけを排出境界にする。
+        void this._pumpInputs(session)
         break
       case "item/completed":
         // T06541 案1: 完了した ThreadItem を高忠実度履歴に追記する（cwd reattach で返す用）。
@@ -1256,176 +1359,142 @@ export class CodexStreamBridge extends EventEmitter {
    * @param {string} [args.effort] - 公式スキーマ `TurnStartParams.effort`
    *   ("Override the reasoning effort for this turn and subsequent turns")。turn/start でのみ有効。
    * @param {string} [args.deliveryId] sibling-inject の内部相関 ID
-   * @returns {Promise<{method: "turn/start"|"turn/steer", deliveryId?: string}>}
-   *
-   * ⚠️ `turn/steer` (`TurnSteerParams`) には model/effort フィールドが存在しない
-   * (公式スキーマで未対応と確認済み、2026-07-03)。そのためターン実行中 (busy) に
-   * model/effort を渡しても turn/steer 経由では反映されず、次の非 busy な input()
-   * (= turn/start) から有効になる。呼び出し側 (main.mjs) はこれを承知の上で常に
-   * model/effort を渡してよい (steer 分岐では単に無視される)。
+   * @param {string} [args.inputId] browser の配達確認・キュー表示用 ID
+   * @returns {Promise<{method: "turn/start"|"queued", deliveryId?: string}>}
    */
-  async input({ stream_id, message, model, effort, deliveryId }) {
+  async input({ stream_id, message, model, effort, deliveryId, inputId }) {
     const session = this._require(stream_id)
     // Stage 5: _touch で lastActivityMs を更新 = LRU 先頭へ。ターン開始で activeTurnId が
     // 立ち、reconcile は healthy busy を protected 扱いにするので実行中に kill されない。
     // 案B: stream_id を渡し端末別活性も更新（死端末 GC が入力継続端末を掃除しない）。
     this._touch(session, stream_id)
     const input = userInputFromMessage(message)
-    // round3 major#1: 全 input を **session 単位の単一 FIFO** に積み、単一 pump に処理させる。
-    // promise は pump が実 delivery で settle する (即 resolve しない)。
+    const text = input.map((part) => part?.text || "").join("\n")
+    if (inputId && session.acceptedInputIds?.includes(inputId)) {
+      return { method: session.activeTurnId ? "queued" : "turn/start", deliveryId }
+    }
+    const queuedAtArrival =
+      !!session.activeTurnId ||
+      session.pumping === true ||
+      !!session._turnActiveWaiter
+    this._recordAcceptedInput(session, inputId)
     return new Promise((resolve, reject) => {
-      session.inputQueue.push({
+      const item = {
         input,
+        text,
         model,
         effort,
         deliveryId,
+        inputId,
         sourceStreamId: stream_id,
         resolve,
         reject,
-        retriedAsStart: false,
-      })
+        acceptedAsQueued: queuedAtArrival && !!inputId,
+      }
+      session.inputQueue.push(item)
+      if (item.acceptedAsQueued) {
+        resolve({ method: "queued", deliveryId })
+        this.logger?.info?.(
+          {
+            stream_id,
+            thread_id: session.threadId,
+            input_id: inputId,
+            queued: this._pendingInputItems(session).length,
+            active_turn_id: session.activeTurnId,
+          },
+          "codex busy, message queued for next turn",
+        )
+        this._emitQueueState(session)
+      }
       void this._pumpInputs(session)
     })
   }
 
   /**
-   * round3 major#1 (案B / T06542): session 単位の単一 FIFO pump。**1 件ずつ直列**に処理し、
-   * 並行 turn/start・turn/steer や queue の追い越しを構造的に排除する (singleflight)。
-   *   - 非 busy (activeTurnId 無し): turn/start で新ターン。成功後、次を steer にするため
-   *     turn/started (activeTurnId 確定) を **timeout 付き**で待つ (round3 major#2: ハング防止)。
-   *   - busy (activeTurnId 有り): turn/steer で追い打ち。
-   *   - turn/steer 失敗 (expectedTurnId 不一致など): activeTurnId を捨て、同 item を **1 回だけ**
-   *     turn/start にフォールバックして自己修復する (旧 self-heal を FIFO 内で継続。並行はしない)。
-   * 各 item の promise は実 delivery の RPC 結果で settle する。
+   * 通常送信の次ターン FIFO pump。activeTurnId がある間は何も App Server へ送らず、
+   * matching turn/completed が activeTurnId を解除した後だけ先頭を turn/start する。
+   * これにより通常クリックと明示的な turn/steer / turn/interrupt の意味を分離する。
    */
   async _pumpInputs(session) {
-    if (session.pumping) return
+    if (session.pumping || session.activeTurnId) return
     session.pumping = true
     try {
       while (session.inputQueue.length > 0) {
+        if (session.activeTurnId) return
         if (session.dead) {
           this._drainRejectQueue(session, { reason: "queue_dead" })
           return
         }
         const item = session.inputQueue[0]
-        // round4 major#3: 試行種別 (steer/start) を **await の前に** 確定する。await 中に
-        // turn/completed が来て session.activeTurnId が null に戻ると、catch 時点の値では steer 試行が
-        // start と誤判定され、self-heal リトライがスキップされて item が誤 reject される。
-        const attemptedSteer = !!session.activeTurnId
+        session.dispatchingInput = item
         try {
-          if (attemptedSteer) {
-            await session.client.request("turn/steer", {
-              threadId: session.threadId,
-              expectedTurnId: session.activeTurnId,
-              input: item.input,
-            })
-            session.inputQueue.shift()
-            this.logger?.info?.(
-              {
-                delivery_id: item.deliveryId || null,
-                stream_id: item.sourceStreamId || session.stream_id,
-                current_stream_id: session.stream_id,
-                thread_id: session.threadId,
-                attempted_steer: true,
-                rpc_method: "turn/steer",
-                rpc_result: "accepted",
-              },
-              "codex input RPC settled",
-            )
-            item.resolve({ method: "turn/steer", deliveryId: item.deliveryId })
-          } else {
-            // round4 major#2: turn/start dispatch の **前に** 世代を控える。start 応答後に
-            // turn/started(+completed) が pump 再開前に処理されても、世代前進で「ターンが始まった」を
-            // 検知でき、誤 timeout しない。
-            const genBefore = session.turnGeneration
-            const params = { threadId: session.threadId, input: item.input }
-            if (item.model) params.model = item.model
-            if (item.effort) params.effort = item.effort
-            await session.client.request("turn/start", params)
-            session.inputQueue.shift()
-            this.logger?.info?.(
-              {
-                delivery_id: item.deliveryId || null,
-                stream_id: item.sourceStreamId || session.stream_id,
-                current_stream_id: session.stream_id,
-                thread_id: session.threadId,
-                attempted_steer: false,
-                rpc_method: "turn/start",
-                rpc_result: "accepted",
-              },
-              "codex input RPC settled",
-            )
+          const genBefore = session.turnGeneration
+          const params = { threadId: session.threadId, input: item.input }
+          if (item.model) params.model = item.model
+          if (item.effort) params.effort = item.effort
+          await session.client.request("turn/start", params)
+          session.inputQueue.shift()
+          session.dispatchingInput = null
+          this.logger?.info?.(
+            {
+              delivery_id: item.deliveryId || null,
+              input_id: item.inputId || null,
+              stream_id: item.sourceStreamId || session.stream_id,
+              current_stream_id: session.stream_id,
+              thread_id: session.threadId,
+              rpc_method: "turn/start",
+              rpc_result: "accepted",
+            },
+            "codex input RPC settled",
+          )
+          if (!item.acceptedAsQueued) {
             item.resolve({ method: "turn/start", deliveryId: item.deliveryId })
-            // 次の item を steer にするため turn/started (= 世代前進) を待つ。timeout でハングを防ぐ。
-            // timeout したら「ターンが正しく始まらなかった」とみなし残り queue を reject して打ち切る。
-            const becameActive = await this._waitTurnActive(session, genBefore)
-            if (!becameActive) {
-              this._drainRejectQueue(session, { reason: "turn_start_timeout" })
-              return
-            }
           }
-        } catch (err) {
-          if (attemptedSteer && !item.retriedAsStart) {
-            this.logger?.warn?.(
-              {
-                delivery_id: item.deliveryId || null,
-                stream_id: item.sourceStreamId || session.stream_id,
-                current_stream_id: session.stream_id,
-                thread_id: session.threadId,
-                attempted_steer: true,
-                rpc_method: "turn/steer",
-                rpc_result: "retry_as_start",
-                err: err instanceof Error ? err.message : String(err),
-              },
-              "codex input RPC settled",
-            )
-            // turn/steer 失敗 → 自己修復: activeTurnId を捨て、同 item を turn/start で 1 回だけリトライ
-            // (shift しない = 同 item を次ループの start 経路で再処理)。並行はしない (単一 pump)。
-            // 元の steer エラーを stash して、リトライも失敗したとき合成メッセージを作れるようにする。
-            session.activeTurnId = null
-            item.retriedAsStart = true
-            item.priorSteerError = err instanceof Error ? err : new Error(String(err))
-            continue
+          this._emitQueueState(session, item.acceptedAsQueued ? item : null)
+          const becameActive = await this._waitTurnActive(session, genBefore)
+          if (!becameActive) {
+            this._drainRejectQueue(session, { reason: "turn_start_timeout" })
+            return
           }
-          // start 失敗 or リトライ済み steer 失敗 → この item を reject。activeTurnId は捨てる
-          // (ターンは始まっていない/不明)。次の item は fresh に turn/start する。
+          // 通常は active のままなので matching turn/completed まで停止する。start 応答前に
+          // started+completed 済みの fast turn だけ、そのまま次の FIFO item へ進める。
+          if (session.activeTurnId) return
+        } catch (err) {
           session.inputQueue.shift()
-          session.activeTurnId = null
-          let e
-          if (item.retriedAsStart && item.priorSteerError) {
-            // steer→start リトライがともに失敗: 合成メッセージ + reason (main.mjs の classifyCodexInputError
-            // が reason を優先採用。従来の単一 input() 実装と同じ診断を保つ)。
-            e = Object.assign(
-              new Error(
-                `turn/steer failed (${item.priorSteerError.message}) and turn/start retry also failed: ${err instanceof Error ? err.message : String(err)}`,
-              ),
-              { reason: "turn_mismatch_retry_failed", cause: err },
-            )
-          } else {
-            e = err instanceof Error ? err : new Error(String(err))
-            if (!e.reason) e.reason = "start_error"
-          }
+          session.dispatchingInput = null
+          const e = err instanceof Error ? err : new Error(String(err))
+          if (!e.reason) e.reason = "start_error"
           this.logger?.error?.(
             {
               delivery_id: item.deliveryId || null,
+              input_id: item.inputId || null,
               stream_id: item.sourceStreamId || session.stream_id,
               current_stream_id: session.stream_id,
               thread_id: session.threadId,
-              attempted_steer: attemptedSteer,
-              rpc_method: attemptedSteer ? "turn/steer" : "turn/start",
+              rpc_method: "turn/start",
               rpc_result: "failed",
               err: e.message,
               reason: e.reason || null,
             },
             "codex input RPC settled",
           )
-          item.reject(e)
+          if (item.acceptedAsQueued) {
+            this.emit("error", {
+              stream_id: item.sourceStreamId || session.stream_id,
+              thread_id: session.threadId,
+              error: e.message,
+            })
+          } else {
+            item.reject(e)
+          }
+          this._emitQueueState(session)
         }
       }
     } finally {
+      session.dispatchingInput = null
       session.pumping = false
       // pumping=false 直後の enqueue 競合窓を拾い直す (取りこぼし防止)。再帰は 1 段のみ。
-      if (session.inputQueue.length > 0 && !session.dead) {
+      if (session.inputQueue.length > 0 && !session.dead && !session.activeTurnId) {
         void this._pumpInputs(session)
       }
     }
@@ -1484,15 +1553,24 @@ export class CodexStreamBridge extends EventEmitter {
     if (!session || !Array.isArray(session.inputQueue) || session.inputQueue.length === 0) return
     const pending = session.inputQueue
     session.inputQueue = []
+    session.dispatchingInput = null
     const reason = cause?.reason || "queue_dead"
-    for (const { reject } of pending) {
-      reject(
-        Object.assign(new Error("codex input dropped: turn could not be delivered"), {
-          reason,
-          cause,
-        }),
+    for (const item of pending) {
+      const error = Object.assign(
+        new Error("codex input dropped: turn could not be delivered"),
+        { reason, cause },
       )
+      if (item.acceptedAsQueued) {
+        this.emit("error", {
+          stream_id: item.sourceStreamId || session.stream_id,
+          thread_id: session.threadId,
+          error: error.message,
+        })
+      } else {
+        item.reject(error)
+      }
     }
+    if (!session.dead) this._emitQueueState(session)
   }
 
   /** @returns {Promise<void>} */
@@ -1947,6 +2025,9 @@ export class CodexStreamBridge extends EventEmitter {
         reason: delivery?.reason || "echo_timeout",
       }
     }
+    // Claude と同じ永続ストアへ記録し、hub-agent 再起動後に rollout を読む場合も
+    // peer / orchestrator 注入を通常の user 依頼として表示しない。
+    recordInjectSourcePersistent(session.cwd, text, source).catch(() => {})
     // rollout は内部形式・flush 遅延の影響を受けるため primary oracle にしない。echo delivered を
     // 返した後、注入前 offset + threadId + 本文 hash で非同期監査し、結果だけを構造化ログへ残す。
     void this._deliveryAuditVerify(durableAudit)