@cocorograph/hub-agent 0.8.75 → 0.8.77

package/src/main.mjs

@@ -115,8 +115,13 @@ import {
   shouldLaunchPaneCli,
   validateInitialPrompt,
 } from "./tmux.mjs"
+import { expandTilde, prepareChatWorkspace, isCwdUnavailableError } from "./chat-workspace.mjs"
+import { buildChatSessionsSnapshot } from "./chat-sessions-snapshot.mjs"
+import { chatTargetsCache } from "./chat-targets.mjs"
+import { ensureChatSession } from "./chat-session-starter.mjs"
+import { beginRemoval } from "./chat-removal-guard.mjs"
 import { SiblingInjectBridge } from "./sibling-inject.mjs"
-import { isSessionWarm } from "./live-sessions.mjs"
+import { describeLiveSessionsUnion, isSessionWarm } from "./live-sessions.mjs"
 import { applyPointerContexts, resolvePointerContexts } from "./pointer-context.mjs"
 import {
   boundSessionId,
@@ -178,6 +183,26 @@ const BUNDLE_MANIFEST_PATH =
   process.env.HUB_BUNDLE_MANIFEST ||
   path.join(os.homedir(), ".claude", "scripts", "manifest.json")
 
+/** 通常接続と自動起動で、現在の Claude 設定を共通に解決する。 */
+export function resolveClaudeAttachOptions(config, msg = {}) {
+  return {
+    model: msg.model || config?.claude_model || null,
+    permissionMode:
+      msg.permission_mode ||
+      config?.claude_permission_mode ||
+      null,
+    // Phase B: チャット SDK に効くオプション (session 単位 override)。
+    maxTurns: typeof msg.max_turns === "number" ? msg.max_turns : null,
+    maxThinkingTokens:
+      typeof msg.max_thinking_tokens === "number"
+        ? msg.max_thinking_tokens
+        : null,
+    // effort (Opus 4.6+): browser がチャット既定 (agent 設定由来) を送る。
+    // 空文字/未指定なら null (SDK / Claude Code 既定 = Opus は high)。
+    effort: msg.effort || config?.claude_effort || null,
+  }
+}
+
 /**
  * `~/.hub/agent.json` の Claude CLI 設定から claude コマンド文字列を組み立てる。
  *
@@ -414,6 +439,25 @@ export function isFastPathMessage(type) {
  * codex.sessions.request は rollout の disk 走査のみで app-server を spawn しない。
  * CodexStreamBridge.listThreads 側の single-flight が同一走査の重複 I/O を畳む。
  */
+/**
+ * cwd を省略したメッセージがレーン分類で使う既定 cwd を、CLI 種別ごとに返す。
+ *
+ * ⚠️ ここが返す値は、ハンドラと bridge が実際に行う補完と **同じ結果**でなければならない。
+ * ずれると、同じ会話への attach が stream レーン・その会話の個別停止が cwd レーンへ散り、
+ * 直列化されないまま同時に走る（停止が 0 件で先に終わった後に会話が起き上がる）。
+ *   claude … handler が `msg.cwd || config.claude_cwd`、bridge がさらに
+ *            `|| process.env.HOME || process.cwd()` まで補う（claude-stream-bridge の attach）
+ *   codex  … handler の `msg.cwd || config.claude_cwd` まで。bridge は補完せず cwd 未設定の
+ *            まま session を持つので、ここで HOME へ寄せない（寄せると誰も居ない cwd の
+ *            レーンへ codex の会話を集めてしまう。codex の個別停止は stream_id の記録済み
+ *            レーンを使うので、そもそも cwd に依存しない）
+ */
+export function defaultLaneCwd(config, mode) {
+  const configured = expandTilde(config?.claude_cwd || "") || ""
+  if (configured || mode !== "claude") return configured
+  return process.env.HOME || process.cwd()
+}
+
 export function isReadOnlyRpc(type) {
   return (
     type === "claude.history.request" ||
@@ -423,6 +467,10 @@ export function isReadOnlyRpc(type) {
     type === "profile.list" ||
     type === "codex.profile.list" ||
     type === "chat.sidebar_snapshot.request" ||
+    // 登録先の走査とライブ集合の読み取りだけで pane・入力・bridge の状態を変えず、
+    // request_id で相関するため WS 受信順に依存しない。直列レーンでは前方の重い
+    // attach spawn 等によりサイドバー更新が数十秒遅れるため、即時実行する。
+    type === "chat.sessions.request" ||
     // T06603 (2026-07-25): キュー snapshot の pull。in-memory 配列を読むだけで副作用が無く、
     // かつ「直列キュー前方の重い処理で再同期が遅延する」と送信待ちチップの固着が長引く
     // (再同期は固着を直すための経路なので、詰まりやすい経路に置いてはならない)。
@@ -1312,6 +1360,10 @@ export async function startDaemon({ version, claudeSdk } = {}) {
     // fast-path (interrupt) / read-only RPC は従来どおり即時実行。接続 lifecycle は
     // scheduler 自身が常に priority 扱いする。
     shouldBypass: (type) => isFastPathMessage(type) || isReadOnlyRpc(type),
+    // cwd 省略時にハンドラ／bridge が補う cwd を、レーン分類にも同じ結果で見せる
+    // (規則と根拠は defaultLaneCwd 側にまとめてある)。scheduler には設定も path 解決も
+    // 持たせず、解決済みの値だけを渡す。
+    defaultCwd: (mode) => defaultLaneCwd(ctx.config, mode),
   })
   client.on("close", () => dispatchScheduler.advanceGeneration("ws_close"))
   client.on("open", () => dispatchScheduler.advanceGeneration("ws_open"))
@@ -1390,6 +1442,10 @@ export async function startDaemon({ version, claudeSdk } = {}) {
     claudeBridge,
     codexBridge,
     logger,
+    starter: ({ cwd, cliKind }) => ensureChatSession({
+      cwd, cliKind, bridges: { claudeBridge, codexBridge }, logger,
+      resolveClaudeOptions: () => resolveClaudeAttachOptions(ctx.config),
+    }),
     onRestartRequested: () => restartCoordinator.request(),
     isInputBlocked: () => lifecycle.restartPending || lifecycle.shutdownStarted,
   })
@@ -2277,6 +2333,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 +2385,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,
   }
@@ -4039,6 +4097,10 @@ export async function handleWorktreeCreate(msg, ctx) {
       tmuxOptions.codexCmd = tmuxOptions.codexCmd ?? buildCodexCmd(tmuxOptions)
     }
     const { wtName, wtPath, createdBranch } = await worktreeCreate(dir, branch)
+    // ⚠️ 宛先一覧の無効化を tmux 作成の成否に依存させない。この一覧の正本はローカルの
+    // ディレクトリ実体なので、worktree ができた時点で既に古い。後続の tmux 作成が失敗しても
+    // worktree dir は残るため、ここで捨てないと残り TTL のあいだ実在する宛先が一覧から欠ける。
+    chatTargetsCache.clear()
     // worktree dir で tmux session を作成。tmux.create_session と同じく cli_kind を
     // 解釈し、codex なら codex を pane 起動する（既定 claude）。
     // T05945: セッション名は cli_kind に応じて `<wt>` / `<wt>__codex` へ分ける。これで
@@ -4070,6 +4132,73 @@ export async function handleWorktreeCreate(msg, ctx) {
   }
 }
 
+/**
+ * 指定ディレクトリ配下を cwd とする会話 (claude / codex) すべてに対して停止 API を呼び、
+ * **呼んだ本数**を返す。
+ *
+ * ⚠️ worktree 削除の前段専用。会話の実体が tmux から離れたので、削除前に止めるのは tmux の
+ * セッションではなく会話そのものになる (ユーザー決定「会話を止めてから削除」)。
+ *
+ * ⚠️ **保証するのは「対象の停止 API を呼んだこと」だけ**で、下の 2 つは保証しない
+ * (2026-09-16 判断)。どちらも現状の bridge では確かめる手段が無く、作るには client 管理の
+ * 作り替えが要る:
+ *   1. **停止が成功したこと。** bridge は内部の停止失敗を握り潰すので、呼び出し側からは失敗が
+ *      見えない (claude-stream-bridge.mjs の `s.close()` を囲む `catch {}` /
+ *      codex-stream-bridge.mjs の `codex reap: stop threw` warn)。
+ *   2. **プロセスが終了したこと。** 終了は待たない (根拠は tmux.mjs の removeWorktree 参照)。
+ * したがって削除を中止するのは **呼び出しが外へ例外を投げたとき**だけで、実際にそうなるのは
+ * bridge の不在・API 呼び出し不能といった構成上の失敗に限られる。
+ *
+ * ⚠️ 戻り値は「停止 API を呼んだ本数」であって「止まった本数」ではない。**成功件数として
+ * 利用者へ見せないこと。**
+ * ⚠️ 生存判定は `describeLiveSessionsUnion` に一本化する。ここで別実装を書くと、表示・配送と
+ * 停止対象が無言でずれる (live-sessions.mjs の不変条件)。
+ * ⚠️ 比較はパス境界を見る。`startsWith(base)` だけだと `<wt>` と `<wt>-backup` を取り違えて、
+ * 消していない worktree の会話まで止めてしまう。
+ *
+ * @param {string} dir 削除対象の worktree パス
+ * @param {{claudeBridge?: object, codexBridge?: object}} ctx
+ * @param {string} [reason] exit に載る停止理由 (既定の "explicit-stop" 等と区別するため明示する)
+ * @returns {Promise<number>} 停止 API を呼んだ本数 (止まった本数ではない)
+ */
+export async function stopChatSessionsUnder(dir, ctx, reason = "worktree-remove") {
+  const base = path.resolve(dir)
+  const isUnder = (cwd) => {
+    if (typeof cwd !== "string" || !cwd) return false
+    const resolved = path.resolve(cwd)
+    return resolved === base || resolved.startsWith(base + path.sep)
+  }
+  const live = describeLiveSessionsUnion({
+    claudeBridge: ctx.claudeBridge,
+    codexBridge: ctx.codexBridge,
+  })
+  const claudeCwds = new Set()
+  const codexStreams = new Set()
+  let stopped = 0
+  // ⚠️ 例外を捕まえない。投げれば removeWorktree がその場で中断し、dir は残る (= 削除しない)。
+  // 「失敗した分を集めて最後にまとめて投げる」形も書けるが、削除しないのであれば残りを止める
+  // 必要はなく、「削除していないのに会話だけ止まっている」という意外な結果を作るだけだった。
+  // ⚠️ ここで捕まるのは **呼び出しそのものが失敗したとき**だけ (bridge の不在・API 呼び出し
+  // 不能といった構成上の失敗)。停止 API の中で起きた失敗は握り潰されて届かないので、
+  // 「止まったこと」はここでは確かめられない。保証の範囲は JSDoc に書いたとおり。
+  for (const session of live) {
+    if (!isUnder(session?.cwd)) continue
+    if (session.kind === "claude") {
+      if (claudeCwds.has(session.cwd)) continue
+      claudeCwds.add(session.cwd)
+      stopped += await ctx.claudeBridge.stopSessionsFor({ cwd: session.cwd, reason })
+    } else if (session.kind === "codex") {
+      if (codexStreams.has(session.stream_id)) continue
+      codexStreams.add(session.stream_id)
+      stopped += await ctx.codexBridge.stopSessionForStream({
+        stream_id: session.stream_id,
+        reason,
+      })
+    }
+  }
+  return stopped
+}
+
 /**
  * DispatchScheduler から呼ばれる本番メッセージ入口。
  * export はハンドラ契約を subprocess なしで検証するテスト専用の公開面でもある。
@@ -4144,6 +4273,25 @@ export async function dispatch(msg, ctx) {
           // (将来 cockpit から worktree path を指定する用)。
           // model / permissionMode は agent.json の値も使えるよう fallback。
           const cwdArg = msg.cwd || ctx.config?.claude_cwd || undefined
+          try {
+            await prepareChatWorkspace({
+              waitForSync: false,
+              cwd: cwdArg || process.env.HOME || process.cwd(),
+              cliKind: "claude",
+              logger: ctx.logger,
+            })
+          } catch (err) {
+            // Claude は attach で会話を登録するだけで、プロセス起動前に ready を返す。
+            // cwd が無くても live・配送対象に載るため、起動時の失敗に頼らず登録前に止める。
+            if (isCwdUnavailableError(err)) {
+              ctx.client.send({ type: "claude.error", stream_id, error: `workspace_missing: ${err.message}` })
+              return
+            }
+            ctx.logger?.warn?.(
+              { cwd: cwdArg, err: err?.message || String(err) },
+              "claude.attach workspace preparation failed (attach continues)",
+            )
+          }
           const resumeSessionId = msg.resume_session_id || null
           // attachは同期処理なので、履歴I/Oを先に開始してreadyまでの待ちを重ねる。
           // 新Browserはhistory_pushedを見て別requestを省略し、旧Browserは従来どおり
@@ -4160,23 +4308,19 @@ export async function dispatch(msg, ctx) {
           const info = ctx.claudeBridge.attach({
             stream_id,
             cwd: cwdArg,
-            model: msg.model || ctx.config?.claude_model || null,
-            permissionMode:
-              msg.permission_mode ||
-              ctx.config?.claude_permission_mode ||
-              null,
-            // Phase B: チャット SDK に効くオプション (session 単位 override)。
-            maxTurns: typeof msg.max_turns === "number" ? msg.max_turns : null,
-            maxThinkingTokens:
-              typeof msg.max_thinking_tokens === "number"
-                ? msg.max_thinking_tokens
-                : null,
-            // effort (Opus 4.6+): browser がチャット既定 (agent 設定由来) を送る。
-            // 空文字/未指定なら null (SDK / Claude Code 既定 = Opus は high)。
-            effort: msg.effort || ctx.config?.claude_effort || null,
+            ...resolveClaudeAttachOptions(ctx.config, msg),
             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)
@@ -4594,6 +4738,24 @@ export async function dispatch(msg, ctx) {
         }
         try {
           const resolvedCwd = msg.cwd || ctx.config?.claude_cwd || undefined
+          try {
+            await prepareChatWorkspace({
+              waitForSync: false,
+              cwd: resolvedCwd || process.env.HOME || process.cwd(),
+              cliKind: "codex",
+              logger: ctx.logger,
+            })
+          } catch (err) {
+            // Claude と同じく、cwd の利用不能が確定したら会話の登録前に止める。
+            if (isCwdUnavailableError(err)) {
+              ctx.client.send({ type: "codex.error", stream_id, error: `workspace_missing: ${err.message}` })
+              return
+            }
+            ctx.logger?.warn?.(
+              { cwd: resolvedCwd, err: err?.message || String(err) },
+              "codex.attach workspace preparation failed (attach continues)",
+            )
+          }
           const resumeThreadId = msg.resume_thread_id || null
           const info = await ctx.codexBridge.attach({
             stream_id,
@@ -4610,6 +4772,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 が
@@ -5410,6 +5581,82 @@ export async function dispatch(msg, ctx) {
         }
         return
       }
+      case "chat.session.stop": {
+        const result = { type: "chat.session.stop.result", request_id: msg.request_id, stopped: 0 }
+        try {
+          if (msg.cli_kind === "claude") {
+            const cwd = typeof msg.cwd === "string" ? msg.cwd : ""
+            const session_id = typeof msg.session_id === "string" ? msg.session_id : ""
+            if (!cwd || !path.isAbsolute(cwd)) result.error = "cwd required"
+            else if (!/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(session_id)) {
+              result.error = "invalid session_id"
+            } else {
+              result.stopped = await ctx.claudeBridge.stopSessionForDeletion({ cwd, session_id, reason: "chat-stop" })
+            }
+          } else if (msg.cli_kind === "codex") {
+            if (typeof msg.stream_id !== "string" || !msg.stream_id) result.error = "stream_id required"
+            else result.stopped = await ctx.codexBridge.stopSessionForStream({ stream_id: msg.stream_id, reason: "chat-stop" })
+          } else {
+            result.error = "unsupported cli_kind"
+          }
+        } catch (err) {
+          result.error = err?.message || String(err)
+        }
+        ctx.client.send(result)
+        return
+      }
+      case "chat.stop_all": {
+        // exit に載る停止理由。bridge 側の既定 ("tui-bind-stop" / "explicit-stop") は
+        // それぞれ TUI 切替・個別停止の名前なので、全停止はここで明示して区別する。
+        const STOP_ALL_REASON = "chat-stop-all"
+        const result = { type: "chat.stop_all.result", request_id: msg.request_id, stopped: 0, failed: [] }
+        try {
+          const live = describeLiveSessionsUnion({ claudeBridge: ctx.claudeBridge, codexBridge: ctx.codexBridge })
+          const claudeCwds = new Set()
+          const codexStreams = new Set()
+          for (const session of live) {
+            let target
+            try {
+              if (session.kind === "claude") {
+                const cwd = session.cwd
+                if (claudeCwds.has(cwd)) continue
+                claudeCwds.add(cwd)
+                // ⚠️ reason を省くと stopSessionsFor の既定 "tui-bind-stop" が exit に載り、
+                // 画面から止めた会話が「tmux へ切り替えたせい」で消えたように見える。
+                target = { cwd, reason: STOP_ALL_REASON }
+                result.stopped += await ctx.claudeBridge.stopSessionsFor(target)
+              } else if (session.kind === "codex") {
+                const stream_id = session.stream_id
+                if (codexStreams.has(stream_id)) continue
+                codexStreams.add(stream_id)
+                target = { stream_id, reason: STOP_ALL_REASON }
+                result.stopped += await ctx.codexBridge.stopSessionForStream(target)
+              }
+            } catch (err) {
+              result.failed.push({ ...target, reason: err?.message || String(err) })
+            }
+          }
+        } catch (err) {
+          result.error = err?.message || String(err)
+        }
+        ctx.client.send(result)
+        return
+      }
+      case "chat.sessions.request": {
+        try {
+          const snapshot = await buildChatSessionsSnapshot({
+            bridges: { claudeBridge: ctx.claudeBridge, codexBridge: ctx.codexBridge },
+            logger: ctx.logger,
+          })
+          ctx.client.send({ type: "chat.sessions", request_id: msg.request_id, ...snapshot })
+        } catch (err) {
+          ctx.client.send({
+            type: "chat.sessions", request_id: msg.request_id, targets: [], live: [],
+            error: err?.message || String(err),
+          })
+        }
+        return
+      }
       case "tmux.list_sessions": {
         try {
           const snapshot = await tmuxSessionsSnapshotCache.get(async () => {
@@ -5569,8 +5816,30 @@ export async function dispatch(msg, ctx) {
         }
         const force = msg.force === true
         try {
-          const result = await removeWorktreeDir(name, { force })
-          if (result.dirty !== true) tmuxSessionsSnapshotCache.clear()
+          const removeWorktree = ctx._removeWorktreeDir || removeWorktreeDir
+          let result
+          let releaseRemoval
+          try {
+            result = await removeWorktree(name, {
+              force,
+              // ⚠️ 会話の停止は dir 削除の **前**に置く（removeWorktree 側の契約）。ここで渡さないと
+              // 会話が生きたまま cwd が消える。dirty で中止した場合は呼ばれない（削除しないのに
+              // 会話だけ止めない）。
+              stopSessions: (wtPath) => {
+                // ⚠️ 万一 2 回呼ばれても前の登録を漏らさない。beginRemoval は参照カウントなので、
+                // 解除し損ねるとそのパスへ以後 attach できなくなる（プロセスを再起動するまで）。
+                releaseRemoval?.()
+                releaseRemoval = beginRemoval(wtPath)
+                return stopChatSessionsUnder(wtPath, ctx)
+              },
+            })
+          } finally {
+            releaseRemoval?.()
+          }
+          if (result.dirty !== true) {
+            tmuxSessionsSnapshotCache.clear()
+            chatTargetsCache.clear()
+          }
           ctx.client.send({
             type: "worktree.remove.result",
             request_id: msg.request_id,
@@ -5580,6 +5849,11 @@ export async function dispatch(msg, ctx) {
             dirty: result.dirty === true,
             changes: result.changes || [],
             unpushed_commits: result.unpushed_commits || 0,
+            // ⚠️ 削除の前に **停止 API を呼んだ**会話の本数。「止まった本数」ではないので、
+            // 画面で成功件数として見せないこと（bridge は内部の停止失敗を握り潰すため、
+            // 止まったかどうかはこの経路では分からない。詳細は stopChatSessionsUnder の JSDoc）。
+            // 呼び出しそのものが失敗した場合は削除せず ok:false になるので、この応答には来ない。
+            stop_requested_sessions: result.stop_requested_sessions || 0,
           })
         } catch (err) {
           ctx.client.send({

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] }
+  }
+}