@cocorograph/hub-agent 0.7.27 → 0.7.29

package/package.json

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

package/src/claude-stream-bridge.mjs

@@ -568,18 +568,27 @@ class ClaudeStreamSession {
     }
   }
 
-  /** モデルが Opus 4.6+ (effort / adaptive thinking 対応) かどうか。
+  /** モデルが effort / adaptive thinking 対応 (Opus 4.6+ / Fable 5) かどうか。
    *  budget 方式 (maxThinkingTokens) は Opus 4.7+ で廃止扱いのため、effort モデルでは
-   *  effort + thinking:{type:'adaptive'} に切り替える。 */
+   *  effort + thinking:{type:'adaptive'} に切り替える。
+   *  ⚠️ frontend の isEffortModelByPattern (types/cockpit.ts) と同一パターンを維持する
+   *  こと。旧実装は fable-5 を含まず、frontend が effort を送っても bridge が非 effort
+   *  分岐に入り「effort も budget も未適用」になる不整合があった (2026-07-02 修正)。 */
   _isEffortModel() {
-    return typeof this.model === "string" && /claude-opus-4-[678]/.test(this.model)
+    return (
+      typeof this.model === "string" && /claude-fable-5|claude-opus-4-[678]/.test(this.model)
+    )
   }
 
   /** 思考関連オプション (effort / adaptive thinking / 旧 budget) を options へ適用する。
    *  per-message / 常駐 query の両方から呼ぶ共通ロジック (分岐の二重定義を避ける)。 */
   _applyThinkingOptions(options) {
-    if (this._isEffortModel()) {
-      // Opus: adaptive thinking を明示 ON にし、effort で深さを指定する。
+    // model 未指定 (= browser が agent/アカウント既定モデルへ委任) でも、browser が
+    // effort を明示送信してきた場合は effort 分岐に入れる。frontend は system/init の
+    // 実効モデル (runtimeModel) で capability 判定してから effort を送るため、ここでは
+    // その判断を信頼する (2026-07-02)。
+    if (this._isEffortModel() || (!this.model && this.effort)) {
+      // effort モデル: adaptive thinking を明示 ON にし、effort で深さを指定する。
       // budget 方式 (maxThinkingTokens) は使わない (Opus 4.7+ で非対応)。
       options.thinking = { type: "adaptive" }
       if (this.effort) options.effort = this.effort
@@ -803,6 +812,26 @@ class ClaudeStreamSession {
         } catch {
           /* ignore */
         }
+        // 停止即時化 (2026-07-02): onTurnSettled はチャット信号 (サイドバードット) 専用で、
+        // browser の SDK ストリーム UI (turnActive / interrupting) を解除するイベントでは
+        // ない。abort でターンが終わると result が届かず、UI は 120s 無音ウォッチドッグ
+        // まで「停止中…」のまま固着する。合成 result を通常のイベント経路 (claude.event)
+        // へ流し、reducer にターン終了を即時確定させる。subtype はユーザー中断 (abort) と
+        // 異常終了 (result 無しの自然終了) を区別する (frontend は前者を「中断しました」
+        // フッターで表示する)。uuid を持たせるのは重複排除 (isDuplicateEvent) が result
+        // 署名 (session_id + num_turns + duration_ms + cost) で判定するため — 合成 result
+        // はこれらが毎回同値になり、2 回目以降の中断で「重複」と誤判定され捨てられるのを防ぐ。
+        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 */
+        }
       }
       // graceful detach: browser が切れている間にターンが完走したら、ここで遅延
       // クローズする。manager 側で sessions Map から撤去 + exit を emit する。

package/src/codex-appserver-client.mjs

@@ -0,0 +1,181 @@
+/**
+ * codex app-server (JSON-RPC 2.0) の低レベルクライアント。
+ *
+ * Claude は @anthropic-ai/claude-agent-sdk をインプロセスで呼べるが、Codex には同等の
+ * JS SDK が無く `codex app-server` (Rust バイナリ) をサブプロセスとして起動し
+ * JSON-RPC で会話するしかない。このモジュールはその配線 (spawn・フレーミング・
+ * リクエスト/レスポンス相関・通知/サーバー発リクエストの emit) のみを担い、
+ * Codex 固有のセッション/ターン概念は codex-stream-bridge.mjs 側の責務とする。
+ *
+ * transport は `--stdio` (デフォルト) を使う。`--listen unix://<path>` も選べるが、
+ * ソケットファイルの生成/権限/クリーンアップ管理が要らず、プロセス終了で自動的に
+ * パイプも閉じる stdio の方が「1 セッション = 1 codex app-server プロセス」という
+ * per-session モデル (claude-stream-bridge.mjs の 1 stream_id = 1 セッションと対称)
+ * に単純に収まる。2026-07-02 に実機で initialize → thread/start → turn/start の
+ * 一往復を確認済み: 改行区切り JSON、レスポンスは `{id, result|error}` (method 無し)、
+ * 通知は `{method, params}` (id 無し)、サーバー発リクエストは `{id, method, params}`。
+ */
+import { spawn } from "node:child_process"
+import { EventEmitter } from "node:events"
+
+const DEFAULT_CODEX_CMD = "codex"
+
+export class CodexAppServerClient extends EventEmitter {
+  constructor({ cwd, codexCmd, env, logger, spawnFn } = {}) {
+    super()
+    this.cwd = cwd
+    this.codexCmd = codexCmd || DEFAULT_CODEX_CMD
+    this.env = env
+    this.logger = logger
+    // テストから spawn をスタブ化できるよう注入可能にする (実 codex バイナリ不要で
+    // JSON-RPC 相関ロジックだけを検証するため。既定は node:child_process の spawn)。
+    this._spawnFn = spawnFn || spawn
+    this.child = null
+    this.closed = false
+    this._buf = ""
+    this._reqId = 0
+    this._pending = new Map()
+  }
+
+  /** codex app-server プロセスを起動する。二重呼び出しは無害 (no-op)。 */
+  start() {
+    if (this.child || this.closed) return
+    this.child = this._spawnFn(this.codexCmd, ["app-server", "--stdio"], {
+      cwd: this.cwd,
+      env: this.env || process.env,
+      stdio: ["pipe", "pipe", "pipe"],
+    })
+    this.child.stdout.on("data", (chunk) => this._onStdout(chunk))
+    this.child.stderr.on("data", (chunk) => {
+      // codex app-server の stderr はエラーログ用途 (プロトコル本体は stdout のみ)。
+      this.logger?.warn?.(
+        { stderr: chunk.toString("utf8").slice(0, 2000) },
+        "codex app-server stderr",
+      )
+    })
+    this.child.on("exit", (code, signal) => {
+      const err = new Error(
+        `codex app-server exited unexpectedly (code=${code}, signal=${signal})`,
+      )
+      this._settleAllPending(err)
+      this.closed = true
+      this.emit("exit", { code, signal })
+    })
+    this.child.on("error", (err) => {
+      this._settleAllPending(err)
+      this.closed = true
+      this.emit("error", err)
+    })
+  }
+
+  _onStdout(chunk) {
+    this._buf += chunk.toString("utf8")
+    let idx
+    while ((idx = this._buf.indexOf("\n")) >= 0) {
+      const line = this._buf.slice(0, idx)
+      this._buf = this._buf.slice(idx + 1)
+      if (!line.trim()) continue
+      let msg
+      try {
+        msg = JSON.parse(line)
+      } catch (err) {
+        this.logger?.warn?.(
+          { err: err.message, line: line.slice(0, 500) },
+          "codex app-server: unparsable line (skipped)",
+        )
+        continue
+      }
+      this._dispatch(msg)
+    }
+  }
+
+  _dispatch(msg) {
+    if (msg.method !== undefined) {
+      if (msg.id !== undefined && msg.id !== null) {
+        // サーバー発リクエスト (承認要求等)。呼び出し側が respond()/respondError() で
+        // 応答を返す責務を負う (codex-stream-bridge.mjs が id を保持して処理する)。
+        this.emit("request", msg)
+      } else {
+        this.emit("notification", msg)
+      }
+      return
+    }
+    if (msg.id !== undefined && msg.id !== null) {
+      const pending = this._pending.get(msg.id)
+      if (!pending) {
+        // 対応する pending が無い (タイムアウト後の遅延応答等)。実害は無いので警告のみ。
+        this.logger?.warn?.({ id: msg.id }, "codex app-server: response for unknown id")
+        return
+      }
+      this._pending.delete(msg.id)
+      if (msg.error) {
+        pending.reject(
+          Object.assign(new Error(msg.error.message || "codex app-server error"), {
+            code: msg.error.code,
+            data: msg.error.data,
+          }),
+        )
+      } else {
+        pending.resolve(msg.result)
+      }
+      return
+    }
+    this.logger?.warn?.({ msg }, "codex app-server: unrecognized message shape")
+  }
+
+  /** クライアント発のリクエストを送り、応答 (result) を Promise で返す。 */
+  request(method, params) {
+    if (this.closed || !this.child) {
+      return Promise.reject(new Error("codex app-server is not running"))
+    }
+    const id = ++this._reqId
+    this._write({ jsonrpc: "2.0", id, method, params })
+    return new Promise((resolve, reject) => {
+      this._pending.set(id, { resolve, reject })
+    })
+  }
+
+  /** クライアント発の通知 (応答不要) を送る。 */
+  notify(method, params) {
+    if (this.closed || !this.child) return
+    this._write({ jsonrpc: "2.0", method, params })
+  }
+
+  /** サーバー発リクエスト (承認要求等) への成功応答。 */
+  respond(id, result) {
+    if (this.closed || !this.child) return
+    this._write({ jsonrpc: "2.0", id, result: result === undefined ? null : result })
+  }
+
+  /** サーバー発リクエストへのエラー応答。 */
+  respondError(id, error) {
+    if (this.closed || !this.child) return
+    this._write({ jsonrpc: "2.0", id, error })
+  }
+
+  _write(obj) {
+    this.child.stdin.write(JSON.stringify(obj) + "\n")
+  }
+
+  _settleAllPending(err) {
+    for (const { reject } of this._pending.values()) reject(err)
+    this._pending.clear()
+  }
+
+  /** プロセスを停止する (stdin を閉じてから kill)。二重呼び出しは無害。 */
+  stop() {
+    if (!this.child || this.closed) return
+    this.closed = true
+    this._settleAllPending(new Error("codex app-server client stopped"))
+    try {
+      this.child.stdin.end()
+    } catch {
+      // stdin が既に閉じている等は無視して良い (stop の冪等性を優先)。
+    }
+    try {
+      this.child.kill()
+    } catch {
+      // プロセスが既に無い場合等は無視して良い。
+    }
+  }
+}

package/src/codex-stream-bridge.mjs

@@ -0,0 +1,257 @@
+/**
+ * Codex 版チャットブリッジ (Cockpit Codex 両対応 item#3, Slice 2)。
+ *
+ * claude-stream-bridge.mjs (ClaudeStreamBridge/ClaudeStreamSession) と対称的な役割を
+ * codex-appserver-client.mjs (CodexAppServerClient) の上に実装する。1 stream_id = 1
+ * codex app-server プロセス (= 1 Thread) の per-session モデルを採る (Slice 0 の実機
+ * 検証で確認した per-session 方針、docs は codex-appserver-client.mjs 冒頭コメント参照)。
+ *
+ * Claude 側との対応 (詳細は main.mjs の codex.* dispatch = Slice 3 で配線):
+ *   claude.attach            → attach()   (initialize → thread/start か thread/resume)
+ *   claude.input              → input()    (turn/start、ターン中は turn/steer)
+ *   claude.interrupt          → interrupt() (turn/interrupt)
+ *   claude.detach              → detach()   (TTL 付き graceful close)
+ *   claude.permission.reply    → permissionReply() (client.respond/respondError)
+ *   claude.event (生 SDK イベント素通し) → 'event' (生 notification 素通し、同じ思想)
+ *   claude.permission.request  → 'permission' (承認/入力要求の生 method+params 素通し)
+ *
+ * Slice 2 のスコープ外 (意図的に見送り、後続スライスで追加する):
+ *   - 複数ブラウザタブでの同一スレッド共有 (Claude の HUB_AGENT_CHAT_SHARED 相当)。
+ *     resumeThreadId が「この hub-agent プロセス内で存命中の別 stream_id のセッション」
+ *     を指す in-memory reattach は今回未対応。resumeThreadId は「未存命のスレッドを
+ *     thread/resume で再ロードする」場合のみ扱う。
+ *   - 画像/添付入力 (テキストのみ)。
+ *   - acceptForSession や execpolicy/network amendment 等の高度な承認 decision
+ *     (permissionReply は decision をそのまま素通しするので呼び出し側が組み立てる)。
+ */
+import { EventEmitter } from "node:events"
+
+import { CodexAppServerClient } from "./codex-appserver-client.mjs"
+
+// detach 後、非 busy なセッションを生かしておく猶予。claude 側 (7 日) と違い短くする:
+// Slice 2 は in-memory reattach 非対応のため、browser の WS 再接続ごとに新 stream_id で
+// 新プロセスが起動し、旧プロセスは detach で TTL 待ちに入る。7 日だと再接続チャーンの
+// たびに codex app-server プロセスが積み上がる (リーク)。Codex は thread/resume が
+// rollout 正本からモデル側コンテキストを完全復元できるため、プロセスを短命にしても
+// 会話は失われない (再 attach 時のプロセス起動コストは 1〜2 秒)。ターン実行中は TTL に
+// 関わらず完走まで絶対に落とさない (_maybeReapAfterIdle が busy 中は予約しない)。
+const IDLE_DETACH_TTL_MS = 5 * 60 * 1000
+
+const CLIENT_INFO = { name: "cockpit-hub-agent", title: "Cockpit", version: "1.0.0" }
+
+function userInputFromMessage(message) {
+  const content = message?.content
+  if (typeof content === "string") {
+    return [{ type: "text", text: content }]
+  }
+  if (Array.isArray(content)) {
+    return content
+      .filter((block) => block && (block.type === "text" || typeof block.text === "string"))
+      .map((block) => ({ type: "text", text: block.text }))
+  }
+  return [{ type: "text", text: String(content ?? "") }]
+}
+
+export class CodexStreamBridge extends EventEmitter {
+  constructor({ codexCmd, logger, clientFactory, detachTtlMs } = {}) {
+    super()
+    this.codexCmd = codexCmd
+    this.logger = logger
+    this._clientFactory = clientFactory || ((opts) => new CodexAppServerClient(opts))
+    // テストから TTL を短縮できるよう注入可能にする (既定は 7 日)。
+    this._detachTtlMs = detachTtlMs ?? IDLE_DETACH_TTL_MS
+    /** @type {Map<string, object>} stream_id -> session record */
+    this.sessions = new Map()
+  }
+
+  /**
+   * @returns {Promise<{resuming: boolean, threadId: string}>}
+   */
+  async attach({ stream_id, cwd, model, effort, approvalPolicy, sandbox, resumeThreadId }) {
+    if (this.sessions.has(stream_id)) {
+      throw new Error(`stream_id already attached: ${stream_id}`)
+    }
+    const client = this._clientFactory({ cwd, codexCmd: this.codexCmd, logger: this.logger })
+    const session = {
+      stream_id,
+      cwd,
+      client,
+      threadId: null,
+      activeTurnId: null,
+      pendingApprovals: new Map(), // request_id -> { turnId }
+      detachTimer: null,
+      dead: false,
+    }
+    this.sessions.set(stream_id, session)
+    this._wireClient(session)
+    client.start()
+
+    try {
+      await client.request("initialize", { clientInfo: CLIENT_INFO })
+      const resuming = !!resumeThreadId
+      const startParams = { cwd, model: model || undefined, sandbox: sandbox || undefined }
+      if (effort) startParams.effort = effort
+      if (approvalPolicy) startParams.approvalPolicy = approvalPolicy
+      const result = resuming
+        ? await client.request("thread/resume", { ...startParams, threadId: resumeThreadId })
+        : await client.request("thread/start", startParams)
+      session.threadId = result?.thread?.id
+      return { resuming, threadId: session.threadId }
+    } catch (err) {
+      this.sessions.delete(stream_id)
+      client.stop()
+      throw err
+    }
+  }
+
+  _wireClient(session) {
+    const { client, stream_id } = session
+    client.on("notification", (msg) => this._onNotification(session, msg))
+    client.on("request", (msg) => this._onServerRequest(session, msg))
+    client.on("exit", (info) => this._onClientExit(session, info))
+    client.on("error", (err) => {
+      this.emit("error", { stream_id, thread_id: session.threadId, error: err.message || String(err) })
+    })
+  }
+
+  _onNotification(session, msg) {
+    const { stream_id } = session
+    switch (msg.method) {
+      case "turn/started":
+        session.activeTurnId = msg.params?.turn?.id || null
+        break
+      case "turn/completed":
+        session.activeTurnId = null
+        this._autoResolveStalePendingApprovals(session, msg.params?.turn?.id)
+        this._maybeReapAfterIdle(session)
+        break
+      default:
+        break
+    }
+    this.emit("event", {
+      stream_id,
+      thread_id: session.threadId,
+      cwd: session.cwd,
+      notification: { method: msg.method, params: msg.params },
+    })
+  }
+
+  _onServerRequest(session, msg) {
+    const { stream_id } = session
+    session.pendingApprovals.set(msg.id, { turnId: session.activeTurnId })
+    this.emit("permission", {
+      stream_id,
+      thread_id: session.threadId,
+      cwd: session.cwd,
+      request_id: msg.id,
+      method: msg.method,
+      params: msg.params,
+    })
+  }
+
+  // ターン完了時、そのターンに紐づく未解決の承認要求は自動 decline する
+  // (browser が応答する前にターンが打ち切られた/クラッシュ相当のケース。
+  // claude-stream-bridge.mjs の「ターン終了時に未解決分は自動 deny」と同じ設計)。
+  _autoResolveStalePendingApprovals(session, completedTurnId) {
+    for (const [requestId, info] of session.pendingApprovals) {
+      if (info.turnId !== completedTurnId) continue
+      session.pendingApprovals.delete(requestId)
+      session.client.respond(requestId, { decision: "decline" })
+    }
+  }
+
+  _onClientExit(session, info) {
+    if (session.dead) return
+    session.dead = true
+    this._clearDetachTimer(session)
+    this.sessions.delete(session.stream_id)
+    this.emit("exit", {
+      stream_id: session.stream_id,
+      thread_id: session.threadId,
+      code: info.code,
+      reason: info.signal ? `signal:${info.signal}` : "process-exit",
+    })
+  }
+
+  /** @returns {Promise<void>} */
+  async input({ stream_id, message }) {
+    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
+    }
+    await session.client.request("turn/start", { threadId: session.threadId, input })
+  }
+
+  /** @returns {Promise<void>} */
+  async interrupt({ stream_id }) {
+    const session = this._require(stream_id)
+    if (!session.activeTurnId) return
+    await session.client.request("turn/interrupt", {
+      threadId: session.threadId,
+      turnId: session.activeTurnId,
+    })
+  }
+
+  /** サーバー発の承認/入力要求への応答。result の shape は method ごとに呼び出し側が組み立てる。 */
+  permissionReply({ stream_id, request_id, result }) {
+    const session = this._require(stream_id)
+    if (!session.pendingApprovals.has(request_id)) {
+      this.logger?.warn?.({ stream_id, request_id }, "codex permissionReply: unknown request_id (ignored)")
+      return
+    }
+    session.pendingApprovals.delete(request_id)
+    session.client.respond(request_id, result)
+  }
+
+  /**
+   * グレースフル切断。ターン実行中は完走を待ち、非 busy ならアイドル TTL 後に
+   * プロセスを reap する (claude-stream-bridge.mjs の softDetach と同じ思想。
+   * Slice 2 は多端末共有非対応なので detach = そのまま TTL 予約でよい)。
+   */
+  detach({ stream_id }) {
+    const session = this.sessions.get(stream_id)
+    if (!session || session.dead) return
+    this._maybeReapAfterIdle(session)
+  }
+
+  _maybeReapAfterIdle(session) {
+    if (session.activeTurnId) return // 完走まで待つ (turn/completed で再評価される)
+    this._clearDetachTimer(session)
+    session.detachTimer = setTimeout(() => {
+      if (session.dead) return
+      session.client.stop()
+    }, this._detachTtlMs)
+    session.detachTimer.unref?.()
+  }
+
+  _clearDetachTimer(session) {
+    if (session.detachTimer) {
+      clearTimeout(session.detachTimer)
+      session.detachTimer = null
+    }
+  }
+
+  _require(stream_id) {
+    const session = this.sessions.get(stream_id)
+    if (!session || session.dead) {
+      throw new Error(`no active codex session for stream_id: ${stream_id}`)
+    }
+    return session
+  }
+
+  /** 全セッションを即座に終了する (agent shutdown 用。ターン完走は待たない)。 */
+  shutdown() {
+    for (const session of this.sessions.values()) {
+      this._clearDetachTimer(session)
+      session.dead = true
+      session.client.stop()
+    }
+    this.sessions.clear()
+  }
+}

package/src/main.mjs

@@ -25,6 +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 { UploadManager } from "./claude-upload.mjs"
 import { requestSelfUninstall } from "./service-install.mjs"
 import {
@@ -270,12 +271,21 @@ async function loadClaudeSdk(logger) {
 
 /**
  * B7: 直列 dispatchChain をバイパスして即時処理してよい高頻度・低レイテンシ経路かを判定する。
- * pty 出力データ (pty.data) と resize (pty.resize) のみ true。入力系 (claude.input)・制御系
- * (tmux.exec / permission / cancel→paste 等) は WS 受信順 = pane 反映順を守るため false
- * (= 直列キューに残す)。1 件の tmux.exec ハングで pty 入出力まで止まるのを防ぐ。
+ * - pty 出力データ (pty.data) と resize (pty.resize): 高頻度・順序保証不要。
+ * - claude.interrupt / codex.interrupt (2026-07-02): 停止指示。前段に重い dispatch
+ *   (tmux.exec 等) が滞留していると停止が遅延するため直列キューをバイパスする。
+ *   中断は「現ターンを止める」冪等な制御で、入力系のような順序依存が無い (むしろ
+ *   キュー内の後続入力より先に届くべき)。
+ * 入力系 (claude.input)・他の制御系 (tmux.exec / permission / cancel→paste 等) は
+ * WS 受信順 = pane 反映順を守るため false (= 直列キューに残す)。
  */
 export function isFastPathMessage(type) {
-  return type === "pty.data" || type === "pty.resize"
+  return (
+    type === "pty.data" ||
+    type === "pty.resize" ||
+    type === "claude.interrupt" ||
+    type === "codex.interrupt"
+  )
 }
 
 /**
@@ -425,6 +435,13 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
   const resolvedPty = ptyModule || (await import("@lydell/node-pty"))
   const ptyBridge = new PtyBridge({ ptyModule: resolvedPty, logger, plugins })
 
+  // ホストで起動可能な CLI (claude / codex) を 1 回検出する。hello で広告する用途に
+  // 加え、codex app-server ベースの chat ブリッジ (codexBridge) を構築するかどうかの
+  // gate にも使う (claudeBridge は npm optional dep の有無で判定するのに対し、codex は
+  // JS SDK が無く CLI バイナリの有無そのものが可否条件になる)。
+  const availableClis = await detectAvailableClis()
+  logger.info({ availableClis }, "available CLIs detected")
+
   // Claude SDK は optional dep 扱い (未インストール時は stream モードのみ無効化)。
   // テストでは引数で stub を差し込める。
   const resolvedSdk = claudeSdk !== undefined ? claudeSdk : await loadClaudeSdk(logger)
@@ -432,6 +449,13 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
     ? new ClaudeStreamBridge({ sdk: resolvedSdk, logger })
     : null
 
+  // codex app-server ベースの chat ブリッジ。PATH 上に codex バイナリが無ければ
+  // null のままにし、claudeBridge と同じ流儀で codex.attach が codex.error を返す
+  // 経路に分岐させる (main.mjs の codex.* dispatch 側で判定)。
+  const codexBridge = availableClis.includes("codex")
+    ? new CodexStreamBridge({ logger })
+    : null
+
   // Cockpit チャットモードの添付ファイル受信器 (browser → agent のチャンク送信を
   // ローカル FS に保存し、保存パスを返す)。SDK 有無に関わらず生成してよいが、添付は
   // チャットモード専用機能なので claudeBridge と同じく stream モード前提で使う。
@@ -442,10 +466,6 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
     logger.info({ bundleVersion }, "hub bundle version detected")
   }
 
-  // ホストで起動可能な CLI (claude / codex) を 1 回検出して hello で広告する。
-  const availableClis = await detectAvailableClis()
-  logger.info({ availableClis }, "available CLIs detected")
-
   const client = new WsClient(config, {
     logger,
     version,
@@ -564,6 +584,53 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
     })
   }
 
+  // codex 版 (Slice 3): codex-stream-bridge.mjs の生 notification/permission/exit/error を
+  // browser にそのまま転送する。claudeBridge と同じ「素通し」方針 (codex-stream-bridge.mjs
+  // 冒頭コメント参照)。claude 版にある rate_limit/MCP control query 相当の処理は無い
+  // (codex 側にまだ存在しない/後続スライス)。ステータスドット用のチャット信号は
+  // turn/started・turn/completed のみ最小限で反映する (claude の assistant/result 相当)。
+  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 */
+        }
+      } else if (notification.method === "turn/completed") {
+        try {
+          recordChatActivity(cwd, { status: "waiting", inputPending: false })
+        } catch {
+          /* ignore */
+        }
+      }
+      client.send({ type: "codex.event", stream_id, thread_id, event: notification })
+    })
+    codexBridge.on("permission", ({ stream_id, thread_id, cwd, request_id, method, params }) => {
+      if (cwd) {
+        try {
+          recordChatActivity(cwd, { inputPending: true })
+        } catch {
+          /* ignore */
+        }
+      }
+      client.send({
+        type: "codex.permission.request",
+        stream_id,
+        thread_id,
+        request_id,
+        method,
+        params,
+      })
+    })
+    codexBridge.on("exit", ({ stream_id, thread_id, code, reason }) => {
+      client.send({ type: "codex.exit", stream_id, thread_id, code, reason })
+    })
+    codexBridge.on("error", ({ stream_id, thread_id, error }) => {
+      client.send({ type: "codex.error", stream_id, thread_id, error })
+    })
+  }
+
   // Hub からのメッセージ dispatch は **直列実行** する。
   //
   // `EventEmitter.emit` は async リスナーの完了を待たないため、`async (msg) =>
@@ -591,7 +658,7 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
     // permission / cancel→paste 等) は WS 受信順 = pane 反映順を守るため dispatchChain に残す。
     if (isFastPathMessage(msg?.type)) {
       Promise.resolve(
-        dispatch(msg, { ...ctx, client, ptyBridge, claudeBridge, uploadManager }),
+        dispatch(msg, { ...ctx, client, ptyBridge, claudeBridge, codexBridge, uploadManager }),
       ).catch((err) => {
         logger.error(
           { err: err.message, type: msg?.type },
@@ -601,7 +668,7 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
       return
     }
     dispatchChain = dispatchChain
-      .then(() => dispatch(msg, { ...ctx, client, ptyBridge, claudeBridge, uploadManager }))
+      .then(() => dispatch(msg, { ...ctx, client, ptyBridge, claudeBridge, codexBridge, uploadManager }))
       .catch((err) => {
         logger.error(
           { err: err.message, type: msg?.type },
@@ -829,6 +896,7 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
     jsonlLiveWatchers.stop()
     ptyBridge.shutdown()
     claudeBridge?.shutdown?.()
+    codexBridge?.shutdown?.()
     client.stop()
     // 0.6.2 fix: watchdog を解放して event loop を抜けられるようにする
     clearInterval(keepaliveTimer)
@@ -856,7 +924,7 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
     )
   })
 
-  return { client, plugins, ptyBridge, claudeBridge, uploadManager }
+  return { client, plugins, ptyBridge, claudeBridge, codexBridge, uploadManager }
 }
 
 const SESSION_EVENTS_DIR =
@@ -2934,6 +3002,76 @@ async function dispatch(msg, ctx) {
         if (!ctx.claudeBridge) return
         ctx.claudeBridge.detach({ stream_id: msg.stream_id })
         return
+      // codex 版 dispatch (Slice 3)。claude.* と同じ流儀だが、codex-stream-bridge.mjs の
+      // attach()/input()/interrupt() は codex app-server との JSON-RPC 往復を伴うため
+      // async (claude 版は SDK 呼び出しが同期/fire-and-forget)。失敗時は codex.error で
+      // browser に伝える。permission.reply の result は method ごとに shape が異なる
+      // (accept/decline 等) ため、正規化せず browser が組み立てたものをそのまま渡す。
+      case "codex.attach": {
+        const stream_id = msg.stream_id
+        if (!ctx.codexBridge) {
+          ctx.client.send({
+            type: "codex.error",
+            stream_id,
+            error: "codex_unavailable: codex CLI が agent の PATH に見つかりません",
+          })
+          return
+        }
+        try {
+          const info = await ctx.codexBridge.attach({
+            stream_id,
+            cwd: msg.cwd || ctx.config?.claude_cwd || undefined,
+            model: msg.model || undefined,
+            effort: msg.effort || undefined,
+            approvalPolicy: msg.approval_policy || undefined,
+            sandbox: msg.sandbox || undefined,
+            resumeThreadId: msg.resume_thread_id || null,
+          })
+          ctx.client.send({
+            type: "codex.ready",
+            stream_id,
+            resuming: info.resuming,
+            thread_id: info.threadId,
+          })
+        } catch (err) {
+          ctx.client.send({
+            type: "codex.error",
+            stream_id,
+            error: err.message,
+          })
+        }
+        return
+      }
+      case "codex.input":
+        if (!ctx.codexBridge) return
+        ctx.codexBridge
+          .input({ stream_id: msg.stream_id, message: msg.message })
+          .catch((err) => {
+            ctx.client.send({
+              type: "codex.error",
+              stream_id: msg.stream_id,
+              error: err.message,
+            })
+          })
+        return
+      case "codex.permission.reply":
+        if (!ctx.codexBridge) return
+        ctx.codexBridge.permissionReply({
+          stream_id: msg.stream_id,
+          request_id: msg.request_id,
+          result: msg.result,
+        })
+        return
+      case "codex.interrupt":
+        if (!ctx.codexBridge) return
+        ctx.codexBridge.interrupt({ stream_id: msg.stream_id }).catch((err) => {
+          ctx.logger?.warn?.({ err: err.message }, "codex.interrupt failed")
+        })
+        return
+      case "codex.detach":
+        if (!ctx.codexBridge) return
+        ctx.codexBridge.detach({ stream_id: msg.stream_id })
+        return
       case "claude.history.request": {
         // Sprint G 0.6.1: ~/.claude/projects/<cwd-encoded>/<session_id>.jsonl を読んで
         // 過去メッセージを返す。ChatView の re-mount 時の UI 復元用。