@cocorograph/hub-agent 0.8.114 → 0.8.116

package/src/main.mjs

@@ -55,6 +55,8 @@ import { AsyncTtlCache } from "./async-ttl-cache.mjs"
 import { makePersistentSeenInputIdRegistry } from "./seen-input-id-store.mjs"
 import { ClaudeStreamBridge } from "./claude-stream-bridge.mjs"
 import { installClaudeDisplayMask } from "./claude-display-mask.mjs"
+import { GrokStreamBridge } from "./grok-stream-bridge.mjs"
+import { resolveGrokBinary } from "./grok-binary.mjs"
 import { CodexMcpControl } from "./codex-mcp-control.mjs"
 import { CodexStreamBridge, classifyCodexInputError } from "./codex-stream-bridge.mjs"
 import { installCodexDisplayMask } from "./codex-result-mask.mjs"
@@ -280,7 +282,7 @@ export function withDeadline(promise, timeoutMs, onTimeout) {
  * WS 受信順 = pane 反映順を守るため false (= 直列キューに残す)。
  */
 export function isFastPathMessage(type) {
-  return type === "claude.interrupt" || type === "codex.interrupt"
+  return type === "claude.interrupt" || type === "codex.interrupt" || type === "grok.interrupt"
 }
 
 /**
@@ -316,7 +318,9 @@ export function isFastPathMessage(type) {
  */
 export function defaultLaneCwd(config, mode) {
   const configured = expandTilde(config?.claude_cwd || "") || ""
-  if (configured || mode !== "claude") return configured
+  // Grok は handler（handleGrokMessage の attach）もこの関数で補完する。scheduler と同じ値を
+  // 使わないと、cwd 省略の attach と HOME 指定の停止が別レーンへ散る。Codex の契約は変えない。
+  if (configured || (mode !== "claude" && mode !== "grok")) return configured
   return process.env.HOME || process.cwd()
 }
 
@@ -325,6 +329,7 @@ export function isReadOnlyRpc(type) {
     type === "claude.history.request" ||
     type === "claude.sessions.request" ||
     type === "codex.sessions.request" ||
+    type === "grok.sessions.request" ||
     type === "codex.history.request" ||
     type === "profile.list" ||
     type === "codex.profile.list" ||
@@ -580,7 +585,7 @@ export function _resetBundleSyncStateForTest() {
 /**
  * ある target（cli_kind）について、要求 version が既に反映済みかを判定する。
  *  - codex: mcp_approval_applied_version（無ければ installed_version）が要求以上
- *  - claude: installed_version が要求以上
+ *  - claude: installed_version と、Grok 導入済みなら grok_mcp_applied_version が要求以上
  * auto_update:false のときは「対象外（＝要求は満たされたものとして扱う＝同期しない）」を返す。
  */
 async function _bundleTargetSatisfied(cliKind, requestedVersion, readStateImpl, readConfigImpl) {
@@ -589,6 +594,10 @@ async function _bundleTargetSatisfied(cliKind, requestedVersion, readStateImpl,
   if (!requestedVersion) return false
   const filesVer = st.installed_version || "0.0.0"
   if (compareBundleVersions(filesVer, requestedVersion) < 0) return false
+  if (cliKind === "claude" && existsSync(process.env.GROK_HOME || path.join(os.homedir(), ".grok"))) {
+    const grokVer = st.grok_mcp_applied_version || "0.0.0"
+    if (compareBundleVersions(grokVer, requestedVersion) < 0) return false
+  }
   if (cliKind === "codex") {
     const approvalVer = st.mcp_approval_applied_version || "0.0.0"
     const approved = compareBundleVersions(approvalVer, requestedVersion) >= 0
@@ -708,6 +717,7 @@ export class DeferredRestartCoordinator {
   constructor({
     claudeBridge,
     codexBridge,
+    grokBridge,
     shutdown,
     logger,
     settleMs = 500,
@@ -719,6 +729,7 @@ export class DeferredRestartCoordinator {
   } = {}) {
     this.claudeBridge = claudeBridge
     this.codexBridge = codexBridge
+    this.grokBridge = grokBridge
     this.shutdown = shutdown
     this.logger = logger
     this.settleMs = settleMs
@@ -746,6 +757,7 @@ export class DeferredRestartCoordinator {
     return !!(
       this.claudeBridge?.hasActiveWork?.() ||
       this.codexBridge?.hasActiveWork?.() ||
+      this.grokBridge?.hasActiveWork?.() ||
       this.workProviders.some((provider) => provider?.hasActiveWork?.())
     )
   }
@@ -810,7 +822,45 @@ export class DeferredRestartCoordinator {
  * `restore:` 購読は browser に存在しないため、ここで捨てないと Hub へ幽霊 stream が流れる。
  * 起動処理から切り出してあるのは、この配線そのものをテストから通すため。
  */
-export function wireBridgeEvents(client, { claudeBridge, codexBridge }) {
+export function wireBridgeEvents(client, { claudeBridge, codexBridge, grokBridge, logger: bridgeLogger = logger }) {
+  if (grokBridge) {
+    grokBridge.on("grok_event", ({ stream_id, session_id, seq, update }) => {
+      sendBridgeMessage(client, { type: "grok.event", stream_id, thread_id: session_id, seq, event: update })
+    })
+    grokBridge.on("grok_permission", ({ stream_id, request_id, params }) => {
+      sendBridgeMessage(client, { type: "grok.permission.request", stream_id,
+        thread_id: grokBridge.getThreadId(stream_id), request_id, params })
+    })
+    // ターン終了・中断で破棄した承認待ち。browser はこれで該当カードを閉じる。
+    grokBridge.on("grok_permission_cancelled", ({ stream_id, session_id, request_ids }) => {
+      sendBridgeMessage(client, { type: "grok.permission.cancelled", stream_id,
+        ...(typeof session_id === "string" && session_id ? { thread_id: session_id } : {}), request_ids })
+    })
+    // last_seq: 切断中に捨てた本文 chunk（ws-client）の末尾欠落を、後続 update が無くても browser が
+    // 検知できるようにする。受信済み seq より大きければ再 attach して history を取り直す。
+    const lastSeqField = (lastSeq) => (Number.isInteger(lastSeq) ? { last_seq: lastSeq } : {})
+    // thread_id: backend が同じ会話を開いている他端末へ fan-out するために要る（Codex の event と同じ）。
+    const threadField = (sessionId) => (typeof sessionId === "string" && sessionId ? { thread_id: sessionId } : {})
+    grokBridge.on("grok_queue_state", ({ stream_id, session_id, queue_state }) => {
+      sendBridgeMessage(client, { type: "grok.queue.state", stream_id, ...threadField(session_id), queue_state })
+    })
+    grokBridge.on("grok_turn_complete", ({ stream_id, session_id, stopReason, lastSeq }) => {
+      sendBridgeMessage(client, { type: "grok.turn.complete", stream_id, ...threadField(session_id),
+        stop_reason: stopReason, ...lastSeqField(lastSeq) })
+    })
+    grokBridge.on("grok_exit", ({ stream_id, session_id, reason, code, lastSeq }) => {
+      sendBridgeMessage(client, { type: "grok.exit", stream_id, thread_id: session_id, reason,
+        ...(code !== undefined ? { code } : {}), ...lastSeqField(lastSeq) })
+    })
+    grokBridge.on("grok_error", ({ stream_id, session_id, message, lastSeq }) => {
+      if (!stream_id) {
+        bridgeLogger?.warn?.({ err: message }, "grok bridge error without stream")
+        return
+      }
+      sendBridgeMessage(client, { type: "grok.error", stream_id, ...threadField(session_id), error: message,
+        ...lastSeqField(lastSeq) })
+    })
+  }
   // stream-json モード (Sprint G): Claude Code を SDK 経由で起動し、stream イベントを
   // そのまま browser に転送する。SDK 未インストール時は claudeBridge=null で全 attach が
   // claude.error を返す経路に分岐 (dispatch 側で判定)。
@@ -962,6 +1012,21 @@ export async function applyStartupEnv({ logger, deps = {} }) {
   }
 }
 
+// ACP のプロセスグループ停止期限とは別に、daemon 終了の待機上限を設ける。
+export async function shutdownGrokBridge(grokBridge, logger, timeoutMs = 6_000) {
+  if (!grokBridge) return
+  try {
+    const result = await withDeadline(
+      Promise.resolve().then(() => grokBridge.shutdown()),
+      timeoutMs,
+      () => logger?.warn?.({ timeout: true }, "grok shutdown incomplete"),
+    )
+    if (result?.unreaped > 0) logger?.warn?.(result, "grok shutdown incomplete")
+  } catch (err) {
+    logger?.warn?.({ err: err?.message }, "grok shutdown failed")
+  }
+}
+
 export async function startDaemon({ version, claudeSdk } = {}) {
   const logRotationTimer = startLogRotation(logger, { isDeferred: hasInheritedOutputChild })
   startEventLoopMetrics(logger)
@@ -1023,6 +1088,10 @@ export async function startDaemon({ version, claudeSdk } = {}) {
   // codex app-server ベースの chat ブリッジ。resolver は各 spawn 時に再評価するため、
   // daemon 起動時に一時的に unavailable でも bridge 自体は保持する。
   const codexBridge = new CodexStreamBridge({ logger })
+  const grokBridge = availableClis.includes("grok")
+    ? new GrokStreamBridge({ grokCmd: resolveGrokBinary().path, logger })
+    : null
+  ctx.grokBridge = grokBridge
 
   // Codex の MCP 状態 control (agent-global, セッション非依存)。MCP は ~/.codex/config.toml
   // = アカウント単位の設定で全セッション共有のため、claudeBridge の「MCP control 専用
@@ -1095,7 +1164,7 @@ export async function startDaemon({ version, claudeSdk } = {}) {
     logger.warn({ err: err.message }, "ws client error (will retry via close handler)")
   })
 
-  wireBridgeEvents(client, { claudeBridge, codexBridge })
+  wireBridgeEvents(client, { claudeBridge, codexBridge, grokBridge, logger })
 
   // Hub からのメッセージ dispatch は、接続世代 + 機能レーン単位で直列実行する。
   //
@@ -1116,6 +1185,7 @@ export async function startDaemon({ version, claudeSdk } = {}) {
     client,
     claudeBridge,
     codexBridge,
+    grokBridge,
     codexMcpControl,
     uploadManager,
   }
@@ -1148,7 +1218,7 @@ export async function startDaemon({ version, claudeSdk } = {}) {
   }, 60_000)
 
   // 会話の回収と常駐数制限を定期実行する。
-  const stateLoop = startStateLoop({ client, logger, intervalMs: 5_000, claudeBridge, codexBridge })
+  const stateLoop = startStateLoop({ client, logger, intervalMs: 5_000, claudeBridge, codexBridge, grokBridge })
   // bundle hook (cockpit_session_event_hook.py) が /tmp/cockpit_session_events/<name>.json
   // に書き出す UserPromptSubmit / Stop / ready の event を fs.watch で拾って WS push する。
   // text マーカー判定 (detectStatusFromText) より精度が高い「ターン境界」の signal。
@@ -1164,9 +1234,10 @@ export async function startDaemon({ version, claudeSdk } = {}) {
   const siblingInjectBridge = new SiblingInjectBridge({
     claudeBridge,
     codexBridge,
+    grokBridge,
     logger,
     starter: ({ cwd, cliKind }) => ensureChatSession({
-      cwd, cliKind, bridges: { claudeBridge, codexBridge }, logger,
+      cwd, cliKind, bridges: { claudeBridge, codexBridge, grokBridge }, logger,
       resolveClaudeOptions: () => resolveClaudeAttachOptions(ctx.config),
     }),
     onRestartRequested: () => restartCoordinator.request(),
@@ -1209,6 +1280,7 @@ export async function startDaemon({ version, claudeSdk } = {}) {
     restartCoordinator?.stop?.()
     claudeBridge?.shutdown?.()
     codexBridge?.shutdown?.()
+    await shutdownGrokBridge(grokBridge, logger)
     // 受理済み input_id の保存を待ってから exit する（再起動後の再送で二重実行しないため）。
     const persistence = await waitForClaudeInputPersistence()
     if (persistence === "timeout") {
@@ -1223,6 +1295,7 @@ export async function startDaemon({ version, claudeSdk } = {}) {
   restartCoordinator = new DeferredRestartCoordinator({
     claudeBridge,
     codexBridge,
+    grokBridge,
     shutdown,
     logger,
     lifecycle,
@@ -1251,7 +1324,7 @@ export async function startDaemon({ version, claudeSdk } = {}) {
     )
   })
 
-  return { client, plugins, claudeBridge, codexBridge, codexMcpControl, uploadManager }
+  return { client, plugins, claudeBridge, codexBridge, grokBridge, codexMcpControl, uploadManager }
 }
 
 const SESSION_EVENTS_DIR =
@@ -1501,14 +1574,31 @@ export function withSortAffectingAt(snapshot, getSortAt = getSortAffectingAt) {
   const live = Array.isArray(snapshot?.live) ? snapshot.live : []
   return {
     ...snapshot,
-    live: live.map((item) => {
-      const name = typeof item?.session_name === "string" ? item.session_name : ""
-      const at = name ? getSortAt(name) : undefined
-      return typeof at === "number" && at > 0 ? { ...item, sort_affecting_at: at } : item
-    }),
+    live: live.map((item) => attachSortAffectingAt(item, getSortAt)),
   }
 }
 
+/** 1 行 (`session_name` を持つ) に送信時刻を載せる。chat.sessions と sidebar_snapshot で共有する。 */
+function attachSortAffectingAt(item, getSortAt) {
+  const name = typeof item?.session_name === "string" ? item.session_name : ""
+  const at = name ? getSortAt(name) : undefined
+  return typeof at === "number" && at > 0 ? { ...item, sort_affecting_at: at } : item
+}
+
+/**
+ * `chat.sidebar_snapshot.response` の各行に、その行の「最後にユーザーが送信した時刻」
+ * (`sort_affecting_at`) を載せる。
+ *
+ * `chat.sessions` は live な会話にしか送信時刻を載せない。サイドバーは、ユーザーが×で閉じて
+ * いないのにプロセスが落ちて一覧から消えた会話も「起きている」段に残して送信時刻順に並べる
+ * ため、再読み込み後はここでしか送信時刻を復元できない (2026-10-24)。
+ * 値は withSortAffectingAt と同じ (sidecar で永続化済みのもの)。送信履歴の無い行は
+ * キーごと付けない。
+ */
+export function withSnapshotSortAt(messages, getSortAt = getSortAffectingAt) {
+  return (Array.isArray(messages) ? messages : []).map((item) => attachSortAffectingAt(item, getSortAt))
+}
+
 // sort 時刻 sidecar の接尾辞。`.json` にしない (readAllSessionEvents / pushFile が
 // `.endsWith(".json")` で event ファイルと誤認しないように)。
 const SORT_AT_SUFFIX = ".sortat"
@@ -2160,7 +2250,7 @@ export function decideTurnActiveSource({
   return "none"
 }
 
-export function startStateLoop({ client, logger, intervalMs, claudeBridge, codexBridge }) {
+export function startStateLoop({ client, logger, intervalMs, claudeBridge, codexBridge, grokBridge }) {
   // 総 live 上限 M のログ抑制状態。⚠️ **この state loop インスタンスが所有する**（module-global に
   // 置くと、複数インスタンスや並行テストが互いのログを抑制してしまう）。「超過しているが全部
   // 保護されていて刈れない」tick は 5 秒ごとに同じ行を出し続けるので、状態が変わったときと
@@ -2203,12 +2293,17 @@ export function startStateLoop({ client, logger, intervalMs, claudeBridge, codex
       } catch (err) {
         logger?.warn({ err: err?.message }, "gcAbandonedSessions failed")
       }
+      try {
+        grokBridge?.gcAbandonedSessions?.()
+      } catch (err) {
+        logger?.warn?.({ err: err?.message }, "grok gcAbandonedSessions failed")
+      }
       // 総 live 上限 M（claude + codex 合算、既定 20）。per-cwd を 1 → K（既定 3）へ緩めたぶん、
       // cwd 単位の境界だけでは総量が膨らむため、cwd をまたいだ天井をここで適用する。
       // ⚠️ 両 CLI の reconcile が **終わった後**に呼ぶ（cwd 単位で畳んだ結果の生存数で判定する）。
       try {
         enforceTotalLiveBound({
-          bridges: [claudeBridge, codexBridge].filter(Boolean),
+          bridges: [claudeBridge, codexBridge, grokBridge].filter(Boolean),
           logger,
           logState: warmBoundsLogState,
         })
@@ -2402,7 +2497,7 @@ export function handleStreamsSyncResponse(msg, ctx) {
   const activeIds = new Set(
     Array.isArray(msg?.active_stream_ids) ? msg.active_stream_ids : [],
   )
-  const activeByMode = { claude: new Set(), codex: new Set() }
+  const activeByMode = { claude: new Set(), codex: new Set(), grok: new Set() }
   const classifiedIds = new Set()
   if (Array.isArray(msg?.active_streams)) {
     for (const item of msg.active_streams) {
@@ -2440,6 +2535,14 @@ export function handleStreamsSyncResponse(msg, ctx) {
         ctx.logger,
       )
     }
+    if (activeByMode.grok.size > 0) {
+      pruneInactiveChatSubscribers(
+        ctx.grokBridge,
+        activeByMode.grok,
+        "grok",
+        ctx.logger,
+      )
+    }
   }
 }
 
@@ -2495,6 +2598,7 @@ export function resetSeenClaudeChatInputIdsForTest() {
   seenClaudeChatInputIds = makePersistentSeenInputIdRegistry(SEEN_INPUT_IDS_MAX)
 }
 const seenCodexChatInputIds = makeSeenInputIdRegistry()
+const seenGrokChatInputIds = makeSeenInputIdRegistry()
 
 /**
  * 通常終了（SIGTERM・安全な再起動）の直前に、処理中の claude.input と受理済み ID の保存を待つ。
@@ -2888,6 +2992,126 @@ export function buildAttachHistoryPromise({
     }))
 }
 
+/**
+ * 要求の失敗を、bridge が通知するターンの失敗（phase なし）と区別する印。
+ * attach は接続そのものの失敗。それ以外の要求の失敗はターンを終わらせない（browser はターン終了に使わない）。
+ */
+function grokRequestPhase(type) {
+  return type === "grok.attach" ? { phase: "attach" } : { phase: "request", request_type: type }
+}
+
+export async function handleGrokMessage(msg, ctx) {
+  const bridge = ctx.grokBridge
+  const stream_id = msg.stream_id
+  const send = (payload) => ctx.client.send({ ...payload, stream_id })
+  if (msg.type === "grok.queue.cancel") {
+    const response = { type: "grok.queue.response", request_id: msg.request_id || null, input_id: msg.id || null }
+    let canceled
+    try {
+      canceled = bridge?.cancelQueued({ stream_id, id: msg.id })
+    } catch (err) {
+      ctx.logger?.warn?.(
+        { err: err?.message, stream_id, input_id: msg.id },
+        "grok queued input cancel failed",
+      )
+      send({ ...response, error: err?.message || "cancel_failed" })
+      return
+    }
+    send({ ...response, outcome: canceled?.outcome || "stream_missing" })
+    canceled?.flush?.()
+    return
+  }
+  if (msg.type === "grok.sessions.request") {
+    const cwd = msg.cwd || ""
+    const epoch = typeof msg.epoch === "number" ? msg.epoch : undefined
+    const response = { type: "grok.sessions.response", cwd, epoch, sessions: [], session_operations: false }
+    try {
+      if (!bridge) throw new Error("grok_unavailable")
+      const rows = await bridge.listThreads({ cwd, limit: typeof msg.limit === "number" ? msg.limit : undefined })
+      const liveByThread = new Map(bridge.describeLiveSessions(cwd).map((s) => [s.thread_id, s]))
+      response.sessions = rows.filter((row) => typeof row?.sessionId === "string").map((row) => {
+        const updated = Date.parse(row.updatedAt)
+        const live = liveByThread.get(row.sessionId)
+        return { thread_id: row.sessionId, cwd: row.cwd ?? cwd,
+          preview: typeof row.title === "string" ? row.title : "",
+          updated_at_ms: Number.isFinite(updated) ? updated : null,
+          live: !!live, busy: !!live?.busy }
+      })
+    } catch (err) {
+      response.error = err?.message || String(err)
+    }
+    send(response)
+    return
+  }
+  if (!bridge) {
+    // Codex と同じく、input_id 付きの入力には NACK を返す（返さないと browser の再送が止まらない）。
+    const input_id = msg.type === "grok.input" && typeof msg.input_id === "string" && msg.input_id ? msg.input_id : null
+    if (input_id) send({ type: "grok.input.nack", input_id, reason: "stream_missing" })
+    else send({ type: "grok.error", error: "grok_unavailable", ...grokRequestPhase(msg.type) })
+    return
+  }
+  if (msg.type === "grok.input") {
+    const input_id = typeof msg.input_id === "string" && msg.input_id ? msg.input_id : null
+    if (input_id && seenGrokChatInputIds.has(input_id)) {
+      send({ type: "grok.input.ack", input_id })
+      return
+    }
+    try {
+      const rejection = inputLifecycleRejection(ctx)
+      if (rejection) throw new Error(rejection.reason)
+      // 受付は同期で完了するため、ターン処理中の再送も上の受理済み ID で除外する。
+      // ターンの失敗は bridge が監視し、grok_error で通知する。
+      bridge.input({ stream_id, message: msg.message, inputId: input_id || undefined,
+        model: msg.model, effort: msg.effort })
+      if (input_id) {
+        seenGrokChatInputIds.remember(input_id)
+        send({ type: "grok.input.ack", input_id })
+      }
+    } catch (err) {
+      if (input_id) send({ type: "grok.input.nack", input_id, reason: err?.message || String(err) })
+      else send({ type: "grok.error", error: err?.message || String(err), ...grokRequestPhase(msg.type) })
+    }
+    return
+  }
+  if (msg.type === "grok.interrupt") {
+    try {
+      await bridge.interrupt({ stream_id })
+      send({ type: "grok.interrupt.response", ok: true })
+    } catch (err) {
+      send({ type: "grok.interrupt.response", ok: false, error: err?.message || String(err) })
+    }
+    return
+  }
+  try {
+    switch (msg.type) {
+      case "grok.attach": {
+        // claude_cwd → HOME の補完。scheduler のレーン分類と同じ defaultLaneCwd を使う。
+        const cwd = msg.cwd || defaultLaneCwd(ctx.config, "grok")
+        const info = await bridge.attach({ stream_id, cwd, model: msg.model, effort: msg.effort,
+          resumeSessionId: msg.resume_session_id, attachId: msg.attach_id })
+        send({ type: "grok.ready", thread_id: info.sessionId, resuming: info.resuming,
+          warm: info.warm, history: info.history, history_truncated: info.historyTruncated,
+          last_seq: info.lastSeq, turn_active: info.turnActive,
+          queue_state: info.queueState, supports_queue_cancel_response: true })
+        break
+      }
+      case "grok.permission.reply":
+        await bridge.permissionReply({ stream_id, request_id: msg.request_id, result: msg.result })
+        break
+      case "grok.detach":
+        await bridge.detach({ stream_id })
+        break
+      case "grok.keepalive":
+        await bridge.keepalive({ stream_id })
+        break
+    }
+  } catch (err) {
+    // phase: "attach" は接続そのものの失敗（backend はこの stream の登録を外す）。それ以外の要求の
+    // 失敗とターン失敗（bridge の grok_error）は会話が続くので、登録を外させない。
+    send({ type: "grok.error", error: err?.message || String(err), ...grokRequestPhase(msg.type) })
+  }
+}
+
 /**
  * SDK チャット配達保証 (S2, 2026-07-05): `codex.input` を処理し、browser が付与した
  * `input_id` があれば `codex.input.ack` / `codex.input.nack` を返す (claude.input と
@@ -3437,9 +3661,11 @@ export async function stopChatSessionsUnder(dir, ctx, reason = "worktree-remove"
   const live = describeLiveSessionsUnion({
     claudeBridge: ctx.claudeBridge,
     codexBridge: ctx.codexBridge,
+    grokBridge: ctx.grokBridge,
   })
   const claudeCwds = new Set()
   const codexStreams = new Set()
+  const grokStreams = new Set()
   let stopped = 0
   // ⚠️ 例外を捕まえない。投げれば removeWorktree がその場で中断し、dir は残る (= 削除しない)。
   // 「失敗した分を集めて最後にまとめて投げる」形も書けるが、削除しないのであれば残りを止める
@@ -3460,6 +3686,10 @@ export async function stopChatSessionsUnder(dir, ctx, reason = "worktree-remove"
         stream_id: session.stream_id,
         reason,
       })
+    } else if (session.kind === "grok") {
+      if (grokStreams.has(session.stream_id)) continue
+      grokStreams.add(session.stream_id)
+      stopped += await ctx.grokBridge.stopSessionForStream({ stream_id: session.stream_id, reason })
     }
   }
   return stopped
@@ -4014,6 +4244,16 @@ export async function dispatch(msg, ctx) {
       // async (claude 版は SDK 呼び出しが同期/fire-and-forget)。失敗時は codex.error で
       // browser に伝える。permission.reply の result は method ごとに shape が異なる
       // (accept/decline 等) ため、正規化せず browser が組み立てたものをそのまま渡す。
+      case "grok.attach":
+      case "grok.input":
+      case "grok.queue.cancel":
+      case "grok.interrupt":
+      case "grok.permission.reply":
+      case "grok.detach":
+      case "grok.keepalive":
+      case "grok.sessions.request":
+        await handleGrokMessage(msg, ctx)
+        return
       case "codex.attach": {
         const stream_id = msg.stream_id
         if (!ctx.codexBridge || !codexAvailableForDispatch(ctx)) {
@@ -4094,55 +4334,57 @@ export async function dispatch(msg, ctx) {
         }
         return
       }
+      case "grok.upload":
       case "codex.upload": {
-        // B4 (T05699 残タスク, 2026-07-04): Cockpit Codexチャットの添付ファイル受信
-        // (チャンク1件)。claude.upload と同じ UploadManager を再利用する (cwd ベースで
-        // CLI 非依存の実装のため無改修で流用可能)。全チャンク到着で cwd 配下の
-        // .cockpit-uploads/<日付>/ に保存し、保存パスを browser へ返す。browser は
-        // そのパスを codex.input 本文に載せ、Codex がシェル/ファイルツールで読む
-        // (Claude 版と同じ「パス参照方式」、Codex 側の model/effort 分離と同様に
-        // アカウント/プロトコルが違うだけでファイル保存の仕組みは共有する)。
-        if (!ctx.uploadManager) {
-          ctx.client.send({
-            type: "codex.upload.done",
-            stream_id: msg.stream_id,
-            upload_id: msg.upload_id,
-            ok: false,
-            error: "upload_unavailable",
-          })
-          return
-        }
-        try {
-          const res = await ctx.uploadManager.addChunk({
-            upload_id: msg.upload_id,
-            filename: msg.filename,
-            media_type: msg.media_type,
-            total_size: msg.total_size,
-            total_chunks: msg.total_chunks,
-            chunk_index: msg.chunk_index,
-            data: msg.data,
-            cwd: msg.cwd || ctx.config?.claude_cwd || undefined,
-          })
-          if (res.done) {
+        // パス参照方式の添付受信を共有し、返信型と既定 cwd だけを切り替える。
+        async function handleUpload(doneType, getDefaultCwd) {
+          if (!ctx.uploadManager) {
             ctx.client.send({
-              type: "codex.upload.done",
+              type: doneType,
               stream_id: msg.stream_id,
               upload_id: msg.upload_id,
-              ok: true,
-              path: res.path,
-              filename: res.filename,
-              media_type: res.media_type,
-              size: res.size,
+              ok: false,
+              error: "upload_unavailable",
             })
+            return
           }
-        } catch (err) {
-          ctx.client.send({
-            type: "codex.upload.done",
-            stream_id: msg.stream_id,
-            upload_id: msg.upload_id,
-            ok: false,
-            error: err?.message || String(err),
-          })
+          try {
+            const res = await ctx.uploadManager.addChunk({
+              upload_id: msg.upload_id,
+              filename: msg.filename,
+              media_type: msg.media_type,
+              total_size: msg.total_size,
+              total_chunks: msg.total_chunks,
+              chunk_index: msg.chunk_index,
+              data: msg.data,
+              cwd: msg.cwd || getDefaultCwd(),
+            })
+            if (res.done) {
+              ctx.client.send({
+                type: doneType,
+                stream_id: msg.stream_id,
+                upload_id: msg.upload_id,
+                ok: true,
+                path: res.path,
+                filename: res.filename,
+                media_type: res.media_type,
+                size: res.size,
+              })
+            }
+          } catch (err) {
+            ctx.client.send({
+              type: doneType,
+              stream_id: msg.stream_id,
+              upload_id: msg.upload_id,
+              ok: false,
+              error: err?.message || String(err),
+            })
+          }
+        }
+        if (msg.type === "grok.upload") {
+          await handleUpload("grok.upload.done", () => defaultLaneCwd(ctx.config, "grok"))
+        } else {
+          await handleUpload("codex.upload.done", () => ctx.config?.claude_cwd || undefined)
         }
         return
       }
@@ -4779,11 +5021,13 @@ export async function dispatch(msg, ctx) {
         try {
           if (msg.scope === "cwd") {
             const cwd = typeof msg.cwd === "string" ? msg.cwd : ""
-            if (msg.cli_kind !== "claude" && msg.cli_kind !== "codex") result.error = "unsupported cli_kind"
+            if (msg.cli_kind !== "claude" && msg.cli_kind !== "codex" && msg.cli_kind !== "grok") result.error = "unsupported cli_kind"
             else if (!cwd || !path.isAbsolute(cwd)) result.error = "cwd required"
             else if (msg.cli_kind === "claude") {
               noteRestoreStop(ctx.sessionRestoreState, "claude", cwd)
               result.stopped = await ctx.claudeBridge.stopSessionsFor({ cwd, reason: "chat-stop" })
+            } else if (msg.cli_kind === "grok") {
+              result.stopped = await ctx.grokBridge?.stopSessionsForCwd({ cwd, reason: "chat-stop" }) ?? 0
             } else {
               noteRestoreStop(ctx.sessionRestoreState, "codex", cwd)
               result.stopped = await ctx.codexBridge.stopSessionsForCwd({ cwd, reason: "chat-stop" })
@@ -4801,6 +5045,9 @@ export async function dispatch(msg, ctx) {
               noteRestoreStop(ctx.sessionRestoreState, "claude", cwd)
               result.stopped = await ctx.claudeBridge.stopSessionForDeletion({ cwd, session_id, reason: "chat-stop" })
             }
+          } else if (msg.cli_kind === "grok") {
+            if (typeof msg.stream_id !== "string" || !msg.stream_id) result.error = "stream_id required"
+            else result.stopped = await ctx.grokBridge?.stopSessionForStream({ stream_id: msg.stream_id, reason: "chat-stop" }) ?? 0
           } else if (msg.cli_kind === "codex") {
             if (typeof msg.stream_id !== "string" || !msg.stream_id) result.error = "stream_id required"
             else {
@@ -4822,7 +5069,7 @@ export async function dispatch(msg, ctx) {
       case "chat.sessions.request": {
         try {
           const snapshot = await buildChatSessionsSnapshot({
-            bridges: { claudeBridge: ctx.claudeBridge, codexBridge: ctx.codexBridge },
+            bridges: { claudeBridge: ctx.claudeBridge, codexBridge: ctx.codexBridge, grokBridge: ctx.grokBridge },
             logger: ctx.logger,
           })
           ctx.client.send({ type: "chat.sessions", request_id: msg.request_id, ...withSortAffectingAt(refreshChatSessionsSignals(snapshot, ctx.logger)) })
@@ -4836,10 +5083,10 @@ export async function dispatch(msg, ctx) {
       }
       case "chat.sidebar_snapshot.request": {
         try {
-          const messages = await readSidebarMessageSnapshot(msg.targets, {
+          const messages = withSnapshotSortAt(await readSidebarMessageSnapshot(msg.targets, {
             claudeBridge: ctx.claudeBridge,
             codexBridge: ctx.codexBridge,
-          })
+          }))
           ctx.client.send({
             type: "chat.sidebar_snapshot.response",
             request_id: msg.request_id,

package/src/review-event-store.mjs

@@ -17,7 +17,7 @@ export function validReviewEvent(event) {
   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 (!["claude", "codex", "grok"].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