@cocorograph/hub-agent 0.8.10 → 0.8.12

package/package.json

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

package/src/claude-stream-bridge.mjs

@@ -525,9 +525,10 @@ export class ClaudeStreamSession {
     this._busy = false
     /** SDK-P0-3 (2026-07-10): 現ターンが既に終端処理済みか (result / idle / abort の
      *  いずれか 1 回だけ _busy=false + drain させるための冪等ガード)。resident query は
-     *  1 ターンにつき `result` と `session_state_changed:idle` の**両方**が流れうるため、
-     *  素朴に両方で drain すると二重 drain (FIFO 崩れ) を起こす。ターン開始時
-     *  (_beginResidentTurn) に false へ戻す。 */
+     *  `result` の後にもバックグラウンド処理が続き、最後に権威的な
+     *  `session_state_changed:idle` が流れることがある。実 SDK では result 後に idle が
+     *  来ないターンもあるため、result / idle の先着 1 件だけが settle し、遅延 idle は
+     *  _staleIdleExpected で次ターンから隔離する。ターン開始時に false へ戻す。 */
     this._turnSettled = false
     /** SDK-P0-3: 現ターンが 1 件でもストリームイベントを出したか。
      *  「前ターンの遅延 idle が、drain で始まったばかりの次ターンを誤終了させる」レースの
@@ -539,9 +540,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 +1132,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 +1187,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 +1227,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 +1244,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,9 +1631,10 @@ export class ClaudeStreamSession {
     }
   }
 
-  /** SDK-P0-3 (2026-07-10): resident の「ターン終端」を 1 箇所に集約する (result / idle 共通)。
-   *  同一ターンで 2 回以上呼ばれても最初の 1 回しか作用しない (_turnSettled ガード)。
-   *  これにより `result` → `idle` の順で両方届く通常ケースでも drain は 1 回だけになる。
+  /** resident の「ターン終端」を 1 箇所に集約する。
+   *  SDK は result 後に session_state_changed:idle を返すことがあるが、実環境では
+   *  idle が欠落するターンもある。result / idle の先着を終端とし、result で畳んだ後の
+   *  遅延 idle はガードで次ターンから隔離する。
    *  @param {string} reason "result" | "idle" — ログ用
    *  @param {(msg: string) => void} [denyPending] 未解決 permission を閉じるクロージャ
    */
@@ -1629,10 +1643,9 @@ 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 を消費済みなので張らない。
+    // result の後に同一ターンの idle が遅れて届く場合がある。pending drain は同期的に
+    // 次ターンの busy を立てるため、その idle を新ターンへ誤帰属させないよう先にガードする。
+    // idle 自身で畳んだ場合は既に消費済みなので張らない。
     if (reason === "result") this._armStaleIdleGuard()
     // 改修4 (A): シリアライズした pending があれば次の 1 件を InputQueue へ流す。
     // ultracode (0.6.28): _drainResidentPending は applyFlagSettings を await するため
@@ -1649,7 +1662,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 +1706,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 +1762,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,11 +1772,11 @@ 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 が届いた時点で前ターンの遅延 idle は順序保証により
+          // 既に通過済み。古いガードを解除し、result 用のガードを張り直して settle する。
+          // 実 SDK では result 後に idle が来ないターンがあるため、idle 待ちだけにすると
+          // _busy が永久に true のまま固着し、以後の入力が pending から drain されない。
           this._clearStaleIdleGuard()
-          // ターン完了: 未解決 permission を閉じ、次 input 受付へ (query は継続)。
           this._settleResidentTurn("result", denyPending)
         } else if (isSessionIdleEvent(msg)) {
           // SDK-P0-3 (2026-07-10): result が届かずに idle でターンが終わるケースの救済。
@@ -1777,11 +1791,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 +1821,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 +1968,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 に
@@ -2256,7 +2288,12 @@ export class ClaudeStreamBridge extends EventEmitter {
           },
           "claude stream reattached to live session",
         )
-        return { stream_id, resuming: true, reattached: true }
+        return {
+          stream_id,
+          resuming: true,
+          reattached: true,
+          turn_active: live._busy === true,
+        }
       }
     }
     const session = new ClaudeStreamSession({
@@ -2369,7 +2406,11 @@ export class ClaudeStreamBridge extends EventEmitter {
     )
     // per-message モデルでは attach 時点では query() を起動しない (即 ready)。
     // 最初の input で query を起動する。
-    return { stream_id, resuming: !!resumeSessionId }
+    return {
+      stream_id,
+      resuming: !!resumeSessionId,
+      turn_active: session._busy === true,
+    }
   }
 
   /**

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
@@ -3426,6 +3433,10 @@ async function dispatch(msg, ctx) {
             type: "claude.ready",
             stream_id,
             resuming: info.resuming,
+            // 再接続時の生成状態は resident session を保持する hub-agent が正本。
+            // jsonl 履歴末尾の推測だけでは「実際は busy なのに UI は idle」となり、
+            // 送信ボタンが楽観バブルを作る一方 agent はキューへ積む二重表示が起きる。
+            turn_active: info.turn_active === true,
             history_pushed: resumeSessionId !== null,
             // id 空間統一 (2026-07-08): この agent は browser の input_id をキュー id として
             // 採用し、楽観送信待ちアイテムの確認前キャンセルに対応することを通知する capability。
@@ -3937,6 +3948,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 +4087,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({