@cocorograph/hub-agent 0.8.19 → 0.8.21

package/bin/hub-agent.mjs

@@ -167,52 +167,6 @@ program
     }
   })
 
-program
-  .command("mirror")
-  .description(
-    "チャット(SDK/app-server)の会話を、このターミナルに読み取り専用で実況表示する " +
-    "(Cockpit Codex 両対応 Stream C)。チャットの動作には一切影響しない (書き込まない)。" +
-    "Ctrl-C / SIGTERM で停止する",
-  )
-  .requiredOption("--cwd <path>", "対象セッションの cwd")
-  .requiredOption("--session <id>", "Claude session_id または Codex threadId")
-  .option("--cli-kind <kind>", "'claude' または 'codex'", "claude")
-  .action(async (opts) => {
-    if (opts.cliKind !== "claude" && opts.cliKind !== "codex") {
-      console.error(`--cli-kind は 'claude' か 'codex' のみ対応: ${opts.cliKind}`)
-      process.exit(2)
-    }
-    const { runClaudeMirror, runCodexMirror } = await import("../src/session-mirror.mjs")
-    // watchSessionFile / watchCodexRollout のポーリング timer は常駐 daemon (main.mjs) の
-    // graceful shutdown を妨げないよう意図的に unref() されている。この単体 CLI プロセスは
-    // 他に event loop を保持する要因が無いため、unref timer だけでは初回同期処理の直後に
-    // 即終了してしまう (実機検証で確認)。ref 付きの keep-alive timer で明示的に生かす。
-    const keepAlive = setInterval(() => {}, 60_000)
-    let watcher
-    try {
-      watcher =
-        opts.cliKind === "codex"
-          ? await runCodexMirror({ threadId: opts.session })
-          : runClaudeMirror({ cwd: opts.cwd, sessionId: opts.session })
-    } catch (err) {
-      clearInterval(keepAlive)
-      console.error(`mirror failed: ${err.message}`)
-      process.exit(1)
-    }
-    const stop = () => {
-      clearInterval(keepAlive)
-      try {
-        watcher?.stop?.()
-      } catch {
-        /* ignore */
-      }
-      console.log("[cockpit mirror] 停止しました")
-      process.exit(0)
-    }
-    process.on("SIGINT", stop)
-    process.on("SIGTERM", stop)
-  })
-
 program
   .command("start")
   .description("daemon を起動して Hub と WSS 接続する")

package/package.json

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

package/src/codex-stream-bridge.mjs

@@ -1953,8 +1953,12 @@ export class CodexStreamBridge extends EventEmitter {
 
   /**
    * 指定 cwd に一致するライブ (attach 済み) codex セッションの threadId を返す。
-   * Claude 版 `liveSessionIdForCwd` の対 (main.mjs の state loop / terminal mirror から
-   * cwd → threadId 解決に使う)。
+   * Claude 版 `liveSessionIdForCwd` の対。
+   *
+   * ⚠️ 2026-08-02 時点で **本番経路からの呼び出し元は無い** (テストのみ)。旧利用元だった
+   * terminal mirror は撤去済み。「main.mjs の state loop から使う」という記述も以前から
+   * 実態と食い違っていた (startStateLoop に codexBridge は渡るが、usage.mjs 側で参照して
+   * いない)。撤去可否は別途調査してから判断すること。
    *
    * ⚠️ T06407 増分2: 旧実装は「先に見つかったもの」を返していたが、これは 5h/7d（アカウント
    * 全体で代表 1 件で十分）前提だった。context% は thread 固有なので liveSessionForCwd の

package/src/main.mjs

@@ -103,11 +103,10 @@ import {
   removeWorktree as removeWorktreeDir,
   setSessionMouse,
   setTmuxGlobalEnv,
-  startTerminalMirror,
-  stopTerminalMirror,
 } from "./tmux.mjs"
 import { SiblingInjectBridge } from "./sibling-inject.mjs"
 import { isSessionWarm } from "./live-sessions.mjs"
+import { applyPointerContexts, resolvePointerContexts } from "./pointer-context.mjs"
 import {
   boundSessionId,
   codexContextPercentFromTokenUsage,
@@ -1752,28 +1751,6 @@ async function readAllSessionEvents() {
 // 共有し、同時要求は single-flight に畳む。create/kill/worktree 変更時は明示 clear する。
 const tmuxSessionsSnapshotCache = new AsyncTtlCache({ ttlMs: 5_000 })
 
-/**
- * 単一 session の最新 session-event をファイル正本から読む。無ければ null。
- * claude.tui.bind 時の `stop` 再配信 (取りこぼし回復) に使う。
- */
-async function readSessionEventFile(sessionName) {
-  if (!sessionName || /[/\\]/.test(sessionName)) return null
-  try {
-    const text = await readFile(
-      path.join(SESSION_EVENTS_DIR, `${sessionName}.json`),
-      "utf-8",
-    )
-    const data = JSON.parse(text)
-    if (!data || typeof data.event !== "string") return null
-    return {
-      event: data.event,
-      at: typeof data.at === "number" ? data.at : Date.now(),
-    }
-  } catch {
-    return null
-  }
-}
-
 /**
  * `/tmp/cockpit_session_events/<tmux_session>.json` を fs.watch して
  * UserPromptSubmit / Stop の event を `session.event` 型で Hub に push する。
@@ -4038,90 +4015,6 @@ async function dispatch(msg, ctx) {
         if (!ctx.claudeBridge) return
         ctx.claudeBridge.interrupt({ stream_id: msg.stream_id })
         return
-      case "terminal.mirror.start": {
-        // Cockpit Codex 両対応 Stream C (2026-07-03): チャット(SDK/app-server)の会話を
-        // 変えずに、ターミナルのペイン (普通のシェルのまま) へ読み取り専用の実況を
-        // 追加する。詳細は tmux.mjs の startTerminalMirror / session-mirror.mjs 参照。
-        //
-        // session_id はブラウザに要求しない。cwd から hub-agent 側でライブなチャット
-        // session を解決する (claudeBridge.liveSessionIdForCwd / codexBridge.sessions を
-        // cwd で検索)。これにより frontend は「今この cwd で実際に動いているチャット」を
-        // 正確に追従でき、古い/取り違えた session_id を渡すリスクが無い。
-        const request_id = msg.request_id
-        const sessionName = typeof msg.session_name === "string" ? msg.session_name : ""
-        const cwd = typeof msg.cwd === "string" ? msg.cwd : ""
-        const cliKind = msg.cli_kind === "codex" ? "codex" : "claude"
-        const reply = (payload) =>
-          ctx.client.send({
-            type: "terminal.mirror.start.result",
-            request_id,
-            session_name: sessionName,
-            ...payload,
-          })
-        if (!sessionName || !cwd) {
-          reply({ ok: false, error: "session_name / cwd は必須です" })
-          return
-        }
-        let sessionId = null
-        if (cliKind === "codex") {
-          for (const s of ctx.codexBridge?.sessions?.values() ?? []) {
-            if (s.cwd === cwd && s.threadId) {
-              sessionId = s.threadId
-              break
-            }
-          }
-        } else {
-          sessionId = ctx.claudeBridge?.liveSessionIdForCwd?.(cwd) || null
-        }
-        if (!sessionId) {
-          reply({
-            ok: false,
-            error: "この cwd で動作中のチャットセッションが見つかりません (先にチャットを開始してください)",
-          })
-          return
-        }
-        try {
-          const r = await startTerminalMirror(
-            sessionName,
-            { cwd, sessionId, cliKind },
-            { logger },
-          )
-          reply(r)
-        } catch (err) {
-          logger?.warn(
-            { err: err?.message, sessionName },
-            "terminal.mirror.start failed",
-          )
-          reply({ ok: false, error: err?.message || String(err) })
-        }
-        return
-      }
-      case "terminal.mirror.stop": {
-        const request_id = msg.request_id
-        const sessionName = typeof msg.session_name === "string" ? msg.session_name : ""
-        const reply = (payload) =>
-          ctx.client.send({
-            type: "terminal.mirror.stop.result",
-            request_id,
-            session_name: sessionName,
-            ...payload,
-          })
-        if (!sessionName) {
-          reply({ ok: false, error: "session_name は必須です" })
-          return
-        }
-        try {
-          const r = await stopTerminalMirror(sessionName, { logger })
-          reply(r)
-        } catch (err) {
-          logger?.warn(
-            { err: err?.message, sessionName },
-            "terminal.mirror.stop failed",
-          )
-          reply({ ok: false, error: err?.message || String(err) })
-        }
-        return
-      }
       case "claude.mcp.status":
       case "claude.mcp.reconnect":
       case "claude.mcp.authenticate":
@@ -5067,10 +4960,32 @@ async function dispatch(msg, ctx) {
             }
             return { sessions: enriched, worktree_stubs: worktreeStubs }
           })
+          // 行ごとの「次に開く会話」の context% (任意)。宛先 (context_targets) は要求ごとに
+          // 違うため、共有される snapshot キャッシュの**外**で解決し、触る行だけ複製して
+          // 載せる (他クライアントの応答を汚さない)。context_targets が無ければ従来どおりの
+          // 応答 (後方互換)。
+          let sessions = snapshot.sessions
+          if (Array.isArray(msg.context_targets) && msg.context_targets.length > 0) {
+            try {
+              const pointerByName = await resolvePointerContexts(
+                msg.context_targets,
+                sessions,
+                { logger: ctx.logger },
+              )
+              sessions = applyPointerContexts(sessions, pointerByName)
+            } catch (err) {
+              // pointer context はあくまで付加情報。失敗してもセッション一覧は返す。
+              ctx.logger?.warn?.(
+                { err: err?.message },
+                "resolvePointerContexts failed",
+              )
+            }
+          }
           ctx.client.send({
             type: "tmux.sessions",
             request_id: msg.request_id,
             ...snapshot,
+            sessions,
           })
         } catch (err) {
           ctx.client.send({

package/src/pointer-context.mjs

@@ -0,0 +1,196 @@
+/**
+ * 「その行が次に開く会話」の context% (= pointer context) を解決する。
+ *
+ * ## 背景 (WHY)
+ * Cockpit のサイドバーは、コンテキスト使用率を **その行が次に開く会話に帰属させて**表示する
+ * ように直した (Hub 側 PR #4534)。しかし供給側 (agent) は「いま動いている会話」の値しか
+ * 出しておらず、一度も開いていない行・閉じた行では使用率が出ない。
+ *
+ * 従来は「その cwd で mtime が一番新しい jsonl」に落として埋めていたが、それが
+ * **サブエージェント / headless `claude -p` / 過去セッションの数字が混ざる**原因だったので
+ * 撤去した (cross-activity contamination)。よってここでは **frontend が行ごとに指定した
+ * 会話 ID (`session_id`) でしか値を引かない**。ID が無い行は推測せず null を返す。
+ *
+ * ## 不変条件 (ここを崩すと汚染が戻る)
+ *   1. `session_id` が渡されていない行では `contextForCwd` を **呼ばない** (mtime 最新への
+ *      フォールバックが走るため)。
+ *   2. `session_id` が渡された行でも、戻り値の `uuid` が要求 ID と**一致するときだけ**採用する。
+ *      `jsonlContextForCwd` は「その ID の jsonl が存在しない」とき mtime 最新へフォールバック
+ *      する仕様のため、件数ではなく**実体 (uuid) の同一性**で確認する。
+ *   3. 鮮度 (mtime) による足切りをしない。止まっている会話の使用率は古くならない
+ *      (次に開けばその値から再開する) ので、statusLine 経路の `SESSION_STALE_MS` は適用しない。
+ *
+ * ## N+1 対策
+ * サイドバーは 8 秒周期でポーリングし、複数タブが位相をずらして同時に叩く。行数分の jsonl
+ * 読み取りをそのまま毎回走らせないよう、`(cwd, session_id)` をキーにした短期 TTL +
+ * single-flight キャッシュを噛ませる (同時要求は 1 本の I/O に畳む)。
+ */
+
+import { cliKindForSessionName } from "./session-names.mjs"
+import { jsonlContextForCwd } from "./usage.mjs"
+
+/** pointer context のキャッシュ TTL (ms)。tmux スナップショットキャッシュと同じ 5 秒。 */
+const POINTER_CONTEXT_TTL_MS = Number(
+  process.env.HUB_AGENT_POINTER_CONTEXT_TTL_MS ?? 5_000,
+)
+
+/** キャッシュ保持数の上限 (会話 ID は増え続けるため LRU で頭打ちにする)。 */
+const POINTER_CONTEXT_MAX_ENTRIES = 512
+
+/**
+ * キー付きの短期 TTL + single-flight キャッシュ。
+ *
+ * `AsyncTtlCache` (単一値版) と役割は同じだが、こちらは `(cwd, session_id)` ごとに独立した
+ * エントリを持つ。build 失敗はキャッシュしない (次の要求で再試行できる)。
+ */
+export class KeyedAsyncTtlCache {
+  constructor({ ttlMs, now = () => Date.now(), maxEntries = POINTER_CONTEXT_MAX_ENTRIES } = {}) {
+    this.ttlMs = Math.max(0, Number(ttlMs) || 0)
+    this.now = now
+    this.maxEntries = Math.max(1, Number(maxEntries) || 1)
+    this.entries = new Map() // key → {value, expiresAt, inFlight}
+  }
+
+  async get(key, build) {
+    const hit = this.entries.get(key)
+    if (hit) {
+      if (hit.inFlight) return hit.inFlight // 同時要求は 1 本の I/O に畳む
+      if (this.now() < hit.expiresAt) return hit.value
+    }
+    const pending = Promise.resolve().then(build)
+    const entry = { value: undefined, expiresAt: 0, inFlight: pending }
+    // delete → set で挿入順 = 最近使った順にし、prune を LRU として使えるようにする。
+    this.entries.delete(key)
+    this.entries.set(key, entry)
+    try {
+      const value = await pending
+      entry.value = value
+      entry.expiresAt = this.now() + this.ttlMs
+      entry.inFlight = null
+      this.prune()
+      return value
+    } catch (err) {
+      if (this.entries.get(key) === entry) this.entries.delete(key)
+      throw err
+    }
+  }
+
+  /** 期限切れエントリを落とし、上限を超えていれば古い順に捨てる。 */
+  prune() {
+    const now = this.now()
+    for (const [key, e] of this.entries) {
+      if (!e.inFlight && now >= e.expiresAt) this.entries.delete(key)
+    }
+    while (this.entries.size > this.maxEntries) {
+      const oldest = this.entries.keys().next()
+      if (oldest.done) break
+      this.entries.delete(oldest.value)
+    }
+  }
+
+  clear() {
+    this.entries.clear()
+  }
+}
+
+/** 既定のプロセス共有キャッシュ (tmux.list_sessions ハンドラ用)。 */
+const defaultPointerContextCache = new KeyedAsyncTtlCache({ ttlMs: POINTER_CONTEXT_TTL_MS })
+
+/** テスト用: 既定キャッシュを空にする。 */
+export function _resetPointerContextCache() {
+  defaultPointerContextCache.clear()
+}
+
+/** cwd と会話 ID の連結。区切りは両者に現れ得ない制御文字 (エスケープ表記で書く)。 */
+function cacheKey(cwd, sessionId) {
+  return `${cwd}\u0000${sessionId}`
+}
+
+/**
+ * `context_targets` (行ごとの「次に開く会話」) を解決し、`session_name → context% | null` の
+ * Map を返す。
+ *
+ * 値が確定しなかった行にも **null を明示的に入れる** (「見に行った上で不明」を表す)。
+ * `context_targets` に含まれない行は Map に載らない = 応答にフィールドを付けない。
+ *
+ * @param {Array<{session_name?: string, session_id?: string|null}>|undefined} targets
+ * @param {Array<{name?: string, cwd?: string|null}>} rows tmux.list_sessions の行 (cwd 解決用)
+ * @param {{contextForCwd?: Function, cache?: KeyedAsyncTtlCache, logger?: object}} [opts]
+ * @returns {Promise<Map<string, number|null>>}
+ */
+export async function resolvePointerContexts(targets, rows, opts = {}) {
+  const {
+    contextForCwd = jsonlContextForCwd,
+    cache = defaultPointerContextCache,
+    logger,
+  } = opts
+  const out = new Map()
+  if (!Array.isArray(targets) || targets.length === 0) return out
+
+  const cwdByName = new Map()
+  for (const row of Array.isArray(rows) ? rows : []) {
+    if (row && typeof row.name === "string") cwdByName.set(row.name, row.cwd || null)
+  }
+
+  const jobs = []
+  for (const target of targets) {
+    const name = typeof target?.session_name === "string" ? target.session_name : ""
+    if (!name || out.has(name)) continue // 同名の重複指定は先勝ち
+    out.set(name, null)
+
+    const sessionId = typeof target?.session_id === "string" ? target.session_id.trim() : ""
+    // 不変条件 1: ID が無ければ読みに行かない (mtime 最新フォールバックを踏まない)。
+    if (!sessionId) continue
+    const cwd = cwdByName.get(name)
+    if (!cwd) continue
+    // codex 行は claude の jsonl を持たない。読んでも uuid 不一致で null になるだけなので、
+    // 無駄な readdir/stat を避けるためここで落とす (結果は同じ)。
+    if (cliKindForSessionName(name) !== "claude") continue
+    jobs.push({ name, cwd, sessionId })
+  }
+
+  await Promise.all(
+    jobs.map(async ({ name, cwd, sessionId }) => {
+      try {
+        const pct = await cache.get(cacheKey(cwd, sessionId), async () => {
+          const res = await contextForCwd(cwd, sessionId)
+          // 不変条件 2: 実体 (uuid) が一致したときだけ採用する。
+          if (!res || res.uuid !== sessionId) return null
+          return typeof res.percent === "number" ? res.percent : null
+        })
+        if (typeof pct === "number") out.set(name, pct)
+      } catch (err) {
+        logger?.warn?.(
+          { err: err?.message, session: name },
+          "pointer context resolve failed",
+        )
+      }
+    }),
+  )
+  return out
+}
+
+/**
+ * 解決済みの pointer context を session 行へ載せる (元配列・元オブジェクトは変更しない)。
+ *
+ * `tmux.list_sessions` の応答行は TTL スナップショットキャッシュで**複数の要求に共有される**
+ * ため、要求ごとに違う値を直接書き込むと他クライアントの応答を汚す。触る行だけ複製する。
+ *
+ * 既存の `context_pct` (いま動いている会話の値) とは**別フィールド**にする。混ぜると
+ * 「どちらの会話の値か」が曖昧になるため。
+ *
+ * @param {Array<object>} sessions
+ * @param {Map<string, number|null>} pointerByName
+ * @returns {Array<object>}
+ */
+export function applyPointerContexts(sessions, pointerByName) {
+  if (!Array.isArray(sessions)) return []
+  if (!(pointerByName instanceof Map) || pointerByName.size === 0) return sessions
+  return sessions.map((s) =>
+    s && pointerByName.has(s.name)
+      ? { ...s, pointer_context_pct: pointerByName.get(s.name) }
+      : s,
+  )
+}
+
+export default { KeyedAsyncTtlCache, resolvePointerContexts, applyPointerContexts }

package/src/state.mjs

@@ -131,17 +131,6 @@ function stripAnsi(s) {
     .replace(/\x1b[()][AB012]/g, "")
 }
 
-/**
- * capturePane 結果の末尾フッター領域 (既定 8 行) を返す。claude TUI の作業スピナー /
- * 中断フッターはペイン最下部に固定描画されるため、本文中に同じ語が出ても誤検出しない
- * よう、作業スピナーの補助判定はこの領域に限定する。
- */
-function footerRegion(text, lines = 8) {
-  if (!text) return ""
-  const rows = text.split("\n")
-  return rows.length <= lines ? text : rows.slice(-lines).join("\n")
-}
-
 /**
  * 作業スピナー行 (ライブステータス行) の構造パターン。実機採取 (2026-06-15〜):
  *   "· Blanching… (2m 4s · ↓ 7.5k tokens)"    (出力中)
@@ -158,9 +147,10 @@ function footerRegion(text, lines = 8) {
  *   - 省略記号 (…/...) **または** 括弧タイマーのどちらか一方で可 (両方必須をやめる)
  *   - タイマーは「分のみ」「秒のみ」「分秒」いずれも可 (秒必須をやめる)
  *   - 行頭インデント制限 (\s{0,4}) を撤廃 (背の高いペイン/折返しで字下げが深い版に備える)
- * 緩めても安全な理由: 検出は必ず footerRegion + _belowIsOnlyChrome (下が入力欄チロムのみ) を
- * 通すため、本文プローズ・表セル・箇条書きへの誤点灯は下チロム判定が弾く。行頭は英数字・空白・
- * 本文記号 (-*>#|) を除く 1 文字に限定し、語は ASCII 英字に限る (日本語プローズは非マッチ)。
+ * 緩めても安全な理由: 検出は必ず capture 末尾 12 行への限定 (workingSpinnerLine) と
+ * _belowIsOnlyChrome (下が入力欄チロムのみ) を通すため、本文プローズ・表セル・箇条書きへの
+ * 誤点灯は下チロム判定が弾く。行頭は英数字・空白・本文記号 (-*>#|) を除く 1 文字に限定し、
+ * 語は ASCII 英字に限る (日本語プローズは非マッチ)。
  * 完了サマリー "✻ Brewed for 2m 52s" は省略記号も**括弧**タイマーも持たない (タイマーが括弧外) ため
  * 引き続き一致しない。
  */
@@ -338,7 +328,7 @@ export async function capturePane(sessionName, opts = {}) {
       sessionName,
       // 末尾 50 行を取得 (旧 30 行)。copy-mode スクロールや背の高いペインで作業/中断
       // フッターが取得窓外に出て生成中を取りこぼす偽陰性を減らす。status 判定の作業
-      // スピナー検出はこのうち末尾フッター領域 (footerRegion) に限定する。
+      // スピナー検出はこのうち末尾 12 行 (workingSpinnerLine) に限定する。
       "-S",
       "-50",
       "-E",

package/src/tmux.mjs

@@ -19,7 +19,6 @@ import fs from "node:fs/promises"
 import os from "node:os"
 import path from "node:path"
 import { promisify } from "node:util"
-import { fileURLToPath } from "node:url"
 
 import { ensureClaudeMd } from "./claude-md.mjs"
 import { syncClaudeMdWithHub } from "./claude-md-sync.mjs"
@@ -1233,156 +1232,3 @@ export async function paneClaudeAliveOrUnknown(name, opts = {}) {
     return "unknown"
   }
 }
-
-
-// ---------------------------------------------------------------------------
-// ターミナルミラー (Cockpit Codex 両対応 Stream C, 2026-07-03)
-//
-// 「チャットの動作は変えず、ターミナルのペインは普通に使えるシェルのまま、そこに
-// チャットの会話を実況表示する読み取り専用の子プロセス」をバックグラウンドで起動/
-// 停止する。session-mirror.mjs / bin/hub-agent.mjs の `mirror` サブコマンド参照。
-//
-// 安全設計:
-//   - ペインの前景が plain shell のときだけ起動を許可する（`claude`/`codex` 対話 TUI が
-//     前景にいる状態で send-keys すると、実況コマンドがその対話プロンプトへの入力として
-//     誤解釈されてしまうため）。
-//   - 起動コマンドは `& echo $! > <pidfile>` で直後に PID を記録し、停止はその PID を
-//     kill するだけ（プロセス名 grep 等の曖昧一致はしない）。
-// ---------------------------------------------------------------------------
-
-/** 現在の hub-agent パッケージの `bin/hub-agent.mjs` 絶対パス。node 実行 (`process.execPath`)
- *  と組み合わせることで、対象ペインの shell の PATH に依存せず確実に起動できる。 */
-function hubAgentBinPath() {
-  return path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "bin", "hub-agent.mjs")
-}
-
-/** POSIX シェルの単一引数として安全な形にクォートする (単純な `'...'` ラップ + `'` エスケープ)。 */
-function shQuote(s) {
-  return `'${String(s).replace(/'/g, "'\\''")}'`
-}
-
-/** ミラーの pidfile パス (セッション名ごとに 1 つ)。 */
-function mirrorPidFile(sessionName) {
-  return path.join(os.tmpdir(), `hub-agent-mirror-${sanitizeTmuxName(sessionName)}.pid`)
-}
-
-/**
- * ミラー起動用の send-keys コマンド文字列を組み立てる (純粋関数)。
- *
- * @param {{cwd: string, sessionId: string, cliKind: 'claude'|'codex', sessionName: string}} args
- * @returns {string}
- * @throws sessionId が安全形でなければ throw (コマンド注入防止、buildResumeCmd と同方針)
- */
-export function buildMirrorStartCmd({ cwd, sessionId, cliKind, sessionName }) {
-  if (!isSafeSessionId(sessionId)) {
-    throw new Error(`unsafe session_id for mirror: ${String(sessionId)}`)
-  }
-  const kind = cliKind === "codex" ? "codex" : "claude"
-  const bin = hubAgentBinPath()
-  const pidFile = mirrorPidFile(sessionName)
-  const args = [
-    shQuote(process.execPath),
-    shQuote(bin),
-    "mirror",
-    "--cwd",
-    shQuote(cwd),
-    "--session",
-    shQuote(sessionId),
-    "--cli-kind",
-    kind,
-  ].join(" ")
-  return `${args} & echo $! > ${shQuote(pidFile)}; disown`
-}
-
-/** ミラー停止用の send-keys コマンド文字列を組み立てる (純粋関数)。 */
-export function buildMirrorStopCmd({ sessionName }) {
-  const pidFile = mirrorPidFile(sessionName)
-  return `kill $(cat ${shQuote(pidFile)} 2>/dev/null) 2>/dev/null; rm -f ${shQuote(pidFile)}`
-}
-
-/**
- * 対象ペインの前景が plain shell か判定する (`paneClaudeAliveOrUnknown` の逆方向・2 値版)。
- * 判定不能 (tmux 失敗等) は false を返す = 起動を許可しない安全側。
- *
- * @param {string} name
- * @param {{ tmux?: string }} [opts]
- * @returns {Promise<boolean>}
- */
-export async function isPaneAtShellPrompt(name, opts = {}) {
-  if (!name) return false
-  try {
-    const { stdout } = await execFileP(tmuxBin(opts), [
-      "display-message",
-      "-p",
-      "-t",
-      `${name}:`,
-      "-F",
-      "#{pane_current_command}",
-    ])
-    const cmd = (stdout || "").trim().toLowerCase()
-    const SHELLS = new Set(["fish", "bash", "zsh", "sh", "dash"])
-    return SHELLS.has(cmd)
-  } catch {
-    return false
-  }
-}
-
-/**
- * ターミナルミラーを対象ペインで起動する。ペイン前景が plain shell のときのみ許可する
- * (対話 TUI が前景にいる状態での誤爆入力を防ぐ)。
- *
- * @param {string} name tmux セッション名
- * @param {{cwd: string, sessionId: string, cliKind: 'claude'|'codex'}} args
- * @param {{ tmux?: string, logger?: import('pino').Logger }} [opts]
- * @returns {Promise<{ ok: boolean, reason?: string, error?: string }>}
- */
-export async function startTerminalMirror(name, { cwd, sessionId, cliKind }, opts = {}) {
-  if (!isSafeSessionName(name)) {
-    return { ok: false, error: "unsafe session name" }
-  }
-  const atShell = await isPaneAtShellPrompt(name, opts)
-  if (!atShell) {
-    return {
-      ok: false,
-      reason: "pane-not-at-shell",
-      error: "ペインが対話 TUI 実行中のためミラーを起動できません (シェルに戻ってから再試行してください)",
-    }
-  }
-  let cmd
-  try {
-    cmd = buildMirrorStartCmd({ cwd, sessionId, cliKind, sessionName: name })
-  } catch (err) {
-    return { ok: false, error: err?.message || String(err) }
-  }
-  try {
-    await execFileP(tmuxBin(opts), ["send-keys", "-t", name, cmd, "Enter"])
-    opts.logger?.info({ session: name, cliKind, sessionId }, "terminal mirror started")
-    return { ok: true }
-  } catch (err) {
-    opts.logger?.warn({ session: name, err: err?.message }, "terminal mirror start failed")
-    return { ok: false, error: err?.message || String(err) }
-  }
-}
-
-/**
- * ターミナルミラーを対象ペインで停止する。pidfile に記録された PID を kill するだけの
- * ベストエフォート (既に停止済み/pidfile 無しでもエラーにしない)。
- *
- * @param {string} name tmux セッション名
- * @param {{ tmux?: string, logger?: import('pino').Logger }} [opts]
- * @returns {Promise<{ ok: boolean, error?: string }>}
- */
-export async function stopTerminalMirror(name, opts = {}) {
-  if (!isSafeSessionName(name)) {
-    return { ok: false, error: "unsafe session name" }
-  }
-  const cmd = buildMirrorStopCmd({ sessionName: name })
-  try {
-    await execFileP(tmuxBin(opts), ["send-keys", "-t", name, cmd, "Enter"])
-    opts.logger?.info({ session: name }, "terminal mirror stop requested")
-    return { ok: true }
-  } catch (err) {
-    opts.logger?.warn({ session: name, err: err?.message }, "terminal mirror stop failed")
-    return { ok: false, error: err?.message || String(err) }
-  }
-}

package/src/usage.mjs

@@ -1361,7 +1361,7 @@ async function scanAllDatesForCodexRollout(base, threadId) {
  *  表示できなくなる（2026-07-15 の resume 修正で古いスレッド復帰が正しく動くようになり
  *  露出）。高速パスで見つからなければ全日付フォールバック走査に落とし、結果を threadId
  *  でメモ化する。
- *  `session-mirror.mjs`（Stream C ターミナルミラー）からも再利用するため export する。
+ *  同モジュール内の usage 集計に加え、`codex-delivery-audit.mjs` からも使うため export する。
  *  @returns {Promise<string|null>}
  */
 export async function findCodexRolloutFile(threadId, { lookbackDays = 9, now = Date.now() } = {}) {

package/src/codex-rollout-watch.mjs

@@ -1,148 +0,0 @@
-/**
- * Codex rollout jsonl のライブ追従 watcher (Cockpit Codex 両対応 Stream C: ターミナル
- * ミラー、2026-07-03)。
- *
- * `claude-history-watch.mjs`（Claude 版 jsonl tail）と対の役割。Codex の
- * `~/.codex/sessions/Y/M/D/rollout-<ts>-<threadId>.jsonl` を byte offset で tail し、
- * 新規行を 1 行ずつ onEvent に渡す。フィルタは行わない（呼び出し側の formatter が
- * 表示対象の `event_msg.payload.type` を選別する）。
- *
- * 設計はミラーリング用途に絞って `claude-history-watch.mjs` と同じ tail 機構
- * （byte offset + fs.watch + アダプティブポーリング + truncate 検知）を複製する。
- * Claude 側の汎用化リファクタは既存の chat 表示経路への回帰リスクがあるため見送り、
- * 新規ファイルとして独立させた（意図的な重複、コメントで明示）。
- */
-import { watch as fsWatch } from "node:fs"
-import { open, stat } from "node:fs/promises"
-
-const POLL_FAST_MS = Number(process.env.HUB_AGENT_JSONL_POLL_FAST_MS ?? 400)
-const POLL_IDLE_MS = Number(process.env.HUB_AGENT_JSONL_POLL_IDLE_MS ?? 1500)
-const FAST_WINDOW_MS = Number(process.env.HUB_AGENT_JSONL_FAST_WINDOW_MS ?? 5000)
-
-/**
- * 1 つの rollout jsonl ファイルを tail する watcher を生成する。
- *
- * @param {object} args
- * @param {string} args.filePath - 監視対象の rollout jsonl 絶対パス
- * @param {(rawLineObj: object) => void} args.onEvent - 新規行ごとに呼ばれる (パース済み JSON)
- * @param {boolean} [args.fromEnd=true] - 既存内容は飛ばし、監視開始後の追記のみ拾う
- * @param {import('pino').Logger} [args.logger]
- * @returns {{ stop: () => void }}
- */
-export function watchCodexRollout({ filePath, onEvent, fromEnd = true, logger }) {
-  let offset = 0
-  let reading = false
-  let stopped = false
-  let leftover = ""
-  let fsWatcher = null
-  let pollTimer = null
-  let initialized = false
-  let lastChangeAt = 0
-
-  async function initOffset() {
-    try {
-      const st = await stat(filePath)
-      offset = fromEnd ? st.size : 0
-      initialized = true
-    } catch {
-      offset = 0
-      initialized = false
-    }
-  }
-
-  async function readIncrement() {
-    if (stopped || reading) return
-    reading = true
-    try {
-      let st
-      try {
-        st = await stat(filePath)
-      } catch {
-        return // まだ無い (rollout はターン開始直後に作られる)
-      }
-      if (!initialized) initialized = true
-      if (st.size < offset) {
-        // truncate / rotate された → 先頭から読み直す (通常 rollout は追記のみだが念のため)
-        offset = 0
-        leftover = ""
-      }
-      if (st.size <= offset) return
-      let fh
-      try {
-        fh = await open(filePath, "r")
-        const len = st.size - offset
-        const buf = Buffer.allocUnsafe(len)
-        await fh.read(buf, 0, len, offset)
-        offset = st.size
-        lastChangeAt = Date.now()
-        const text = leftover + buf.toString("utf-8")
-        const lines = text.split("\n")
-        leftover = lines.pop() ?? ""
-        for (const line of lines) {
-          if (!line) continue
-          let d
-          try {
-            d = JSON.parse(line)
-          } catch {
-            continue // 途中で読んだ不完全な行 (稀) はスキップ
-          }
-          try {
-            onEvent(d)
-          } catch (err) {
-            logger?.warn?.({ err: err?.message }, "codex rollout watch onEvent failed")
-          }
-        }
-      } finally {
-        try {
-          await fh?.close()
-        } catch {
-          /* ignore */
-        }
-      }
-    } catch (err) {
-      logger?.debug?.({ err: err?.message, filePath }, "codex rollout watch read failed")
-    } finally {
-      reading = false
-    }
-  }
-
-  function schedulePoll() {
-    if (stopped) return
-    const idle = Date.now() - lastChangeAt > FAST_WINDOW_MS
-    const delay = idle ? POLL_IDLE_MS : POLL_FAST_MS
-    pollTimer = setTimeout(async () => {
-      await readIncrement()
-      schedulePoll()
-    }, delay)
-    pollTimer?.unref?.()
-  }
-
-  async function start() {
-    await initOffset()
-    await readIncrement()
-    try {
-      fsWatcher = fsWatch(filePath, { persistent: false }, () => {
-        readIncrement()
-      })
-    } catch {
-      // ファイル未存在等で fs.watch が張れない場合はポーリングのみに頼る
-    }
-    schedulePoll()
-  }
-
-  start()
-
-  return {
-    stop() {
-      stopped = true
-      if (pollTimer) clearTimeout(pollTimer)
-      try {
-        fsWatcher?.close()
-      } catch {
-        /* ignore */
-      }
-    },
-  }
-}
-
-export default watchCodexRollout

package/src/session-mirror.mjs

@@ -1,190 +0,0 @@
-/**
- * ターミナルへの「チャット追従ミラー」(Cockpit Codex 両対応 Stream C, 2026-07-03)。
- *
- * 背景: 2026-06-06 の `claude.tui.bind`（会話継続バインディング）以降、チャット
- * (SDK/app-server) と TUI ペインは同一 session_id を同時ホストしない排他設計になった
- * （DESIGN.md C7「二重ホスト防止」）。それ以前は両者が独立 session として並走していたが、
- * 「別々の会話が同じ cwd で表示を取り合いパタパタする」実害があり意図的に廃止された。
- *
- * 本機能は「チャットの動作は一切変えず（今まで通り SDK/app-server が単独で会話を進める）、
- * ターミナルのペインはユーザーが普通に使えるシェルのまま、そこにチャットの会話ログを
- * 実況表示するだけの読み取り専用プロセス」を **バックグラウンドジョブとして** 追加する。
- * ターミナル側は一切書き込まないため C7 のリスクには当たらない（同一ファイルへの
- * 二重書込は発生しない。読むだけ）。
- *
- * 実行方式: `tmux.mjs` の `startTerminalMirror` が対象ペインへ `send-keys` で
- * `hub-agent mirror ... & disown` を打ち込み、ペインの現在のシェルの子プロセスとして
- * バックグラウンドで起動する（実機検証済み: 子プロセスの stdout はペインに自然に
- * 割り込み表示され、ユーザーの入力行は破壊されない — 通常の Unix ターミナルで
- * バックグラウンドジョブの出力を眺めながら作業するのと同じ挙動）。
- */
-import { watchSessionFile } from "./claude-history-watch.mjs"
-import { jsonlPath } from "./claude-history.mjs"
-import { watchCodexRollout } from "./codex-rollout-watch.mjs"
-import { findCodexRolloutFile } from "./usage.mjs"
-
-// 依存追加を避けるため、chalk 相当の最小 ANSI ヘルパーを自前で持つ (SGR コードのみ)。
-const noColor = process.env.NO_COLOR || !process.stdout.isTTY
-const ANSI = { cyan: "36", green: "32", yellow: "33", dim: "2", red: "31" }
-
-function c(color, text) {
-  if (noColor) return text
-  return `\x1b[${ANSI[color]}m${text}\x1b[0m`
-}
-
-/** 長い本文をターミナル向けに省略する。 */
-function truncate(text, max = 400) {
-  const s = String(text ?? "")
-  if (s.length <= max) return s
-  return `${s.slice(0, max)}… (${s.length - max} 文字省略)`
-}
-
-function indentBlock(text) {
-  return String(text ?? "")
-    .split("\n")
-    .map((l) => `  ${l}`)
-    .join("\n")
-}
-
-/**
- * Claude jsonl の 1 イベント (`normalizeHistoryEvent` 済み) をミラー表示用テキストに
- * 変換する。表示すべきものが無ければ null を返す (呼び出し側は print しない)。
- *
- * @param {object} event
- * @returns {string|null}
- */
-export function formatClaudeEvent(event) {
-  if (!event || typeof event !== "object") return null
-  const content = event.message?.content
-  if (event.type === "user") {
-    if (!Array.isArray(content)) {
-      const text = typeof content === "string" ? content : ""
-      if (!text.trim()) return null
-      // コマンド echo (/clear /compact /skill 等) はノイズなのでスキップ。
-      if (/<command-name>/.test(text)) return null
-      return `${c('cyan', "›")} ${indentBlock(truncate(text)).trimStart()}`
-    }
-    const isToolResult = content.some((b) => b?.type === "tool_result")
-    if (isToolResult) return null // ツール結果の自動 user ラッパーは表示しない (ノイズ)
-    const text = content
-      .filter((b) => b?.type === "text")
-      .map((b) => b.text)
-      .join("")
-    if (!text.trim() || /<command-name>/.test(text)) return null
-    return `${c('cyan', "›")} ${indentBlock(truncate(text)).trimStart()}`
-  }
-  if (event.type === "assistant") {
-    if (!Array.isArray(content)) return null
-    const lines = []
-    for (const b of content) {
-      if (!b) continue
-      if (b.type === "text" && b.text?.trim()) {
-        lines.push(`${c('green', "●")} ${indentBlock(truncate(b.text)).trimStart()}`)
-      } else if (b.type === "tool_use") {
-        const brief = summarizeToolInput(b.name, b.input)
-        lines.push(`${c('yellow', "⚙")} ${b.name}${brief ? ` ${brief}` : ""}`)
-      }
-    }
-    return lines.length > 0 ? lines.join("\n") : null
-  }
-  return null
-}
-
-/** tool_use の input から簡潔な 1 行要約を作る (Bash はコマンド、それ以外は主要パス等)。 */
-function summarizeToolInput(name, input) {
-  if (!input || typeof input !== "object") return ""
-  if (name === "Bash" && typeof input.command === "string") {
-    return c('dim', truncate(input.command, 120))
-  }
-  const path = input.file_path || input.path || input.notebook_path
-  if (typeof path === "string") return c('dim', path)
-  return ""
-}
-
-/**
- * Codex rollout jsonl の 1 行 (`{timestamp, type, payload}`) をミラー表示用テキストに
- * 変換する。表示対象は実機確認済みの `event_msg` サブタイプ（user_message / agent_message /
- * task_started）に絞る（未確認スキーマの exec 系は誤表示を避けるため今回は対象外）。
- *
- * @param {object} line
- * @returns {string|null}
- */
-export function formatCodexEvent(line) {
-  if (!line || typeof line !== "object" || line.type !== "event_msg") return null
-  const payload = line.payload
-  if (!payload || typeof payload !== "object") return null
-  switch (payload.type) {
-    case "user_message": {
-      const text = typeof payload.message === "string" ? payload.message : ""
-      if (!text.trim()) return null
-      return `${c('cyan', "›")} ${indentBlock(truncate(text)).trimStart()}`
-    }
-    case "agent_message": {
-      const text = typeof payload.message === "string" ? payload.message : ""
-      if (!text.trim()) return null
-      return `${c('green', "●")} ${indentBlock(truncate(text)).trimStart()}`
-    }
-    case "task_started":
-      return c('dim', "… thinking")
-    default:
-      return null
-  }
-}
-
-/**
- * Claude セッションのミラーを実行し続ける (SIGINT/SIGTERM まで)。
- *
- * @param {object} args
- * @param {string} args.cwd
- * @param {string} args.sessionId
- * @param {string} [args.projectsRoot]
- * @param {(line: string) => void} [args.write] - テスト用に stdout 以外へ差し替え可能
- * @param {import('pino').Logger} [args.logger]
- * @returns {{ stop: () => void }}
- */
-export function runClaudeMirror({ cwd, sessionId, projectsRoot, write = defaultWrite, logger }) {
-  const filePath = jsonlPath({ cwd, session_id: sessionId, projectsRoot })
-  write(c('dim', `[cockpit mirror] Claude session ${sessionId} を追従中… (${filePath})`))
-  const watcher = watchSessionFile({
-    filePath,
-    fromEnd: true,
-    logger,
-    onEvent: (event) => {
-      const text = formatClaudeEvent(event)
-      if (text) write(text)
-    },
-  })
-  return watcher
-}
-
-/**
- * Codex セッションのミラーを実行し続ける (SIGINT/SIGTERM まで)。
- *
- * @param {object} args
- * @param {string} args.threadId
- * @param {(line: string) => void} [args.write]
- * @param {import('pino').Logger} [args.logger]
- * @returns {Promise<{ stop: () => void }>}
- */
-export async function runCodexMirror({ threadId, write = defaultWrite, logger }) {
-  const filePath = await findCodexRolloutFile(threadId)
-  if (!filePath) {
-    write(c('red', `[cockpit mirror] Codex thread ${threadId} の rollout が見つかりません`))
-    return { stop() {} }
-  }
-  write(c('dim', `[cockpit mirror] Codex thread ${threadId} を追従中… (${filePath})`))
-  const watcher = watchCodexRollout({
-    filePath,
-    fromEnd: true,
-    logger,
-    onEvent: (line) => {
-      const text = formatCodexEvent(line)
-      if (text) write(text)
-    },
-  })
-  return watcher
-}
-
-function defaultWrite(line) {
-  process.stdout.write(`${line}\n`)
-}