@cocorograph/hub-agent 0.7.36 → 0.7.39

package/package.json

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

package/src/claude-stream-bridge.mjs

@@ -31,6 +31,25 @@ import {
   createEventMasker,
   maskJsonlFileAtRest,
 } from "./tool-result-mask.mjs"
+import { getOrCreateSiblingToken } from "./sibling-token.mjs"
+
+/**
+ * sibling-inject (2026-07-04) 用: spawn する claude プロセス自身の環境変数に、
+ * この cwd の capability トークンを乗せる。ディスクには書かず、プロセス環境変数
+ * としてのみ渡す (src/sibling-token.mjs のコメント参照)。
+ * @param {string} cwd
+ * @returns {{COCKPIT_SIBLING_TOKEN: string, COCKPIT_SIBLING_CWD: string}}
+ */
+function siblingEnvFor(cwd) {
+  return {
+    ...process.env,
+    COCKPIT_SIBLING_TOKEN: getOrCreateSiblingToken(cwd),
+    COCKPIT_SIBLING_CWD: cwd,
+    // ask-sibling スキル (cockpit_orch.py) が「自分は claude/codex どちらか」を
+    // 環境変数から確実に判定できるようにする (ヒューリスティック不要)。
+    COCKPIT_SIBLING_SELF_KIND: "claude",
+  }
+}
 
 /** browser 切断後、セッションを生かしたまま再接続を待つ idle TTL (ミリ秒)。これを過ぎ、
  *  かつ走行中でなければ撤去する。端末スリープ/長期離席後の再接続も吸収できるよう 7 日に
@@ -709,6 +728,7 @@ class ClaudeStreamSession {
 
     const options = {
       cwd: this.cwd,
+      env: siblingEnvFor(this.cwd),
       canUseTool: (toolName, input) => this._canUseTool(toolName, input),
       includePartialMessages: true,
       abortController: this._abortController,
@@ -1017,6 +1037,7 @@ class ClaudeStreamSession {
   async _runResidentQuery() {
     const options = {
       cwd: this.cwd,
+      env: siblingEnvFor(this.cwd),
       canUseTool: (toolName, input) => this._canUseTool(toolName, input),
       includePartialMessages: true,
     }
@@ -1134,6 +1155,24 @@ class ClaudeStreamSession {
         /* ignore */
       }
       this._busy = false
+      // T05699 残タスク #2-1 (2026-07-04): interrupt() は現ターンの result を発火しない
+      // (query は継続、次 input 受付継続のみ)。そのため abort 時点で _pendingMessages に
+      // 溜まっている送信待ちメッセージは、result 経由の drain (_runResidentQuery 内の
+      // result ハンドラ) を永久に迎えられず、_busy=false のまま取り残されていた。この
+      // 状態で直後に次の sendMessage が届くと (_busy===false のため) pending をすっ飛ばして
+      // _inputQueue へ直接 push してしまい、先に積んだメッセージより後着メッセージが
+      // 先に処理される FIFO 順序崩れが起きる。ここで明示的に drain し、pending があれば
+      // 同一 query 内で継続処理させる (無ければ _emitQueueState() のみで no-op)。
+      // _drainResidentPending は async だが最初の await 前に _busy=true を同期的に
+      // セットするため、この関数の呼び出し (await しない fire-and-forget) が完了した
+      // 時点 (= abortTurn() の同期実行が終わるまでの同一 tick 内) で以降の sendMessage は
+      // 正しく busy 状態を観測できる。
+      this._drainResidentPending().catch((err) =>
+        this.logger?.warn(
+          { stream_id: this.stream_id, err: err?.message },
+          "drainResidentPending (abort) threw",
+        ),
+      )
       return
     }
     if (this._abortController) {
@@ -1660,6 +1699,50 @@ export class ClaudeStreamBridge extends EventEmitter {
     return best
   }
 
+  /**
+   * 指定 cwd でライブなセッションへメッセージを直接注入する (sibling-inject 用、
+   * 2026-07-04)。同一マシン内の別プロセス (ask-sibling スキル経由の cockpit_orch.py)
+   * が、Cockpit ブラウザの WS 接続を経由せず、hub-agent デーモンへローカル IPC
+   * (src/sibling-inject.mjs) 経由でこの cwd の生きているチャットセッションへ新規
+   * ターンを開始させる。liveSessionIdForCwd と同じ走査ロジックだが、返すのは
+   * sessionId 文字列ではなく session オブジェクト自体 (sendMessage を直接呼べるように
+   * するため)。同一 cwd に複数ライブセッションがある場合は最終アクティビティが最も
+   * 新しいものを採用する。
+   *
+   * ⚠️ このメソッド自体は認証を行わない (呼び出し元の sibling-inject.mjs が
+   * src/sibling-token.mjs の capability トークンで入力元を検証する前提)。
+   *
+   * @param {string} cwd
+   * @param {string} text
+   * @returns {boolean} 送信できたか (対象セッションが見つからなければ false)
+   */
+  sendToCwd(cwd, text) {
+    if (!cwd || !text) return false
+    let best = null
+    let bestAt = -1
+    const seen = new Set()
+    for (const session of this.sessions.values()) {
+      if (seen.has(session) || session.cwd !== cwd) continue
+      seen.add(session)
+      let at = 0
+      for (const t of session.lastActivityByStream.values()) {
+        if (t > at) at = t
+      }
+      if (at >= bestAt) {
+        bestAt = at
+        best = session
+      }
+    }
+    if (!best) return false
+    best.sendMessage({ role: "user", content: text }).catch((err) => {
+      this.logger?.error(
+        { cwd, err: err?.message },
+        "sendToCwd: sendMessage threw unexpectedly",
+      )
+    })
+    return true
+  }
+
   /**
    * `mcpServerStatus()` の結果に、needs-auth キャッシュにあるが結果へ含まれない
    * サーバーを `needs-auth` として補完する。

package/src/codex-stream-bridge.mjs

@@ -34,6 +34,26 @@
 import { EventEmitter } from "node:events"
 
 import { CodexAppServerClient } from "./codex-appserver-client.mjs"
+import { getOrCreateSiblingToken } from "./sibling-token.mjs"
+
+/**
+ * sibling-inject (2026-07-04) 用: spawn する codex app-server プロセス自身の
+ * 環境変数に、この cwd の capability トークンを乗せる。ディスクには書かず、
+ * プロセス環境変数としてのみ渡す (src/sibling-token.mjs のコメント参照、
+ * claude-stream-bridge.mjs の同名ヘルパーと対)。
+ * @param {string} cwd
+ * @returns {NodeJS.ProcessEnv}
+ */
+function siblingEnvFor(cwd) {
+  return {
+    ...process.env,
+    COCKPIT_SIBLING_TOKEN: getOrCreateSiblingToken(cwd),
+    COCKPIT_SIBLING_CWD: cwd,
+    // ask-sibling スキル (cockpit_orch.py) が「自分は claude/codex どちらか」を
+    // 環境変数から確実に判定できるようにする (ヒューリスティック不要)。
+    COCKPIT_SIBLING_SELF_KIND: "codex",
+  }
+}
 
 // detach 後、非 busy なセッションを生かしておく猶予。claude 側 (7 日) と違い短くする:
 // Slice 2 は in-memory reattach 非対応のため、browser の WS 再接続ごとに新 stream_id で
@@ -89,7 +109,12 @@ export class CodexStreamBridge extends EventEmitter {
     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 client = this._clientFactory({
+      cwd,
+      codexCmd: this.codexCmd,
+      logger: this.logger,
+      env: siblingEnvFor(cwd),
+    })
     const session = {
       stream_id,
       cwd,
@@ -300,6 +325,52 @@ export class CodexStreamBridge extends EventEmitter {
     this._maybeReapAfterIdle(session)
   }
 
+  /**
+   * 指定 cwd に一致するライブ (attach 済み) codex セッションの threadId を返す。
+   * Claude 版 `liveSessionIdForCwd` の対 (main.mjs の state loop / terminal mirror から
+   * cwd → threadId 解決に使う)。複数一致時は先に見つかったものを返す (5h/7d はアカウント
+   * 全体の値のためどのセッションから読んでも同じ契約の残量、代表 1 件で十分)。
+   *
+   * @param {string} cwd
+   * @returns {string|null}
+   */
+  threadIdForCwd(cwd) {
+    if (!cwd) return null
+    for (const session of this.sessions.values()) {
+      if (session.cwd === cwd && session.threadId) return session.threadId
+    }
+    return null
+  }
+
+  /**
+   * 指定 cwd でライブなセッションへメッセージを直接注入する (sibling-inject 用、
+   * 2026-07-04)。Claude 版 `sendToCwd` の対。同一 cwd に複数ライブセッションがある
+   * 場合は `threadIdForCwd` と同じく先に見つかったものを使う。
+   *
+   * ⚠️ このメソッド自体は認証を行わない (呼び出し元の sibling-inject.mjs が
+   * src/sibling-token.mjs の capability トークンで入力元を検証する前提)。
+   *
+   * @param {string} cwd
+   * @param {string} text
+   * @returns {boolean} 送信できたか (対象セッションが見つからなければ false)
+   */
+  sendToCwd(cwd, text) {
+    if (!cwd || !text) return false
+    for (const session of this.sessions.values()) {
+      if (session.cwd !== cwd) continue
+      this.input({ stream_id: session.stream_id, message: { role: "user", content: text } }).catch(
+        (err) => {
+          this.logger?.error(
+            { cwd, err: err?.message },
+            "sendToCwd: input threw unexpectedly",
+          )
+        },
+      )
+      return true
+    }
+    return false
+  }
+
   _maybeReapAfterIdle(session) {
     if (session.activeTurnId) return // 完走まで待つ (turn/completed で再評価される)
     this._clearDetachTimer(session)

package/src/main.mjs

@@ -93,9 +93,11 @@ import {
 import { TuiPermissionBridge } from "./tui-permission-bridge.mjs"
 import { TuiViewerRegistry } from "./tui-viewer-registry.mjs"
 import { JsonlLiveWatchers } from "./jsonl-live-watchers.mjs"
+import { SiblingInjectBridge } from "./sibling-inject.mjs"
 import {
   boundSessionId,
   codexSessionUsages,
+  codexTurnActiveForThread,
   codexUsageForThread,
   contextWindowSize,
   getSessionUsages,
@@ -766,6 +768,10 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
     logger,
     intervalMs: 5_000,
     claudeBridge,
+    // T05699 残タスク #1 (2026-07-04): 背景 Codex チャットセッションの turn_active を
+    // rollout ベースで解決するために渡す (main.mjs startStateLoop 内の codexBridge.threadIdForCwd
+    // 参照)。
+    codexBridge,
     readinessTracker,
     // tmux session_name → bind 中の session_id。turn_active を「そのペインが実際に走らせている
     // セッションの jsonl」で判定するために渡す (cwd dir 内の別 jsonl 取り違え=メタ欠陥#1 の根治)。
@@ -863,6 +869,14 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
   await tuiViewerRegistry.start()
   ctx.tuiViewerRegistry = tuiViewerRegistry
 
+  // sibling-inject (ask-sibling スキル, 2026-07-04): 同一 cwd の claude⇄codex
+  // 相互依頼のためのローカル IPC 受信口。cwd スコープ capability トークン
+  // (src/sibling-token.mjs) で検証した要求のみ claudeBridge/codexBridge.sendToCwd()
+  // へ橋渡しする。
+  const siblingInjectBridge = new SiblingInjectBridge({ claudeBridge, codexBridge, logger })
+  await siblingInjectBridge.start()
+  ctx.siblingInjectBridge = siblingInjectBridge
+
   // jsonl ライブ追従 (T04784 逐次表示): TUI チャットの閲覧ハートビートを起点に対象
   // session の jsonl を tail し、追記行を claude.jsonl.event として逐次 push する。
   // これで session.event 合図 → 全体再 hydrate + 2.5s ポーリングの「どさっと」を廃せる。
@@ -921,6 +935,7 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
     tuiPermissionBridge.stop()
     tuiViewerRegistry.stop()
     jsonlLiveWatchers.stop()
+    siblingInjectBridge.stop()
     ptyBridge.shutdown()
     claudeBridge?.shutdown?.()
     codexBridge?.shutdown?.()
@@ -1425,7 +1440,31 @@ export function resolveStateLoopBoundSessionId(boundSessions, sessionName, cwd,
   return null
 }
 
-export function startStateLoop({ client, plugins, logger, intervalMs, claudeBridge, readinessTracker, boundSessions }) {
+/**
+ * turn_active をどの情報源で判定するかを決める純関数 (main.mjs startStateLoop から抽出、
+ * T05699 残タスク #1)。実際の非同期解決 (turnActiveForCwd / codexTurnActiveForThread の
+ * 呼び出し) は呼び出し側 (tick) が行う。優先順位:
+ *
+ *  1. chat 信号が processing → "chat-active" (true)
+ *  2. chat 信号が waiting/idle → "chat-inactive" (false)
+ *  3. fresh unbound bind (adopt 前の bind プレースホルダ) → "fresh-unbound" (null=不明、安全側)
+ *  4. cwd に一致するライブ codexBridge セッションがある → "codex" (rollout ベース判定)
+ *  5. cwd があれば → "claude" (jsonl ベース判定、TUI/bound session フォールバック)
+ *  6. cwd も無ければ → "none" (null=不明)
+ *
+ * @param {{chatStatus?: string|null, cwd?: string|null, isFreshUnbound?: boolean, codexThreadId?: string|null}} params
+ * @returns {'chat-active'|'chat-inactive'|'fresh-unbound'|'codex'|'claude'|'none'}
+ */
+export function decideTurnActiveSource({ chatStatus, cwd, isFreshUnbound, codexThreadId }) {
+  if (chatStatus === "processing") return "chat-active"
+  if (chatStatus === "waiting" || chatStatus === "idle") return "chat-inactive"
+  if (cwd && isFreshUnbound) return "fresh-unbound"
+  if (codexThreadId) return "codex"
+  if (cwd) return "claude"
+  return "none"
+}
+
+export function startStateLoop({ client, plugins, logger, intervalMs, claudeBridge, codexBridge, readinessTracker, boundSessions }) {
   const lastByName = new Map() // session_name → {status, context_pct}
   const lastTurnAtByName = new Map() // session_name → 最後に event ファイル化した turnAt
   // (i) session_name → {sig, changedAt}: 出力領域署名の最終変化時刻 (出力フロー検知用)。
@@ -1553,23 +1592,50 @@ export function startStateLoop({ client, plugins, logger, intervalMs, claudeBrid
         //    null を返し mtime 最新 jsonl へフォールバックしていた (chat 版の cross-activity
         //    汚染, 2026-07 発覚)。resolveStateLoopBoundSessionId が claudeBridge のライブ
         //    セッション id へフォールバックすることで TUI と同じ方式で根治する。
+        //  - Codex (T05699 残タスク #1, 2026-07-04): この cwd にライブな codexBridge セッション
+        //    (chat モード) があれば、chat 信号の 90s TTL に依存しない rollout ベースの判定
+        //    (codexTurnActiveForThread, task_started/task_complete イベント対) を使う。長時間
+        //    ターン中に chat 信号が stale 化してドットが消える欠落を根治する。Claude 版のような
+        //    paneAliveProbe は渡さない (chat モードのペインは素のシェルのまま = 実処理は別
+        //    プロセスのため、pane 生存判定を適用すると誤って dead 扱いになる)。cwd がライブな
+        //    codex セッションと一致しなければ従来通り Claude jsonl (turnActiveForCwd) にフォール
+        //    バックする (TUI/bare codex pane は現状 bound thread 解決が無いため、これまで通り
+        //    null=不明のまま、退行はしない)。
+        //    分岐の優先順位は decideTurnActiveSource (純関数、単体テスト済み) が権威。
         let turnActive = null
-        if (chat?.status === "processing") {
-          turnActive = true
-        } else if (chat?.status === "waiting" || chat?.status === "idle") {
-          turnActive = false
-        } else if (s.cwd && isFreshUnboundBind(boundSessions?.get(s.session_name))) {
-          // 症状2b 根治: fresh bind プレースホルダの間は、別アクティビティ jsonl を mtime 最新で
-          // 取り違える汚染を避けて turn_active を出さない (null=不明)。実セッション id へ adopt
-          // されれば下の通常経路に乗る。青を出さない安全側にのみ倒すため固着青は生まない。
-          turnActive = null
-        } else if (s.cwd) {
-          turnActive = await turnActiveForCwd(
-            s.cwd,
-            resolveStateLoopBoundSessionId(boundSessions, s.session_name, s.cwd, claudeBridge),
-            s.session_name,
-            { paneAliveProbe: paneClaudeAliveOrUnknown },
-          )
+        const codexThreadId = s.cwd ? codexBridge?.threadIdForCwd?.(s.cwd) || null : null
+        const turnActiveSource = decideTurnActiveSource({
+          chatStatus: chat?.status,
+          cwd: s.cwd,
+          isFreshUnbound: isFreshUnboundBind(boundSessions?.get(s.session_name)),
+          codexThreadId,
+        })
+        switch (turnActiveSource) {
+          case "chat-active":
+            turnActive = true
+            break
+          case "chat-inactive":
+            turnActive = false
+            break
+          case "fresh-unbound":
+            // 症状2b 根治: fresh bind プレースホルダの間は、別アクティビティ jsonl を mtime 最新で
+            // 取り違える汚染を避けて turn_active を出さない (null=不明)。実セッション id へ adopt
+            // されれば下の通常経路に乗る。青を出さない安全側にのみ倒すため固着青は生まない。
+            turnActive = null
+            break
+          case "codex":
+            turnActive = await codexTurnActiveForThread(codexThreadId)
+            break
+          case "claude":
+            turnActive = await turnActiveForCwd(
+              s.cwd,
+              resolveStateLoopBoundSessionId(boundSessions, s.session_name, s.cwd, claudeBridge),
+              s.session_name,
+              { paneAliveProbe: paneClaudeAliveOrUnknown },
+            )
+            break
+          default:
+            turnActive = null
         }
 
         const prev = lastByName.get(s.session_name)
@@ -3243,6 +3309,58 @@ async function dispatch(msg, ctx) {
         }
         return
       }
+      case "codex.upload": {
+        // B4 (T05699 残タスク, 2026-07-04): Cockpit Codexチャットの添付ファイル受信
+        // (チャンク1件)。claude.upload と同じ UploadManager を再利用する (cwd ベースで
+        // CLI 非依存の実装のため無改修で流用可能)。全チャンク到着で cwd 配下の
+        // .cockpit-uploads/<日付>/ に保存し、保存パスを browser へ返す。browser は
+        // そのパスを codex.input 本文に載せ、Codex がシェル/ファイルツールで読む
+        // (Claude 版と同じ「パス参照方式」、Codex 側の model/effort 分離と同様に
+        // アカウント/プロトコルが違うだけでファイル保存の仕組みは共有する)。
+        if (!ctx.uploadManager) {
+          ctx.client.send({
+            type: "codex.upload.done",
+            stream_id: msg.stream_id,
+            upload_id: msg.upload_id,
+            ok: false,
+            error: "upload_unavailable",
+          })
+          return
+        }
+        try {
+          const res = await ctx.uploadManager.addChunk({
+            upload_id: msg.upload_id,
+            filename: msg.filename,
+            media_type: msg.media_type,
+            total_size: msg.total_size,
+            total_chunks: msg.total_chunks,
+            chunk_index: msg.chunk_index,
+            data: msg.data,
+            cwd: msg.cwd || ctx.config?.claude_cwd || undefined,
+          })
+          if (res.done) {
+            ctx.client.send({
+              type: "codex.upload.done",
+              stream_id: msg.stream_id,
+              upload_id: msg.upload_id,
+              ok: true,
+              path: res.path,
+              filename: res.filename,
+              media_type: res.media_type,
+              size: res.size,
+            })
+          }
+        } catch (err) {
+          ctx.client.send({
+            type: "codex.upload.done",
+            stream_id: msg.stream_id,
+            upload_id: msg.upload_id,
+            ok: false,
+            error: err?.message || String(err),
+          })
+        }
+        return
+      }
       case "codex.input":
         // model/effort: turn/start (非 busy 時) にのみ反映される override。turn/steer
         // (busy 時) は公式スキーマ上 model/effort 非対応のため、その場合は

package/src/sibling-inject.mjs

@@ -0,0 +1,150 @@
+/**
+ * sibling-inject (同一 cwd の claude⇄codex 相互依頼) の受信ブリッジ (2026-07-04)。
+ *
+ * ask-sibling スキル経由の `cockpit_orch.py` (Cockpit ブラウザの WS 接続を持たない、
+ * Bash tool 経由で動く別プロセス) が、同一マシン上で稼働中の hub-agent デーモンへ
+ * 「この cwd の生きているチャットセッション (claude/codex) へ新規ターンを注入して
+ * ほしい」と頼むための受信口。
+ *
+ * 設計 (WHY): hub-agent はローカル HTTP/Unix ソケットサーバを持たないため、既存の
+ * ファイル IPC 前例 (tui-permission-bridge.mjs 等、`/tmp/cockpit_*` + fs.watch +
+ * atomic write) と同じパターンに揃える。
+ *
+ * ⚠️ セキュリティ設計 (2026-07-04 セッションでユーザー承認済み): この機構は
+ * 「生きている自律エージェント (シェル/API/MCP ツールへのフルアクセス権を持つ)
+ * へ外部プロセスから新規指示を注入する」という強い書き込み権限を持つため、
+ * `src/sibling-token.mjs` の cwd スコープ capability トークンによる検証を必須とする。
+ * トークンが一致しない要求は無視し (実行せず削除)、warn ログのみ残す。
+ *
+ * 契約: request file `<request_id>.json` = `{cwd, target_cli_kind, text, token}`。
+ * 処理後は必ず削除し (成否問わず)、呼び出し側が待ち受けられるよう
+ * `<request_id>.result.json` = `{ok, error?}` を書く。
+ */
+
+import { watch } from "node:fs"
+import { mkdir, readFile, writeFile, rename, unlink, readdir } from "node:fs/promises"
+import path from "node:path"
+
+import { verifySiblingToken } from "./sibling-token.mjs"
+
+export const SIBLING_REQUESTS_DIR =
+  process.env.COCKPIT_SIBLING_REQUESTS_DIR || "/tmp/cockpit_sibling_requests"
+
+export class SiblingInjectBridge {
+  /**
+   * @param {{dir?: string, claudeBridge?: object, codexBridge?: object, logger?: object}} [opts]
+   */
+  constructor({ dir = SIBLING_REQUESTS_DIR, claudeBridge, codexBridge, logger } = {}) {
+    this.dir = dir
+    this.claudeBridge = claudeBridge
+    this.codexBridge = codexBridge
+    this.logger = logger
+    /** @type {Set<string>} 二重処理防止 (request_id) */
+    this._seen = new Set()
+    this._watcher = null
+  }
+
+  /** 監視ディレクトリを作成し、既存要求を sweep してから fs.watch を張る。 */
+  async start() {
+    await mkdir(this.dir, { recursive: true })
+    await this._sweep()
+    try {
+      this._watcher = watch(this.dir, (_event, filename) => {
+        if (filename && filename.endsWith(".json") && !filename.endsWith(".result.json")) {
+          this._ingest(filename).catch((err) => {
+            this.logger?.warn({ err: err?.message, filename }, "sibling-inject ingest failed")
+          })
+        }
+      })
+    } catch (err) {
+      this.logger?.warn(
+        { err: err?.message },
+        "sibling-inject watcher: fs.watch failed, watcher disabled",
+      )
+    }
+  }
+
+  /** 起動時 / 取りこぼし保険: dir 内の全要求ファイルを読む。 */
+  async _sweep() {
+    let names = []
+    try {
+      names = await readdir(this.dir)
+    } catch {
+      return
+    }
+    for (const n of names) {
+      if (n.endsWith(".json") && !n.endsWith(".result.json")) {
+        await this._ingest(n).catch((err) => {
+          this.logger?.warn({ err: err?.message, filename: n }, "sibling-inject sweep failed")
+        })
+      }
+    }
+  }
+
+  /**
+   * 要求ファイル 1 件を読み、トークン検証後に対象 cwd のセッションへ注入する。
+   * 成否によらず要求ファイルは削除し、結果ファイルを書く。
+   * @param {string} filename `<request_id>.json`
+   */
+  async _ingest(filename) {
+    const request_id = filename.slice(0, -".json".length)
+    if (this._seen.has(request_id)) return
+    this._seen.add(request_id)
+    const fp = path.join(this.dir, filename)
+    let body
+    try {
+      body = JSON.parse(await readFile(fp, "utf-8"))
+    } catch {
+      // partial write / 既に消えた → 次の watch イベントで拾い直す (seen から外す)。
+      this._seen.delete(request_id)
+      return
+    }
+
+    const { cwd, target_cli_kind, text, token } = body || {}
+    let result
+    if (!cwd || !text || (target_cli_kind !== "claude" && target_cli_kind !== "codex")) {
+      result = { ok: false, error: "invalid_request" }
+    } else if (!verifySiblingToken(cwd, token)) {
+      this.logger?.warn({ cwd, request_id }, "sibling-inject: token mismatch, request denied")
+      result = { ok: false, error: "invalid_token" }
+    } else {
+      const bridge = target_cli_kind === "codex" ? this.codexBridge : this.claudeBridge
+      const sent = bridge?.sendToCwd?.(cwd, text) ?? false
+      result = sent
+        ? { ok: true }
+        : { ok: false, error: "no_live_session_for_cwd" }
+    }
+
+    await this._writeResult(request_id, result)
+    // 要求ファイルは処理後に必ず削除する (成否問わず、再処理させないため)。
+    try {
+      await unlink(fp)
+    } catch {
+      /* 既に無ければ no-op */
+    }
+  }
+
+  /** 結果ファイルを atomic write する (呼び出し側 CLI がポーリングする)。 */
+  async _writeResult(request_id, result) {
+    const fp = path.join(this.dir, `${request_id}.result.json`)
+    const tmp = `${fp}.tmp`
+    try {
+      await writeFile(tmp, JSON.stringify(result))
+      await rename(tmp, fp)
+    } catch (err) {
+      this.logger?.warn({ err: err?.message, request_id }, "sibling-inject result write failed")
+    }
+  }
+
+  /** watcher を閉じる。 */
+  stop() {
+    try {
+      this._watcher?.close()
+    } catch {
+      /* ignore */
+    }
+    this._watcher = null
+  }
+}
+
+export default SiblingInjectBridge

package/src/sibling-token.mjs

@@ -0,0 +1,62 @@
+/**
+ * sibling-inject (同一 cwd の claude⇄codex 相互依頼) 用の cwd スコープ capability
+ * トークンストア (2026-07-04)。
+ *
+ * 設計の背景 (WHY):
+ * hub-agent はローカル HTTP/Unix ソケットサーバを持たず、既存のローカル IPC は
+ * すべて `/tmp/cockpit_*` 配下のファイルベース (tui-permission-bridge.mjs 等) で、
+ * 認証機構を持たない (同一 UID なら誰でも読み書きできる想定)。
+ *
+ * sibling-inject はこの上に「生きているチャットセッションへ新規ターンを注入する」
+ * という強い書き込み権限を追加するため、無認証のままだと「同一マシン上の無関係な
+ * 別プロセス (npm postinstall スクリプト等) が自律エージェント (シェル/API/MCP
+ * ツールへのフルアクセス権を持つ) へ任意の指示を注入できる」という新しい攻撃面に
+ * なる (2026-07-04 セッションで実装時に確認済みの懸念、ユーザー承認済み)。
+ *
+ * 対策: cwd ごとにランダムな capability トークンを発行し、hub-agent がそのセッション
+ * (claude/codex いずれも) を spawn する際に **そのプロセス自身の環境変数にのみ**
+ * 渡す (`COCKPIT_SIBLING_TOKEN`、ディスクには書かない)。sibling-inject の受信側は
+ * このトークンが一致した場合のみ注入を実行する。これにより「/tmp を書き換えられる
+ * 全プロセス」ではなく「そのセッション自身の環境変数を読めるプロセス (= 既に
+ * hub-agent が spawn した agent 自身、またはその子プロセス)」だけが注入できる設計に
+ * 絞り込める。Hub ユーザートークン (agent 全体を認証する、より広い権限を持つ鍵) を
+ * 転用しない理由: ディスク保存されるため同じ攻撃者から結局読める上、漏洩時の被害
+ * 範囲がこの cwd 限定トークンより大きくなるため。
+ */
+
+import { randomBytes } from "node:crypto"
+
+/** @type {Map<string, string>} cwd -> token */
+const tokensByCwd = new Map()
+
+/**
+ * 指定 cwd の capability トークンを返す (無ければ新規発行)。
+ * @param {string} cwd
+ * @returns {string}
+ */
+export function getOrCreateSiblingToken(cwd) {
+  if (!cwd) throw new Error("getOrCreateSiblingToken: cwd is required")
+  let token = tokensByCwd.get(cwd)
+  if (!token) {
+    token = randomBytes(32).toString("hex")
+    tokensByCwd.set(cwd, token)
+  }
+  return token
+}
+
+/**
+ * 指定 cwd に対して提示されたトークンが正しいか検証する。
+ * @param {string} cwd
+ * @param {string} token
+ * @returns {boolean}
+ */
+export function verifySiblingToken(cwd, token) {
+  if (!cwd || !token) return false
+  const expected = tokensByCwd.get(cwd)
+  return typeof expected === "string" && expected === token
+}
+
+/** テスト用: トークンストアを全クリアする。 */
+export function _resetSiblingTokens() {
+  tokensByCwd.clear()
+}

package/src/usage.mjs

@@ -1450,3 +1450,123 @@ export async function codexSessionUsages(liveSessions) {
   )
   return out
 }
+
+// ---------------------------------------------------------------------------
+// Codex 版 turn_active 判定 (Cockpit Codex 両対応 T05699 残タスク #1, 2026-07-04)。
+//
+// 背景: サイドバー背景セッションのステータスドット (turn_active) は state loop
+// (main.mjs startStateLoop) が権威。Codex はこれまで in-memory チャット信号
+// (chat-signals.mjs, TTL 90s) だけに依存しており、長時間ターン中に 90s 無通知の
+// 間隔が空くと stale 化しドットが消える欠落があった (main.mjs:1556-1573 の
+// else-if 分岐は Claude jsonl 専用 turnActiveForCwd しか知らない)。
+//
+// 実機の rollout jsonl (2026-07-04, 実データ 2444 ファイル走査) で `event_msg` の
+// `task_started`/`task_complete` が turn の開始/終了を示す明確なペアであることを
+// 確認済み (全ファイルで started==completed の対応が崩れた例は無し)。B3
+// (codexUsageForThread) と同じ「threadId → rollout ファイル特定 → 末尾 tail 走査」
+// パターンを踏襲し、チャット信号の TTL に依存しない独立した真実源にする。
+// ---------------------------------------------------------------------------
+
+// task_started の記録から task_complete が届かないまま経過した場合の猶予。TUI (bare pane)
+// 経由の bound thread 解決は未対応 (2026-07-04 時点、`codex.tui.bind` 相当が無い) のため、
+// 現状 paneAliveProbe を渡すのは将来の TUI 対応時のみ想定。チャットモード (app-server 駆動)
+// はペインが素のシェルのまま (実処理は別プロセス) なので pane 生存判定の対象外。
+const CODEX_STALE_TASK_MS = 5_000
+
+/** P5(perf): codex turn_active 判定結果を mtime+size でメモ化。 */
+const _codexTurnActiveMemo = new Map() // fp → { mtimeMs, size, result }
+
+/**
+ * rollout jsonl テキストを走査して「最終 turn_active 状態 + 直近 task_started の時刻」を
+ * 返す内部ヘルパー。Claude の `_scanTurnState` と対だが、Codex は `task_started`/
+ * `task_complete` という明示イベントペアがあるため stop_reason 解釈のステートマシンは不要。
+ *
+ * @param {string} text
+ * @returns {{active: boolean, activeSinceTs: number|null}}
+ */
+export function _scanCodexTurnState(text) {
+  const empty = { active: false, activeSinceTs: null }
+  if (!text) return empty
+  let active = false
+  let activeSinceTs = null
+  const lines = text.split("\n")
+  for (const line of lines) {
+    if (!line) continue
+    let d
+    try {
+      d = JSON.parse(line)
+    } catch {
+      continue
+    }
+    if (d.type !== "event_msg") continue
+    const pt = d.payload?.type
+    if (pt === "task_started") {
+      active = true
+      activeSinceTs = parseEntryTs(d.timestamp)
+    } else if (pt === "task_complete") {
+      active = false
+      activeSinceTs = null
+    }
+  }
+  return { active, activeSinceTs }
+}
+
+/**
+ * 指定 threadId の Codex セッションが現在ターン進行中かを rollout jsonl から判定する。
+ * `turnActiveForCwd` (Claude) の対。チャット信号 (in-memory, TTL 90s) が stale なときの
+ * フォールバックとして main.mjs の state loop から呼ばれる想定。
+ *
+ * @param {string} threadId
+ * @param {{sessionName?: string, paneAliveProbe?: (name:string)=>Promise<'alive'|'dead'|'unknown'>, now?: number}} [opts]
+ *   sessionName/paneAliveProbe: 将来の TUI (bare pane) 対応用。チャットモードはペインが
+ *   素のシェルのまま (実処理は別プロセス) のため渡さないこと (誤って dead 判定され得る)。
+ * @returns {Promise<boolean|null>} true=生成中 / false=待機中 / null=rollout 不明
+ */
+export async function codexTurnActiveForThread(threadId, opts = {}) {
+  if (!threadId) return null
+  const fp = await findCodexRolloutFile(threadId)
+  if (!fp) return null
+  let st
+  try {
+    st = await fs.stat(fp)
+  } catch {
+    return null
+  }
+
+  const memo = _codexTurnActiveMemo.get(fp)
+  if (memo && memo.mtimeMs === st.mtimeMs && memo.size === st.size) {
+    return memo.result
+  }
+
+  const tail = await readTail(fp, 256 * 1024)
+  let state = { active: false, activeSinceTs: null }
+  if (tail != null) state = _scanCodexTurnState(tail)
+  // tail で active=false の場合のみ、巨大 response_item で先頭の task_started が
+  // tail 窓から落ちていないか全文で確認する (Claude 版 turnActiveForCwd と同じ方針)。
+  if (state.active === false) {
+    const full = await readOrNull(fp)
+    if (full != null) state = _scanCodexTurnState(full)
+  }
+
+  let active = state.active
+  const now = typeof opts.now === "number" ? opts.now : Date.now()
+  if (
+    active &&
+    state.activeSinceTs !== null &&
+    now - state.activeSinceTs > CODEX_STALE_TASK_MS &&
+    opts.sessionName &&
+    typeof opts.paneAliveProbe === "function"
+  ) {
+    const verdict = await opts.paneAliveProbe(opts.sessionName)
+    if (verdict === "dead") active = false
+  }
+
+  const result = active
+  _codexTurnActiveMemo.set(fp, { mtimeMs: st.mtimeMs, size: st.size, result })
+  return result
+}
+
+/** テスト用: codex turn_active メモをクリアする。 */
+export function _resetCodexTurnActiveMemo() {
+  _codexTurnActiveMemo.clear()
+}