@cocorograph/hub-agent 0.7.70 → 0.7.72

package/package.json

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

package/src/codex-stream-bridge.mjs

@@ -16,11 +16,15 @@
  *   claude.event (生 SDK イベント素通し) → 'event' (生 notification 素通し、同じ思想)
  *   claude.permission.request  → 'permission' (承認/入力要求の生 method+params 素通し)
  *
+ * ## in-memory reattach (Stage4 caller レビューで追加)
+ *   `attachId` を伴う attach は、同じ attach_id のライブ session を **新 stream_id へ付け替える**
+ *   (新 app-server を起動しない)。browser の WS 再接続で stream_id が変わっても、fresh 直後
+ *   (rollout 0件) の会話も含めて復元できる。詳細は attach() の docstring 参照。
+ *
  * Slice 2 のスコープ外 (意図的に見送り、後続スライスで追加する):
- *   - 複数ブラウザタブでの同一スレッド共有 (Claude の HUB_AGENT_CHAT_SHARED 相当)。
- *     resumeThreadId が「この hub-agent プロセス内で存命中の別 stream_id のセッション」
- *     を指す in-memory reattach は今回未対応。resumeThreadId は「未存命のスレッドを
- *     thread/resume で再ロードする」場合のみ扱う。
+ *   - 複数ブラウザタブでの **同時** 同一スレッド共有 (Claude の HUB_AGENT_CHAT_SHARED 相当)。
+ *     in-memory reattach は「1 つの持ち主が WS を張り直す」ケース (単一勝者) であり、複数タブが
+ *     同時に同一スレッドを操作する共有はまだ扱わない。
  *   - 画像/添付入力 (テキストのみ)。
  *   - acceptForSession や execpolicy/network amendment 等の高度な承認 decision
  *     (permissionReply は decision をそのまま素通しするので呼び出し側が組み立てる)。
@@ -36,6 +40,7 @@ import { EventEmitter } from "node:events"
 
 import { CodexAppServerClient } from "./codex-appserver-client.mjs"
 import { getOrCreateSiblingToken } from "./sibling-token.mjs"
+import { codexRolloutPresence } from "./usage.mjs"
 
 /**
  * sibling-inject (2026-07-04) 用: spawn する codex app-server プロセス自身の
@@ -67,11 +72,12 @@ function siblingEnvFor(cwd) {
 //      全ターンで出続ける)。
 // 予約は detach 済みセッションに限り、発火時にも busy/再活性を再確認すること。
 // detach 後、非 busy なセッションを生かしておく猶予。claude 側 (7 日) と違い短くする:
-// Slice 2 は in-memory reattach 非対応のため、browser の WS 再接続ごとに新 stream_id で
-// 新プロセスが起動し、旧プロセスは detach で TTL 待ちに入る。7 日だと再接続チャーンの
-// たびに codex app-server プロセスが積み上がる (リーク)。Codex は thread/resume が
-// rollout 正本からモデル側コンテキストを完全復元できるため、プロセスを短命にしても
-// 会話は失われない (再 attach 時のプロセス起動コストは 1〜2 秒)。ターン実行中は TTL に
+// この TTL は **in-memory reattach の猶予窓** を兼ねる。WS が切れて browser disconnect が
+// codex.detach を送っても、この TTL 内に **同じ attach_id で再接続** すれば _tryReattach が
+// その session を新 stream へ付け替えて拾える (fresh 直後 rollout 0件の会話も復元可)。TTL を
+// 超えて reap されたら、再接続は通常経路 (thread/resume は rollout 正本から復元、または fresh)
+// にフォールスルーする。7 日だと再接続チャーンのたびにプロセスが積み上がる (リーク) ため短命に
+// する。ターン実行中は TTL に
 // 関わらず完走まで絶対に落とさない (_maybeReapAfterIdle が busy 中は予約しない)。
 const IDLE_DETACH_TTL_MS = 5 * 60 * 1000
 
@@ -178,34 +184,76 @@ function userInputFromMessage(message) {
 }
 
 export class CodexStreamBridge extends EventEmitter {
-  constructor({ codexCmd, logger, clientFactory, detachTtlMs } = {}) {
+  constructor({ codexCmd, logger, clientFactory, detachTtlMs, rolloutPresence } = {}) {
     super()
     this.codexCmd = codexCmd
     this.logger = logger
     this._clientFactory = clientFactory || ((opts) => new CodexAppServerClient(opts))
     // テストから TTL を短縮できるよう注入可能にする (既定は 7 日)。
     this._detachTtlMs = detachTtlMs ?? IDLE_DETACH_TTL_MS
+    // #4 失敗分類の rollout 存在チェック (tri-state。テストから注入可能)。
+    this._rolloutPresence = rolloutPresence || codexRolloutPresence
     /** @type {Map<string, object>} stream_id -> session record */
     this.sessions = new Map()
   }
 
   /**
+   * Codex セッションへ attach する。
+   *
+   * ## in-memory reattach (Stage4 caller レビュー major #1)
+   * `attachId` は「1 つの attach 試行」の安定 id。browser の WS が attach〜利用中に切れて
+   * **同じ attach_id で再接続**してきたら、新しい app-server を起動して thread/resume するのでは
+   * なく、**既にメモリ上で生きている session をこの新しい stream_id へ付け替える**(所有権と
+   * イベントルーティングを移す)。これにより「fresh thread を作成したが初回入力前で rollout が
+   * まだ 0 件」の状態でも復元でき、二重 thread/start も起きない (rollout 依存の thread/resume は
+   * このケースを復元できない)。live session が既に reap 済み / hub-agent 再起動後などで見つから
+   * なければ、通常の attach (thread/start | thread/resume) にフォールスルーする。
+   *
    * @returns {Promise<{resuming: boolean, threadId: string, history: object[],
    *   threadStatus: string|null, lastTurnStatus: string|null, turnActive: boolean}>}
    */
-  async attach({ stream_id, cwd, model, effort, approvalPolicy, sandbox, resumeThreadId }) {
+  async attach({ stream_id, cwd, model, effort, approvalPolicy, sandbox, resumeThreadId, attachId }) {
     if (this.sessions.has(stream_id)) {
       throw new Error(`stream_id already attached: ${stream_id}`)
     }
+    // #1: 同じ attach_id のライブ session があれば in-memory reattach を試みる。
+    if (attachId) {
+      const existing = this._findLiveSessionByAttachId(attachId)
+      if (existing && existing.stream_id !== stream_id) {
+        const r = await this._tryReattach(existing, stream_id)
+        if (r.status === "reattached") return r.info
+        if (r.status === "superseded") {
+          // 別 reattach が勝って session を奪った (concurrent reconnect)。**通常経路へ落とさない**
+          // — 落とすと敗者が別 thread を thread/start してしまい I2 (fresh 最大1回) を再び破る /
+          // 同一 thread の app-server が複数化する (major #1 ラウンド5)。二重 thread 副作用を作らず
+          // superseded として失敗させる (実運用では同 attach_id の同時 attach は起きない防御。
+          // 起きても実 thread/start は勝者の 1 本だけに保たれる)。
+          const err = new Error("attach superseded by a concurrent reattach")
+          err.attachOperation = "reattach"
+          err.attachReason = "superseded"
+          throw err
+        }
+        // r.status === "unavailable": session が (await 中に) 死んだ / first の thread 確定に失敗。
+        // = ライブ session はもう無い → 通常経路 (thread/resume or fresh) へフォールスルーしてよい
+        // (二重生成の相手が居ないため)。
+      }
+    }
+
     const client = this._clientFactory({
       cwd,
       codexCmd: this.codexCmd,
       logger: this.logger,
       env: siblingEnvFor(cwd),
     })
+    // #2: この session の thread 確定を待つ単一 promise。reattach の待ち合わせ (in-flight) に使う。
+    // **成功で threadId、失敗で null を resolve** する (reject しない = 待ち手がいなくても
+    // unhandled rejection を作らず、複数の reconnect が同じ promise を安全に await できる)。
+    let settleReady
     const session = {
       stream_id,
       cwd,
+      // #1 in-memory reattach のキー。attach 試行を跨いで安定 (WS 再接続で stream_id は変わる)。
+      attachId: attachId || null,
       client,
       threadId: null,
       activeTurnId: null,
@@ -219,14 +267,22 @@ export class CodexStreamBridge extends EventEmitter {
       // 放棄セッション reaper (gcAbandonedSessions) 用の最終活性時刻。browser 入力と
       // app-server 通知 (ターン進捗) の両方で更新する。Date.now() は hub-agent 実行環境で利用可。
       lastActivityMs: Date.now(),
+      ready: null,
     }
+    session.ready = new Promise((resolve) => {
+      settleReady = resolve
+    })
     this.sessions.set(stream_id, session)
     this._wireClient(session)
     client.start()
 
+    const resuming = !!resumeThreadId
+    // #3: initialize と thread op を分離し、thread op に到達したかを記録する。initialize / config
+    //     / MCP 起動の失敗 (thread op 未到達) は attach 失敗分類の対象外にする (pointer を消さない)。
+    let reachedThreadOp = false
     try {
       await client.request("initialize", { clientInfo: CLIENT_INFO })
-      const resuming = !!resumeThreadId
+      reachedThreadOp = true
       const startParams = { cwd, model: model || undefined, sandbox: sandbox || undefined }
       if (effort) startParams.effort = effort
       if (approvalPolicy) startParams.approvalPolicy = approvalPolicy
@@ -246,6 +302,10 @@ export class CodexStreamBridge extends EventEmitter {
       // Codex が「ターン実行中」と権威的に報告した場合のみ activeTurnId を復元する
       // (通常の fresh resume では null = 次入力が turn/start になり固着しない)。
       session.activeTurnId = turnState.activeTurnId
+      // minor #3: session の権威状態 (activeTurnId) を **設定し終えてから** reattach 待ちへ
+      // resolve する。先に resolve すると、in-flight 中の reconnect が activeTurnId 未設定
+      // (turnActive=false) の状態で reattach し得るため、初期化完了後にスナップショットで通知する。
+      settleReady(session.threadId || null)
       // セッションのライフサイクルは必ずログに残す (2026-07-17: attach/detach/reap/exit の
       // 記録が皆無で「なぜ消えたか」を事後に辿れなかった)。同一 cwd に何本のセッションが
       // 積み上がっているかも併記し、ゾンビ蓄積をログだけで検知できるようにする。
@@ -271,10 +331,101 @@ export class CodexStreamBridge extends EventEmitter {
     } catch (err) {
       this.sessions.delete(stream_id)
       client.stop()
+      settleReady(null) // reattach 待ちへ「失敗」を通知 (reject しない)
+      // #3/#4: thread op に到達した失敗だけ分類する (initialize 失敗は分類しない)。
+      if (reachedThreadOp) await this._classifyAttachFailure(err, { resuming, resumeThreadId })
       throw err
     }
   }
 
+  /** attach_id に一致するライブ session を返す (in-memory reattach 用。無ければ null)。 */
+  _findLiveSessionByAttachId(attachId) {
+    if (!attachId) return null
+    for (const s of this.sessions.values()) {
+      if (!s.dead && s.attachId === attachId) return s
+    }
+    return null
+  }
+
+  /**
+   * 既存ライブ session を新 stream_id へ付け替える (in-memory reattach)。thread が未確定
+   * (thread/start in-flight) なら session.ready を await する (成功=threadId / 失敗=null)。
+   * 付け替えられなければ null を返し、呼び出し側 attach() は通常経路へフォールスルーする。
+   */
+  async _tryReattach(session, newStreamId) {
+    // ⚠️ 付け替え前の stream_id を **await の前に capture** する (major #1: 同じ attach_id へ
+    // 複数 reconnect が session.ready 待ちで重なったとき、`session.stream_id` を await 後に
+    // 読むと勝者が既に付け替えた現在値を追ってしまい「別 stream へ移動済み」を検出できず、
+    // 敗者も成功してしまう。capture 値で CAS することで **単一勝者**にする)。
+    // 戻り値 status:
+    //   "reattached" - この呼び出しが session を newStreamId へ付け替えた (info 同梱)。
+    //   "superseded" - 別 reattach が勝って session を奪った (session は生きている)。呼び出し側は
+    //                  **通常経路に落とさず** 失敗させる (二重 thread を作らない)。
+    //   "unavailable"- session が死んだ / first の thread 確定に失敗 (ライブ session 無し)。
+    //                  呼び出し側は通常経路へフォールスルーしてよい。
+    const originalStreamId = session.stream_id
+    let threadId = session.threadId
+    if (!threadId && session.ready) threadId = await session.ready
+    // first の thread op が失敗 / session が死んだ = ライブ session はもう無い。
+    if (!threadId || session.dead) return { status: "unavailable" }
+    // await 中に別 reattach が勝って session を移動した = concurrent の敗者。
+    if (this.sessions.get(originalStreamId) !== session) return { status: "superseded" }
+    if (this.sessions.has(newStreamId)) return { status: "superseded" } // 新 stream 側が別 session 保持 (異常)
+    this.sessions.delete(originalStreamId)
+    session.stream_id = newStreamId
+    session.detachRequested = false
+    this._cancelIdleReap(session, "reattach")
+    session.lastActivityMs = Date.now()
+    this.sessions.set(newStreamId, session)
+    this.logger?.info?.(
+      { stream_id: newStreamId, thread_id: threadId, cwd: session.cwd, reattached: true },
+      "codex session reattached (in-memory)",
+    )
+    // 履歴は返さない: reconnect では frontend が表示を保持している (resetDisplay=false) ため
+    // 再 hydrate 不要。turnActive は session が保持する activeTurnId から権威的に決める。
+    return {
+      status: "reattached",
+      info: {
+        resuming: true,
+        threadId,
+        history: [],
+        threadStatus: session.activeTurnId ? "active" : "idle",
+        lastTurnStatus: null,
+        turnActive: !!session.activeTurnId,
+      },
+    }
+  }
+
+  /**
+   * resume/start 失敗を frontend が扱える reason に分類する (Stage4 caller レビュー major #3/#4)。
+   * - resume: **timeout を最優先** (thread/resume が timeout なら rollout 有無に関係なく timeout)。
+   *   それ以外は rollout の tri-state (present/absent/unknown) で判定し、**absent のときだけ**
+   *   thread_not_found (frontend が pointer を compare-delete してよい)。unknown/present は
+   *   resume_error (有効 pointer を保持する)。
+   * - start (fresh): thread_not_found はあり得ない。timeout か start_error。
+   * initialize 段階の失敗はここに来ない (呼び出し側が reachedThreadOp で gate 済み)。
+   */
+  async _classifyAttachFailure(err, { resuming, resumeThreadId }) {
+    if (resuming) {
+      err.attachOperation = "resume"
+      err.attachThreadId = resumeThreadId
+      if (err.reason === "timeout") {
+        err.attachReason = "timeout"
+        return
+      }
+      let presence = "unknown"
+      try {
+        presence = await this._rolloutPresence(resumeThreadId)
+      } catch {
+        presence = "unknown"
+      }
+      err.attachReason = presence === "absent" ? "thread_not_found" : "resume_error"
+    } else {
+      err.attachOperation = "start"
+      err.attachReason = err.reason === "timeout" ? "timeout" : "start_error"
+    }
+  }
+
   /**
    * cwd 配下の Codex thread 一覧を返す (Cockpit Codex 両対応 セッションピッカー/最新
    * セッション自動選択用。claude 側 listSessions と対称)。
@@ -317,12 +468,18 @@ export class CodexStreamBridge extends EventEmitter {
   }
 
   _wireClient(session) {
-    const { client, stream_id } = session
+    const { client } = session
     client.on("notification", (msg) => this._onNotification(session, msg))
     client.on("request", (msg) => this._onServerRequest(session, msg))
     client.on("exit", (info) => this._onClientExit(session, info))
     client.on("error", (err) => {
-      this.emit("error", { stream_id, thread_id: session.threadId, error: err.message || String(err) })
+      // ⚠️ session.stream_id を **都度読む** (in-memory reattach で付け替わるため。wire 時に
+      //    分割代入で固定すると reattach 後に旧 stream へ error を emit してしまう)。
+      this.emit("error", {
+        stream_id: session.stream_id,
+        thread_id: session.threadId,
+        error: err.message || String(err),
+      })
     })
   }
 

package/src/config.mjs

@@ -10,6 +10,7 @@
 import { promises as fs, constants as fsConsts, readFileSync } from "node:fs"
 import path from "node:path"
 import os from "node:os"
+import { randomUUID } from "node:crypto"
 import { execFile, execFileSync } from "node:child_process"
 import { promisify } from "node:util"
 
@@ -90,6 +91,9 @@ function resolveConfigDir() {
   return path.join(os.homedir(), ".hub")
 }
 
+/** canonical UUID (v4 想定だが版は問わない)。host_key の契約。 */
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+
 export const paths = {
   get configDir() {
     return resolveConfigDir()
@@ -97,11 +101,111 @@ export const paths = {
   get configFile() {
     return path.join(resolveConfigDir(), "agent.json")
   },
+  get hostKeyFile() {
+    return path.join(resolveConfigDir(), "host_key")
+  },
   get pluginsDir() {
     return path.join(resolveConfigDir(), "plugins")
   },
 }
 
+/**
+ * このインストール (物理ホスト) の不変な識別子を返す (無ければ生成して永続化)。
+ *
+ * ## なぜ必要か (2026-07-17)
+ *
+ * Hub 側に「このワークスペースで今どの会話 (claude=session_id / codex=thread_id) を
+ * 開くか」を保存するにあたり、**その会話がどのホストのファイルシステムに存在するか**
+ * を指す必要がある。ところが Hub には物理ホストの安定した ID が無かった:
+ *
+ * - `CockpitAgent`(agent_id) = **credential のレコード**。再 enroll のたびに revoke /
+ *   再作成される (= ホストの同一性を表さない)
+ * - `hostname` = **表示用の属性**。Hub の PATCH API で変更でき、OS rename でも変わり、
+ *   別の物理端末が同名を名乗れる (= 一意でも不変でもない)
+ *
+ * そこで install 単位の opaque UUID をここで生成し、enroll 時に Hub へ送る。
+ *
+ * ## なぜ agent.json ではなく専用ファイルなのか
+ *
+ * `writeConfig()` は **agent.json を全置換**し、`clearConfig()` は **削除**する。
+ * host_key を agent.json に入れると credential のライフサイクルに巻き込まれ、
+ * 再 enroll / unenroll で消える = 「credential から独立した ID」という目的を
+ * 自ら壊す。別ファイルにして、credential の rotate と完全に分離する。
+ *
+ * ## 並行安全 (2026-07-17, Codex レビュー指摘)
+ *
+ * read → ENOENT → write の check-then-create は非原子的で、同じ config dir で 2 つの
+ * プロセスが初回起動すると **別々の UUID を生成して互いに上書きし得る** (片方が A を
+ * Hub へ送ったのに最終ファイルは B になり、次回起動で B を送る = identity が変わる)。
+ * 「install 単位で不変」を生成関数自身が保証できない。
+ *
+ * ⚠️ 単純な `flag: "wx"` でも不十分だった (2026-07-17、Codex レビュー 6 巡目):
+ * wx は **open の排他性**しか保証せず、勝者が open → write → close する間に、
+ * EEXIST を受けた敗者が**空 / 書きかけのファイルを読む窓**が残る (その起動だけ
+ * host_key の解決に失敗し、ポインタ機能が無効化される)。
+ *
+ * そこで **temp file へ完成品を書いてから `link()` で公開**する:
+ * link(2) は「リンク先が既に存在すれば EEXIST」で原子的なので、**排他性と
+ * 「公開されたファイルは常に完成済み」の両方**が同時に満たされる。敗者は勝者の
+ * 完成済みファイルを読むだけでよい。
+ *
+ * @param {{ randomUUIDImpl?: () => string, onBeforePublish?: () => Promise<void> }} [opts]
+ *   テスト用の注入口 (onBeforePublish は publish 直前に割り込んで競合窓を再現する)
+ * @returns {Promise<string>} 既存の値、または新規生成した UUID
+ */
+export async function getOrCreateHostKey(opts = {}) {
+  const existing = await _readHostKey()
+  if (existing) return existing
+
+  await ensureConfigDir()
+  const uuid = (opts.randomUUIDImpl || randomUUID)()
+  // 一意な temp 名 (同一 dir。link は同一 FS でしか張れないため)。
+  const tmp = `${paths.hostKeyFile}.${process.pid}.${randomUUID()}.tmp`
+  try {
+    // 0o600 は秘密だからではなく、書き換えられると別ホストになりすませるため。
+    await fs.writeFile(tmp, `${uuid}\n`, { mode: 0o600 })
+    if (opts.onBeforePublish) await opts.onBeforePublish()
+    try {
+      // 原子的 publish: 既にあれば EEXIST (= 競合の敗者)。
+      await fs.link(tmp, paths.hostKeyFile)
+      return uuid
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err
+      // 敗者: 勝者が publish したのは **完成済み**のファイルなので、そのまま読める。
+      const winner = await _readHostKey()
+      if (!winner) {
+        throw new Error("host_key の生成が競合し、勝者の値も読めませんでした")
+      }
+      return winner
+    }
+  } finally {
+    await fs.unlink(tmp).catch(() => {})
+  }
+}
+
+/** host_key ファイルを読む。無ければ null。中身が UUID でなければ throw。 */
+async function _readHostKey() {
+  let raw
+  try {
+    raw = await fs.readFile(paths.hostKeyFile, "utf-8")
+  } catch (err) {
+    if (err.code === "ENOENT") return null
+    throw err
+  }
+  const value = raw.trim()
+  if (!value) return null
+  if (!UUID_RE.test(value)) {
+    // ⚠️ 黙って新しい値へ rotate しない: identity が静かに変わると、Hub 側の
+    // 「今どの会話を開くか」が別ホスト扱いで引けなくなり、原因も追えない
+    // (Codex レビュー指摘、2026-07-17)。壊れているなら明示的に落とす。
+    throw new Error(
+      `${paths.hostKeyFile} の内容が UUID ではありません (${value.slice(0, 16)}...)。` +
+        "手動で修復するか、ファイルを削除して再生成してください。",
+    )
+  }
+  return value
+}
+
 /** ~/.hub を作成する (chmod 700)。 */
 export async function ensureConfigDir() {
   await fs.mkdir(paths.configDir, { recursive: true, mode: 0o700 })

package/src/enroll.mjs

@@ -8,7 +8,13 @@
  */
 import os from "node:os"
 
-import { detectAvailableClis, detectPlatform, hasConfig, writeConfig } from "./config.mjs"
+import {
+  detectAvailableClis,
+  detectPlatform,
+  getOrCreateHostKey,
+  hasConfig,
+  writeConfig,
+} from "./config.mjs"
 
 const DEFAULT_HUB_URL = process.env.HUB_URL || "https://hub.cocorograph.com"
 
@@ -35,6 +41,11 @@ export async function enroll(enrollmentToken, opts = {}) {
   }
 
   const availableClis = await detectAvailableClis()
+  // このインストール (物理ホスト) の不変な ID。credential (agent_id) と違い、
+  // 再 enroll しても同じ値を送り続けるため、Hub 側は「同じホスト」だと分かる。
+  // Hub の「今どの会話を開くか」ポインタがこれをキーにする (config.mjs の
+  // getOrCreateHostKey の docstring 参照)。
+  const hostKey = await getOrCreateHostKey()
 
   const res = await fetchImpl(`${hubUrl}/api/cockpit/agents/enroll-complete/`, {
     method: "POST",
@@ -42,6 +53,7 @@ export async function enroll(enrollmentToken, opts = {}) {
     body: JSON.stringify({
       enrollment_token: enrollmentToken,
       hostname,
+      host_key: hostKey,
       version,
       platform: detectPlatform(),
       available_clis: availableClis,

package/src/main.mjs

@@ -19,7 +19,13 @@ import path from "node:path"
 
 import pino from "pino"
 
-import { detectAvailableClis, detectPlatform, readConfig, writeConfig } from "./config.mjs"
+import {
+  detectAvailableClis,
+  detectPlatform,
+  getOrCreateHostKey,
+  readConfig,
+  writeConfig,
+} from "./config.mjs"
 import {
   codexTerminalSkipVersion,
   compareBundleVersions,
@@ -775,9 +781,25 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
     }
   }
 
+  // 物理ホストの不変 ID。**全起動が通るこの経路で解決**し hello に載せる
+  // (enroll 専用にすると既存端末が更新しても Hub に届かない。config.mjs の
+  // getOrCreateHostKey docstring 参照)。読めない/壊れている場合は fail-soft:
+  // 空文字で続行し、Hub 側はポインタ機能だけを無効化する (agent は通常どおり動く)。
+  let hostKey = ""
+  try {
+    hostKey = await getOrCreateHostKey()
+    logger.info({ host_key: hostKey }, "host key resolved")
+  } catch (err) {
+    logger.warn(
+      { err: err.message },
+      "host key の解決に失敗 (会話ポインタ機能のみ無効化。agent は通常どおり動作)",
+    )
+  }
+
   const client = new WsClient(config, {
     logger,
     version,
+    hostKey,
     platform: detectPlatform(),
     availableClis,
     bundleVersion,
@@ -4175,6 +4197,9 @@ async function dispatch(msg, ctx) {
             approvalPolicy: msg.approval_policy || undefined,
             sandbox: msg.sandbox || undefined,
             resumeThreadId,
+            // Stage4 caller レビュー major #1: attach 試行の安定 id。同じ attach_id で再接続
+            // すると bridge が rebind し、fresh の二重生成を防ぐ (browser の stream_id は都度変わる)。
+            attachId: msg.attach_id || undefined,
           })
           ctx.client.send({
             type: "codex.ready",
@@ -4201,7 +4226,11 @@ async function dispatch(msg, ctx) {
           //  - fresh (resume 無し): ゼロ値 + 確定済み threadId で即時 push (症状④)。
           //  - resume: codexUsageForThread で実 context% を解決し即時 push (症状③)。
           if (resolvedCwd) {
-            if (!resumeThreadId) {
+            // Stage4 caller レビュー major #6: fresh/resume の分岐は **実際の attach 結果**
+            // (info.resuming) で判定する。in-memory reattach は元 msg.resume_thread_id が空
+            // (fresh 再接続) でも既存 thread への復帰 = info.resuming=true なので、resume 側の
+            // 実 context% 解決に載せる (fresh 扱いで context を 0 に戻さない)。
+            if (!info.resuming) {
               clearChatSignal(resolvedCwd, "codex")
               recordChatActivity(resolvedCwd, "codex", {
                 status: "waiting",
@@ -4250,7 +4279,14 @@ async function dispatch(msg, ctx) {
             // S3 Codex 堅牢化: request() タイムアウト (codex-appserver-client.mjs) は
             // err.reason='timeout' を付与する。frontend が理由別の文言/表示を出し分け
             // られるよう素通しする (無ければ undefined = キー自体を省略)。
-            ...(err.reason ? { reason: err.reason } : {}),
+            // Stage4 caller レビュー major #3: attach 失敗は bridge が operation (resume|start) と
+            // reason (thread_not_found|timeout|resume_error|start_error) を分類する。frontend は
+            // operation=resume かつ reason=thread_not_found のときだけ pointer を修復して既存
+            // thread へ fallback する (I5)。err.attachReason があればそれを優先する。
+            ...(err.attachReason || err.reason
+              ? { reason: err.attachReason || err.reason }
+              : {}),
+            ...(err.attachOperation ? { operation: err.attachOperation } : {}),
           })
         }
         return

package/src/usage.mjs

@@ -1366,6 +1366,67 @@ export async function findCodexRolloutFile(threadId, { lookbackDays = 9, now = D
   return scanned
 }
 
+/**
+ * threadId の rollout ファイルの存在を **tri-state** で厳格判定する
+ * (Cockpit Stage4 caller レビュー major #4)。`findCodexRolloutFile` は全 readdir エラーを
+ * 握って null（不在扱い）にするため、EACCES/EIO 等の「走査できなかった」を「存在しない」と
+ * 誤認し、有効な pointer を compare-delete してしまう。ここでは:
+ *   - "present": rollout ファイルを実際に見つけた。
+ *   - "absent" : 全走査が完了し、readdir 失敗は ENOENT（＝そのシャードがまだ無い）だけで、
+ *                ファイルが無かった。→ 恒久不在と判断してよい (thread_not_found)。
+ *   - "unknown": 途中の readdir が ENOENT 以外 (EACCES/EIO 等) で失敗した / base 自体が読めない。
+ *                → 走査不能なので「不在」と断定しない (pointer を保持する)。
+ * @returns {Promise<"present"|"absent"|"unknown">}
+ */
+export async function codexRolloutPresence(threadId) {
+  if (!threadId) return "unknown"
+  // メモ命中で present 即返し（findCodexRolloutFile と同じメモを共有）。
+  const memoed = _codexRolloutPathMemo.get(threadId)
+  if (memoed) {
+    try {
+      await fs.stat(memoed)
+      return "present"
+    } catch {
+      _codexRolloutPathMemo.delete(threadId)
+    }
+  }
+  const base = codexSessionsDir()
+  const suffix = `-${threadId}.jsonl`
+  let sawUnknownError = false
+  const readdirSafe = async (dir) => {
+    try {
+      return await fs.readdir(dir)
+    } catch (err) {
+      // ENOENT = そのディレクトリがまだ無い（正常な「そこには無い」）。それ以外は走査不能。
+      if (err?.code !== "ENOENT") sawUnknownError = true
+      return null
+    }
+  }
+  const years = await readdirSafe(base)
+  if (years !== null) {
+    for (const y of years.filter((s) => /^\d{4}$/.test(s)).sort().reverse()) {
+      const months = await readdirSafe(path.join(base, y))
+      if (!months) continue
+      for (const m of months.sort().reverse()) {
+        const days = await readdirSafe(path.join(base, y, m))
+        if (!days) continue
+        for (const d of days.sort().reverse()) {
+          const dDir = path.join(base, y, m, d)
+          const files = await readdirSafe(dDir)
+          if (!files) continue
+          const match = files.find((f) => f.endsWith(suffix))
+          if (match) {
+            _codexRolloutPathMemo.set(threadId, path.join(dDir, match))
+            return "present"
+          }
+        }
+      }
+    }
+  }
+  // ファイルは見つからなかった。走査不能エラーがあったなら「不在」と断定しない。
+  return sawUnknownError ? "unknown" : "absent"
+}
+
 /** P5(perf): rollout ファイルの token_count 抽出結果を mtime+size でメモ化。 */
 const _codexTokenCountMemo = new Map() // fp → { mtimeMs, size, result }
 

package/src/ws-client.mjs

@@ -114,6 +114,11 @@ export class WsClient extends EventEmitter {
     this.config = config
     this.logger = opts.logger
     this.version = opts.version || "0.1.0"
+    // このインストール (物理ホスト) の不変 ID。**enroll だけでなく毎起動の hello で送る**:
+    // 既に enroll 済みの端末は更新後も enroll-complete を通らないため、enroll 専用に
+    // すると「更新しても host_key が Hub に届かず機能が永久に無効」になる
+    // (Codex レビュー指摘、2026-07-17)。backend は hello で空の host_key を backfill する。
+    this.hostKey = opts.hostKey || ""
     this.bundleVersion = opts.bundleVersion || null
     this.bundleVersionProvider =
       typeof opts.bundleVersionProvider === "function"
@@ -243,6 +248,7 @@ export class WsClient extends EventEmitter {
       type: "hello",
       agent_id: this.config.agent_id,
       hostname: this.hostname,
+      host_key: this.hostKey,
       version: this.version,
       bundle_version: this.bundleVersion,
       platform: this.platform,