@cocorograph/hub-agent 0.7.39 → 0.7.43

package/package.json

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

package/src/chat-signals.mjs

@@ -21,9 +21,18 @@
  *
  * cwd をキーにする理由: チャットセッションは tmux セッション名を持たず (SDK 子
  * プロセス)、サイドバー行 (= tmux セッション) とは cwd で対応するため。
+ *
+ * identity 次元 (cliKind/sessionId, S1 2026-07): 同一 cwd 上で Claude⇔Codex の
+ * エンジン切替や、プルダウンからの別セッション選択が起こりうる。従来は cwd だけを
+ * キーにしていたため、切替後も前のエンジン/セッションが残した status/context_pct を
+ * そのまま引き継いでしまい (ドーナツ/ステータスドットが前セッションの値のまま固着する
+ * 症状③④の真因)、新しい identity への切替を検知できなかった。recordChatActivity の
+ * patch に cliKind/sessionId を明示的に含めることで「この更新はどの CLI・どのセッション
+ * のものか」を宣言でき、前回記録した identity と不一致なら温存 (keep-prev) せず
+ * status/context_pct をリセットしてから組み立て直す。
  */
 
-// cwd → { status, context_pct, statusAt, inputPending, turnAt, updatedAtMs }
+// cwd → { status, context_pct, statusAt, inputPending, turnAt, updatedAtMs, cliKind, sessionId }
 const _byCwd = new Map()
 
 // チャット信号を「生きている」と見なす最大経過時間 (ms)。これを過ぎたら tmux
@@ -62,21 +71,52 @@ function _now() {
  *   "確認待ち" を別軸で表現するため)。permission 要求で true、次の assistant / result
  *   イベント (= ユーザーが応答してターンが再開/完了) で false に落とす。
  *
+ * cliKind / sessionId (S1, 2026-07): 「この更新がどの CLI・どのセッションのものか」を
+ * 明示する identity。patch に **どちらか一方でも** キーとして含まれていれば identity
+ * 更新とみなし、前回記録した identity (cliKind/sessionId) と比較する:
+ *   - 一致 (= 同一セッションの継続) → 従来通り前回値へ status/context_pct を温存 (keep-prev)。
+ *   - 不一致 (= エンジン切替 or 別セッションへの乗り換え) → 前回の status/context_pct/
+ *     inputPending を温存せずリセットしてから patch を適用する (旧セッションの値が
+ *     切替後にも残り続ける症状③④の根治)。
+ * patch に cliKind/sessionId のいずれのキーも含まれない (= 既存呼び出し元: permission
+ * ハンドラの inputPending 単独更新等) 場合は identity 判定をスキップし、後方互換のため
+ * 従来通り温存する。
+ *
  * @param {string} cwd セッションの作業ディレクトリ
- * @param {{ status?: string, contextPct?: number|null, inputPending?: boolean }} patch
+ * @param {{ status?: string, contextPct?: number|null, inputPending?: boolean, cliKind?: string|null, sessionId?: string|null }} patch
  * @param {number} [now] テスト用の時刻注入 (省略時は Date.now())
  */
 export function recordChatActivity(cwd, patch = {}, now = _now()) {
   if (!cwd || typeof cwd !== "string") return
-  const prev = _byCwd.get(cwd) || {
+  const empty = {
     status: null,
     context_pct: null,
     statusAt: 0,
     inputPending: false,
     turnAt: 0,
     updatedAtMs: 0,
+    cliKind: null,
+    sessionId: null,
   }
-  const next = { ...prev, turnAt: now, updatedAtMs: now }
+  const prev = _byCwd.get(cwd) || empty
+
+  const hasCliKind = Object.prototype.hasOwnProperty.call(patch, "cliKind")
+  const hasSessionId = Object.prototype.hasOwnProperty.call(patch, "sessionId")
+  let base = prev
+  let cliKind = prev.cliKind
+  let sessionId = prev.sessionId
+  if (hasCliKind || hasSessionId) {
+    cliKind = hasCliKind ? patch.cliKind ?? null : prev.cliKind
+    sessionId = hasSessionId ? patch.sessionId ?? null : prev.sessionId
+    const identityChanged = cliKind !== prev.cliKind || sessionId !== prev.sessionId
+    if (identityChanged) {
+      // 新しい identity: 前回の status/context_pct/inputPending は引き継がない。
+      // turnAt/updatedAtMs はこの後どちらにせよ now で上書きするため据え置きで良い。
+      base = empty
+    }
+  }
+
+  const next = { ...base, cliKind, sessionId, turnAt: now, updatedAtMs: now }
   // statusAt: status / context_pct を「実際に SDK イベントが更新した」時刻。
   // inputPending だけの記録 (TUI 権限ブリッジ) では更新しない。これを分けないと、
   // TUI モードの承認カードが届くたびに「過去の SDK チャットが残した status (多くは
@@ -129,7 +169,7 @@ export function recordChatStreamTick(cwd, now = _now()) {
  *
  * @param {string} cwd
  * @param {number} [now]
- * @returns {{ status: string|null, context_pct: number|null, inputPending?: boolean, turnAt: number, updatedAtMs: number } | null}
+ * @returns {{ status: string|null, context_pct: number|null, inputPending?: boolean, turnAt: number, updatedAtMs: number, cliKind?: string|null, sessionId?: string|null } | null}
  */
 export function getChatSignal(cwd, now = _now()) {
   if (!cwd) return null

package/src/claude-stream-bridge.mjs

@@ -291,6 +291,14 @@ class ClaudeStreamSession {
     this._residentQuery = null
     /** 常駐 query を起動済みか (二重起動防止)。 */
     this._residentStarted = false
+    /** A-2 (2026-07-05 配達保証): 常駐 query の generator が自然終了 (for await ループが
+     *  完走) したかを示すフラグ。_runResidentQuery の finally で _residentQuery=null に
+     *  なるより前に true を立てる。sendMessage は `await this._reconcileResidentUltracode()`
+     *  を挟むため、その await 中に generator が終了すると「_residentQuery はまだ non-null
+     *  (finally 未実行)」に見えたまま push してしまい、誰も consume しない返却済み
+     *  InputQueue にメッセージが消えることがある。このフラグで「push 直前に本当にまだ
+     *  生きているか」を再確認する。新しい query を (再)起動するたびに false へリセットする。 */
+    this._residentQueryReturned = false
 
     /** 改修3: per-message セッションで busy 中に届いた送信を退避する pending キュー。
      *  常駐 query 化 (改修2) とは別レイヤー。resume チェーンは維持したまま、現ターン
@@ -648,11 +656,16 @@ class ClaudeStreamSession {
    * ユーザーメッセージ 1 件を 1 query() として実行する。
    * 既存ターン実行中 (busy) は破棄せず pending キューへ退避し、現ターン完了時に drain する
    * (改修3)。常駐 query 対象 (新規セッション) は InputQueue へ積む (改修2)。
+   *
+   * 配達保証 (S2, 2026-07-05): 戻り値は `{ accepted: boolean, reason?: string }`。
+   * `accepted` は「キュー/常駐 query への投入が完了した (= ack を返してよい)」ことを
+   * 意味し、ターンの完走までは待たない (フル実行を待つと ack が数十秒〜数分遅れるため)。
+   * `accepted:false` のときは呼び出し元 (ClaudeStreamBridge.input) が nack を組み立てる。
    */
   async sendMessage(message, opts = {}) {
-    if (this._closed) return
+    if (this._closed) return { accepted: false, reason: "queue_dead" }
     const prompt = extractPromptText(message)
-    if (!prompt) return
+    if (!prompt) return { accepted: false, reason: "empty_message" }
 
     // ultracode ワンショット (0.6.28): このターンのみ xhigh effort + 常時 dynamic-workflow
     // オーケストレーションを有効化する。セッション既定としては持たず (トークン消費が
@@ -683,7 +696,7 @@ class ClaudeStreamSession {
           "resident busy, message queued",
         )
         this._emitQueueState()
-        return
+        return { accepted: true }
       }
       this._busy = true
       // 改修4 (A): 死亡ガード。常駐 query が未起動 or (エラー等で) 終了済み (_residentQuery=null)
@@ -697,23 +710,49 @@ class ClaudeStreamSession {
         this._startResidentQuery()
       }
       await this._reconcileResidentUltracode(ultracode)
+      // A-2 修正 (2026-07-05): 上の await 中に常駐 query の generator が自然終了している
+      // ことがある (_residentQueryReturned が finally で true になる)。その場合 this._residentQuery
+      // はまだ非 null (finally 未実行) に見えても、実体は既に誰も consume しない返却済み
+      // generator であり、そのまま push すると消失する。fresh-start と同じ手順 (InputQueue の
+      // 再生成 + 再起動) を踏んでから push することで、既存の resident 復活ガード
+      // (B6 / 異常終了時の自動再起動) に合流させる。
+      if (this._residentQueryReturned || !this._residentQuery) {
+        this._inputQueue = new InputQueue()
+        this._residentStarted = true
+        this._startResidentQuery()
+      }
+      if (this._closed) return { accepted: false, reason: "queue_dead" }
       this._inputQueue.push(toSDKUserMessage(prompt))
-      return
+      return { accepted: true }
     }
 
     // 従来 per-message: 1 メッセージ = 1 query (resume チェーン)。既存セッション (resume) 用。
     // 改修3: busy 中の送信は破棄せず pending キューへ退避し、現ターン完了時に drain する
     // (ターミナル流の「積む→待機→順次実行」)。常駐 query 化はしないので暴走リスクは増えない。
-    if (this._busy) {
+    // A-3 (2026-07-05): busy===false でも _pendingMessages が非空なら (本来は
+    // _runPerMessage の finally が同一 tick 内で busy=false→drain を行うため到達しない
+    // はずだが、将来の変更で両者の間に await が入り込んだ場合の防御) 直接実行へ
+    // バイパスさせず、必ず pending 経由の FIFO へ合流させる (resident 側の FIFO 修正
+    // (PR #212) と同じ「pending を追い越させない」という設計思想)。
+    if (this._busy || this._pendingMessages.length > 0) {
       this._enqueuePending(prompt, ultracode)
       this.logger?.info(
         { stream_id: this.stream_id, queued: this._pendingMessages.length },
         "claude busy, message queued",
       )
       this._emitQueueState()
-      return
+      return { accepted: true }
     }
-    return this._runPerMessage(prompt, { ultracode })
+    // ack はターン完走を待たず「起動できたか」で返すため、フル実行の Promise を
+    // 呼び出し元へ伝播させない (fire-and-forget)。例外は _runPerMessage 内部で
+    // 握っているため通常は reject しないが、念のため warn だけ残す。
+    this._runPerMessage(prompt, { ultracode }).catch((err) => {
+      this.logger?.error(
+        { stream_id: this.stream_id, err: err?.message },
+        "per-message run threw unexpectedly",
+      )
+    })
+    return { accepted: true }
   }
 
   /** per-message 1 ターンを実行する (resume チェーン)。busy 中に届いた送信は sendMessage
@@ -1049,6 +1088,10 @@ class ClaudeStreamSession {
     // 適用済み状態の追跡を false にリセットし、次ターンの reconcile が正しく差分判定できる
     // ようにする (異常終了→resume 再起動時にも確実にリセット)。
     this._ultracodeCurrent = false
+    // A-2 (2026-07-05): 新しい query を起動するたびに「まだ generator は返却されていない」
+    // 状態へリセットする (前回の finally で true になったままだと、この新しい query が
+    // 生きている間も sendMessage が誤って「返却済み」と判定してしまう)。
+    this._residentQueryReturned = false
     // 改修4: 起動時に sessionId (= resumeSessionId) があれば resume チェーンで文脈を引き継ぐ。
     // query 起動時点の値のみ有効 (起動後に確定/変化する session_id は同一 query 内で継続される)。
     if (this.sessionId) options.resume = this.sessionId
@@ -1106,6 +1149,11 @@ class ClaudeStreamSession {
         }
       }
     } finally {
+      // A-2 (2026-07-05): generator が返却された (for await ループが完走した) ことを、
+      // this._residentQuery を null にするより前に記録する。sendMessage 側の
+      // await 中にこのタイミングを跨いだ場合、push 先が誰も consume しない
+      // generator になっていたことを検知できるようにするため。
+      this._residentQueryReturned = true
       this._residentQuery = null
       this._busy = false
       denyPending("closed")
@@ -1149,12 +1197,44 @@ class ClaudeStreamSession {
   abortTurn() {
     // 常駐 query は interrupt() で現ターンのみ中断する (query は継続、次 input 受付継続)。
     if (this._residentQuery && typeof this._residentQuery.interrupt === "function") {
+      const wasBusy = this._busy
       try {
         this._residentQuery.interrupt()
       } catch {
         /* ignore */
       }
       this._busy = false
+      // SDK-P0-2 (2026-07-07): resident 経路のターン終端イベント非対称の解消。
+      // per-message の abort (_runPerMessage finally) は合成 result (aborted_by_user) を
+      // frontend へ emit + onTurnSettled を呼んで UI (turnActive/interrupting) とサイドバー
+      // 信号 (processing→waiting) を即時解除するが、resident の abortTurn は interrupt() が
+      // result を発火しない (下記 T05699 コメント参照) ため、どちらも出さず UI は 120s 無音
+      // ウォッチドッグ / サイドバーは 90s TTL 失効まで「停止中…」で固着していた。ここで
+      // per-message と対称な終端イベントを出し、即時にターン終了を確定させる。
+      // - 実行中ターンがあった (wasBusy) ときだけ emit する (未走行での空 abort に
+      //   「中断しました」フッターを出さない)。
+      // - close()/reap 経由の abort (_closed=true) では browser は既に離脱しているため抑止する。
+      // - drain タイミングは変更しない (既存の同期 drain を維持し、result+idle 二重 drain や
+      //   中断ターンの遅延 idle が新ターンを誤終了させる新種レースを持ち込まない)。
+      // - 合成 result の uuid は重複排除 (isDuplicateEvent の result 署名判定) 回避のため必須。
+      if (wasBusy && !this._closed) {
+        try {
+          this.onTurnSettled?.()
+        } catch {
+          /* ignore */
+        }
+        try {
+          this._emit({
+            type: "result",
+            subtype: "aborted_by_user",
+            uuid: randomUUID(),
+            session_id: this.sessionId ?? undefined,
+            timestamp: new Date().toISOString(),
+          })
+        } catch {
+          /* ignore */
+        }
+      }
       // T05699 残タスク #2-1 (2026-07-04): interrupt() は現ターンの result を発火しない
       // (query は継続、次 input 受付継続のみ)。そのため abort 時点で _pendingMessages に
       // 溜まっている送信待ちメッセージは、result 経由の drain (_runResidentQuery 内の
@@ -1482,23 +1562,34 @@ export class ClaudeStreamBridge extends EventEmitter {
     return { stream_id, resuming: !!resumeSessionId }
   }
 
-  /** browser → claude の user メッセージ。1 件 = 1 query (resume チェーン)。 */
-  input({ stream_id, message, ultracode }) {
+  /**
+   * browser → claude の user メッセージ。1 件 = 1 query (resume チェーン)。
+   *
+   * 配達保証 (S2, 2026-07-05): 戻り値は `{ ok: boolean, reason?: string }`
+   * (旧: boolean のみ)。呼び出し元 (main.mjs) はこれを見て `claude.input.ack` /
+   * `claude.input.nack` を browser へ送出する。`ok:true` は「ターン完走」ではなく
+   * 「キュー/常駐 query への投入が完了した」ことを意味する (ターン完走まで待つと
+   * ack が大幅に遅延するため)。ターン実行自体の結果は従来どおり onEvent 経由で届く。
+   */
+  async input({ stream_id, message, ultracode }) {
     const s = this.sessions.get(stream_id)
     if (!s) {
       this.logger?.warn({ stream_id }, "claude.input but stream missing")
-      return false
+      return { ok: false, reason: "stream_missing" }
     }
     s.touch(stream_id) // B11: この端末の最終アクティビティを更新 (死端末 GC 用)
-    // 非同期でターン実行 (完了は result イベント + onEvent 経由で browser に届く)
     // ultracode (0.6.28): このメッセージのみ ultracode ワンショットを適用するフラグ。
-    s.sendMessage(message, { ultracode: ultracode === true }).catch((err) => {
+    try {
+      const result = await s.sendMessage(message, { ultracode: ultracode === true })
+      if (result?.accepted) return { ok: true }
+      return { ok: false, reason: result?.reason || "queue_dead" }
+    } catch (err) {
       this.logger?.error(
         { stream_id, err: err?.message },
         "claude sendMessage threw unexpectedly",
       )
-    })
-    return true
+      return { ok: false, reason: "error" }
+    }
   }
 
   /** browser → claude の permission 応答。allow/deny + 加工された input を SDK に返す。 */

package/src/codex-appserver-client.mjs

@@ -20,8 +20,22 @@ import { EventEmitter } from "node:events"
 
 const DEFAULT_CODEX_CMD = "codex"
 
+// S3 Codex 堅牢化 (2026-07-05): request() の既定タイムアウト。app-server プロセスが
+// 生きたまま応答しなくなるケース (ハング/デッドロック) では、プロセス exit イベントに
+// 依存する既存の _settleAllPending() が発火せず、turn/start 等の Promise が永久に
+// pending のままになる (「attach 後バブルは出るが Codex が反応しない」報告の根本原因の
+// 一つ)。HUB_CODEX_REQUEST_TIMEOUT_MS で上書き可能。
+const DEFAULT_REQUEST_TIMEOUT_MS = 20_000
+
+function resolveRequestTimeoutMs(explicit) {
+  if (typeof explicit === "number" && explicit >= 0) return explicit
+  const raw = process.env.HUB_CODEX_REQUEST_TIMEOUT_MS
+  const parsed = raw !== undefined ? Number(raw) : NaN
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : DEFAULT_REQUEST_TIMEOUT_MS
+}
+
 export class CodexAppServerClient extends EventEmitter {
-  constructor({ cwd, codexCmd, env, logger, spawnFn } = {}) {
+  constructor({ cwd, codexCmd, env, logger, spawnFn, requestTimeoutMs } = {}) {
     super()
     this.cwd = cwd
     this.codexCmd = codexCmd || DEFAULT_CODEX_CMD
@@ -30,6 +44,9 @@ export class CodexAppServerClient extends EventEmitter {
     // テストから spawn をスタブ化できるよう注入可能にする (実 codex バイナリ不要で
     // JSON-RPC 相関ロジックだけを検証するため。既定は node:child_process の spawn)。
     this._spawnFn = spawnFn || spawn
+    // テストから短縮できるよう注入可能にする (既定は 20000ms、env でも上書き可能)。
+    // 0 を指定するとタイムアウト無効 (旧挙動、テスト以外での使用は非推奨)。
+    this._requestTimeoutMs = resolveRequestTimeoutMs(requestTimeoutMs)
     this.child = null
     this.closed = false
     this._buf = ""
@@ -136,7 +153,15 @@ export class CodexAppServerClient extends EventEmitter {
     this.logger?.warn?.({ msg }, "codex app-server: unrecognized message shape")
   }
 
-  /** クライアント発のリクエストを送り、応答 (result) を Promise で返す。 */
+  /**
+   * クライアント発のリクエストを送り、応答 (result) を Promise で返す。
+   *
+   * S3 Codex 堅牢化: `this._requestTimeoutMs` (既定 20000ms、`HUB_CODEX_REQUEST_TIMEOUT_MS`
+   * で上書き可) を過ぎても応答が来なければ reject する。app-server プロセス自体は生きて
+   * いる (exit イベントが発火しない) ハングを想定した保険であり、`_pending` からは
+   * タイムアウト時に確実に除去する (遅延応答が届いても再度 resolve/reject されないよう
+   * 二重解決を防ぎつつ、マップの肥大化 = メモリリークも防ぐ)。
+   */
   request(method, params) {
     if (this.closed || !this.child) {
       return Promise.reject(new Error("codex app-server is not running"))
@@ -144,7 +169,26 @@ export class CodexAppServerClient extends EventEmitter {
     const id = ++this._reqId
     this._write({ jsonrpc: "2.0", id, method, params })
     return new Promise((resolve, reject) => {
-      this._pending.set(id, { resolve, reject })
+      let timer = null
+      const settle = (fn) => (value) => {
+        if (timer) clearTimeout(timer)
+        this._pending.delete(id)
+        fn(value)
+      }
+      const entry = { resolve: null, reject: null }
+      entry.resolve = settle(resolve)
+      entry.reject = settle(reject)
+      if (this._requestTimeoutMs > 0) {
+        timer = setTimeout(() => {
+          entry.reject(
+            Object.assign(new Error(`codex app-server request timed out: ${method}`), {
+              reason: "timeout",
+            }),
+          )
+        }, this._requestTimeoutMs)
+        timer.unref?.()
+      }
+      this._pending.set(id, entry)
     })
   }
 

package/src/codex-stream-bridge.mjs

@@ -77,6 +77,37 @@ function flattenThreadItems(thread) {
   return items
 }
 
+/**
+ * 配達保証 (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 が組み立てる
+ * `codex.error.reason` と同じ値になり、frontend 側の分岐を一致させられる)、付与されて
+ * いない場合 (例: `_require()` の「セッション不在」) のみメッセージ文言からの
+ * ベストエフォート分類にフォールバックする。
+ *
+ * - stream_missing: `_require` が投げる「セッション不在」(stream_id 誤り / 既に detach 済み)
+ * - queue_dead: app-server プロセスが既に停止/終了している
+ * - timeout / turn_mismatch_retry_failed: 上記 S3 由来の err.reason をそのまま採用
+ * @param {unknown} err
+ * @returns {string}
+ */
+export function classifyCodexInputError(err) {
+  if (typeof err?.reason === "string" && err.reason) return err.reason
+  const message = String(err?.message || err || "")
+  if (/no active codex session/i.test(message)) return "stream_missing"
+  if (/not running|exited unexpectedly|client stopped/i.test(message)) {
+    return "queue_dead"
+  }
+  if (/turn/i.test(message) && /(mismatch|expected|stale|unknown)/i.test(message)) {
+    return "turn_mismatch"
+  }
+  return "error"
+}
+
 function userInputFromMessage(message) {
   const content = message?.content
   if (typeof content === "string") {
@@ -280,12 +311,41 @@ export class CodexStreamBridge extends EventEmitter {
     const session = this._require(stream_id)
     const input = userInputFromMessage(message)
     if (session.activeTurnId) {
-      await session.client.request("turn/steer", {
-        threadId: session.threadId,
-        expectedTurnId: session.activeTurnId,
-        input,
-      })
-      return
+      try {
+        await session.client.request("turn/steer", {
+          threadId: session.threadId,
+          expectedTurnId: session.activeTurnId,
+          input,
+        })
+        return
+      } catch (err) {
+        // S3 Codex 堅牢化 (2026-07-05): turn/steer が reject される最大の原因は
+        // expectedTurnId 不一致 (turn/completed 通知の取りこぼしで session.activeTurnId
+        // が古いまま残るケース) や request() タイムアウト。回復キューが無いと、以降の
+        // 入力が全て turn/steer として送られ続けて無反応になる (報告症状②の原因)。
+        // ここで activeTurnId を捨てて「busy ではない」扱いに戻し、同一メッセージを
+        // 1 回だけ turn/start として自動リトライすることで自己修復する。
+        session.activeTurnId = null
+        try {
+          const retryParams = { threadId: session.threadId, input }
+          if (model) retryParams.model = model
+          if (effort) retryParams.effort = effort
+          await session.client.request("turn/start", retryParams)
+          return
+        } catch (retryErr) {
+          // 呼び出し元 (main.mjs の codex.input dispatch) が既存の .catch() で
+          // codex.error を送出する経路に reason を乗せて届ける (bridge 側で二重に
+          // 'error' イベントを emit すると frontend へ codex.error が二重送出される
+          // ため、ここでは throw のみに留める)。
+          const reason = "turn_mismatch_retry_failed"
+          throw Object.assign(
+            new Error(
+              `turn/steer failed (${err.message}) and turn/start retry also failed: ${retryErr.message}`,
+            ),
+            { reason, cause: retryErr },
+          )
+        }
+      }
     }
     const params = { threadId: session.threadId, input }
     if (model) params.model = model

package/src/main.mjs

@@ -25,7 +25,7 @@ import { loadPlugins, runHookBroadcast, runHookChain } from "./plugin-loader.mjs
 import { WsClient } from "./ws-client.mjs"
 import { PtyBridge } from "./pty-bridge.mjs"
 import { ClaudeStreamBridge } from "./claude-stream-bridge.mjs"
-import { CodexStreamBridge } from "./codex-stream-bridge.mjs"
+import { CodexStreamBridge, classifyCodexInputError } from "./codex-stream-bridge.mjs"
 import { UploadManager } from "./claude-upload.mjs"
 import { requestSelfUninstall } from "./service-install.mjs"
 import {
@@ -103,6 +103,7 @@ import {
   getSessionUsages,
   getUsage,
   isFreshUnboundBind,
+  jsonlContextForCwd,
   recordChatRateLimit,
   recordChatUsageSnapshot,
   turnActiveForCwd,
@@ -547,13 +548,23 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
             status: "processing",
             contextPct: pct,
             inputPending: false,
+            // identity (S1): この cwd の chat 信号が「今どの CLI・どのセッションのものか」を
+            // 明示する。claude.attach で確定させた identity と一致すれば温存、別セッション/
+            // エンジンに切り替わっていれば chat-signals.mjs 側が自動でリセットする。
+            cliKind: "claude",
+            sessionId: session_id || null,
           })
         } catch {
           /* ignore */
         }
       } else if (event?.type === "result") {
         try {
-          recordChatActivity(cwd, { status: "waiting", inputPending: false })
+          recordChatActivity(cwd, {
+            status: "waiting",
+            inputPending: false,
+            cliKind: "claude",
+            sessionId: session_id || null,
+          })
         } catch {
           /* ignore */
         }
@@ -621,17 +632,51 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
   if (codexBridge) {
     codexBridge.on("event", ({ stream_id, thread_id, cwd, notification }) => {
       if (notification.method === "turn/started") {
-        try {
-          recordChatActivity(cwd, { status: "processing", inputPending: false })
-        } catch {
-          /* ignore */
-        }
+        // S1 (2026-07): contextPct を渡していなかったため、Codex 選択中は状態ドット
+        // (processing/waiting) こそ更新されるがコンテキスト% は claude 由来の古い値の
+        // ままだった (症状③の一因)。codexUsageForThread は rollout ファイルの I/O を
+        // 伴うため fire-and-forget (await せず、取得できた時点で反映)。
+        ;(async () => {
+          let contextPct = null
+          try {
+            const usage = await codexUsageForThread(thread_id)
+            contextPct = typeof usage?.context === "number" ? usage.context : null
+          } catch {
+            /* ignore */
+          }
+          try {
+            recordChatActivity(cwd, {
+              status: "processing",
+              contextPct,
+              inputPending: false,
+              cliKind: "codex",
+              sessionId: thread_id || null,
+            })
+          } catch {
+            /* ignore */
+          }
+        })()
       } else if (notification.method === "turn/completed") {
-        try {
-          recordChatActivity(cwd, { status: "waiting", inputPending: false })
-        } catch {
-          /* ignore */
-        }
+        ;(async () => {
+          let contextPct = null
+          try {
+            const usage = await codexUsageForThread(thread_id)
+            contextPct = typeof usage?.context === "number" ? usage.context : null
+          } catch {
+            /* ignore */
+          }
+          try {
+            recordChatActivity(cwd, {
+              status: "waiting",
+              contextPct,
+              inputPending: false,
+              cliKind: "codex",
+              sessionId: thread_id || null,
+            })
+          } catch {
+            /* ignore */
+          }
+        })()
       }
       client.send({ type: "codex.event", stream_id, thread_id, event: notification })
     })
@@ -1415,6 +1460,59 @@ export function applyChatOverlay(paneStatus, paneContextPct, chat) {
   return { status, contextPct }
 }
 
+/**
+ * S1 (2026-07): claude.attach / codex.attach の直後に、その cwd に対応する session.state を
+ * 1 回だけ即時 push する。startStateLoop の周期 (既定 5s) を待つと、エンジン切替や新規
+ * セッション選択の直後もサイドバーのドーナツ/ステータスドットが前セッションの値のまま
+ * 数秒間残ってしまう (症状③④)。claude.tui.bind が既に持つ「即時ステータススナップショット」
+ * (main.mjs 内 detectSessionState 直後の push) と同じ発想で、チャット (SDK/app-server) 側にも
+ * 対称の即時 push を用意する。
+ *
+ * cwd → session_name の解決: claude.attach / codex.attach は tmux の session_name を知らない
+ * (browser は cwd/stream_id しか送らない) ため、listSessionStates で全 tmux session を走査し
+ * cwd が一致するものへ push する (通常は 1 cwd = 1 tmux session)。tmux 自体が無い / 一致が
+ * 無ければ何もしない (安全側、次の poll 系フォールバックに委ねる)。
+ *
+ * `listSessionStatesFn` は単体テスト用の DI ポイント (既定は実 `listSessionStates`、tmux を
+ * 起動する)。実運用では省略してよい。
+ *
+ * @param {{ client: object, plugins: object, logger?: object, cwd: string, cliKind: 'claude'|'codex', sessionId: string|null, contextPct?: number|null, listSessionStatesFn?: Function }} args
+ */
+export async function pushImmediateChatState({
+  client,
+  plugins,
+  logger,
+  cwd,
+  cliKind,
+  sessionId,
+  contextPct = 0,
+  listSessionStatesFn = listSessionStates,
+}) {
+  if (!cwd || !client) return
+  try {
+    const states = await listSessionStatesFn({ plugins, logger })
+    for (const s of states) {
+      if (s.cwd !== cwd) continue
+      client.send({
+        type: "session.state",
+        session_name: s.session_name,
+        status: "waiting",
+        context_pct: typeof contextPct === "number" ? contextPct : 0,
+        permission_mode: s.permission_mode ?? null,
+        stable: true,
+        proc_busy: false,
+        child_busy: false,
+        stalled: false,
+        turn_active: false,
+        cli_kind: cliKind,
+        chat_session_id: sessionId ?? null,
+      })
+    }
+  } catch (err) {
+    logger?.warn?.({ err: err?.message, cwd }, "pushImmediateChatState failed")
+  }
+}
+
 /**
  * turnActiveForCwd / jsonlContextForCwd に渡す bound session_id を解決する純関数。
  *
@@ -1638,6 +1736,13 @@ export function startStateLoop({ client, plugins, logger, intervalMs, claudeBrid
             turnActive = null
         }
 
+        // S1 (2026-07): チャット信号 (getChatSignal) が identity (cliKind/sessionId) を
+        // 持っていれば、それをそのまま session.state に同梱する。frontend はこれで「今
+        // 表示中のエンジン/セッションと一致する push か」を判定し、不一致の値を適用しない
+        // (前セッションの値を上書きし続ける症状③④の frontend 側の受け口)。
+        const chatCliKind = chat?.cliKind ?? null
+        const chatSessionId = chat?.sessionId ?? null
+
         const prev = lastByName.get(s.session_name)
         if (
           !prev ||
@@ -1648,7 +1753,9 @@ export function startStateLoop({ client, plugins, logger, intervalMs, claudeBrid
           prev.proc_busy !== procBusy ||
           prev.child_busy !== childBusy ||
           prev.stalled !== stalled ||
-          prev.turn_active !== turnActive
+          prev.turn_active !== turnActive ||
+          prev.cli_kind !== chatCliKind ||
+          prev.chat_session_id !== chatSessionId
         ) {
           lastByName.set(s.session_name, {
             status,
@@ -1659,6 +1766,8 @@ export function startStateLoop({ client, plugins, logger, intervalMs, claudeBrid
             child_busy: childBusy,
             stalled,
             turn_active: turnActive,
+            cli_kind: chatCliKind,
+            chat_session_id: chatSessionId,
           })
           // 計装 (2026-06-19, 既定 OFF=2026-06-20): 状態変化時に値を記録する。常時 info はログ肥大の
           // 主因のため HUB_AGENT_STATE_TRACE=1 のときだけ出す。childBusy/outputActive を分けて出し、
@@ -1676,6 +1785,8 @@ export function startStateLoop({ client, plugins, logger, intervalMs, claudeBrid
               stable,
               context_pct: contextPct,
               turn_active: turnActive,
+              cli_kind: chatCliKind,
+              chat_session_id: chatSessionId,
             },
             "session.state push",
           )
@@ -1695,6 +1806,11 @@ export function startStateLoop({ client, plugins, logger, intervalMs, claudeBrid
             // turn_active: ステータスドット 4 状態統一の権威ソース。null は旧クライアント互換
             // (frontend は欠落時に旧 prompt_submit/stale 降格ロジックへフォールバック)。
             turn_active: turnActive,
+            // cli_kind / chat_session_id (S1, 2026-07): このセッションの現在の chat 信号が
+            // どの CLI・どのセッションのものか。チャット信号が無い (TUI 専用/未対応) 行では
+            // null (旧クライアント互換、frontend は無条件マージにフォールバック)。
+            cli_kind: chatCliKind,
+            chat_session_id: chatSessionId,
           })
         }
         // 消滅セッションの GC (perf監査/メモリリーク対策): tmux から消えたセッションの状態 Map を
@@ -1916,6 +2032,31 @@ function rememberInputId(input_id) {
   }
 }
 
+/**
+ * SDK チャット配達保証 (S2, 2026-07-05) 用の冪等化レジストリ。
+ *
+ * `claude.input` / `codex.input` に browser が付与する `input_id` を記憶し、ack
+ * ウォッチドッグ再送 (browser 側が 5s 以内に ack/nack を受け取れず再送するケース) で
+ * 同じメッセージが 2 回ターン実行されないようにする。tracked pty.data
+ * (`seenInputIds` 上) と同じ設計だが、チャンネル別に Set を分ける
+ * (input_id の採番元は browser 側で共通の可能性があるが、pty と chat で
+ * 意味論が異なる衝突を避けるため)。
+ */
+function makeSeenInputIdRegistry(max = SEEN_INPUT_IDS_MAX) {
+  const seen = new Set()
+  return {
+    has: (id) => seen.has(id),
+    remember: (id) => {
+      seen.add(id)
+      while (seen.size > max) {
+        seen.delete(seen.values().next().value)
+      }
+    },
+  }
+}
+const seenClaudeChatInputIds = makeSeenInputIdRegistry()
+const seenCodexChatInputIds = makeSeenInputIdRegistry()
+
 /**
  * input_id 付き pty.data (tracked 入力) の処理。write 成功で pty.input.ack を返し、
  * stream 不在なら pty.error を返して browser の再 attach → 再送に繋げる。
@@ -1959,6 +2100,138 @@ export function handleUntrackedPtyData(msg, ctx) {
   }
 }
 
+/**
+ * SDK チャット配達保証 (S2, 2026-07-05): `claude.input` を処理し、browser が付与した
+ * `input_id` があれば `claude.input.ack` / `claude.input.nack` を返す。無ければ従来
+ * どおり無応答の fire-and-forget (旧 frontend / 内部呼び出しとの後方互換)。
+ *
+ * `ClaudeStreamBridge.input()` の戻り値 `{ ok, reason? }` は「ターン完走」ではなく
+ * 「キュー/常駐 query への投入が完了したか」を表す (ack を素早く返すため)。
+ * テストから直接呼べるよう dispatch から切り出して export する
+ * (handleTrackedPtyData と同じ設計)。
+ */
+export function handleClaudeChatInput(msg, ctx) {
+  const stream_id = msg.stream_id
+  const input_id = typeof msg.input_id === "string" && msg.input_id ? msg.input_id : null
+  if (!ctx.claudeBridge) {
+    if (input_id) {
+      ctx.client.send({
+        type: "claude.input.nack",
+        stream_id,
+        input_id,
+        reason: "stream_missing",
+      })
+    }
+    return undefined
+  }
+  if (input_id && seenClaudeChatInputIds.has(input_id)) {
+    // 再送 (ack 喪失想定)。同じターンを 2 回実行しないよう sendMessage を
+    // 呼び直さず ack のみ返す (tracked pty.data の dedup と同じ考え方)。
+    ctx.logger?.info?.({ stream_id, input_id }, "claude.input dedup (ack only)")
+    ctx.client.send({ type: "claude.input.ack", stream_id, input_id })
+    return undefined
+  }
+  return ctx.claudeBridge
+    .input({
+      stream_id,
+      message: msg.message,
+      // ultracode (0.6.28): browser がこのメッセージ単位で送るワンショット指定。
+      // true のときだけそのターンを xhigh effort + dynamic-workflow で実行する。
+      ultracode: msg.ultracode === true,
+    })
+    .then((result) => {
+      if (!input_id) return
+      if (result?.ok) {
+        seenClaudeChatInputIds.remember(input_id)
+        ctx.client.send({ type: "claude.input.ack", stream_id, input_id })
+      } else {
+        ctx.client.send({
+          type: "claude.input.nack",
+          stream_id,
+          input_id,
+          reason: result?.reason || "queue_dead",
+        })
+      }
+    })
+    .catch((err) => {
+      ctx.logger?.error?.(
+        { stream_id, err: err?.message },
+        "claude.input dispatch threw unexpectedly",
+      )
+      if (input_id) {
+        ctx.client.send({
+          type: "claude.input.nack",
+          stream_id,
+          input_id,
+          reason: "error",
+        })
+      }
+    })
+}
+
+/**
+ * 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 の判定になる。
+ * 既存の `codex.error` 通知も維持する (input_id を知らない旧 frontend や、他の消費者向け)。
+ * テストから直接呼べるよう dispatch から切り出して export する。
+ */
+export function handleCodexChatInput(msg, ctx) {
+  const stream_id = msg.stream_id
+  const input_id = typeof msg.input_id === "string" && msg.input_id ? msg.input_id : null
+  if (!ctx.codexBridge) {
+    if (input_id) {
+      ctx.client.send({
+        type: "codex.input.nack",
+        stream_id,
+        input_id,
+        reason: "stream_missing",
+      })
+    }
+    return undefined
+  }
+  if (input_id && seenCodexChatInputIds.has(input_id)) {
+    // 再送 (ack 喪失想定)。turn/start・turn/steer を再送出せず ack のみ返す
+    // (二重ターン実行を避ける。claude.input dedup と同じ考え方)。
+    ctx.logger?.info?.({ stream_id, input_id }, "codex.input dedup (ack only)")
+    ctx.client.send({ type: "codex.input.ack", stream_id, input_id })
+    return undefined
+  }
+  return ctx.codexBridge
+    .input({
+      stream_id,
+      message: msg.message,
+      model: msg.model || undefined,
+      effort: msg.effort || undefined,
+    })
+    .then(() => {
+      if (!input_id) return
+      seenCodexChatInputIds.remember(input_id)
+      ctx.client.send({ type: "codex.input.ack", stream_id, input_id })
+    })
+    .catch((err) => {
+      if (input_id) {
+        ctx.client.send({
+          type: "codex.input.nack",
+          stream_id,
+          input_id,
+          reason: classifyCodexInputError(err),
+        })
+      }
+      // 既存の error 通知も維持する (input_id を知らない旧 frontend や、
+      // input_id 以外の理由でエラー表示を必要とする他の消費者向け)。S3 Codex 堅牢化
+      // 由来の err.reason ('timeout' / 'turn_mismatch_retry_failed') があれば
+      // 引き続き codex.error にも乗せる (S2 導入前からの互換維持)。
+      ctx.client.send({
+        type: "codex.error",
+        stream_id,
+        error: err.message,
+        ...(err.reason ? { reason: err.reason } : {}),
+      })
+    })
+}
+
 /**
  * 離席中キュー投入 (claude.tui.queue.flush) の冪等化用に、処理済み flush_id を記憶する。
  * WS 再送で同じ flush が二重に届いても二重 paste しないため。上限を超えたら全消去 (best-effort)。
@@ -2290,9 +2563,11 @@ async function dispatch(msg, ctx) {
           // cwd は明示指定が無ければ agent.json の cwd → HOME の順で fallback
           // (将来 cockpit から worktree path を指定する用)。
           // model / permissionMode は agent.json の値も使えるよう fallback。
+          const cwdArg = msg.cwd || ctx.config?.claude_cwd || undefined
+          const resumeSessionId = msg.resume_session_id || null
           const info = ctx.claudeBridge.attach({
             stream_id,
-            cwd: msg.cwd || ctx.config?.claude_cwd || undefined,
+            cwd: cwdArg,
             model: msg.model || ctx.config?.claude_model || null,
             permissionMode:
               msg.permission_mode ||
@@ -2307,13 +2582,67 @@ async function dispatch(msg, ctx) {
             // effort (Opus 4.6+): browser がチャット既定 (agent 設定由来) を送る。
             // 空文字/未指定なら null (SDK / Claude Code 既定 = Opus は high)。
             effort: msg.effort || ctx.config?.claude_effort || null,
-            resumeSessionId: msg.resume_session_id || null,
+            resumeSessionId,
           })
           ctx.client.send({
             type: "claude.ready",
             stream_id,
             resuming: info.resuming,
           })
+          // S1 (2026-07): セッション状態の identity 正本化。TUI の claude.tui.bind
+          // (main.mjs 内 clearChatSignal 呼び出し箇所参照) と対称に、SDK チャットの
+          // attach 時点でも前セッションのチャット信号を引き継がない。
+          //  - fresh (resume 無し): 新規セッションで session_id はまだ確定しない
+          //    (SDK が最初の assistant イベントで通知する) ため null。前の信号を破棄し
+          //    ゼロ値を即時 push してドーナツ/ドットを即座にリセットする (症状④)。
+          //  - resume: bound session の jsonl から実 context% を解決し、cli_kind='claude' +
+          //    実 session_id で identity を確定させて即時 push する (症状③)。
+          const resolvedCwd = cwdArg || process.env.HOME || process.cwd()
+          if (resolvedCwd) {
+            if (!resumeSessionId) {
+              clearChatSignal(resolvedCwd)
+              recordChatActivity(resolvedCwd, {
+                status: "waiting",
+                contextPct: 0,
+                inputPending: false,
+                cliKind: "claude",
+                sessionId: null,
+              })
+              pushImmediateChatState({
+                client: ctx.client,
+                plugins: ctx.plugins,
+                logger: ctx.logger,
+                cwd: resolvedCwd,
+                cliKind: "claude",
+                sessionId: null,
+                contextPct: 0,
+              }).catch(() => {})
+            } else {
+              jsonlContextForCwd(resolvedCwd, resumeSessionId)
+                .catch(() => null)
+                .then((jsonlCtx) => {
+                  const contextPct =
+                    typeof jsonlCtx?.percent === "number" ? jsonlCtx.percent : 0
+                  recordChatActivity(resolvedCwd, {
+                    status: "waiting",
+                    contextPct,
+                    inputPending: false,
+                    cliKind: "claude",
+                    sessionId: resumeSessionId,
+                  })
+                  return pushImmediateChatState({
+                    client: ctx.client,
+                    plugins: ctx.plugins,
+                    logger: ctx.logger,
+                    cwd: resolvedCwd,
+                    cliKind: "claude",
+                    sessionId: resumeSessionId,
+                    contextPct,
+                  })
+                })
+                .catch(() => {})
+            }
+          }
         } catch (err) {
           ctx.client.send({
             type: "claude.error",
@@ -2325,14 +2654,7 @@ async function dispatch(msg, ctx) {
       }
       case "claude.input":
         // message: { role: 'user', content: string | Array } を期待
-        if (!ctx.claudeBridge) return
-        ctx.claudeBridge.input({
-          stream_id: msg.stream_id,
-          message: msg.message,
-          // ultracode (0.6.28): browser がこのメッセージ単位で送るワンショット指定。
-          // true のときだけそのターンを xhigh effort + dynamic-workflow で実行する。
-          ultracode: msg.ultracode === true,
-        })
+        handleClaudeChatInput(msg, ctx)
         return
       case "claude.upload": {
         // Cockpit チャットモードの添付ファイル受信 (チャンク 1 件)。全チャンク到着で
@@ -3281,14 +3603,16 @@ async function dispatch(msg, ctx) {
           return
         }
         try {
+          const resolvedCwd = msg.cwd || ctx.config?.claude_cwd || undefined
+          const resumeThreadId = msg.resume_thread_id || null
           const info = await ctx.codexBridge.attach({
             stream_id,
-            cwd: msg.cwd || ctx.config?.claude_cwd || undefined,
+            cwd: resolvedCwd,
             model: msg.model || undefined,
             effort: msg.effort || undefined,
             approvalPolicy: msg.approval_policy || undefined,
             sandbox: msg.sandbox || undefined,
-            resumeThreadId: msg.resume_thread_id || null,
+            resumeThreadId,
           })
           ctx.client.send({
             type: "codex.ready",
@@ -3300,11 +3624,65 @@ async function dispatch(msg, ctx) {
             // 変更は不要 (_AGENT_PER_STREAM_TYPES の codex.ready がそのまま運ぶ)。
             history: info.history || [],
           })
+          // S1 (2026-07): claude.attach と対称の identity 正本化。Codex は thread/start
+          // 応答時点で threadId が確定するため (Claude の fresh とは異なり)、fresh でも
+          // 既に分かっている threadId を sessionId として記録する (直後の turn/started が
+          // 同じ threadId を伴って届いても identity 一致でリセットが起きないように)。
+          //  - fresh (resume 無し): ゼロ値 + 確定済み threadId で即時 push (症状④)。
+          //  - resume: codexUsageForThread で実 context% を解決し即時 push (症状③)。
+          if (resolvedCwd) {
+            if (!resumeThreadId) {
+              clearChatSignal(resolvedCwd)
+              recordChatActivity(resolvedCwd, {
+                status: "waiting",
+                contextPct: 0,
+                inputPending: false,
+                cliKind: "codex",
+                sessionId: info.threadId || null,
+              })
+              pushImmediateChatState({
+                client: ctx.client,
+                plugins: ctx.plugins,
+                logger: ctx.logger,
+                cwd: resolvedCwd,
+                cliKind: "codex",
+                sessionId: info.threadId || null,
+                contextPct: 0,
+              }).catch(() => {})
+            } else {
+              codexUsageForThread(info.threadId)
+                .catch(() => null)
+                .then((usage) => {
+                  const contextPct = typeof usage?.context === "number" ? usage.context : 0
+                  recordChatActivity(resolvedCwd, {
+                    status: "waiting",
+                    contextPct,
+                    inputPending: false,
+                    cliKind: "codex",
+                    sessionId: info.threadId,
+                  })
+                  return pushImmediateChatState({
+                    client: ctx.client,
+                    plugins: ctx.plugins,
+                    logger: ctx.logger,
+                    cwd: resolvedCwd,
+                    cliKind: "codex",
+                    sessionId: info.threadId,
+                    contextPct,
+                  })
+                })
+                .catch(() => {})
+            }
+          }
         } catch (err) {
           ctx.client.send({
             type: "codex.error",
             stream_id,
             error: err.message,
+            // S3 Codex 堅牢化: request() タイムアウト (codex-appserver-client.mjs) は
+            // err.reason='timeout' を付与する。frontend が理由別の文言/表示を出し分け
+            // られるよう素通しする (無ければ undefined = キー自体を省略)。
+            ...(err.reason ? { reason: err.reason } : {}),
           })
         }
         return
@@ -3365,21 +3743,11 @@ async function dispatch(msg, ctx) {
         // model/effort: turn/start (非 busy 時) にのみ反映される override。turn/steer
         // (busy 時) は公式スキーマ上 model/effort 非対応のため、その場合は
         // codex-stream-bridge.mjs 側で無視され次の非 busy な input() から効く。
-        if (!ctx.codexBridge) return
-        ctx.codexBridge
-          .input({
-            stream_id: msg.stream_id,
-            message: msg.message,
-            model: msg.model || undefined,
-            effort: msg.effort || undefined,
-          })
-          .catch((err) => {
-            ctx.client.send({
-              type: "codex.error",
-              stream_id: msg.stream_id,
-              error: err.message,
-            })
-          })
+        // 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 内)。
+        handleCodexChatInput(msg, ctx)
         return
       case "codex.permission.reply":
         if (!ctx.codexBridge) return