@cocorograph/hub-agent 0.7.71 → 0.7.72

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocorograph/hub-agent",
-  "version": "0.7.71",
+  "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/main.mjs

@@ -4197,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",
@@ -4223,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",
@@ -4272,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 }