@cocorograph/hub-agent 0.8.46 → 0.8.48

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocorograph/hub-agent",
-  "version": "0.8.46",
+  "version": "0.8.48",
   "description": "Hub Hosted Cockpit のローカル常駐 agent。Hub と outbound WSS で接続し、ローカルの Claude / Codex チャットと tmux セッションを中継する。",
   "type": "module",
   "license": "UNLICENSED",

package/src/codex-appserver-client.mjs

@@ -17,8 +17,7 @@
  */
 import { spawn } from "node:child_process"
 import { EventEmitter } from "node:events"
-
-const DEFAULT_CODEX_CMD = "codex"
+import { requireCodexBinary } from "./codex-binary.mjs"
 
 // S3 Codex 堅牢化 (2026-07-05): request() の既定タイムアウト。app-server プロセスが
 // 生きたまま応答しなくなるケース (ハング/デッドロック) では、プロセス exit イベントに
@@ -35,15 +34,16 @@ function resolveRequestTimeoutMs(explicit) {
 }
 
 export class CodexAppServerClient extends EventEmitter {
-  constructor({ cwd, codexCmd, env, logger, spawnFn, requestTimeoutMs } = {}) {
+  constructor({ cwd, codexCmd, env, logger, spawnFn, binaryResolver, requestTimeoutMs } = {}) {
     super()
     this.cwd = cwd
-    this.codexCmd = codexCmd || DEFAULT_CODEX_CMD
+    this.codexCmd = codexCmd
     this.env = env
     this.logger = logger
     // テストから spawn をスタブ化できるよう注入可能にする (実 codex バイナリ不要で
     // JSON-RPC 相関ロジックだけを検証するため。既定は node:child_process の spawn)。
     this._spawnFn = spawnFn || spawn
+    this._binaryResolver = binaryResolver || requireCodexBinary
     // テストから短縮できるよう注入可能にする (既定は 20000ms、env でも上書き可能)。
     // 0 を指定するとタイムアウト無効 (旧挙動、テスト以外での使用は非推奨)。
     this._requestTimeoutMs = resolveRequestTimeoutMs(requestTimeoutMs)
@@ -57,6 +57,13 @@ export class CodexAppServerClient extends EventEmitter {
   /** codex app-server プロセスを起動する。二重呼び出しは無害 (no-op)。 */
   start() {
     if (this.child || this.closed) return
+    const resolved = this.codexCmd
+      ? { available: true, path: this.codexCmd, source: "explicit" }
+      : this._binaryResolver()
+    this.logger?.info?.(
+      { codex_binary_source: resolved.source, codex_binary_path: resolved.path },
+      "codex binary resolved for app-server",
+    )
     // Cockpit Codex 両対応 Stream A5（2026-07-02 実機検証で確定、中村さん明示承認済み）:
     // app-server は stdio 駆動で TTY が無いため、Codex 標準の対話的 hook 信頼確認
     // プロンプトを出す余地が無い。--dangerously-bypass-hook-trust を付けないと
@@ -102,7 +109,7 @@ export class CodexAppServerClient extends EventEmitter {
       "app-server",
       "--stdio",
     ]
-    this.child = this._spawnFn(this.codexCmd, args, {
+    this.child = this._spawnFn(resolved.path, args, {
       cwd: this.cwd,
       env: this.env || process.env,
       stdio: ["pipe", "pipe", "pipe"],

package/src/codex-binary.mjs

@@ -0,0 +1,90 @@
+import { constants as fsConstants, accessSync, statSync } from "node:fs"
+import { execFileSync } from "node:child_process"
+import os from "node:os"
+import path from "node:path"
+
+/**
+ * Cockpit が起動する Codex の共通 resolver。
+ *
+ * 呼び出しごとに再評価し、plugin の更新・一時不在からの復帰を daemon 再起動なしで
+ * 反映する。HUB_CODEX_BIN は明示指定なので、不正時に別バイナリへ黙って切り替えない。
+ */
+export function resolveCodexBinary({
+  env = process.env,
+  homedir = os.homedir(),
+  platform = process.platform,
+  accessSyncImpl = accessSync,
+  statSyncImpl = statSync,
+  execFileSyncImpl = execFileSync,
+} = {}) {
+  const pathApi = platform === "win32" ? path.win32 : path
+  const executable = (candidate) => {
+    try {
+      if (!statSyncImpl(candidate).isFile()) return false
+      accessSyncImpl(candidate, fsConstants.X_OK)
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  const explicit = typeof env.HUB_CODEX_BIN === "string" ? env.HUB_CODEX_BIN.trim() : ""
+  if (explicit) {
+    if (!pathApi.isAbsolute(explicit)) {
+      return { available: false, path: explicit, source: "env", error: `HUB_CODEX_BIN must be an absolute path: ${explicit}` }
+    }
+    const explicitPath = explicit
+    if (executable(explicitPath)) {
+      return { available: true, path: explicitPath, source: "env" }
+    }
+    return {
+      available: false,
+      path: explicitPath,
+      source: "env",
+      error: `HUB_CODEX_BIN is not executable: ${explicitPath}`,
+    }
+  }
+
+  const pluginPath = pathApi.join(homedir, ".codex", "plugins", ".plugin-appserver", "codex")
+  if (executable(pluginPath)) {
+    return { available: true, path: pluginPath, source: "plugin-appserver" }
+  }
+
+  try {
+    const lookup = platform === "win32" ? "where" : "which"
+    const output = execFileSyncImpl(lookup, ["codex"], { encoding: "utf8" })
+    const resolved = String(output)
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .find(Boolean)
+    if (resolved) {
+      return {
+        available: true,
+        path: pathApi.isAbsolute(resolved) ? resolved : pathApi.resolve(resolved),
+        source: "path",
+      }
+    }
+  } catch {
+    // PATH に無い場合は unavailable。plugin は次回呼び出し時に再評価される。
+  }
+
+  return { available: false, path: null, source: "path", error: "codex CLI is unavailable" }
+}
+
+export function requireCodexBinary(opts) {
+  const resolved = resolveCodexBinary(opts)
+  if (!resolved.available) {
+    const err = new Error(resolved.error || "codex CLI is unavailable")
+    err.code = "CODEX_CLI_UNAVAILABLE"
+    err.codexBinary = resolved
+    throw err
+  }
+  return resolved
+}
+
+/** POSIX shell の単一 argv として安全に埋め込む。 */
+export function quotePosixShellArg(value) {
+  const s = String(value)
+  if (/^[A-Za-z0-9_@%+=:,./-]+$/.test(s) && !s.startsWith("-")) return s
+  return `'${s.replaceAll("'", `'"'"'`)}'`
+}

package/src/codex-stream-bridge.mjs

@@ -814,16 +814,15 @@ export class CodexStreamBridge extends EventEmitter {
     })
     this.sessions.set(stream_id, session)
     this._wireClient(session)
-    client.start()
-    // app-server の spawn は同期呼び出し (fork/exec のみ)。プロセス起動の実コストは
-    // 直後の initialize RPC 応答待ちに現れるので、spawn_ms と initialize_ms は必ずセットで読む。
-    timing.spawn_ms = lap()
-
     const resuming = !!resumeThreadId
     // #3: initialize と thread op を分離し、thread op に到達したかを記録する。initialize / config
     //     / MCP 起動の失敗 (thread op 未到達) は attach 失敗分類の対象外にする (pointer を消さない)。
     let reachedThreadOp = false
     try {
+      client.start()
+      // app-server の spawn は同期呼び出し (fork/exec のみ)。プロセス起動の実コストは
+      // 直後の initialize RPC 応答待ちに現れるので、spawn_ms と initialize_ms は必ずセットで読む。
+      timing.spawn_ms = lap()
       this.logger?.info?.(
         { stream_id, cwd, resuming, lifecycle_stage: "initialize_started" },
         "codex app-server session initialization",

package/src/config.mjs

@@ -13,6 +13,7 @@ import os from "node:os"
 import { randomUUID } from "node:crypto"
 import { execFile, execFileSync } from "node:child_process"
 import { promisify } from "node:util"
+import { resolveCodexBinary } from "./codex-binary.mjs"
 
 const _execFileP = promisify(execFile)
 
@@ -62,12 +63,13 @@ export function detectPlatform({ execImpl } = {}) {
 export const CLI_CANDIDATES = ["claude", "codex"]
 
 /**
- * PATH 上に存在する CLI 種別 (capability) を検出する。Cockpit が「この hub-agent で
+ * 起動可能な CLI 種別 (capability) を検出する。Cockpit が「この hub-agent で
  * どの CLI を起動できるか」を知るため、起動時に 1 回呼んで enroll/hello payload で
- * Hub に広告する (`CockpitAgent.available_clis`)。which/where が成功したものだけ返す。
+ * Hub に広告する (`CockpitAgent.available_clis`)。Codex は共通 resolver、その他は
+ * which/where が成功したものだけ返す。
  *
- * @param {{candidates?:string[], exec?:(cmd:string,args:string[])=>Promise<any>}} [opts]
- *   exec はテスト差し替え用 (既定は which/where を叩く promisified execFile)。
+ * @param {{candidates?:string[], exec?:(cmd:string,args:string[])=>Promise<any>, _resolveCodexBinary?:()=>{available:boolean}}} [opts]
+ *   exec / _resolveCodexBinary はテスト差し替え用。
  * @returns {Promise<string[]>} 例: ["claude", "codex"]
  */
 export async function detectAvailableClis(opts = {}) {
@@ -76,6 +78,10 @@ export async function detectAvailableClis(opts = {}) {
   const lookup = process.platform === "win32" ? "where" : "which"
   const found = []
   for (const cli of candidates) {
+    if (cli === "codex") {
+      if ((opts._resolveCodexBinary || resolveCodexBinary)().available) found.push(cli)
+      continue
+    }
     try {
       await exec(lookup, [cli])
       found.push(cli)

package/src/hub-bundle.mjs

@@ -21,6 +21,7 @@ import path from "node:path"
 import os from "node:os"
 import { spawn } from "node:child_process"
 import { randomBytes, createHash } from "node:crypto"
+import { resolveCodexBinary } from "./codex-binary.mjs"
 
 const HUB_AI_RULES_BEGIN = "<!-- BEGIN HUB-AI-RULES -->"
 const HUB_AI_RULES_END = "<!-- END HUB-AI-RULES -->"
@@ -479,7 +480,21 @@ export async function applyCodexMcpServers(
   }
   // CLI バイナリ解決 / 実行はテスト注入可能（既定は実 which/spawn）。実 subprocess に依存しない
   // 決定的テストのため（環境の TMPDIR noexec / PATH 解決差で偽バイナリ方式が不安定になる問題の対処）。
-  const resolveBin = resolveBinImpl || resolveCliBin
+  const resolveCodexBin = resolveBinImpl || (async () => {
+    const resolved = resolveCodexBinary()
+    if (!resolved.available) {
+      logger?.warn?.(
+        { source: resolved.source, path: resolved.path, err: resolved.error },
+        "codex CLI unavailable",
+      )
+      return null
+    }
+    logger?.info?.(
+      { source: resolved.source, path: resolved.path },
+      "codex binary resolved for bundle sync",
+    )
+    return resolved.path
+  })
   const run = runImpl || runOnce
 
   const added = []
@@ -490,9 +505,9 @@ export async function applyCodexMcpServers(
   // ユーザーの操作を勝手に奪う）。登録＝対話（enroll / 明示手動 sync / 明示的認証）に限定し、自動同期は
   // 「既に登録済み（＝ OAuth 認証済み）テーブルへ承認モードを補完する」ことだけを行う。
   if (!nonInteractive) {
-    const codexBin = await resolveBin("codex")
+    const codexBin = await resolveCodexBin("codex")
     if (!codexBin) {
-      logger?.info("codex CLI が PATH に無いため MCP server 自動登録をスキップ")
+      logger?.info("codex CLI が利用できないため MCP server 自動登録をスキップ")
       skipped.push(...servers.map((s) => s?.name || "<unnamed>"))
     } else {
       for (const s of servers) {

package/src/main.mjs

@@ -50,6 +50,10 @@ import { AsyncTtlCache } from "./async-ttl-cache.mjs"
 import { ClaudeStreamBridge } from "./claude-stream-bridge.mjs"
 import { CodexMcpControl } from "./codex-mcp-control.mjs"
 import { CodexStreamBridge, classifyCodexInputError } from "./codex-stream-bridge.mjs"
+import {
+  quotePosixShellArg,
+  resolveCodexBinary,
+} from "./codex-binary.mjs"
 import { enforceTotalLiveBound } from "./warm-bounds-total.mjs"
 import { UploadManager } from "./claude-upload.mjs"
 import { requestSelfUninstall } from "./service-install.mjs"
@@ -90,6 +94,7 @@ import {
 } from "./claude-credentials.mjs"
 import {
   buildClaudeCmd,
+  buildCodexCmd,
   buildWorktreeIndex,
   createSession as createTmuxSession,
   createWorktreeDir,
@@ -102,6 +107,8 @@ import {
   paneClaudeAliveOrUnknown,
   removeWorktree as removeWorktreeDir,
   setTmuxGlobalEnv,
+  shouldLaunchPaneCli,
+  validateInitialPrompt,
 } from "./tmux.mjs"
 import { SiblingInjectBridge } from "./sibling-inject.mjs"
 import { isSessionWarm } from "./live-sessions.mjs"
@@ -142,6 +149,21 @@ import {
 } from "./proc-introspect.mjs"
 import { hydrateProcessEnvFromShell } from "./shell-env.mjs"
 
+export function resolveCodexLoginCommand(configDir, { isDefault = false, _resolveCodexBinary = resolveCodexBinary } = {}) {
+  const resolved = _resolveCodexBinary()
+  if (!resolved.available) {
+    return { login_command: undefined, login_command_reason: resolved.error || "codex_cli_unavailable" }
+  }
+  const bin = quotePosixShellArg(resolved.path)
+  return {
+    login_command: isDefault ? `${bin} login` : `CODEX_HOME=${quotePosixShellArg(configDir)} ${bin} login`,
+  }
+}
+
+export function codexAvailableForDispatch(ctx) {
+  return (ctx?._resolveCodexBinary || resolveCodexBinary)().available
+}
+
 const logger = pino({ name: "hub-agent" })
 
 
@@ -207,9 +229,12 @@ function codexDefaultsFromAgentConfig(config) {
  */
 export async function restartAllTmuxSessionsForProfileSwitch(ctx) {
   const result = { killed: [], recreated: [], failed: [] }
+  const listSessionsForRestart = ctx._listTmuxSessions || listTmuxSessions
+  const killSessionsForRestart = ctx._killManySessions || killManySessions
+  const createSessionForRestart = ctx._createTmuxSession || createTmuxSession
   let sessions = []
   try {
-    sessions = await listTmuxSessions({ plugins: ctx.plugins, logger: ctx.logger })
+    sessions = await listSessionsForRestart({ plugins: ctx.plugins, logger: ctx.logger })
   } catch (err) {
     ctx.logger?.debug?.(
       { err: err?.message || String(err) },
@@ -218,24 +243,45 @@ export async function restartAllTmuxSessionsForProfileSwitch(ctx) {
     return result
   }
   if (!sessions.length) return result
-  const { killed } = await killManySessions(
-    sessions.map((s) => s.name),
+  const codexDefaults = codexDefaultsFromAgentConfig(ctx.config)
+  let prebuiltCodexCmd
+  const codexSessions = sessions.filter((s) => cliKindForSessionName(s.name) === "codex")
+  let sessionsToRestart = sessions
+  if (shouldLaunchPaneCli() && codexSessions.length) {
+    try {
+      prebuiltCodexCmd = buildCodexCmd({
+        ...codexDefaults,
+        _resolveCodexBinary: ctx._resolveCodexBinary,
+      })
+    } catch (err) {
+      const reason = err?.message || String(err)
+      result.failed.push(...codexSessions.map((s) => ({ name: s.name, reason })))
+      const blocked = new Set(codexSessions.map((s) => s.name))
+      sessionsToRestart = sessions.filter((s) => !blocked.has(s.name))
+    }
+  }
+  if (!sessionsToRestart.length) return result
+  const { killed } = await killSessionsForRestart(
+    sessionsToRestart.map((s) => s.name),
     { logger: ctx.logger },
   )
   result.killed = killed
-  for (const s of sessions) {
+  for (const s of sessionsToRestart) {
     if (!killed.includes(s.name)) continue
     if (!s.cwd) {
       result.failed.push({ name: s.name, reason: "cwd unknown" })
       continue
     }
     try {
-      await createTmuxSession(s.name, s.cwd, {
+      const cliKind = cliKindForSessionName(s.name)
+      await createSessionForRestart(s.name, s.cwd, {
         // cliKind はセッション名 (`<dir>__codex` か否か) だけで決まる。渡し忘れると
         // createSession が既定の claude として扱い、codex セッションの再生成でも
         // AGENTS.md ではなく CLAUDE.md を同期対象にしてしまう。
-        cliKind: cliKindForSessionName(s.name),
+        cliKind,
         claudeCmd: claudeCmdFromAgentConfig(ctx.config),
+        codexCmd: cliKind === "codex" ? prebuiltCodexCmd : undefined,
+        ...codexDefaults,
         logger: ctx.logger,
       })
       result.recreated.push(s.name)
@@ -352,15 +398,14 @@ export function isFastPathMessage(type) {
  * 捨てるため、WS 受信順に対する順序依存が無い。
  *
  * これを直列 dispatchChain から外す理由 (view/spawn 分離の核): 直列キューは「WS 受信順 = pane 反映順」
- * を守るためのものだが、その代償として前方の重い処理 (codex.sessions.request/codex.attach の
- * app-server spawn = 数秒、claude.sessions.request の全ファイル読み) が後続の claude.attach を
+ * を守るためのものだが、その代償として前方の重い処理 (codex.attach の app-server spawn = 数秒、
+ * claude.sessions.request / codex.sessions.request の全ファイル読み) が後続の claude.attach を
  * head-of-line blocking し、attach→ready を数十秒遅延させていた (本番計測 cold p95 40〜54s)。
- * claude/codex が同一 dispatchChain を共有するため codex の spawn が claude の切替まで巻き込む。
+ * claude/codex が同一 dispatchChain を共有するため一方の重い処理が他方の切替まで巻き込む。
  * 読み取り RPC を並行レーンへ逃がすことで、タイムライン閲覧が live 接続 (spawn) の完了を待たなくなる。
  *
- * ⚠️ codex.sessions.request は listThreads が app-server を spawn するため、off-queue 化の副作用で
- * 同一 cwd への同時リクエストが spawn storm を起こしうる。CodexStreamBridge.listThreads 側に
- * single-flight ガードを併設して同時 spawn を 1 本に畳む (B で rollout disk 走査へ置換すれば spawn 自体が消える)。
+ * codex.sessions.request は rollout の disk 走査のみで app-server を spawn しない。
+ * CodexStreamBridge.listThreads 側の single-flight が同一走査の重複 I/O を畳む。
  */
 export function isReadOnlyRpc(type) {
   return (
@@ -758,11 +803,21 @@ export async function startDaemon({ version, claudeSdk } = {}) {
   await kickSetupHubAiForDetectedClis({ logger })
 
   // ホストで起動可能な CLI (claude / codex) を 1 回検出する。hello で広告する用途に
-  // 加え、codex app-server ベースの chat ブリッジ (codexBridge) を構築するかどうかの
-  // gate にも使う (claudeBridge は npm optional dep の有無で判定するのに対し、codex は
-  // JS SDK が無く CLI バイナリの有無そのものが可否条件になる)。
+  // 加え、Codex capability の初期状態を広告する。実際の spawn は共通 resolver が
+  // 呼び出しごとに再評価するため、この初期値で bridge の生成可否は固定しない。
+  // available_clis の広告値自体は daemon 再起動まで更新されないが、spawn 可否は都度判定する。
   const availableClis = await detectAvailableClis()
   logger.info({ availableClis }, "available CLIs detected")
+  const initialCodexBinary = resolveCodexBinary()
+  logger.info(
+    {
+      available: initialCodexBinary.available,
+      source: initialCodexBinary.source,
+      path: initialCodexBinary.path,
+      error: initialCodexBinary.error,
+    },
+    "codex binary resolver initialized",
+  )
 
   // Claude SDK は optional dep 扱い (未インストール時は stream モードのみ無効化)。
   // テストでは引数で stub を差し込める。
@@ -771,20 +826,15 @@ export async function startDaemon({ version, 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
+  // codex app-server ベースの chat ブリッジ。resolver は各 spawn 時に再評価するため、
+  // daemon 起動時に一時的に unavailable でも bridge 自体は保持する。
+  const codexBridge = new CodexStreamBridge({ logger })
 
   // Codex の MCP 状態 control (agent-global, セッション非依存)。MCP は ~/.codex/config.toml
   // = アカウント単位の設定で全セッション共有のため、claudeBridge の「MCP control 専用
   // query」と同じ流儀で、チャットの thread に紐付けない専用クライアントで扱う。
-  // codex バイナリが無ければ null (codex.mcp.* は cli_unavailable を返す)。
-  const codexMcpControl = availableClis.includes("codex")
-    ? new CodexMcpControl({ logger })
-    : null
+  // resolver は control client の spawn 時にも再評価する。
+  const codexMcpControl = new CodexMcpControl({ logger })
 
   // Cockpit チャットモードの添付ファイル受信器 (browser → agent のチャンク送信を
   // ローカル FS に保存し、保存パスを返す)。SDK 有無に関わらず生成してよいが、添付は
@@ -3712,37 +3762,42 @@ export async function handleWorktreeCreate(msg, ctx) {
     return
   }
   try {
-    const { wtName, wtPath, createdBranch } = await createWorktreeDir(dir, branch)
-    // worktree dir で tmux session を作成。tmux.create_session と同じく cli_kind を
-    // 解釈し、codex なら codex を pane 起動する（既定 claude）。
-    // T05945: セッション名は cli_kind に応じて `<wt>` / `<wt>__codex` へ分ける。これで
-    // 同一 worktree でも claude と codex を独立に起動/終了できる (旧実装は cli_kind に
-    // 関わらず `<wt>` 固定だったため、片方しか立てられなかった)。
+    const worktreeCreate = ctx._createWorktreeDir || createWorktreeDir
+    const tmuxCreate = ctx._createTmuxSession || createTmuxSession
     const wtCliKind = msg.cli_kind === "codex" ? "codex" : "claude"
-    const wtSessionName = sessionNameFor(wtName, wtCliKind)
-    await createTmuxSession(wtSessionName, wtPath, {
+    const launchPaneCli = shouldLaunchPaneCli()
+    const codexDefaults = codexDefaultsFromAgentConfig(ctx.config)
+    const tmuxOptions = {
       cliKind: wtCliKind,
       claudeCmd:
         typeof msg.claude_cmd === "string"
           ? msg.claude_cmd
           : claudeCmdFromAgentConfig(ctx.config),
       codexCmd: typeof msg.codex_cmd === "string" ? msg.codex_cmd : undefined,
-      // codex 用設定 (claude 経路では無視される)。
-      model:
-        typeof msg.model === "string"
-          ? msg.model
-          : codexDefaultsFromAgentConfig(ctx.config).model,
+      model: typeof msg.model === "string" ? msg.model : codexDefaults.model,
       sandbox: typeof msg.sandbox === "string" ? msg.sandbox : undefined,
       approvalPolicy:
         typeof msg.approval_policy === "string" ? msg.approval_policy : undefined,
-      effort:
-        typeof msg.effort === "string"
-          ? msg.effort
-          : codexDefaultsFromAgentConfig(ctx.config).effort,
+      effort: typeof msg.effort === "string" ? msg.effort : codexDefaults.effort,
       initialPrompt:
         typeof msg.initial_prompt === "string" ? msg.initial_prompt : undefined,
       logger: ctx.logger,
-    })
+      _resolveCodexBinary: ctx._resolveCodexBinary,
+    }
+    if (launchPaneCli) validateInitialPrompt(tmuxOptions.initialPrompt)
+    // 下流 createSession と同じ options・優先順位で command を1回だけ生成する。
+    // 失敗はこの try の catch へ流れ、worktree / tmux の副作用前に ok:false となる。
+    if (launchPaneCli && wtCliKind === "codex") {
+      tmuxOptions.codexCmd = tmuxOptions.codexCmd ?? buildCodexCmd(tmuxOptions)
+    }
+    const { wtName, wtPath, createdBranch } = await worktreeCreate(dir, branch)
+    // worktree dir で tmux session を作成。tmux.create_session と同じく cli_kind を
+    // 解釈し、codex なら codex を pane 起動する（既定 claude）。
+    // T05945: セッション名は cli_kind に応じて `<wt>` / `<wt>__codex` へ分ける。これで
+    // 同一 worktree でも claude と codex を独立に起動/終了できる (旧実装は cli_kind に
+    // 関わらず `<wt>` 固定だったため、片方しか立てられなかった)。
+    const wtSessionName = sessionNameFor(wtName, wtCliKind)
+    await tmuxCreate(wtSessionName, wtPath, tmuxOptions)
     tmuxSessionsSnapshotCache.clear()
     ctx.client.send({
       type: "worktree.create.result",
@@ -3767,7 +3822,11 @@ export async function handleWorktreeCreate(msg, ctx) {
   }
 }
 
-async function dispatch(msg, ctx) {
+/**
+ * DispatchScheduler から呼ばれる本番メッセージ入口。
+ * export はハンドラ契約を subprocess なしで検証するテスト専用の公開面でもある。
+ */
+export async function dispatch(msg, ctx) {
   const t = msg?.type || ""
   try {
     switch (t) {
@@ -4144,7 +4203,7 @@ async function dispatch(msg, ctx) {
         //                (authenticate の応答で callbackExpected: false を返す)
         //   - clearauth: 対応する RPC が無い (CLI の `codex mcp logout` のみ)
         const request_id = msg.request_id
-        if (!ctx.codexMcpControl) {
+        if (!ctx.codexMcpControl || !codexAvailableForDispatch(ctx)) {
           ctx.client.send({
             type: "codex.mcp.response",
             request_id,
@@ -4268,7 +4327,7 @@ async function dispatch(msg, ctx) {
       // (accept/decline 等) ため、正規化せず browser が組み立てたものをそのまま渡す。
       case "codex.attach": {
         const stream_id = msg.stream_id
-        if (!ctx.codexBridge) {
+        if (!ctx.codexBridge || !codexAvailableForDispatch(ctx)) {
           ctx.client.send({
             type: "codex.error",
             stream_id,
@@ -4482,7 +4541,8 @@ async function dispatch(msg, ctx) {
         // (env の揮発値に依存しない)、epoch と解決済み文脈をエコーして frontend の
         // 単一 read ゲートが stale/逆順/別プロファイル応答を判別できるようにする。
         const epoch = typeof msg.epoch === "number" ? msg.epoch : undefined
-        const { sessionsDir, profileId } = await codexProfiles.resolveSessionsDir(
+        const profileApi = ctx.codexProfiles || codexProfiles
+        const { sessionsDir, profileId } = await profileApi.resolveSessionsDir(
           msg.profile_id,
         )
         if (!ctx.codexBridge) {
@@ -4799,9 +4859,10 @@ async function dispatch(msg, ctx) {
         // 分離のため CODEX_HOME 切替だけでアカウントが変わる (スワップ不要)。
         const id = msg.profile_id || msg.id || ""
         try {
-          const target = await codexProfiles.setActiveProfile(id)
-          applyActiveCodexEnv(target, ctx.logger)
-          await syncTmuxCodexEnv(target, ctx.logger)
+          const profileApi = ctx.codexProfiles || codexProfiles
+          const target = await profileApi.setActiveProfile(id)
+          ;(ctx.applyActiveCodexEnv || applyActiveCodexEnv)(target, ctx.logger)
+          await (ctx.syncTmuxCodexEnv || syncTmuxCodexEnv)(target, ctx.logger)
           // Codex セッションだけ撤去 (Claude セッションは残す = 独立切替)。
           const before = ctx.codexBridge?.sessions?.size ?? 0
           ctx.codexBridge?.shutdown()
@@ -4810,9 +4871,16 @@ async function dispatch(msg, ctx) {
           // 見せ続けない (rate limits 自体は profileId 別キャッシュなので混ざらないが、
           // usage.response の中身は両アカウントを束ねているため明示的に捨てる)。
           usageResponseCache.clear()
-          const hasCreds = await codexProfiles.hasCodexCredentials(target.configDir)
+          const hasCreds = await profileApi.hasCodexCredentials(target.configDir)
           const needsLogin = !hasCreds
-          const isDefaultTarget = target.id === codexProfiles.DEFAULT_CODEX_PROFILE_ID
+          const isDefaultTarget =
+            target.id === (profileApi.DEFAULT_CODEX_PROFILE_ID || codexProfiles.DEFAULT_CODEX_PROFILE_ID)
+          const login = needsLogin
+            ? resolveCodexLoginCommand(target.configDir, {
+                isDefault: isDefaultTarget,
+                _resolveCodexBinary: ctx._resolveCodexBinary || resolveCodexBinary,
+              })
+            : { login_command: undefined }
           ctx.logger.info(
             { profile_id: target.id, reaped: before, needs_login: needsLogin },
             "codex profile switched; codex sessions reaped",
@@ -4829,11 +4897,7 @@ async function dispatch(msg, ctx) {
             },
             reaped: before,
             needs_login: needsLogin,
-            login_command: needsLogin
-              ? isDefaultTarget
-                ? "codex login"
-                : `CODEX_HOME=${target.configDir} codex login`
-              : undefined,
+            ...login,
           })
         } catch (err) {
           ctx.client.send({
@@ -4850,7 +4914,11 @@ async function dispatch(msg, ctx) {
         // 新規 Codex プロファイル追加 (連番 id・中立パス `~/.codex-<n>`)。共有資産を
         // provisioning 済み。追加直後はログイン未了 (CODEX_HOME=<dir> codex login)。
         try {
-          const created = await codexProfiles.addProfile({ label: msg.label })
+          const profileApi = ctx.codexProfiles || codexProfiles
+          const created = await profileApi.addProfile({ label: msg.label })
+          const login = resolveCodexLoginCommand(created.configDir, {
+            _resolveCodexBinary: ctx._resolveCodexBinary || resolveCodexBinary,
+          })
           ctx.client.send({
             type: "codex.profile.add.result",
             request_id: msg.request_id,
@@ -4861,10 +4929,10 @@ async function dispatch(msg, ctx) {
               config_dir: created.configDir,
             },
             needs_login: created.needsLogin,
-            login_command: `CODEX_HOME=${created.configDir} codex login`,
+            ...login,
           })
           // 新プロファイルへ bundle hooks / AGENTS.md を反映 (codex 向け setup)。
-          kickSetupHubAi({ logger: ctx.logger, cliKind: "codex" })
+          ;(ctx.kickSetupHubAi || kickSetupHubAi)({ logger: ctx.logger, cliKind: "codex" })
         } catch (err) {
           ctx.client.send({
             type: "codex.profile.add.result",
@@ -4879,7 +4947,8 @@ async function dispatch(msg, ctx) {
         // Codex プロファイルの表示ラベルのみ変更 (切替・認証に触れない)。
         const id = msg.profile_id || msg.id || ""
         try {
-          const updated = await codexProfiles.renameProfile(id, msg.label)
+          const profileApi = ctx.codexProfiles || codexProfiles
+          const updated = await profileApi.renameProfile(id, msg.label)
           ctx.client.send({
             type: "codex.profile.rename.result",
             request_id: msg.request_id,

package/src/tmux.mjs

@@ -27,6 +27,7 @@ import { detectSessionState, getSessionCwd } from "./state.mjs"
 import { shouldLaunchPaneCli } from "./pane-cli-flag.mjs"
 import { baseSessionName, sessionNameFor } from "./session-names.mjs"
 import { boundSessionId, getSessionUsages, isFreshUnboundBind, jsonlContextForCwd } from "./usage.mjs"
+import { quotePosixShellArg, requireCodexBinary } from "./codex-binary.mjs"
 
 const execFileP = promisify(execFile)
 
@@ -514,6 +515,19 @@ function tmuxBin(opts = {}) {
   return opts.tmuxBin || DEFAULT_TMUX_BIN
 }
 
+/**
+ * pane CLI に渡す initialPrompt の危険な制御文字を拒否する。
+ * 対話入力として必要な tab (HT) / LF / CR は許可する。
+ */
+export function validateInitialPrompt(initialPrompt) {
+  if (
+    typeof initialPrompt === "string" &&
+    /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/.test(initialPrompt)
+  ) {
+    throw new Error("initialPrompt contains unsupported control characters")
+  }
+}
+
 /**
  * claudeCmd の各セグメント末尾に initialPrompt を shell-safe quoting で
  * 末尾引数として注入する。
@@ -523,13 +537,13 @@ function tmuxBin(opts = {}) {
  * 旧実装は `--permission-mode auto` を marker として正規表現マッチしていたが、
  * model / permission-mode が個人ごとに変わる前提で marker 非依存に変更した。
  *
- * `JSON.stringify` は `"` `\` 制御文字を `\u00xx` 等で安全にエスケープし、
- * 結果は double-quoted な shell リテラルとしてそのまま使える。
+ * POSIX shell の単一 argv として quote し、`$()` / backtick 等を展開させない。
  */
 export function injectInitialPrompt(claudeCmd, initialPrompt) {
   if (!initialPrompt || typeof initialPrompt !== "string") return claudeCmd
+  validateInitialPrompt(initialPrompt)
   if (typeof claudeCmd !== "string" || claudeCmd.length === 0) return claudeCmd
-  const quoted = JSON.stringify(initialPrompt)
+  const quoted = quotePosixShellArg(initialPrompt)
   return claudeCmd
     .split("||")
     .map((part) => `${part.trim()} ${quoted}`)
@@ -555,7 +569,7 @@ export function injectInitialPrompt(claudeCmd, initialPrompt) {
 export function injectConfigDirEnv(claudeCmd, configDir) {
   if (!configDir || typeof configDir !== "string") return claudeCmd
   if (typeof claudeCmd !== "string" || claudeCmd.length === 0) return claudeCmd
-  const assignment = `CLAUDE_CONFIG_DIR=${JSON.stringify(configDir)}`
+  const assignment = `CLAUDE_CONFIG_DIR=${quotePosixShellArg(configDir)}`
   return claudeCmd
     .split("||")
     .map((part) => `${assignment} ${part.trim()}`)
@@ -790,9 +804,16 @@ export async function killManySessions(names, opts = {}) {
  *   TUI の初回プロンプトとして実行される (`/orchestrate` 等のスキル発火に利用)
  */
 export async function createSession(name, cwd, opts = {}) {
+  const launchPaneCli = shouldLaunchPaneCli()
+  if (launchPaneCli) validateInitialPrompt(opts.initialPrompt)
   // tmux は `-c` をシェル展開しないため、ここで `~` を絶対パスに展開する。
   // 展開後の cwd は同名引数で以降の検証 / tmux に渡す。
   const resolvedCwd = expandTilde(cwd)
+  // resolver 失敗時に workspace 作成・Hub 同期・tmux 作成の副作用を残さない。
+  const prebuiltCodexBaseCmd =
+    launchPaneCli && opts.cliKind === "codex"
+      ? opts.codexCmd ?? buildCodexCmd(opts)
+      : null
   // cwd 存在チェック (旧 Cockpit 単体実装と同等の防御)
   // 無いまま tmux に渡すと pane の current_path が HOME など別ディレクトリに
   // fallback して、SessionStart hook が project を解決できなくなる。
@@ -957,7 +978,7 @@ export async function createSession(name, cwd, opts = {}) {
   // 効くよう main.mjs の syncTmuxProfileEnv / syncTmuxCodexEnv が
   // `tmux set-environment -g` でサーバーのグローバル環境へ流し込んでいるため、
   // ここでコマンド文字列に焼き込む必要があるのは CLI を起動する場合だけ。
-  if (!shouldLaunchPaneCli()) {
+  if (!launchPaneCli) {
     opts.logger?.debug?.(
       { session: name, cwd: resolvedCwd },
       "pane CLI launch skipped (set HUB_AGENT_TMUX_LAUNCH_CLI=1 to enable)",
@@ -971,7 +992,7 @@ export async function createSession(name, cwd, opts = {}) {
     opts.cliKind === "codex"
       ? injectInitialPrompt(
           injectCodexHomeEnv(
-            opts.codexCmd ?? buildCodexCmd(opts),
+            prebuiltCodexBaseCmd,
             opts.codexHome ?? process.env.CODEX_HOME ?? null,
           ),
           opts.initialPrompt,
@@ -1041,6 +1062,15 @@ function codexHookTrustBypassFlag() {
   return process.env.HUB_CODEX_BYPASS_HOOK_TRUST !== "0" ? "--dangerously-bypass-hook-trust" : ""
 }
 
+function codexShellBinary(opts = {}) {
+  const resolver = opts._resolveCodexBinary || requireCodexBinary
+  const resolved = resolver()
+  if (!resolved?.available || !resolved.path) {
+    throw new Error(resolved?.error || "codex CLI is unavailable")
+  }
+  return quotePosixShellArg(resolved.path)
+}
+
 /**
  * agent 設定から codex 起動 flags を組み立てる (純粋関数)。
  * model / sandbox / approvalPolicy / effort のうち指定されたものだけを並べ、
@@ -1068,7 +1098,7 @@ export function composeCodexFlags(opts = {}) {
 /**
  * codex 既定起動コマンド (claude の buildClaudeCmd 相当)。
  * hub オプション (model/sandbox/approval/effort) があれば反映、無ければ
- * HUB_CODEX_CMD 環境変数、どちらも無ければ最小デフォルト `codex`。
+ * HUB_CODEX_CMD 環境変数、どちらも無ければ共通 resolver の実行ファイル。
  * ⚠️ hub オプション有無に関わらず `--dangerously-bypass-hook-trust` は常時付与する
  * （hub オプション判定と bypass flag 判定を分離しているため、HUB_CODEX_CMD
  * 分岐を選んでも bypass flag は付く。詳細は `codexHookTrustBypassFlag` 参照）。
@@ -1085,12 +1115,13 @@ export function buildCodexCmd(opts = {}) {
 
   if (hasHubOptions) {
     const flags = composeCodexFlags(opts)
-    return `codex ${flags}`.trim()
+    return `${codexShellBinary(opts)} ${flags}`.trim()
   }
   if (process.env.HUB_CODEX_CMD) {
     return `${process.env.HUB_CODEX_CMD}${bypass ? ` ${bypass}` : ""}`.trim()
   }
-  return bypass ? `codex ${bypass}` : "codex"
+  const codex = codexShellBinary(opts)
+  return bypass ? `${codex} ${bypass}` : codex
 }
 
 /**
@@ -1101,7 +1132,8 @@ export function buildCodexCmd(opts = {}) {
  */
 export function buildCodexFreshCmd(opts = {}) {
   const flags = composeCodexFlags(opts)
-  return `codex${flags ? " " + flags : ""}`.trim()
+  const codex = codexShellBinary(opts)
+  return `${codex}${flags ? " " + flags : ""}`.trim()
 }
 
 /**
@@ -1117,7 +1149,8 @@ export function buildCodexResumeCmd(sessionId, opts = {}) {
     throw new Error(`unsafe session_id for codex resume: ${String(sessionId)}`)
   }
   const flags = composeCodexFlags(opts)
-  return `codex resume ${sessionId}${flags ? " " + flags : ""}`.trim()
+  const codex = codexShellBinary(opts)
+  return `${codex} resume ${sessionId}${flags ? " " + flags : ""}`.trim()
 }
 
 /**
@@ -1130,7 +1163,7 @@ export function buildCodexResumeCmd(sessionId, opts = {}) {
 export function injectCodexHomeEnv(codexCmd, codexHome) {
   if (!codexHome || typeof codexHome !== "string") return codexCmd
   if (typeof codexCmd !== "string" || codexCmd.length === 0) return codexCmd
-  const assignment = `CODEX_HOME=${JSON.stringify(codexHome)}`
+  const assignment = `CODEX_HOME=${quotePosixShellArg(codexHome)}`
   return codexCmd
     .split("||")
     .map((part) => `${assignment} ${part.trim()}`)

package/src/usage.mjs

@@ -1489,6 +1489,7 @@ const _codexThreadListIndex = new Map() // base → Map<fp, {mtimeMs,size,lastSe
 const _codexThreadListLastWarnAt = new Map() // base → wall-clock ms
 const CODEX_THREAD_LIST_LOG_INTERVAL_MS = 5 * 60 * 1000
 const CODEX_THREAD_LIST_STALE_ENTRY_MS = 24 * 60 * 60 * 1000
+const CODEX_THREAD_LIST_HEADER_PARSE_CONCURRENCY = 16
 const CODEX_ROLLOUT_PARSE_IO_ERROR = Symbol("codex-rollout-parse-io-error")
 
 function sameCodexThreadListFingerprint(a, b) {
@@ -1736,18 +1737,29 @@ export async function listCodexThreadsFromDisk({
   // 4. 新規・変更分だけ header を解析する。別 cwd は session_meta を得た時点で止め、
   //    その cwd が後で要求された時に一度だけ preview まで補完する。一時 I/O 失敗は cache せず、
   //    次 poll で再試行する。解析済み不正 header (meta=null) は fingerprint 不変なら再解析しない。
-  let parsedHeaders = 0
   const headerParseStartedAt = Date.now()
-  for (const { fp, mtimeMs, size } of candidates) {
-    if (snapshot.has(fp)) continue
-    const observed = index.get(fp)
-    parsedHeaders++
-    const meta = await parseCodexRolloutHead(fp, cwd, _testHooks)
-    if (meta === CODEX_ROLLOUT_PARSE_IO_ERROR) continue
-    const entry = { mtimeMs, size, lastSeenAt: seenAt, meta }
-    commitCodexThreadListEntry(index, fp, observed, entry)
-    snapshot.set(fp, entry)
+  const uncachedCandidates = candidates.filter(({ fp }) => !snapshot.has(fp))
+  const parsedHeaders = uncachedCandidates.length
+  let nextHeaderIndex = 0
+  const parseNextHeader = async () => {
+    while (nextHeaderIndex < uncachedCandidates.length) {
+      const { fp, mtimeMs, size } = uncachedCandidates[nextHeaderIndex++]
+      const observed = index.get(fp)
+      const meta = await parseCodexRolloutHead(fp, cwd, _testHooks)
+      if (meta === CODEX_ROLLOUT_PARSE_IO_ERROR) continue
+      const entry = { mtimeMs, size, lastSeenAt: seenAt, meta }
+      commitCodexThreadListEntry(index, fp, observed, entry)
+      snapshot.set(fp, entry)
+    }
   }
+  await Promise.all(
+    Array.from(
+      {
+        length: Math.min(CODEX_THREAD_LIST_HEADER_PARSE_CONCURRENCY, uncachedCandidates.length),
+      },
+      parseNextHeader,
+    ),
+  )
 
   // 5. cwd で絞ってから mtime 降順・limit を適用する。グローバル候補数には左右されない。
   const out = []