@cocorograph/hub-agent 0.8.75 → 0.8.76

package/package.json

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

package/src/claude-stream-bridge.mjs

@@ -49,6 +49,8 @@ function siblingEnvFor(cwd) {
     ...process.env,
     COCKPIT_SIBLING_TOKEN: getOrCreateSiblingToken(cwd),
     COCKPIT_SIBLING_CWD: cwd,
+    // Spawn-time display capability; rejection by an older daemon does not stop the review.
+    COCKPIT_REVIEW_EVENTS: "1",
     // hub-agent が spawn した Claude 配下 producer だけが delegate-event の受理 ACK を
     // 要求するための capability。能力は spawn 時点で固定されるため、hub-agent を旧版へ
     // ロールバックしても既存 producer は ACK を要求し続け、timeout し得る。

package/src/codex-stream-bridge.mjs

@@ -44,7 +44,7 @@ import { EventEmitter } from "node:events"
 import { randomUUID } from "node:crypto"
 import path from "node:path"
 
-import { recordInjectSourcePersistent } from "./inject-source-store.mjs"
+import { lookupInjectSource, recordInjectSourcePersistent } from "./inject-source-store.mjs"
 
 import { AsyncTtlCache } from "./async-ttl-cache.mjs"
 import { CodexAppServerClient } from "./codex-appserver-client.mjs"
@@ -203,6 +203,8 @@ function siblingEnvFor(cwd) {
     ...process.env,
     COCKPIT_SIBLING_TOKEN: getOrCreateSiblingToken(cwd),
     COCKPIT_SIBLING_CWD: cwd,
+    // Spawn-time display capability; rejection by an older daemon does not stop the review.
+    COCKPIT_REVIEW_EVENTS: "1",
     // ask-sibling スキル (cockpit_orch.py) が「自分は claude/codex どちらか」を
     // 環境変数から確実に判定できるようにする (ヒューリスティック不要)。
     COCKPIT_SIBLING_SELF_KIND: "codex",
@@ -1206,13 +1208,13 @@ export class CodexStreamBridge extends EventEmitter {
         : { items: [], start: 0, truncated: false, total: 0 }
       // hub-agent 側の履歴整形コスト (巨大スレッドで効く)。thread_op_ms とは別勘定にする。
       timing.history_flatten_ms = lap()
-      const history = flat.items
+      const history = await this._restoreHistoryInjectSources(flat.items, cwd)
       const historyTruncated = flat.truncated
       // T06541 案1: cold attach で得た高忠実度履歴をセッションに保持する。以降ライブ item
       // 完了ごとに追記し、cwd reattach 時にこれを返す（新プロセス thread/resume を再実行しない）。
       // major#2: byte 予算判定を O(1) にするため概算 byte 合計も持つ (flatten は既に byte 上限適用済み)。
       // app-server reap 後の cold resume は rollout が正本になるため、未 rollout の空 fresh session や
-      // in-memory の sibling source タグは復元できない。空 session の滞留を避けるため fresh 例外は作らない。
+      // 未保存の sibling source タグは復元できない。空 session の滞留を避けるため fresh 例外は作らない。
       session.historyItems = history.slice()
       session.historyBytes = history.reduce((n, it) => n + estimateItemBytes(it), 0)
       session.historyTruncated = historyTruncated
@@ -1800,7 +1802,7 @@ export class CodexStreamBridge extends EventEmitter {
     })
     return {
       threadId: session.threadId,
-      history: page.items,
+      history: await this._restoreHistoryInjectSources(page.items, session.cwd),
       historyStart: page.start,
       historyTotal: page.total,
       historyTruncated: page.truncated,
@@ -2398,6 +2400,21 @@ export class CodexStreamBridge extends EventEmitter {
     this._settleInjectDelivery(handle, { delivered: false, reason: "input_failed" })
   }
 
+  /** 履歴にも既存の cwd・本文一致ストアから注入元を戻す。元 item と既存 source は保持する。 */
+  async _restoreHistoryInjectSources(items, cwd) {
+    return Promise.all(items.map(async (item) => {
+      if (item?.type !== "userMessage" || item.source != null) return item
+      const content = item.content
+      const text = typeof content === "string"
+        ? content
+        : Array.isArray(content)
+          ? content.map((block) => typeof block?.text === "string" ? block.text : "").join("")
+          : ""
+      const source = await lookupInjectSource(cwd, text)
+      return source ? { ...item, source } : item
+    }))
+  }
+
   /** userMessage の echo (item/completed) が控えた注入本文と一致すれば、params を **クローン**して
    *  item.source を付けたものを返す (元の app-server オブジェクトは変更しない)。一致しなければ null。
    *  frontend の userMessageItemToEvent がこの item.source を読み専用カードへ分岐する。 */
@@ -3306,8 +3323,7 @@ export class CodexStreamBridge extends EventEmitter {
     // ライブ emit だけタグしていたため、cwd reattach で historyItems が返ると連携カードが通常の青い
     // 自分バブルへ戻っていた。同一プロセス内 reattach で表示が維持されるよう、以降 effectiveParams
     // (タグ済み or 素) を history と emit の両方で使う。一致しなければ null → 素の params のまま。
-    // ※ hub-agent 再起動 (cold resume) では historyItems が揮発するため青バブルへ戻る (claude の
-    //    jsonl at-rest と同じ許容範囲。source 永続マップは TTL/ID 再利用の複雑さに見合わないため不採用)。
+    // cold resume と過去履歴 page は既存の永続ストアから source を復元する。
     const eventThreadId = msg?.params?.threadId
     if (
       typeof eventThreadId === "string" &&
@@ -4136,6 +4152,22 @@ export class CodexStreamBridge extends EventEmitter {
     return out
   }
 
+  /** Display events never start a turn and only target an exact thread in this cwd. */
+  emitToStream(cwd, sessionId, event) {
+    if (!cwd || !sessionId) return { status: "not_found" }
+    const matches = [...this._liveSessions()].filter((s) => s.cwd === cwd && s.threadId === sessionId)
+    if (matches.length !== 1) return { status: matches.length ? "ambiguous" : "not_found" }
+    const session = matches[0]
+    this.emit("event", {
+      stream_id: session.stream_id,
+      producer_seq: session.seq,
+      thread_id: session.threadId,
+      cwd: session.cwd,
+      notification: { method: "cockpit/review_event", params: event },
+    })
+    return { status: "delivered", session: this._describe(session) }
+  }
+
   /**
    * 指定 cwd の「権威セッション」を返す（T06407 増分2, axis2 の単一正本）。同一 cwd に複数
    * ライブ codex セッションがあるとき、**最終活性が最新のもの**（＝いまユーザーが使っている

package/src/main.mjs

@@ -2277,6 +2277,7 @@ export function buildClaudeReadyPayload(streamId, info) {
     turn_active: info?.turn_active === true,
     history_pushed: info?.resuming === true,
     supports_queue_input_id: true,
+    supports_review_events: true,
     supports_queue_snapshot: true,
     supports_session_options_cas: true,
   }
@@ -2328,6 +2329,7 @@ export function buildCodexReadyPayload(streamId, info, queueState) {
     // Browser は旧 hub-agent との混在期間、この明示 capability が true のときだけ
     // 子 thread の個別停止 UI を有効化する。省略は未対応を意味する。
     supports_subagent_interrupt: true,
+    supports_review_events: true,
     // 旧 agent との混在時、取消結果を待てることを明示する。
     supports_queue_cancel_response: true,
   }
@@ -4177,6 +4179,15 @@ export async function dispatch(msg, ctx) {
             resumeSessionId,
           })
           ctx.client.send(buildClaudeReadyPayload(stream_id, info))
+          try {
+            if (resumeSessionId) {
+              void ctx.siblingInjectBridge
+                ?.replayReviews?.("claude", cwdArg || process.env.HOME || process.cwd(), resumeSessionId)
+                ?.catch((err) => ctx.logger?.warn?.({ err: err?.message }, "failed to replay review events"))
+            }
+          } catch (err) {
+            ctx.logger?.warn?.({ err: err?.message }, "failed to replay review events")
+          }
           if (resumeSessionId) {
             void ctx.siblingInjectBridge
               ?.replayDelegations(cwdArg || process.env.HOME || process.cwd(), resumeSessionId)
@@ -4610,6 +4621,15 @@ export async function dispatch(msg, ctx) {
           ctx.client.send(
             buildCodexReadyPayload(stream_id, info, ctx.codexBridge.queueState(stream_id)),
           )
+          try {
+            if (info.threadId) {
+              void ctx.siblingInjectBridge
+                ?.replayReviews?.("codex", resolvedCwd || process.env.HOME || process.cwd(), info.threadId)
+                ?.catch((err) => ctx.logger?.warn?.({ err: err?.message }, "failed to replay review events"))
+            }
+          } catch (err) {
+            ctx.logger?.warn?.({ err: err?.message }, "failed to replay review events")
+          }
           // S1 (2026-07): claude.attach と対称の identity 正本化。Codex は thread/start
           // 応答時点で threadId が確定するため (Claude の fresh とは異なり)、fresh でも
           // 既に分かっている threadId を sessionId として記録する (直後の turn/started が

package/src/review-event-store.mjs

@@ -0,0 +1,141 @@
+import fs from "node:fs/promises"
+import path from "node:path"
+import { createHash, randomUUID } from "node:crypto"
+
+// Maximum retention; the IPC temp directory can be removed earlier by the OS.
+const RETENTION = 30 * 24 * 60 * 60 * 1000
+export const REVIEW_SESSION_MAX_BYTES = 4 * 1024 * 1024
+const FIELDS = new Set([
+  "type", "subtype", "schema_version", "review_id", "phase", "reviewer", "round",
+  "workdir", "timestamp", "report", "verdict", "summary", "pid", "pid_started_at",
+])
+
+export function validReviewEvent(event) {
+  if (!event || typeof event !== "object" || Array.isArray(event)) return false
+  if (Object.keys(event).some((key) => !FIELDS.has(key))) return false
+  if (Buffer.byteLength(JSON.stringify(event)) > 512 * 1024) return false
+  if (event.type !== "system" || event.subtype !== "cross_review" || event.schema_version !== 1) return false
+  if (typeof event.review_id !== "string" || !/^[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i.test(event.review_id)) return false
+  if (!["started", "completed", "failed", "stopped"].includes(event.phase)) return false
+  if (!["claude", "codex"].includes(event.reviewer)) return false
+  if (!Number.isSafeInteger(event.round) || event.round <= 0) return false
+  if (typeof event.workdir !== "string" || !path.isAbsolute(event.workdir)) return false
+  if (typeof event.timestamp !== "string" || !/^\d{4}-\d\d-\d\dT/.test(event.timestamp) || !Number.isFinite(Date.parse(event.timestamp))) return false
+  if (["report", "summary"].some((key) => event[key] !== undefined && typeof event[key] !== "string")) return false
+  if (event.pid !== undefined && (!Number.isSafeInteger(event.pid) || event.pid <= 0)) return false
+  if (event.pid_started_at !== undefined && typeof event.pid_started_at !== "string") return false
+  if (event.verdict !== undefined && !["pass", "changes_requested"].includes(event.verdict)) return false
+  return event.phase !== "completed" || (typeof event.report === "string" && event.verdict !== undefined)
+}
+
+/** Single daemon writer; atomic snapshots preserve start and first terminal independently.
+ * Synthetic stopped is also final. Replay is best-effort across daemon restarts, not OS temp cleanup.
+ */
+export class ReviewEventStore {
+  constructor(dir, now = Date.now) {
+    this.dir = dir
+    this.now = now
+    this.queue = Promise.resolve()
+    this.lastSweep = 0
+  }
+  _serial(operation) {
+    const pending = this.queue.then(operation)
+    this.queue = pending.catch(() => {})
+    return pending
+  }
+  _file(kind, cwd, sessionId) {
+    const hash = createHash("sha256").update(JSON.stringify([kind, cwd, sessionId])).digest("hex")
+    return path.join(this.dir, hash + ".json")
+  }
+  async _checkDirectory() {
+    const info = await fs.lstat(this.dir)
+    if (!info.isDirectory() || info.isSymbolicLink() || info.uid !== process.getuid?.() || (info.mode & 0o777) !== 0o700) {
+      throw new Error("unsafe review directory")
+    }
+  }
+  async _read(file, target) {
+    try {
+      await this._checkDirectory()
+      const info = await fs.lstat(file)
+      if (!info.isFile() || info.isSymbolicLink() || info.uid !== process.getuid?.() || (info.mode & 0o777) !== 0o600) {
+        throw new Error("unsafe review store")
+      }
+      if (info.size > REVIEW_SESSION_MAX_BYTES) throw new Error("review store exceeds size limit")
+      const snapshot = JSON.parse(await fs.readFile(file, "utf8"))
+      if (JSON.stringify(snapshot.target) !== JSON.stringify(target) || !Array.isArray(snapshot.rows) || snapshot.rows.length > 100) {
+        throw new Error("invalid review store target or rows")
+      }
+      const ids = new Set()
+      for (const row of snapshot.rows) {
+        if (!row || !Number.isFinite(row.at) || ids.has(row.id) || (!row.started && !row.terminal)) {
+          throw new Error("invalid review store row")
+        }
+        ids.add(row.id)
+        for (const key of ["started", "terminal"]) {
+          const event = row[key]
+          if (event && (!validReviewEvent(event) || event.review_id !== row.id || (key === "started") !== (event.phase === "started"))) {
+            throw new Error("invalid review store event")
+          }
+        }
+      }
+      return snapshot.rows.filter((row) => row.at >= this.now() - RETENTION)
+    } catch (err) {
+      if (err.code === "ENOENT") return []
+      throw err
+    }
+  }
+  events(kind, cwd, sessionId) {
+    return this._serial(async () => {
+      const rows = await this._read(this._file(kind, cwd, sessionId), [kind, cwd, sessionId])
+      return rows.flatMap((row) => [row.started, row.terminal].filter(Boolean))
+    })
+  }
+  record(kind, cwd, sessionId, event) {
+    return this._serial(() => this._record(kind, cwd, sessionId, event))
+  }
+  async _record(kind, cwd, sessionId, event) {
+    if (!validReviewEvent(event)) throw new Error("invalid review event")
+    await fs.mkdir(this.dir, { recursive: true, mode: 0o700 })
+    await this._checkDirectory()
+    if (this.now() - this.lastSweep >= 86400 * 1000) {
+      for (const name of await fs.readdir(this.dir)) {
+        if (!/^[a-f0-9]{64}\.json$/.test(name)) continue
+        const file = path.join(this.dir, name)
+        if ((await fs.lstat(file)).mtimeMs < this.now() - RETENTION) await fs.unlink(file)
+      }
+      this.lastSweep = this.now()
+    }
+    const file = this._file(kind, cwd, sessionId)
+    const target = [kind, cwd, sessionId]
+    const rows = await this._read(file, target)
+    let row = rows.find((r) => r.id === event.review_id)
+    const key = event.phase === "started" ? "started" : "terminal"
+    if (row?.[key]) return { duplicate: true, events: [] }
+    if (!row) {
+      row = { id: event.review_id, at: this.now() }
+      rows.push(row)
+    }
+    row[key] = event
+    row.at = this.now()
+    let serialized = JSON.stringify({ target, rows })
+    while (rows.length > 100 || Buffer.byteLength(serialized) > REVIEW_SESSION_MAX_BYTES) {
+      // Prefer evicting old completed reviews, preserving the incoming review and active work.
+      let index = rows.findIndex((candidate) => candidate !== row && candidate.terminal)
+      if (index < 0) index = rows.findIndex((candidate) => candidate !== row)
+      rows.splice(index, 1)
+      serialized = JSON.stringify({ target, rows })
+    }
+    const tmp = file + "." + randomUUID() + ".tmp"
+    try {
+      await fs.writeFile(tmp, serialized, { mode: 0o600, flag: "wx" })
+      await fs.rename(tmp, file)
+    } finally {
+      try {
+        await fs.unlink(tmp)
+      } catch (err) {
+        if (err.code !== "ENOENT") throw err
+      }
+    }
+    return { duplicate: false, events: key === "started" && row.terminal ? [event, row.terminal] : [event] }
+  }
+}

package/src/sibling-inject.mjs

@@ -32,6 +32,10 @@
  *       新 agent だけが処理する (probe を挟まず単一リクエストで TOCTOU を排除)。
  *       宛先は session_id(claude) / stream_id・thread_id(codex) を cwd 一致下に確定解決。
  *   - 一覧: `{op:"list", cwd, target_cli_kind, token}` → `{ok, live_sessions}` (--list 用)。
+ *   - レビュー通知: `{op:"review-event", cwd, target_cli_kind, token, target_session_id, event}`。
+ *       許可キーはこの6つのみ。要求ファイルは所有者の0600通常ファイルに限定する。
+ *       成功は `{ok:true, duplicate?}`、保存後の配送失敗は
+ *       `{ok:false, error:"review_delivery_failed", persisted:true}`。
  *   - 全一覧: `{op:"list-all", token}` → `{ok, live_sessions}` (全 cwd・両 CLI。クロス cwd
  *       宛先探索用、2026-07-23。cwd/target_cli_kind 不要、token のみ必須)。
  *   - 安全な再起動: `{op:"restart"}` → `{ok:true, restart_pending:true}`。本文と token を持たず、
@@ -75,6 +79,7 @@ import path from "node:path"
 
 import { verifySiblingTokenAny, siblingTokenCwd } from "./sibling-token.mjs"
 import { describeLiveSessionsUnion } from "./live-sessions.mjs"
+import { ReviewEventStore, validReviewEvent } from "./review-event-store.mjs"
 
 export const SIBLING_REQUESTS_DIR =
   process.env.COCKPIT_SIBLING_REQUESTS_DIR || "/tmp/cockpit_sibling_requests"
@@ -437,6 +442,7 @@ export class SiblingInjectBridge {
     this._watcher = null
     this._sweepTimer = null
     this._now = now
+    this.reviewEvents = new ReviewEventStore(path.join(dir, "review-events"), now)
     this._processKill = processKill
     this._pidStartedAt = pidStartedAt
     this._onRestartRequested = onRestartRequested
@@ -660,6 +666,23 @@ export class SiblingInjectBridge {
     return { claudeBridge: this.claudeBridge, codexBridge: this.codexBridge }
   }
 
+  async replayReviews(kind, cwd, sessionId) {
+    const bridge = kind === "codex" ? this.codexBridge : this.claudeBridge
+    const events = await this.reviewEvents.events(kind, cwd, sessionId)
+    const terminalIds = new Set(events.filter((event) => event.phase !== "started").map((event) => event.review_id))
+    for (const event of events) {
+      bridge?.emitToStream?.(cwd, sessionId, event)
+      if (event.phase === "started" && !terminalIds.has(event.review_id) && !(await this._delegateProcessAlive(event))) {
+        const saved = await this.reviewEvents.record(kind, cwd, sessionId, {
+          ...event,
+          phase: "stopped",
+          timestamp: new Date(this._now()).toISOString(),
+        })
+        for (const stopped of saved.events) bridge?.emitToStream?.(cwd, sessionId, stopped)
+      }
+    }
+  }
+
   async _lstatDir() {
     return lstat(this.dir)
   }
@@ -841,6 +864,7 @@ export class SiblingInjectBridge {
     const isList = op === "list"
     const isExplicit = op === "inject"
     const isDelegateEvent = op === "delegate-event"
+    const isReviewEvent = op === "review-event"
     const hasRequestAck = Object.prototype.hasOwnProperty.call(body || {}, "request_ack")
     const isRestart = op === "restart"
     let result
@@ -861,7 +885,13 @@ export class SiblingInjectBridge {
       (request_ack !== undefined && request_ack !== true) ||
       (timestamp !== undefined &&
         (typeof timestamp !== "string" || Number.isNaN(Date.parse(timestamp))))
-    const badBody = isDelegateEvent
+    const badBody = isReviewEvent
+      ? !validReviewEvent(body.event) || typeof target_session_id !== "string" || !target_session_id ||
+        typeof cwd !== "string" || !path.isAbsolute(cwd) ||
+        Object.keys(body).some((key) => !["op", "token", "cwd", "target_cli_kind", "target_session_id", "event"].includes(key)) ||
+        !requestInfo.isFile() || requestInfo.isSymbolicLink() || requestInfo.uid !== process.getuid?.() ||
+        (requestInfo.mode & 0o777) !== 0o600
+      : isDelegateEvent
       ? badDelegateBody
       : isList
       ? false
@@ -927,7 +957,25 @@ export class SiblingInjectBridge {
         }
       }
       const bridge = target_cli_kind === "codex" ? this.codexBridge : this.claudeBridge
-      if (isDelegateEvent) {
+      if (isReviewEvent) {
+        const matches = describeLiveSessionsUnion(this._bridges(), { cwd, cliKind: target_cli_kind })
+          .filter((s) => (target_cli_kind === "codex" ? s.thread_id : s.session_id) === target_session_id)
+        if (matches.length !== 1) {
+          result = { ok: false, error: AMBIGUOUS_TARGET_ERROR }
+        } else {
+          try {
+            const saved = await this.reviewEvents.record(target_cli_kind, cwd, target_session_id, body.event)
+            result = { ok: true, duplicate: saved.duplicate }
+            for (const event of saved.events) {
+              const delivered = bridge?.emitToStream?.(cwd, target_session_id, event)
+              if (delivered?.status !== "delivered") result = { ok: false, error: "review_delivery_failed", persisted: true }
+            }
+          } catch (err) {
+            this.logger?.warn?.({ request_id, error: err?.message }, "review event display failed")
+            result = { ok: false, error: "review_display_failed" }
+          }
+        }
+      } else if (isDelegateEvent) {
         // 委譲カードは別 Claude 会話へ誤配送すると誤解を生むため、cwd 内の 1 本へ推測配送しない。
         // target_session_id が無い場合も、指定先が一意に見つからない場合も同じ fail-closed 契約にする。
         if (!target_session_id) {