@cocorograph/hub-agent 0.8.10 → 0.8.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocorograph/hub-agent",
-  "version": "0.8.10",
+  "version": "0.8.11",
   "description": "Hub Hosted Cockpit のローカル常駐 agent。Hub と outbound WSS で接続し、ローカルの tmux/pty を中継する。",
   "type": "module",
   "license": "UNLICENSED",

package/src/claude-stream-bridge.mjs

@@ -523,11 +523,11 @@ export class ClaudeStreamSession {
     this._permissionResolvers = new Map()
     /** 現在ターン実行中か (多重 query 防止) */
     this._busy = false
-    /** SDK-P0-3 (2026-07-10): 現ターンが既に終端処理済みか (result / idle / abort の
+    /** SDK-P0-3 (2026-07-10): 現ターンが既に終端処理済みか (idle / abort の
      *  いずれか 1 回だけ _busy=false + drain させるための冪等ガード)。resident query は
-     *  1 ターンにつき `result` と `session_state_changed:idle` の**両方**が流れうるため、
-     *  素朴に両方で drain すると二重 drain (FIFO 崩れ) を起こす。ターン開始時
-     *  (_beginResidentTurn) に false へ戻す。 */
+     *  `result` の後にもバックグラウンド処理が続き、最後に権威的な
+     *  `session_state_changed:idle` が流れる。通常完了では idle だけが settle し、
+     *  明示 interrupt だけが先行して settled を立てる。ターン開始時に false へ戻す。 */
     this._turnSettled = false
     /** SDK-P0-3: 現ターンが 1 件でもストリームイベントを出したか。
      *  「前ターンの遅延 idle が、drain で始まったばかりの次ターンを誤終了させる」レースの
@@ -539,9 +539,9 @@ export class ClaudeStreamSession {
     this._turnProgressed = false
     /** SDK-P0-4 (2026-07-13): ターン連番。ログと帰属デバッグ用 (_beginResidentTurn で ++)。 */
     this._turnSeq = 0
-    /** SDK-P0-4: 「直前ターンの idle がこれから 1 件届きうる」状態。result で settle したとき、
-     *  および abort (interrupt) でターンを畳んだときに arm する (SDK は result → idle の順で
-     *  流し、interrupt 後にも中断ターンの idle を流すため)。arm 中に届いた idle は
+    /** SDK-P0-4: 「直前ターンの idle がこれから 1 件届きうる」状態。abort (interrupt) で
+     *  ターンを先行して畳んだときに arm する (interrupt 後にも中断ターンの idle が流れるため)。
+     *  通常完了は idle 自身で畳むので arm しない。arm 中に届いた idle は
      *  **前ターンのもの**として 1 件だけ握り潰し、現ターンを終端しない。
      *  解除条件: (a) idle を 1 件消費した (b) SDK の running が届いた (= 前ターンの全イベントは
      *  順序保証により既に通過済み) (c) 現ターンの result が届いた (d) STALE_IDLE_GUARD_MS 経過。 */
@@ -1131,9 +1131,10 @@ export class ClaudeStreamSession {
     this._busy = true
     this._abortController = new AbortController()
     let aborted = false
-    // RC-4: このターンで SDK の result イベントが届いたか。届かずに終わった
-    // (abort / 異常終了) ときだけ onTurnSettled でチャット信号を waiting へ落とす。
+    // `session_state_changed:idle` がターン終了の正本。SDK が idle を流さず generator が
+    // 閉じた旧/異常経路だけ合成 idle と onTurnSettled で waiting へ落とす。
     let resultDelivered = false
+    let idleDelivered = false
 
     const options = {
       cwd: this.cwd,
@@ -1185,6 +1186,7 @@ export class ClaudeStreamSession {
           resultDelivered = true
           if (typeof msg.session_id === "string") this.sessionId = msg.session_id
         }
+        if (isSessionIdleEvent(msg)) idleDelivered = true
         try {
           this._emit(msg)
         } catch (err) {
@@ -1224,12 +1226,9 @@ export class ClaudeStreamSession {
       if (aborted) {
         this.logger?.info({ stream_id: this.stream_id }, "claude turn aborted")
       }
-      // RC-4: result を届けずにターンが終わった (abort / 異常終了) 場合、チャット信号の
-      // status=processing が解除されず三点リーダー/ステータスドットが TTL まで固着する。
-      // ターン確定として onTurnSettled を呼び processing→waiting へ落とす。正常完了は
-      // result が既に waiting にしているので !resultDelivered のときだけ。_drainPending で
-      // 次ターン (processing) が始まる前に呼ぶこと (順序: ここ → reap/drain)。
-      if (!resultDelivered) {
+      // RC-4: idle を届けずに generator が閉じた旧/異常経路では、チャット信号と browser の
+      // 双方へ同じ終了境界を補う。_drainPending で次ターンを始める前に行うこと。
+      if (!idleDelivered) {
         try {
           this.onTurnSettled?.()
         } catch {
@@ -1244,11 +1243,24 @@ export class ClaudeStreamSession {
         // フッターで表示する)。uuid を持たせるのは重複排除 (isDuplicateEvent) が result
         // 署名 (session_id + num_turns + duration_ms + cost) で判定するため — 合成 result
         // はこれらが毎回同値になり、2 回目以降の中断で「重複」と誤判定され捨てられるのを防ぐ。
+        if (!resultDelivered) {
+          try {
+            this._emit({
+              type: "result",
+              subtype: aborted ? "aborted_by_user" : "turn_settled",
+              uuid: randomUUID(),
+              session_id: this.sessionId ?? undefined,
+              timestamp: new Date().toISOString(),
+            })
+          } catch {
+            /* ignore */
+          }
+        }
         try {
           this._emit({
-            type: "result",
-            subtype: aborted ? "aborted_by_user" : "turn_settled",
-            uuid: randomUUID(),
+            type: "system",
+            subtype: "session_state_changed",
+            state: "idle",
             session_id: this.sessionId ?? undefined,
             timestamp: new Date().toISOString(),
           })
@@ -1618,10 +1630,10 @@ export class ClaudeStreamSession {
     }
   }
 
-  /** SDK-P0-3 (2026-07-10): resident の「ターン終端」を 1 箇所に集約する (result / idle 共通)。
-   *  同一ターンで 2 回以上呼ばれても最初の 1 回しか作用しない (_turnSettled ガード)。
-   *  これにより `result` → `idle` の順で両方届く通常ケースでも drain は 1 回だけになる。
-   *  @param {string} reason "result" | "idle" — ログ用
+  /** resident の権威的な「ターン終端」を 1 箇所に集約する。
+   *  通常完了は SDK の session_state_changed:idle だけが呼ぶ。result は最終結果の
+   *  flush であり、バックグラウンド処理を含むターン全体の終了境界ではない。
+   *  @param {string} reason "idle" — ログ用
    *  @param {(msg: string) => void} [denyPending] 未解決 permission を閉じるクロージャ
    */
   _settleResidentTurn(reason, denyPending) {
@@ -1629,11 +1641,6 @@ export class ClaudeStreamSession {
     this._turnSettled = true
     denyPending?.("turn ended")
     this._busy = false
-    // SDK-P0-4: result で畳んだターンは、この後に自分の idle を必ず 1 件流す
-    // (sdk.d.ts: "'idle' fires after heldBackResult flushes … authoritative turn-over signal")。
-    // drain が同期で次ターンを開始するため、その idle が新ターンに誤帰属しないようガードを張る。
-    // idle 自身で畳んだ場合は既にその idle を消費済みなので張らない。
-    if (reason === "result") this._armStaleIdleGuard()
     // 改修4 (A): シリアライズした pending があれば次の 1 件を InputQueue へ流す。
     // ultracode (0.6.28): _drainResidentPending は applyFlagSettings を await するため
     // async。for await ループ内からは fire-and-forget で呼ぶ (最初の await より前に
@@ -1649,7 +1656,7 @@ export class ClaudeStreamSession {
   /** 改修4 (A): ターン完了時に pending の先頭 1 件を InputQueue へ流す (ターンのシリアライズ)。
    *  queue_state を更新して送信待ちチップを drain させる (frontend がバブル昇格する)。
    *  ultracode (0.6.28): 次ターンの目標 ultracode 状態へ reconcile してから push する
-   *  (await するため async 化。result ハンドラからは fire-and-forget で呼ばれる)。 */
+   *  (await するため async 化。idle ハンドラからは fire-and-forget で呼ばれる)。 */
   async _drainResidentPending() {
     if (this._closed) return
     if (this._pendingMessages.length === 0) {
@@ -1693,7 +1700,7 @@ export class ClaudeStreamSession {
 
   /** 改修2+4: 常駐 query を 1 回だけ起動し、streaming input キューから複数ターンを処理する。
    *  system/init は最初の 1 回のみ (毎ターン init = 文脈/キャッシュ温め直しを解消)。各ターンは
-   *  終端シグナル (result / session_state_changed:idle) で _busy=false にするが query は継続し
+   *  権威的終端シグナル (session_state_changed:idle) で _busy=false にするが query は継続し
    *  次 input を待つ。close (inputQueue.close) で generator が終わり query が完走する。
    *  SDK-P0-3 (2026-07-10): 終端を result だけに頼ると、SDK が idle でターンを終えたときに
    *  _busy が固着し、以降の送信が pending へ永久滞留する (T06052)。
@@ -1749,6 +1756,7 @@ export class ClaudeStreamSession {
       const q = this.sdk.query({ prompt: this._inputQueue, options })
       this._residentQuery = q
       for await (const msg of q) {
+        let suppressEmit = false
         if (
           msg?.type === "system" &&
           msg?.subtype === "init" &&
@@ -1758,12 +1766,12 @@ export class ClaudeStreamSession {
         }
         if (msg?.type === "result") {
           if (typeof msg.session_id === "string") this.sessionId = msg.session_id
-          // SDK-P0-4: 現ターンの result が届いた = 前ターンの遅延 idle は順序保証により
-          // 既に通過済み (届いたなら消費済み / 届かないなら二度と来ない)。ガードを解除してから
-          // settle する (settle が result 用のガードを張り直す)。
+          // result は結果 flush でありターン終了ではない。SDK の型定義が権威的な
+          // turn-over signal とする session_state_changed:idle まで busy を維持し、
+          // pending を streaming input へ流さない。
+          // 現ターンの result が届いた時点で前ターンの遅延 idle は順序保証により
+          // 既に通過済みなので、interrupt 由来のガードだけ解除できる。
           this._clearStaleIdleGuard()
-          // ターン完了: 未解決 permission を閉じ、次 input 受付へ (query は継続)。
-          this._settleResidentTurn("result", denyPending)
         } else if (isSessionIdleEvent(msg)) {
           // SDK-P0-3 (2026-07-10): result が届かずに idle でターンが終わるケースの救済。
           // これを見ていなかったため _busy が true で固着し、以降の送信が
@@ -1777,11 +1785,14 @@ export class ClaudeStreamSession {
           //  2) それ以外で _busy かつ (running を観測済み or 何かイベントを出した) → 現ターンの終端。
           if (this._staleIdleExpected) {
             this._clearStaleIdleGuard()
+            // browser にも転送しない。前ターンの遅延 idle を新ターンの reducer が受けると、
+            // 3点リーダーと送信ボタンだけが誤って idle になる。
+            suppressEmit = true
             this.logger?.debug?.(
               { stream_id: this.stream_id, turn: this._turnSeq },
               "stale idle from previous turn ignored",
             )
-          } else if (this._busy && (this._turnRunningSeen || this._turnProgressed)) {
+          } else if (this._busy) {
             this._settleResidentTurn("idle", denyPending)
             // per-message の RC-4 と対称に、チャット信号 (サイドバードット) を
             // processing→waiting へ落とす。result 経由なら main.mjs が result を見て
@@ -1804,13 +1815,15 @@ export class ClaudeStreamSession {
           // および session_state_changed の running / requires_action もここに含む。
           this._turnProgressed = true
         }
-        try {
-          this._emit(msg)
-        } catch (err) {
-          this.logger?.warn(
-            { err: err.message, stream_id: this.stream_id },
-            "onEvent callback threw",
-          )
+        if (!suppressEmit) {
+          try {
+            this._emit(msg)
+          } catch (err) {
+            this.logger?.warn(
+              { err: err.message, stream_id: this.stream_id },
+              "onEvent callback threw",
+            )
+          }
         }
       }
     } catch (err) {
@@ -1949,6 +1962,19 @@ export class ClaudeStreamSession {
         } catch {
           /* ignore */
         }
+        // 通常完了と同じ権威境界を browser へ即時提示する。SDK が後から流す
+        // 中断ターン由来の実 idle は _staleIdleExpected で抑止する。
+        try {
+          this._emit({
+            type: "system",
+            subtype: "session_state_changed",
+            state: "idle",
+            session_id: this.sessionId ?? undefined,
+            timestamp: new Date().toISOString(),
+          })
+        } catch {
+          /* ignore */
+        }
       }
       // T05699 残タスク #2-1 (2026-07-04): interrupt() は現ターンの result を発火しない
       // (query は継続、次 input 受付継続のみ)。そのため abort 時点で _pendingMessages に

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 相当)
@@ -136,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 に残らない入力を成功扱いしない。
@@ -255,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
@@ -269,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()` の「セッション不在」) のみメッセージ文言からの
  * ベストエフォート分類にフォールバックする。
@@ -481,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,
@@ -943,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 であり、
@@ -1120,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)
@@ -1138,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 で返す用）。
@@ -1258,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)
       }
     }
@@ -1486,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>} */

package/src/main.mjs

@@ -853,8 +853,9 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
       // ドーナツ) と session.event (ソート) に橋渡しする。チャットは tmux ペインに
       // TUI を出さず、capture-pane スクレイプも bundle hook も発火しないための補完。
       //   - assistant (生成中) → processing + usage から context%
-      //   - result   (ターン完了/入力待ち) → waiting
-      // assistant / result はターンの進行/完了 = permission 応答後に必ず流れるため、
+      //   - session_state_changed:idle → waiting
+      // result は結果 flush であり、SDK が権威的ターン終了と定義する idle より早く届く。
+      // assistant / idle はターンの進行/完了 = permission 応答後に必ず流れるため、
       // ここで inputPending を落として「確認待ち」ドット/通知を自己解消させる。
       if (event?.type === "assistant") {
         // 分母は result で学習したセッション固有の窓サイズ (無ければグローバル概算)。
@@ -876,6 +877,11 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
       } else if (event?.type === "result") {
         // SDK の権威的な窓サイズ (result.modelUsage[model].contextWindow) をここで学習する。
         resolveChatContextPct(cwd, "claude", event)
+      } else if (
+        event?.type === "system" &&
+        event?.subtype === "session_state_changed" &&
+        event?.state === "idle"
+      ) {
         try {
           recordChatActivity(cwd, "claude", {
             status: "waiting",
@@ -3134,8 +3140,8 @@ export function buildAttachHistoryPromise({
 /**
  * SDK チャット配達保証 (S2, 2026-07-05): `codex.input` を処理し、browser が付与した
  * `input_id` があれば `codex.input.ack` / `codex.input.nack` を返す (claude.input と
- * 対称)。`CodexStreamBridge.input()` は `turn/start` / `turn/steer` の JSON-RPC 呼び出し
- * そのものを await する設計のため、resolve/reject がそのまま ack/nack の判定になる。
+ * 対称)。idle 入力は turn/start の受理、生成中入力は hub-agent FIFO への受理をもって
+ * ack する。FIFO の実配送は matching turn/completed 後に bridge が行う。
  * 既存の `codex.error` 通知も維持する (input_id を知らない旧 frontend や、他の消費者向け)。
  * テストから直接呼べるよう dispatch から切り出して export する。
  */
@@ -3172,6 +3178,7 @@ export function handleCodexChatInput(msg, ctx) {
       message: msg.message,
       model: msg.model || undefined,
       effort: msg.effort || undefined,
+      inputId: input_id || undefined,
     })
     .then(() => {
       if (!input_id) return
@@ -3937,6 +3944,9 @@ async function dispatch(msg, ctx) {
             turn_active: info.turnActive === true,
             thread_status: info.threadStatus || null,
             last_turn_status: info.lastTurnStatus || null,
+            // Codex の通常送信 FIFO。ready と同じ封筒に初期 snapshot を載せ、
+            // reattach / reload でも送信待ち表示を即時復元する。
+            queue_state: ctx.codexBridge.queueState(stream_id),
           })
           // S1 (2026-07): claude.attach と対称の identity 正本化。Codex は thread/start
           // 応答時点で threadId が確定するため (Claude の fresh とは異なり)、fresh でも
@@ -4073,15 +4083,23 @@ async function dispatch(msg, ctx) {
         return
       }
       case "codex.input":
-        // model/effort: turn/start (非 busy 時) にのみ反映される override。turn/steer
-        // (busy 時) は公式スキーマ上 model/effort 非対応のため、その場合は
-        // codex-stream-bridge.mjs 側で無視され次の非 busy な input() から効く。
-        // S2/S3 統合 (2026-07-05): S3 の自己修復 (turn/steer 失敗 → turn/start 自動
-        // リトライ) が付与する err.reason ('timeout' / 'turn_mismatch_retry_failed') を
-        // classifyCodexInputError が優先採用し、input_id 付きなら codex.input.nack の
-        // reason としてそのまま使う (handleCodexChatInput 内)。
+        // 通常送信は idle なら turn/start、busy なら hub-agent の次ターン FIFO。
+        // turn/steer / turn/interrupt は明示操作の別経路として扱う。
         handleCodexChatInput(msg, ctx)
         return
+      case "codex.queue.cancel":
+        try {
+          ctx.codexBridge?.cancelQueued({
+            stream_id: msg.stream_id,
+            id: msg.id,
+          })
+        } catch (err) {
+          ctx.logger?.warn?.(
+            { err: err?.message, stream_id: msg.stream_id, input_id: msg.id },
+            "codex queued input cancel failed",
+          )
+        }
+        return
       case "codex.permission.reply":
         if (!ctx.codexBridge) return
         ctx.codexBridge.permissionReply({