@cocorograph/hub-agent 0.7.105 → 0.8.1

package/src/main.mjs

@@ -37,7 +37,6 @@ import {
   resolveSyncTargets,
   syncBundleTargets,
 } from "./hub-bundle.mjs"
-import { extractLastAssistantText, pickContextText } from "./extract-paragraph.mjs"
 import { loadPlugins, runHookBroadcast, runHookChain } from "./plugin-loader.mjs"
 import { WsClient } from "./ws-client.mjs"
 import { PtyBridge } from "./pty-bridge.mjs"
@@ -47,11 +46,9 @@ import { CodexStreamBridge, classifyCodexInputError } from "./codex-stream-bridg
 import { UploadManager } from "./claude-upload.mjs"
 import { requestSelfUninstall } from "./service-install.mjs"
 import {
-  decideSessionRotation,
   fetchSessionHistory,
   jsonlPath,
   listSessions,
-  validateRotationCandidate,
 } from "./claude-history.mjs"
 import { listAgents } from "./agents.mjs"
 import { listSkills } from "./skills.mjs"
@@ -61,7 +58,6 @@ import {
   detectSessionState,
   invalidateSessionCache,
   listSessionStates,
-  resolveBindSnapshotStatus,
   StallTracker,
 } from "./state.mjs"
 import {
@@ -72,6 +68,7 @@ import {
   getActiveProfile,
   getActiveProjectsRoot,
   readProfileAccount,
+  resolveProjectsRoot,
   setActiveProfile,
   addProfile,
   renameProfile,
@@ -84,36 +81,22 @@ import {
   profileHasKeychainCredentials,
 } from "./claude-credentials.mjs"
 import {
-  answerAskUserQuestion,
   buildClaudeCmd,
   createSession as createTmuxSession,
   createWorktreeDir,
-  cyclePermissionMode,
   execTmux,
   killManySessions,
   killSession as killTmuxSession,
   listSessions as listTmuxSessions,
   listWorktreeNameHistory,
   listWorktreeStubs,
-  isPaneRunningClaude,
   paneClaudeAliveOrUnknown,
-  rebindClaudeSession,
-  shouldSkipRebindRespawn,
-  recoverTuiInput,
   removeWorktree as removeWorktreeDir,
-  resumeWithMessage,
-  pasteToSessionByName,
-  sendInterruptKey,
   setSessionMouse,
   setTmuxGlobalEnv,
-  setTuiEffort,
-  setTuiModel,
   startTerminalMirror,
   stopTerminalMirror,
 } from "./tmux.mjs"
-import { TuiPermissionBridge } from "./tui-permission-bridge.mjs"
-import { TuiViewerRegistry } from "./tui-viewer-registry.mjs"
-import { JsonlLiveWatchers } from "./jsonl-live-watchers.mjs"
 import { SiblingInjectBridge } from "./sibling-inject.mjs"
 import {
   boundSessionId,
@@ -153,27 +136,6 @@ import { hydrateProcessEnvFromShell } from "./shell-env.mjs"
 
 const logger = pino({ name: "hub-agent" })
 
-// 遅延回答 resume: 書き込んだ .decision がフックに消費されない (= フック死亡) かを
-// 判定する猶予 (ms)。生存フックは ~0.15s で消費するので 2s 残れば死亡とみなす。
-const RESUME_DECISION_GRACE_MS = 2000
-// resume の二重実行防止 (request_id -> 実施時刻ms)。低頻度なので Map で十分。
-const _tuiResumed = new Map()
-function _markResumed(requestId) {
-  const now = Date.now()
-  // 古い項目を掃除 (10 分超)。
-  for (const [id, at] of _tuiResumed) {
-    if (now - at > 600000) _tuiResumed.delete(id)
-  }
-  if (_tuiResumed.has(requestId)) return false
-  _tuiResumed.set(requestId, now)
-  return true
-}
-/** 遅延回答を新メッセージとして tmux セッションへ届けて会話を再開する。 */
-async function _resumeTuiAnswer(sessionName, resumeText, requestId) {
-  if (!sessionName || !resumeText) return
-  if (!_markResumed(requestId)) return // 二重実行防止
-  await resumeWithMessage(sessionName, resumeText, { logger })
-}
 
 const BUNDLE_MANIFEST_PATH =
   process.env.HUB_BUNDLE_MANIFEST ||
@@ -365,7 +327,11 @@ export function isReadOnlyRpc(type) {
   return (
     type === "claude.history.request" ||
     type === "claude.sessions.request" ||
-    type === "codex.sessions.request"
+    type === "codex.sessions.request" ||
+    // T06603 (2026-07-25): キュー snapshot の pull。in-memory 配列を読むだけで副作用が無く、
+    // かつ「直列キュー前方の重い処理で再同期が遅延する」と送信待ちチップの固着が長引く
+    // (再同期は固着を直すための経路なので、詰まりやすい経路に置いてはならない)。
+    type === "claude.queue.request"
   )
 }
 
@@ -1190,50 +1156,17 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
   // ready-for-input 判定: claude プロセスの子プロセスを内省し「Stop フック/ツール実行が
   // 終わって真に入力可能になった」エッジを検出する (proc-introspect.mjs)。capture-pane は
   // Stop フック実行中を観測できないため、これが「stop の早期消灯/誤フラッシュ」の根治。
-  // TUI の tmux session_name → Claude session_id。state loop 起動より**前**に作る。
-  // 後で作ると state loop には undefined が渡り、バックグラウンド時だけ cwd 最新 JSONL
-  // へフォールバックして別会話の context% を表示する。
+  // state loop に渡す boundSessions (tmux session_name → session_id) の器。
+  // ⚠️ 純 SDK チャット化 (2026-07) で唯一の writer だった claude.tui.bind が消えたため、
+  // この Map は **常に空**。それでも state loop 起動より前に「空 Map として」用意する:
+  // undefined を渡すと state loop がバックグラウンド時に cwd 最新 JSONL へフォールバックして
+  // 別会話の context% を出す。空 Map なら boundSessionId が常に null を返し、
+  // resolveStateLoopBoundSessionId の「SDK チャットは bind 台帳を持たないので claudeBridge の
+  // ライブセッションへフォールバック」経路 (下記) が正しく効く。
   ctx.tuiReboundSessions = new Map()
 
   const readinessTracker = new ReadinessTracker()
-  // claude.tui.bind ハンドラが「生成中か (isArmed)」を参照して、生成中 claude を rebind の
-  // respawn-pane -k で kill する「謎停止」を防ぐ (生成中ガード)。
   ctx.readinessTracker = readinessTracker
-  // 【+新規 defer — 構造版 root 2026-06-22】busy (ターン進行中) のペインへ来た fresh (+新規) は
-  // respawn-pane -k で殺さず保留し、ready (ターン終了) で 1 回だけ実行する。
-  // session_name → {cwd, request_id, at, model, permissionMode}。
-  const pendingFreshRespawn = new Map()
-  ctx.pendingFreshRespawn = pendingFreshRespawn
-  // fresh respawn のスロットル: idle ペインへの remount storm (再マウント毎に新 request_id) で
-  // fresh が連打され new セッションを乱造するのを防ぐ。session_name → epoch ms。
-  const lastFreshRespawnAt = new Map()
-  ctx.lastFreshRespawnAt = lastFreshRespawnAt
-  // ready エッジで呼ばれ、保留中の +新規 を実行する (busy が解けたので非破壊)。
-  const flushDeferredFreshRespawn = async (name) => {
-    const pending = pendingFreshRespawn.get(name)
-    if (!pending) return
-    pendingFreshRespawn.delete(name)
-    if (Date.now() - pending.at > PENDING_FRESH_TTL_MS) {
-      logger.info({ session: name }, "tui rebind: deferred +new expired before ready, dropped")
-      return
-    }
-    try {
-      const rebind = await rebindClaudeSession(name, null, {
-        cwd: pending.cwd,
-        model: pending.model || "",
-        permissionMode: pending.permissionMode || "",
-        fresh: true,
-        busy: false,
-        logger,
-      })
-      if (rebind.ok) {
-        lastFreshRespawnAt.set(name, Date.now())
-        logger.info({ session: name }, "tui rebind: executed deferred +new after ready")
-      }
-    } catch (err) {
-      logger.warn({ session: name, err: err?.message }, "deferred +new respawn failed")
-    }
-  }
   const stateLoop = startStateLoop({
     client,
     plugins,
@@ -1269,79 +1202,8 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
     logger,
     tracker: readinessTracker,
     intervalMs: 700,
-    onReady: flushDeferredFreshRespawn,
   })
 
-  // TUI 権限ブリッジ: 対話 TUI の PreToolUse フックが書く権限要求を fs.watch で
-  // 拾い、既存 SDK 経路と同じ `claude.permission.request` として push する。
-  // 決定 (claude.permission.reply) は dispatch 側で request_id を見て
-  // tuiPermissionBridge.resolve() に優先ルーティングする。
-  const tuiPermissionBridge = new TuiPermissionBridge({ logger })
-  tuiPermissionBridge.on(
-    "permission",
-    async ({ request_id, session_id, cwd, tool_name, input, context_text }) => {
-      if (cwd) {
-        try {
-          // TUI 権限ブリッジ (PreToolUse フック) は Claude Code TUI 専用の経路なので
-          // 常に claude バケットへ記録する (T05945)。
-          recordChatActivity(cwd, "claude", { inputPending: true })
-        } catch {
-          /* ignore */
-        }
-      }
-      // ── 直前アシスタント説明の抽出 (症状4 根治) ─────────────────────────────
-      // PreToolUse フック発火時点で jsonl はまだ前ターン止まり (フックがブロック
-      // している間 claude は現ターンを jsonl に commit しない=デッドロック構造) の
-      // ため、フック側の transcript 抽出は前ターンの古い説明を掴む「取り違え」を
-      // 起こす。代わりに hub-agent がここで tmux capture-pane を打ち、TUI のペイン上
-      // に既に描画されている「現ターンの assistant 本文段落 (⏺ プレフィックス)」を
-      // 抜き出す。これが回答前に説明を届ける唯一の信頼ソースなので、フック由来の
-      // context_text の有無に関わらず **常に** capture-pane を試み、pickContextText で
-      // liveContext を最優先する (旧 bundle が古い context_text を送ってきても汚染
-      // しない)。抽出失敗時は null フォールバック (= 説明なし) で安全縮退。
-      let liveContext = null
-      if (cwd) {
-        try {
-          const sessions = await listTmuxSessions({ logger })
-          const match = Array.isArray(sessions)
-            ? sessions.find((s) => s && s.cwd === cwd)
-            : null
-          if (match && match.name) {
-            const pane = await capturePane(match.name, { noCache: true })
-            liveContext = extractLastAssistantText(pane)
-          }
-        } catch (err) {
-          logger?.debug?.(
-            { err: err?.message, cwd },
-            "capture-pane based context_text extraction failed; falling back to null",
-          )
-        }
-      }
-      client.send({
-        type: "claude.permission.request",
-        stream_id: null,
-        session_id,
-        cwd,
-        request_id,
-        tool_name,
-        input,
-        // 質問/承認カードの直前アシスタント説明 (browser がカード上部に表示)。
-        // 優先順位: (1) capture-pane で抽出した現ターンの liveContext、(2) フック由来
-        // の context_text (後方互換フォールバック)、(3) null。pickContextText 参照。
-        context_text: pickContextText(context_text, liveContext),
-      })
-    },
-  )
-  await tuiPermissionBridge.start()
-  ctx.tuiPermissionBridge = tuiPermissionBridge
-
-  // TUI 閲覧マーカー registry: browser の claude.tui.viewing ハートビートを受けて
-  // 「閲覧中の session」をローカルのマーカーファイルとして保持する。承認フックは
-  // その鮮度を見て「閲覧者がいる session だけブリッジ、いなければ即 ask」する
-  // (watcher ゲート, WATCHER-GATE.md)。
-  const tuiViewerRegistry = new TuiViewerRegistry({ logger })
-  await tuiViewerRegistry.start()
-  ctx.tuiViewerRegistry = tuiViewerRegistry
 
   // sibling-inject (ask-sibling スキル, 2026-07-04): 同一 cwd の claude⇄codex
   // 相互依頼のためのローカル IPC 受信口。cwd スコープ capability トークン
@@ -1351,44 +1213,6 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
   await siblingInjectBridge.start()
   ctx.siblingInjectBridge = siblingInjectBridge
 
-  // jsonl ライブ追従 (T04784 逐次表示): TUI チャットの閲覧ハートビートを起点に対象
-  // session の jsonl を tail し、追記行を claude.jsonl.event として逐次 push する。
-  // これで session.event 合図 → 全体再 hydrate + 2.5s ポーリングの「どさっと」を廃せる。
-  const jsonlLiveWatchers = new JsonlLiveWatchers({
-    send: (obj) => client.send(obj),
-    getProjectsRoot: getActiveProjectsRoot,
-    logger,
-    // ネイティブ回答検知 (症状1b 根治): tail 中の jsonl に tool_result が着弾し「あるツールが
-    // ターミナル側で解決された」と分かったら、その session の同名ツールの pending 権限カードを
-    // 畳み、browser へ claude.permission.cancel を送って残存カードを消す。browser が先に
-    // resolve() 済みなら _pending は既に空で dropBySession は [] を返す (= no-op、cancel も出ない)。
-    onToolResolved: ({ session_id, cwd, toolName }) => {
-      const dropped =
-        tuiPermissionBridge.dropBySession({ session_id, cwd, toolName }) || []
-      for (const request_id of dropped) {
-        try {
-          client.send({
-            type: "claude.permission.cancel",
-            request_id,
-            session_id,
-            cwd,
-            reason: "answered_in_terminal",
-          })
-        } catch {
-          /* ignore */
-        }
-      }
-      if (dropped.length) {
-        logger.info(
-          { session_id, cwd, tool: toolName, count: dropped.length },
-          "tui permission resolved natively → cancelled browser card",
-        )
-      }
-    },
-  })
-  jsonlLiveWatchers.start()
-  ctx.jsonlLiveWatchers = jsonlLiveWatchers
-
   // モデル能力レジストリ (2026-07-11): SDK supportedModels() を起動時に引き、effort
   // 対応可否の判定を正規表現ハードコードから権威データへ置き換える。能力はセッション中
   // 不変なので attach ごとには引き直さない。ただし control-only query は cold start 直後に
@@ -1409,21 +1233,12 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
     )
   }
 
-  // session 回転通知 (T04786 後続) の多重送信ガード: 回転キー (tmux 名 or cwd) →
-  // 最後に push した new_session_id。閲覧ハートビートは 5s 間隔で来るため、フロントが
-  // 切替を完了し new id でハートビートを送り直すまでの間に来る余分なハートビートで
-  // claude.session.rotated を連発しないようにする。
-  ctx.tuiRotationNotified = new Map()
-
   const shutdown = async (signal) => {
     logger.info({ signal }, "shutting down")
     await runHookBroadcast(plugins, "onAgentStop", ctx)
     stateLoop.stop()
     sessionEventLoop?.stop?.()
     readinessLoop?.stop?.()
-    tuiPermissionBridge.stop()
-    tuiViewerRegistry.stop()
-    jsonlLiveWatchers.stop()
     siblingInjectBridge.stop()
     ptyBridge.shutdown()
     claudeBridge?.shutdown?.()
@@ -2027,39 +1842,6 @@ async function startSessionEventWatcher({ client, logger, readinessTracker }) {
   }
 }
 
-/**
- * 【構造版 root 2026-06-22】idle ペインへの fresh remount storm を 1 回へ collapse する閾値。
- * 直近 fresh respawn からこの時間内の同一セッションへの fresh は idempotent な再送とみなす。
- */
-const FRESH_RESPAWN_THROTTLE_MS = 8_000
-/** busy で defer した +新規 の保留 TTL。ready が来ないまま席を立った等で破棄する。 */
-const PENDING_FRESH_TTL_MS = 600_000
-
-/**
- * 【構造版 root 2026-06-22】bind 時の即時 busy プローブ (プロセス実体)。
- * 「ターン進行中の claude を kill しない」判定の唯一の根拠にする。capture スクレイプや armed の
- * 140s cap の脆さに依存しない:
- *  - isArmed: prompt_submit→ready の間 true (生成中 + Stop フック中を含む)。一次シグナル。
- *  - 補強: pane_pid 子孫数 > 学習 baseline を ps スナップショットで直接確認 (armed cap / 未観測の
- *    隙間でも取りこぼさない)。baseline 未学習 (= ターン未観測の純 idle) は false (idle の +新規を妨げない)。
- * 判定不能時は安全側 false (= kill 許可) で idle の +新規 を妨げない。armed が一次防御なので、
- * 真にターン中なら isArmed=true でここに来る前に true を返す。
- */
-async function isPaneBusyNow(readinessTracker, name) {
-  if (!name || !readinessTracker) return false
-  if (readinessTracker.isArmed(name) === true) return true
-  try {
-    const panePid = await getPanePid(name)
-    if (!panePid) return false
-    const procMap = await snapshotProcs()
-    if (procMap.size === 0) return false
-    const baseline = readinessTracker.getBaseline(name)
-    if (baseline === null) return false
-    return busyChildCount(panePid, procMap) > baseline
-  } catch {
-    return false
-  }
-}
 
 /**
  * arm 済みセッション (prompt_submit / stop を受けた or busy 観測中) の claude プロセスを
@@ -3081,6 +2863,13 @@ const seenCodexChatInputIds = makeSeenInputIdRegistry()
 // Promise へ合流させる (settle 時に元の .then/.catch が 1 回だけ ack/nack を出す)。
 const codexInflightByInputId = new Map()
 
+// T06603 (2026-07-25): claude.input の **in-flight** dedup 用レジストリ (input_id -> Promise)。
+// 上の codex 版と同じ理由・同じ流儀。claude 側は sendMessage が resident query への
+// reconcile (applyFlagSettings の control request 往復) を await するため settle まで数秒
+// かかることがあり、その窓で ackWatchdog(5s) の再送が入ると `seen` 未登録のまま二重投入され、
+// 同一 input_id がキューに 2 件積まれて drain 後も 1 件残る (送信待ちチップが消えない)。
+const claudeInflightByInputId = new Map()
+
 /**
  * input_id 付き pty.data (tracked 入力) の処理。write 成功で pty.input.ack を返し、
  * stream 不在なら pty.error を返して browser の再 attach → 再送に繋げる。
@@ -3155,7 +2944,20 @@ export function handleClaudeChatInput(msg, ctx) {
     ctx.client.send({ type: "claude.input.ack", stream_id, input_id })
     return undefined
   }
-  return ctx.claudeBridge
+  if (input_id && claudeInflightByInputId.has(input_id)) {
+    // T06603 (2026-07-25): **処理中** の同一 input_id (browser の ackWatchdog が 5s で
+    // 再送してくるが、こちらはまだ settle していない窓)。codex 側は round4 major#1 で
+    // 対処済みだったが claude 側だけ欠けており、`seen` は settle 後にしか登録されないため
+    // 再送がそのまま二重投入されていた (同じ本文が 2 回実行され、かつ同一 id の項目が
+    // キューに 2 つ積まれて drain 後も 1 つ残る = 「実行されたのにキューから消えない」)。
+    // 既存 Promise へ合流させ、ack/nack は元の 1 回だけ出す。
+    ctx.logger?.info?.(
+      { stream_id, input_id },
+      "claude.input in-flight dedup (join, no re-dispatch)",
+    )
+    return claudeInflightByInputId.get(input_id)
+  }
+  const p = ctx.claudeBridge
     .input({
       stream_id,
       message: msg.message,
@@ -3194,23 +2996,55 @@ export function handleClaudeChatInput(msg, ctx) {
         })
       }
     })
+    .finally(() => {
+      // in-flight レジストリから外す (成功時は seen が以降の再送を dedup、
+      // 失敗時は再送で正当にリトライさせる)。codex 版と同じ流儀。
+      if (input_id) claudeInflightByInputId.delete(input_id)
+    })
+  if (input_id) claudeInflightByInputId.set(input_id, p)
+  return p
 }
 
 /**
  * claude.attach の ready 直後にpushする履歴を組み立てる。
  * Browserからの claude.history.request 往復を省くため、resume時だけ先回りして読む。
  * 失敗しても空のhistory.responseへ縮退し、attach自体を失敗させない。
+ *
+ * ⚠️ これは **agent 発の push** であり browser 発の read ではないため epoch を持たない
+ * (Read-plane 案C)。frontend の read ゲートは epoch 無しの応答を「版なしの先回り
+ * hydration」として扱い、現 view (profile/cwd/session) が一致するときだけ適用する。
+ *
+ * ⚠️ **read root と label は 1 回の解決結果から取る** (cross-review major1/nit2)。
+ * projects root (履歴を読む dir) と応答の profile_id ラベルを別々に解決すると、
+ * その間にプロファイル切替が挟まったとき「A と名乗る応答に B の履歴」が入りうる。
+ * これを API で表現するため、呼び出し側は `resolveProjectsRoot(profile_id)` を **1 回だけ**
+ * 解決し、その戻り値 `{projectsRoot, profileId}` を **単一の `resolved` として渡す**。
+ * root と label を別引数で受けないことで「別解決の混在」を構造的に不可能にする。
+ *
+ * @param {{projectsRoot:string, profileId?:string}} [resolved] 解決済みの root と profile を組で。
+ *   projectsRoot=履歴を読む dir、profileId=応答ラベル (省略時はラベルを載せない=後方互換)。
+ *   未指定なら active を 1 回解決してその root を使う (ラベルは載せない)。
+ * @param {(args:object)=>Promise<object>} [fetchHistoryFn] テスト用の履歴読取注入。
  */
 export async function loadClaudeAttachHistory({
   cwd,
   sessionId,
   logger,
-  getProjectsRootFn = getActiveProjectsRoot,
+  resolved,
   fetchHistoryFn = fetchSessionHistory,
 }) {
   if (!cwd || !sessionId) return null
+  const profileId = resolved?.profileId
+  const withProfile = (payload) =>
+    profileId ? { ...payload, profile_id: profileId } : payload
   try {
-    const projectsRoot = await getProjectsRootFn()
+    // root と label は必ず同一の `resolved` 由来。resolved 省略時のみ active を読む
+    // (この場合 profileId は無く、従来どおりラベル無し応答になる)。
+    // ⚠️ active root 解決も try 内で行う (公開前 major): fallback 解決が失敗しても
+    // 空 history.response へ縮退させ、attach を落とさない契約を守る。
+    const projectsRoot = resolved
+      ? resolved.projectsRoot
+      : await getActiveProjectsRoot()
     const result = await fetchHistoryFn({
       cwd,
       session_id: sessionId,
@@ -3218,7 +3052,7 @@ export async function loadClaudeAttachHistory({
       projectsRoot,
       logger,
     })
-    return {
+    return withProfile({
       type: "claude.history.response",
       session_id: sessionId,
       cwd,
@@ -3226,9 +3060,9 @@ export async function loadClaudeAttachHistory({
       total_lines: result.total_lines || 0,
       truncated: result.truncated === true,
       error: result.error,
-    }
+    })
   } catch (err) {
-    return {
+    return withProfile({
       type: "claude.history.response",
       session_id: sessionId,
       cwd,
@@ -3236,10 +3070,52 @@ export async function loadClaudeAttachHistory({
       total_lines: 0,
       truncated: false,
       error: err?.message || String(err),
-    }
+    })
   }
 }
 
+/**
+ * claude.attach の先回り履歴 push 用 promise を組み立てる。
+ *
+ * ⚠️ **この promise は決して reject しない** (公開前 major の契約)。`resolveProjectsRoot` を
+ * attach ハンドラの直列 await にも try にも載せると、`~/.hub/profiles.json` 破損・権限エラー等の
+ * 解決失敗で attach/ready ごと落ち (claude.error)、かつ registry 解決が ready 前の同期待ちになる。
+ * ここで非同期チェーンとして開始し、解決失敗は label 無しの空 `claude.history.response`(error 付き)
+ * へ縮退させる。root と label は 1 回の解決 (resolved) から取り (major1/nit2 の単一 resolved 不変
+ * 条件)、attach/ready を profile/read I/O から独立させる。
+ *
+ * @param {object} p
+ * @param {string|null} p.resumeSessionId resume 対象。null/空なら履歴を読まず null を返す。
+ * @param {string} p.cwd 履歴を読む cwd。
+ * @param {string} [p.profileId] read の profile ヒント (msg.profile_id)。resolveFn へ渡す。
+ * @param {(profileId?:string)=>Promise<{projectsRoot:string,profileId?:string}>} [p.resolveFn]
+ * @param {(args:object)=>Promise<object|null>} [p.loadFn]
+ * @returns {Promise<object|null>} history.response 相当 or null (fresh)。reject しない。
+ */
+export function buildAttachHistoryPromise({
+  resumeSessionId,
+  cwd,
+  logger,
+  profileId,
+  resolveFn = resolveProjectsRoot,
+  loadFn = loadClaudeAttachHistory,
+}) {
+  if (!resumeSessionId) return Promise.resolve(null)
+  return resolveFn(profileId)
+    .then((resolved) =>
+      loadFn({ cwd, sessionId: resumeSessionId, logger, resolved }),
+    )
+    .catch((err) => ({
+      type: "claude.history.response",
+      session_id: resumeSessionId,
+      cwd,
+      events: [],
+      total_lines: 0,
+      truncated: false,
+      error: err?.message || String(err),
+    }))
+}
+
 /**
  * SDK チャット配達保証 (S2, 2026-07-05): `codex.input` を処理し、browser が付与した
  * `input_id` があれば `codex.input.ack` / `codex.input.nack` を返す (claude.input と
@@ -3315,97 +3191,6 @@ export function handleCodexChatInput(msg, ctx) {
   return p
 }
 
-/**
- * 離席中キュー投入 (claude.tui.queue.flush) の冪等化用に、処理済み flush_id を記憶する。
- * WS 再送で同じ flush が二重に届いても二重 paste しないため。上限を超えたら全消去 (best-effort)。
- */
-const _seenFlushIds = new Set()
-const _SEEN_FLUSH_CAP = 2000
-
-/**
- * claude.tui.queue.flush の処理 (離席中キュー自動投入の agent 側受け口)。
- * ブラウザの常駐ドレイン (useCockpitTuiQueueDrainAll) が、表示していないセッションの送信待ち
- * キュー先頭 1 件をここへ送る。tmux send-keys (PTY 非依存) で投入するので、そのセッションの
- * ターミナルを誰も開いていなくても届く。結果を flush.ack で返し、ブラウザは ack を受けて
- * はじめて localStorage から 1 件 dequeue する。
- *
- * 冪等性は 2 段:
- *   1. flush_id 単位 (_seenFlushIds): WS 再送・ack 取りこぼしによる同一 flush の二重投入を防ぐ。
- *   2. 論理 item id 単位 (cross-path): browser の active 経路 (tracked PTY paste) は同一 item を
- *      input_id `qd:<itemId>:p` / `:r` で送る。ここと単一レジストリ (seenInputIds) を共有し、同一
- *      item がどちらの経路で配送されても agent は at-most-once でしか paste しない (二重送信の根治)。
- *
- * テストから直接呼べるよう dispatch から切り出して export する。paste 実体は ctx で差し替え可能。
- */
-export async function handleQueueFlush(msg, ctx) {
-  const paste = ctx.pasteToSessionByName || pasteToSessionByName
-  const sessionName =
-    typeof msg.session_name === "string" ? msg.session_name : ""
-  const text = typeof msg.text === "string" ? msg.text : ""
-  const flushId = typeof msg.flush_id === "string" ? msg.flush_id : ""
-  const itemId = typeof msg.item_id === "string" ? msg.item_id : ""
-  const pasteKey = itemId ? `qd:${itemId}:p` : ""
-  const crKey = itemId ? `qd:${itemId}:r` : ""
-  const ackFail = (reason) => {
-    if (flushId && sessionName) {
-      ctx.client.send({
-        type: "claude.tui.queue.flush.ack",
-        session_name: sessionName,
-        flush_id: flushId,
-        ok: false,
-        error: reason,
-      })
-    }
-  }
-  const ackOk = () => {
-    if (_seenFlushIds.size >= _SEEN_FLUSH_CAP) _seenFlushIds.clear()
-    _seenFlushIds.add(flushId)
-    ctx.client.send({
-      type: "claude.tui.queue.flush.ack",
-      session_name: sessionName,
-      flush_id: flushId,
-      ok: true,
-    })
-  }
-  if (!sessionName || !flushId || !text) {
-    ackFail("missing session_name / flush_id / text")
-    return
-  }
-  // 冪等化1 (message 再送)。
-  if (_seenFlushIds.has(flushId)) {
-    ackOk()
-    return
-  }
-  // 冪等化2 (cross-path): 同一 item を active 経路 (tracked PTY paste) が既に配送済みなら
-  // 再 paste せず ok を返す (browser は ack で dequeue する)。
-  if (pasteKey && seenInputIds.has(pasteKey)) {
-    ackOk()
-    return
-  }
-  // paste 前に cross-path キーを登録する。await 中に並走する active 経路の tracked paste
-  // (handleTrackedPtyData) を dedup させ二重 paste を防ぐため (登録は paste 完了より先)。
-  // 失敗時は登録解除し、再試行 (別 flush_id) で再配送できるようにする。
-  if (pasteKey) {
-    rememberInputId(pasteKey)
-    rememberInputId(crKey)
-  }
-  const result = await paste(sessionName, text, { logger: ctx.logger })
-  if (result.ok) {
-    if (_seenFlushIds.size >= _SEEN_FLUSH_CAP) _seenFlushIds.clear()
-    _seenFlushIds.add(flushId)
-  } else if (pasteKey) {
-    seenInputIds.delete(pasteKey)
-    seenInputIds.delete(crKey)
-  }
-  ctx.client.send({
-    type: "claude.tui.queue.flush.ack",
-    session_name: sessionName,
-    flush_id: flushId,
-    ok: !!result.ok,
-    error: result.ok ? undefined : result.error,
-  })
-}
-
 /**
  * tmux.kill_session の処理 (症状3 根治)。要求された session を kill し、要求元へ
  * tmux.kill_session.result を返したうえで、kill できた各 session について
@@ -3452,76 +3237,6 @@ export async function handleKillSession(msg, ctx) {
   }
 }
 
-/**
- * claude.tui.interrupt の処理 (確認付き中断 = Phase3)。生 ESC を tracked pty.data で best-effort
- * 送出する旧経路 (stream 欠落で無言ドロップ + ESC 到達でも止まったか未検証) を、agent が ESC を
- * tmux send-keys (PTY 非依存で確実配達) で送り、ペイン status で生成停止を観測してから結果を返す
- * 方式に置き換える。
- *
- * 不変条件: 中断指示は、claude と同一ホストで生成状態を観測できる agent が「停止を観測 or deadline」
- * まで責任を持つ。止まらなければ deadline 内で 1 度だけ ESC を再送する (初回が一過性 mode に吸われた
- * 場合の保険)。Ctrl+C へはエスカレーションしない (claude を終了させる事故を避けるため。別判断)。
- *
- * テストから直接呼べるよう export。送出 (sendInterruptKey) / 観測 (detectSessionState) / 待機 (delay)
- * は ctx で差し替え可能。
- */
-export async function handleTuiInterrupt(msg, ctx) {
-  const sessionName =
-    typeof msg.session_name === "string" ? msg.session_name : ""
-  const cwd = typeof msg.cwd === "string" ? msg.cwd : ""
-  const requestId = typeof msg.request_id === "string" ? msg.request_id : ""
-  if (!sessionName || !requestId) return
-  const sendEsc = ctx.sendInterruptKey || sendInterruptKey
-  const detect = ctx.detectSessionState || detectSessionState
-  const delay = ctx.delay || ((ms) => new Promise((r) => setTimeout(r, ms)))
-  // 症状⑤: 初回チェックまでの settle と poll 間隔を 350→150ms に詰め、maxPolls を 7→16 に
-  // 増やす。総 deadline は ~2.4s で従来(~2.5s)とほぼ同じだが、実際に停止した瞬間の観測が
-  // 約2倍速くなり「停止押下→画面が止まる」体感ラグを縮める。capture-pane スクレイプ回数は
-  // 増えるが 150ms 間隔なら許容範囲。Ctrl+C 非エスカレーション方針は不変。
-  const settleMs = ctx.interruptSettleMs ?? 150
-  const pollMs = ctx.interruptPollMs ?? 150
-  const maxPolls = ctx.interruptMaxPolls ?? 16 // ~2.4s deadline (150 + 150*15)
-  const reply = (stopped, attempts) =>
-    ctx.client.send({
-      type: "claude.tui.interrupt.result",
-      request_id: requestId,
-      session_name: sessionName,
-      cwd: cwd || undefined,
-      stopped: !!stopped,
-      attempts,
-    })
-  const stillProcessing = async () => {
-    try {
-      const snap = await detect(sessionName, { logger: ctx.logger })
-      return (snap?.status ?? "processing") === "processing"
-    } catch {
-      // capture 失敗時は判定不能 → 保守的に「まだ生成中かも」と扱う (誤って stopped=true にしない)。
-      return true
-    }
-  }
-  // 1) ESC 送出 (= 中断)。
-  await sendEsc(sessionName, { logger: ctx.logger })
-  let attempts = 1
-  let resent = false
-  // 2) 停止 (status が processing を離れる) を deadline 内で観測。
-  for (let i = 0; i < maxPolls; i++) {
-    await delay(i === 0 ? settleMs : pollMs)
-    if (!(await stillProcessing())) {
-      reply(true, attempts)
-      return
-    }
-    // deadline 中盤でまだ processing なら 1 度だけ ESC 再送 (初回が一過性 mode に吸われた保険)。
-    // status=processing 継続が条件なので、アイドル箱への二度押し (rewind ダイアログ誤爆) は避ける。
-    if (!resent && i >= Math.floor(maxPolls / 2)) {
-      resent = true
-      await sendEsc(sessionName, { logger: ctx.logger })
-      attempts++
-    }
-  }
-  // 3) deadline 到達でまだ processing。停止確認できず (frontend は旧 tracked-ESC 経路へ degrade)。
-  reply(false, attempts)
-}
-
 async function dispatch(msg, ctx) {
   const t = msg?.type || ""
   try {
@@ -3664,13 +3379,15 @@ async function dispatch(msg, ctx) {
           // attachは同期処理なので、履歴I/Oを先に開始してreadyまでの待ちを重ねる。
           // 新Browserはhistory_pushedを見て別requestを省略し、旧Browserは従来どおり
           // requestしてもhydrateのuuid dedupで安全に収束する。
-          const historyPromise = resumeSessionId
-            ? loadClaudeAttachHistory({
-                cwd: cwdArg || process.env.HOME || process.cwd(),
-                sessionId: resumeSessionId,
-                logger: ctx.logger,
-              })
-            : Promise.resolve(null)
+          // 案C ①/major1/nit2/公開前 major: 履歴 push を attach/ready から独立させる。
+          // resolveProjectsRoot を attach の直列 await/try に載せない (解決失敗で attach ごと
+          // 落とさない・ready を遅らせない)。詳細は buildAttachHistoryPromise の doc 参照。
+          const historyPromise = buildAttachHistoryPromise({
+            resumeSessionId,
+            cwd: cwdArg || process.env.HOME || process.cwd(),
+            logger: ctx.logger,
+            profileId: msg.profile_id,
+          })
           const info = ctx.claudeBridge.attach({
             stream_id,
             cwd: cwdArg,
@@ -3700,6 +3417,12 @@ async function dispatch(msg, ctx) {
             // 旧 agent にはこのフラグが無く、browser は楽観アイテムの×を出さない (ゴースト
             // 実行防止のフォールバック)。
             supports_queue_input_id: true,
+            // pull 型再同期 capability (T06603, 2026-07-25): この agent は
+            // claude.queue.request に claude.queue.response で答え、queue_state に
+            // 版番号 (seq) と受理済み input_id (accepted) を載せることを通知する。
+            // 旧 agent はこのフラグが無く、browser は従来の「配信到達に依存する」
+            // 挙動へフォールバックする (混在期間も安全に段階デプロイできる)。
+            supports_queue_snapshot: true,
           })
           // dispatch全体はWSメッセージ順を守る直列キュー上にある。ここで履歴I/Oをawaitすると
           // 同一接続のpermission/input等まで停止するため、readyの同期送信後は非同期でpushする。
@@ -3831,43 +3554,6 @@ async function dispatch(msg, ctx) {
         return
       }
       case "claude.permission.reply": {
-        // TUI ブリッジの pending なら .decision を書いて返す (TUI 経路優先)。
-        // 管理外 (= SDK チャットの request) なら従来の permissionReply へ。
-        const handledByTui = ctx.tuiPermissionBridge
-          ? await ctx.tuiPermissionBridge.resolve(
-              msg.request_id,
-              !!msg.allow,
-              msg.deny_message,
-              msg.updated_input,
-            )
-          : false
-        // 遅延回答 resume (frontend が session_name + resume_text を載せた TUI 回答のみ)。
-        // フックが既に死んでいて即時確定 (.decision 注入) が届かない場合、回答を新メッセージ
-        // として同一セッションへ送り、永続 claude が文脈ごと続行できるようにする。
-        const resumeText =
-          typeof msg.resume_text === "string" ? msg.resume_text : ""
-        const resumeSession =
-          typeof msg.session_name === "string" ? msg.session_name : ""
-        if (resumeText && resumeSession && ctx.tuiPermissionBridge) {
-          if (!handledByTui) {
-            // 期限切れ (pending に無い) → 即 resume。再配信しないよう drop。
-            ctx.tuiPermissionBridge.drop(msg.request_id)
-            void _resumeTuiAnswer(resumeSession, resumeText, msg.request_id)
-          } else {
-            // pending だった: 生存フックは ~0.15s で .decision を消費する。猶予後も
-            // 残っていれば フック死亡 (Claude Code timeout で kill 等) → resume へ。
-            const reqId = msg.request_id
-            setTimeout(() => {
-              if (ctx.tuiPermissionBridge?.hasUnconsumedDecision(reqId)) {
-                ctx.tuiPermissionBridge.dropDecision(reqId).catch(() => {})
-                ctx.tuiPermissionBridge.drop(reqId)
-                void _resumeTuiAnswer(resumeSession, resumeText, reqId)
-              }
-            }, RESUME_DECISION_GRACE_MS)
-          }
-          return
-        }
-        if (handledByTui) return
         if (!ctx.claudeBridge) return
         ctx.claudeBridge.permissionReply({
           stream_id: msg.stream_id,
@@ -3882,675 +3568,6 @@ async function dispatch(msg, ctx) {
         if (!ctx.claudeBridge) return
         ctx.claudeBridge.interrupt({ stream_id: msg.stream_id })
         return
-      case "claude.tui.viewing": {
-        // T04778 watcher ゲート: browser が TUI チャットでこの session を閲覧中。
-        // 閲覧マーカーを更新し、承認フックが「閲覧者あり」と判定できるようにする。
-        ctx.tuiViewerRegistry
-          ?.note({ session_id: msg.session_id, cwd: msg.cwd })
-          .catch(() => {})
-        // T04784 逐次表示: 閲覧中だけ jsonl を tail して claude.jsonl.event を push。
-        ctx.jsonlLiveWatchers
-          ?.note({ session_id: msg.session_id, cwd: msg.cwd })
-          .catch(() => {})
-        // T04786 後続: session 回転検知 (/clear で裏 claude が新 session_id へ切替)。
-        // 追従中ビュー (follow_newest 既定 true) のときだけ、cwd の最新 session_id と
-        // 閲覧中 id を突き合わせ、ズレていれば claude.session.rotated を push してフロントに
-        // 読み出し先の切替を促す。過去セッションを意図的に開いているビュー (follow_newest=false)
-        // では検知しない (ピン留め閲覧を最新へ引きずらない)。
-        const viewSid = msg.session_id
-        const viewCwd = msg.cwd
-        const viewName =
-          typeof msg.session_name === "string" ? msg.session_name : ""
-        const followNewest = msg.follow_newest !== false
-        if (followNewest && viewSid && viewCwd) {
-          ;(async () => {
-            try {
-              const projectsRoot = await getActiveProjectsRoot()
-              const { sessions } = await listSessions({
-                cwd: viewCwd,
-                projectsRoot,
-                limit: 1,
-                logger,
-              })
-              const newestId = sessions?.[0]?.session_id || null
-              const key = viewName || viewCwd
-              const prev = ctx.tuiRotationNotified.get(key)
-              const now = Date.now()
-              const prevNewId =
-                prev && typeof prev === "object" ? prev.newId : prev
-              const prevCount =
-                prev && typeof prev === "object" ? (prev.count ?? 0) : 0
-              const { rotated, newSessionId, capped } = decideSessionRotation({
-                viewingSessionId: viewSid,
-                newestSessionId: newestId,
-                // 旧形式 (文字列) と新形式 ({newId, ts, count}) の両対応。
-                lastNotifiedNewId: prevNewId,
-                lastNotifiedAt:
-                  prev && typeof prev === "object" ? prev.ts : null,
-                lastNotifiedCount: prevCount,
-                now,
-              })
-              if (capped) {
-                // 安全弁発火: フロントが採用しないまま maxReNotify 回再通知済み。これ以上の
-                // rotated 連発を止め、無限ピンポンを断つ (フロント側 cwd 必須化で通常は到達しない)。
-                logger.warn(
-                  { session: viewName, cwd: viewCwd, view: viewSid, newest: newestId },
-                  "tui session rotation: capped (frontend not adopting; stopped re-notify)",
-                )
-                return
-              }
-              if (!rotated) return
-
-              // 2a 根治: rotate-bind の前に「候補が本物の /clear 先か」を head 4KB で検証する。
-              // subagent (parent_uuid 等) / SDK headless (type=result) / cwd 不一致のものは
-              // 抑止し、別アクティビティ jsonl への汚染 bind を断つ。検証 NG 時は capped と同様に
-              // tuiRotationNotified を進めて連発を防ぐ。検証失敗 (read error) は accept = 旧挙動。
-              const candidatePath = jsonlPath({
-                cwd: viewCwd,
-                session_id: newSessionId,
-                projectsRoot,
-              })
-              const { accept, reason } = await validateRotationCandidate({
-                candidatePath,
-                viewCwd,
-                logger,
-              })
-              if (!accept) {
-                ctx.tuiRotationNotified.set(key, {
-                  newId: newSessionId,
-                  ts: now,
-                  count: newSessionId === prevNewId ? prevCount + 1 : 1,
-                })
-                logger.warn(
-                  {
-                    session: viewName,
-                    cwd: viewCwd,
-                    view: viewSid,
-                    newest: newestId,
-                    reason,
-                  },
-                  "tui session rotation: suppressed (sibling activity / not a real /clear)",
-                )
-                return
-              }
-              // {newId, ts, count} で保存。同一 new への再通知をスロットリング+回数キャップする。
-              // newId が変われば count を 1 にリセット、同一なら加算する。
-              ctx.tuiRotationNotified.set(key, {
-                newId: newSessionId,
-                ts: now,
-                count: newSessionId === prevNewId ? prevCount + 1 : 1,
-              })
-              // 冪等マップも新 id へ更新し、将来の remount bind が旧 id へ
-              // respawn (claude 再起動) してしまうのを防ぐ。
-              if (viewName) ctx.tuiReboundSessions.set(viewName, newSessionId)
-              ctx.client.send({
-                type: "claude.session.rotated",
-                cwd: viewCwd,
-                session_name: viewName || undefined,
-                old_session_id: viewSid,
-                new_session_id: newSessionId,
-              })
-              // ★回転 (= session_id 境界) で、この NAME に紐づく状態トラッカーを忘れる。生成中を表す
-              // 信号 (proc_busy=ReadinessTracker baseline/armed, status gate ラッチ, spinner freeze,
-              // capture cache) は全て NAME キーのため、忘れないと旧ターンの busy が新 session_id の
-              // 表示へ漏れ、フロントで「/clear 後に三点リーダーが固着」する。発生源 (agent) で断つのが
-              // 主、フロントの再点灯レジスタ reset が従の不変条件 (name→id 漏れの根治)。
-              if (viewName) {
-                ctx.readinessTracker?.forget(viewName)
-                invalidateSessionCache(viewName)
-              }
-              // 回転 = 旧 session_id 境界。旧 session に紐づく pending 権限カードは orphan に
-              // なる (claude は新会話へ移った) ので畳み、browser へ cancel して残存カードを消す
-              // (症状1b 根治)。旧 session_id 完全一致で drop するため、回転直後に新 session で
-              // 出たばかりのカード (payload.session_id === newSessionId) は誤って巻き込まない。
-              if (ctx.tuiPermissionBridge) {
-                const dropped = ctx.tuiPermissionBridge.dropBySession({
-                  session_id: viewSid,
-                })
-                for (const request_id of dropped) {
-                  try {
-                    ctx.client.send({
-                      type: "claude.permission.cancel",
-                      request_id,
-                      session_id: viewSid,
-                      cwd: viewCwd,
-                      reason: "session_rotated",
-                    })
-                  } catch {
-                    /* ignore */
-                  }
-                }
-              }
-              logger.info(
-                { session: viewName, cwd: viewCwd, old: viewSid, new: newSessionId },
-                "tui session rotated (/clear) → notified browser",
-              )
-            } catch (err) {
-              logger.warn(
-                { err: err?.message, cwd: viewCwd },
-                "tui session rotation check failed",
-              )
-            }
-          })()
-        }
-        return
-      }
-      case "claude.tui.unviewing":
-        // 閲覧終了。session_id マーカーを即失効させ、以降の Bash を即 ask に倒す。
-        ctx.tuiViewerRegistry
-          ?.unview({ session_id: msg.session_id })
-          .catch(() => {})
-        // jsonl tail も即停止 (閲覧していない session を追従し続けない)。
-        ctx.jsonlLiveWatchers?.unwatch({ session_id: msg.session_id })
-        return
-      case "claude.tui.cyclePermission": {
-        // 権限バッジ押下 → 対話 claude TUI へ shift+tab を送って権限モードを循環。
-        // 旧実装は frontend が raw pty.data (BACKTAB) を送り、各端末が楽観値を
-        // 個別に 1 段進めるだけだったため、複数端末間でズレ、かつ tmux 上で直接
-        // 切り替えた変更とも乖離した。ここで agent が実キー送出 → ペイン再読込で
-        // 実モードを確定 → 全ブラウザへ claude.tui.permission を broadcast し、
-        // 「実際に動いているターミナルの状態」を正本として全端末に同期する。
-        const cwd = typeof msg.cwd === "string" ? msg.cwd : ""
-        const sessionName =
-          typeof msg.session_name === "string" ? msg.session_name : ""
-        if (!sessionName) return
-        ;(async () => {
-          try {
-            await cyclePermissionMode(sessionName, { logger })
-            // TUI がフッターバナーを再描画するまで少し待ってから実モードを読む。
-            await new Promise((r) => setTimeout(r, 250))
-            const text = await capturePane(sessionName, { noCache: true })
-            const mode = detectPermissionModeFromText(text)
-            ctx.client.send({
-              type: "claude.tui.permission",
-              cwd: cwd || undefined,
-              session_name: sessionName,
-              permission_mode: mode,
-            })
-            logger.info(
-              { session: sessionName, cwd, mode },
-              "tui permission cycled → notified browser",
-            )
-          } catch (err) {
-            logger.warn(
-              { err: err?.message, session: sessionName },
-              "claude.tui.cyclePermission failed",
-            )
-          }
-        })()
-        return
-      }
-      case "claude.tui.setModel": {
-        // モデルバッジ選択 → 対話 claude TUI へ `/model <id>` を送ってモデルを切り替える。
-        // 権限循環 (cyclePermission) と同設計: agent が実キーを送出 → 確認プロンプトを確定 →
-        // 全ブラウザへ claude.tui.model を broadcast し、実際に動いているターミナルのモデルを
-        // 正本として全端末に同期する。jsonl の message.model は次の assistant ターンまで更新
-        // されないため、この即時 broadcast で切替直後のバッジズレを解消する。
-        const cwd = typeof msg.cwd === "string" ? msg.cwd : ""
-        const sessionName =
-          typeof msg.session_name === "string" ? msg.session_name : ""
-        if (!sessionName) return
-        // model="" は「デフォルト」= `/model default`。frontend へはそのまま空で返し、
-        // 解決後の実 id は次ターンの jsonl 由来 (message.model) に委ねる。
-        const model = typeof msg.model === "string" ? msg.model : ""
-        // 先に broadcast してフロントの fallback (raw `/model` paste) を即キャンセルさせる。
-        // setTuiModel は「Switch model?」確認ダイアログの描画検知で数秒かかり得るため、その
-        // 完了を待つとフロントの MODEL_SYNC_FALLBACK_MS が先に発火して二重 paste になる。
-        // バッジは要求モデルを即表示し、確定値は次ターンの jsonl (message.model) で補正される。
-        ctx.client.send({
-          type: "claude.tui.model",
-          cwd: cwd || undefined,
-          session_name: sessionName,
-          model,
-        })
-        ;(async () => {
-          try {
-            await setTuiModel(sessionName, model || "default", { logger })
-            logger.info(
-              { session: sessionName, cwd, model: model || "(default)" },
-              "tui model switched → notified browser",
-            )
-          } catch (err) {
-            logger.warn(
-              { err: err?.message, session: sessionName },
-              "claude.tui.setModel failed",
-            )
-          }
-        })()
-        return
-      }
-      case "claude.tui.setEffort": {
-        // effort バッジ選択 → 対話 claude TUI へ `/effort <level>` を送って reasoning effort を
-        // 切り替える。setModel と同設計: agent が実キーを送出 → 全ブラウザへ claude.tui.effort を
-        // broadcast し、実際に動いているターミナルの effort を正本として全端末に同期する。
-        // effort は jsonl に記録されないため、この即時 broadcast が唯一の表示根拠になる。
-        const cwd = typeof msg.cwd === "string" ? msg.cwd : ""
-        const sessionName =
-          typeof msg.session_name === "string" ? msg.session_name : ""
-        if (!sessionName) return
-        // effort="" は「auto」= `/effort auto`。frontend へはそのまま空で返し、バッジは auto 表示。
-        const effort = typeof msg.effort === "string" ? msg.effort : ""
-        // setModel と同様、先に broadcast してフロントの fallback (raw `/effort` paste) を即
-        // キャンセルさせる。setTuiEffort も「Change effort level?」確認ダイアログの描画検知で
-        // 数秒かかり得るため、完了待ちだと EFFORT_SYNC_FALLBACK_MS が先に発火して二重 paste
-        // になる。effort は jsonl に記録されないので、この即時 broadcast が表示の根拠になる。
-        ctx.client.send({
-          type: "claude.tui.effort",
-          cwd: cwd || undefined,
-          session_name: sessionName,
-          effort,
-        })
-        ;(async () => {
-          try {
-            await setTuiEffort(sessionName, effort || "auto", { logger })
-            logger.info(
-              { session: sessionName, cwd, effort: effort || "(auto)" },
-              "tui effort switched → notified browser",
-            )
-          } catch (err) {
-            logger.warn(
-              { err: err?.message, session: sessionName },
-              "claude.tui.setEffort failed",
-            )
-          }
-        })()
-        return
-      }
-      case "claude.tui.answerAskUserQuestion": {
-        // 症状1a 根治 (1-B): ブラウザの AskUserQuestion カード回答を、フックの updatedInput
-        // (AskUserQuestion では原理的に効かない) でなく、agent が同一ホストの tmux ネイティブ
-        // メニューへ send-keys で届ける。capturePane で描画検知してから送出し状態変化を検証する
-        // (blind 送出禁止)。回答後 claude が tool_result を commit → JsonlLiveWatchers が検知して
-        // dropBySession → claude.permission.cancel でカードを畳む (1-A 経路と合成)。
-        const sessionName =
-          typeof msg.session_name === "string" ? msg.session_name : ""
-        const requestId =
-          typeof msg.request_id === "string" ? msg.request_id : undefined
-        // answers: 質問順の [{question?, labels: string[]}]。frontend が card の {questions, answers}
-        // から構築する。labels は選んだ選択肢ラベル群 (multiSelect は複数、single は1件)。
-        const answers = Array.isArray(msg.answers) ? msg.answers : []
-        if (!sessionName) return
-        const reply = (payload) =>
-          ctx.client.send({
-            type: "claude.tui.answerAskUserQuestion.result",
-            request_id: requestId,
-            session_name: sessionName,
-            ...payload,
-          })
-        ;(async () => {
-          try {
-            const r = await answerAskUserQuestion(sessionName, answers, { logger })
-            logger.info(
-              { session: sessionName, ok: r.ok, answered: r.answered, error: r.error },
-              "tui answerAskUserQuestion via send-keys",
-            )
-            reply({ ok: !!r.ok, answered: r.answered ?? 0, error: r.error })
-          } catch (err) {
-            logger.warn(
-              { err: err?.message, session: sessionName },
-              "claude.tui.answerAskUserQuestion failed",
-            )
-            reply({ ok: false, error: err?.message || String(err) })
-          }
-        })()
-        return
-      }
-      case "claude.tui.probePermission": {
-        // 読み取り専用の権限モード問い合わせ (cold-load seed)。キーは送らず、ペインを
-        // 読んで現在の実モードを claude.tui.permission として broadcast するだけ。
-        // ブラウザがマウント直後に「今ターミナルが何モードか」を取得し、楽観値や
-        // 古い jsonl 値とのズレを開始時点から揃えるために使う。検出不能 (claude 起動中・
-        // 素のシェル) のときは mode=null となり、frontend 側は据え置く。
-        const cwd = typeof msg.cwd === "string" ? msg.cwd : ""
-        const sessionName =
-          typeof msg.session_name === "string" ? msg.session_name : ""
-        if (!sessionName) return
-        ;(async () => {
-          try {
-            const text = await capturePane(sessionName, { noCache: true })
-            const mode = detectPermissionModeFromText(text)
-            // 検出できた時だけ通知する (null で badge を消さない)。
-            if (!mode) return
-            ctx.client.send({
-              type: "claude.tui.permission",
-              cwd: cwd || undefined,
-              session_name: sessionName,
-              permission_mode: mode,
-            })
-          } catch (err) {
-            logger.warn(
-              { err: err?.message, session: sessionName },
-              "claude.tui.probePermission failed",
-            )
-          }
-        })()
-        return
-      }
-      case "claude.tui.recoverInput": {
-        // 中断キャンセル後の入力欄復旧 (agent >= 0.6.57)。対話 claude は「送信直後の Esc」
-        // で本文を入力ボックスへ戻すため、放置すると次の bracketed paste が後ろへ連結され
-        // メッセージが合体する (2026-06-08 報告バグ)。frontend が Esc 送出直後にこれを送り、
-        // agent がペインを実測して「expect_text が入力ボックスへ戻った」ことを確認してから
-        // クリアし、結果を claude.tui.recoverInput.result で返す (backend が user-level
-        // broadcast し、frontend は request_id で自分の要求と照合する)。
-        const sessionName =
-          typeof msg.session_name === "string" ? msg.session_name : ""
-        const cwd = typeof msg.cwd === "string" ? msg.cwd : ""
-        const requestId =
-          typeof msg.request_id === "string" ? msg.request_id : ""
-        const expectText =
-          typeof msg.expect_text === "string" ? msg.expect_text : ""
-        if (!sessionName || !requestId) return
-        ;(async () => {
-          const result = await recoverTuiInput(sessionName, expectText, {
-            logger,
-          })
-          ctx.client.send({
-            type: "claude.tui.recoverInput.result",
-            request_id: requestId,
-            session_name: sessionName,
-            cwd: cwd || undefined,
-            cleared: !!result.cleared,
-          })
-        })()
-        return
-      }
-      case "claude.tui.interrupt": {
-        // 確認付き中断 (Phase3)。ロジックは handleTuiInterrupt に切り出し (テスト可能化)。
-        // async だが dispatch をブロックしないよう投げっぱなし (自前で result を返す)。
-        void handleTuiInterrupt(msg, ctx)
-        return
-      }
-      case "claude.tui.queue.flush": {
-        // 離席中(非アクティブセッション)キュー自動投入 (案A の agent 側受け口)。
-        // ロジックは handleQueueFlush に切り出し (テスト可能化 + cross-path 冪等)。async だが
-        // dispatch をブロックしないよう投げっぱなしにする (自前で flush.ack を返す)。
-        void handleQueueFlush(msg, ctx)
-        return
-      }
-      case "claude.tui.rehydratePermissions": {
-        // セッション切替でビューが再マウントすると、その時点の承認/質問カードは React
-        // state ごと消える (agent は claude.permission.request を 1 回しか push しない)。
-        // browser が再購読時にこれを送り、該当セッションの未応答リクエストを再 push して
-        // カードを復元する (frontend は request_id で重複排除)。
-        if (!ctx.tuiPermissionBridge) return
-        const sid =
-          typeof msg.session_id === "string" ? msg.session_id : null
-        const reqCwd = typeof msg.cwd === "string" ? msg.cwd : null
-        const pend = ctx.tuiPermissionBridge.listPending({
-          session_id: sid,
-          cwd: reqCwd,
-        })
-        for (const p of pend) {
-          ctx.client.send({
-            type: "claude.permission.request",
-            stream_id: null,
-            session_id: p.session_id,
-            cwd: p.cwd,
-            request_id: p.request_id,
-            tool_name: p.tool_name,
-            input: p.input,
-            // 再 hydrate でも直前説明を保つ (listPending が payload ごと保持している)。
-            context_text: p.context_text ?? null,
-          })
-        }
-        if (pend.length) {
-          logger.info(
-            { session_id: sid, cwd: reqCwd, count: pend.length },
-            "tui permission re-hydrated to browser",
-          )
-        }
-        return
-      }
-      case "claude.tui.bind": {
-        // T04784 会話継続バインディング: TUI モード突入時に 1 回送られる。
-        //   1. 対象 cwd の最新 session_id を確定 (browser 指定があれば優先)。
-        //   2. その session の SDK を完全停止 (二重ホスト/枠流出を防ぐ)。
-        //   3. 裏の tmux claude を `--resume <id>` で同じ会話に載せ替える (read=write 一致)。
-        // ベストエフォート。失敗時は frontend が従来 newest 表示に degrade する。
-        const request_id = msg.request_id
-        const cwd = typeof msg.cwd === "string" ? msg.cwd : ""
-        const sessionName =
-          typeof msg.session_name === "string" ? msg.session_name : ""
-        const reply = (payload) =>
-          ctx.client.send({
-            type: "claude.tui.bind.result",
-            request_id,
-            ...payload,
-          })
-        try {
-          // fresh: 「まっさらな新規セッション」要求 (ピッカーの「＋新規」)。cwd 最新へ
-          // resume せず resume 無しの claude を起動する。session_id は起動後の初回送信で
-          // 生成され、frontend は回転検知 / sessions 応答で拾う。
-          const fresh = msg.fresh === true
-          // 1) 載せ替え先 session_id を確定 (fresh は解決しない = 新規起動)。あわせて
-          //    現在動いているセッション (= cwd の最新 jsonl = newestId) も解決する。生成中ガードで
-          //    「再接続/remount による同一セッションへの再 bind」か「別 session への明示 switch」かを
-          //    区別するのに使う (前者は respawn を抑止して生成中 claude を温存する)。
-          let targetId =
-            typeof msg.session_id === "string" && msg.session_id
-              ? msg.session_id
-              : null
-          let newestId = null
-          if (!fresh && cwd) {
-            const projectsRoot = await getActiveProjectsRoot()
-            const { sessions } = await listSessions({
-              cwd,
-              projectsRoot,
-              limit: 1,
-              logger,
-            })
-            newestId = sessions?.[0]?.session_id || null
-            if (!targetId) targetId = newestId
-          }
-          // 生成中ガード (謎停止対策): respawn-pane -k は生成中 claude を強制 kill し in-flight 応答を失う。
-          // hub-agent 再起動直後は tuiReboundSessions が空で冪等ガードが効かず、ブラウザ再接続の bind が
-          // 生成中 claude を kill する。armed (ターン進行中) か pane=processing なら生成中とみなす。
-          let generating = ctx.readinessTracker?.isArmed?.(sessionName) === true
-          if (!generating && sessionName) {
-            try {
-              const snap = await detectSessionState(sessionName, {})
-              if (snap?.status === "processing") generating = true
-            } catch {
-              // capture 失敗時は据え置き (生成中とみなさない = 従来挙動)
-            }
-          }
-          // 2) SDK を停止 (cwd 全体 + 対象 id)。
-          let stoppedSdk = 0
-          if (ctx.claudeBridge) {
-            stoppedSdk = ctx.claudeBridge.stopSessionsFor({
-              cwd,
-              session_id: targetId || undefined,
-            })
-          }
-          // SDK を止めて TUI へ載せ替えた時点で、cwd のチャット信号 (SDK 用の
-          // status/context% 補完) は役目を終える。残すと TUI 権限カードの
-          // inputPending 記録が stale status の鮮度を延命し、state loop が
-          // ペイン実状態を waiting で上書きし続ける (2026-06-12 真因修正)。
-          // T05945: claude バケットのみ消す。同一 cwd で走っている codex チャットの
-          // 信号まで消すと、codex 行のドット/ドーナツが巻き添えで消灯する。
-          if (cwd) clearChatSignal(cwd, "claude")
-          // 3) tmux claude を起動し直す (resume or fresh)。
-          //    冪等性: 同じ session を同じキーへ既に載せ替え済みなら respawn しない
-          //    (TUI ビューは remount のたびに bind を送るため、毎回 respawn すると
-          //     claude が再起動ループになり送信不能になる。2026-06-06 leader 実機)。
-          //    resume は targetId をキー、fresh は session_id 不在のため bind の request_id を
-          //    キーにする (同一マウントの再送は同 request_id で skip、新規要求は再マウントで
-          //    新 request_id になり 1 回だけ起動する)。
-          // 実プロセス由来の「claude 実行中か」。respawn-pane -k による生成中 claude の誤 kill
-          // (症状D 再発 D2: armed 140s cap / capture gap で generating=false に倒れ、--resume bind
-          // でも実行中 claude を kill していた)を、capture/armed に依存しない pane_current_command で防ぐ。
-          const paneRunningClaude = await isPaneRunningClaude(sessionName, { logger })
-          // 【構造版 root 2026-06-22】プロセス実体の busy (ターン進行中) を bind 時に確定する。
-          // 「動いている claude を kill しない」の唯一の判定基準。frontend が fresh:true を誤送しても
-          // 生成中 claude を殺さない (frontend 単独依存からの脱却)。
-          const busy = await isPaneBusyNow(ctx.readinessTracker, sessionName)
-          // 非 fresh (resume/auto) の bind = ユーザーが既存会話を選んだ → 保留中の +新規 defer は破棄。
-          if (!fresh) ctx.pendingFreshRespawn.delete(sessionName)
-          let rebind = { ok: false, skipped: false }
-          // 新規会話の 0% は会話切替として扱うため、request_id を送れない旧 client
-          // 経由でも bind ごとに固有IDを作る。空の `fresh:` を再利用すると、2回目以降の
-          // 新規会話が同一会話扱いになり、直前値が残る。
-          const freshBindId = request_id || randomUUID()
-          const bindKey = fresh ? `fresh:${freshBindId}` : targetId
-          const recordDeferredFresh = () =>
-            ctx.pendingFreshRespawn.set(sessionName, {
-              cwd,
-              request_id,
-              at: Date.now(),
-              model: ctx.config?.claude_model || "",
-              permissionMode: ctx.config?.claude_permission_mode || "",
-            })
-          if (bindKey && sessionName && (fresh || targetId)) {
-            if (ctx.tuiReboundSessions.get(sessionName) === bindKey) {
-              rebind = { ok: true, skipped: true }
-            } else if (
-              shouldSkipRebindRespawn({
-                generating,
-                fresh,
-                targetId,
-                newestId,
-                paneRunningClaude,
-                busy,
-              })
-            ) {
-              // busy (ターン進行中) または最新セッションへの再 bind → respawn を抑止し生成中 claude を温存。
-              rebind = { ok: true, skipped: true }
-              if (fresh && busy) {
-                // ユーザーの +新規 を ready (ターン終了) まで defer する (in-flight ターンを殺さない)。
-                recordDeferredFresh()
-                logger?.info(
-                  { session: sessionName },
-                  "tui rebind: deferred +new (pane busy) until turn ends",
-                )
-              } else {
-                // 非 fresh の冪等記録 (動いているセッション本人への再 bind)。
-                ctx.tuiReboundSessions.set(sessionName, bindKey)
-                logger?.info(
-                  { session: sessionName, session_id: targetId },
-                  "tui rebind: skipped respawn (turn in progress on the running session)",
-                )
-              }
-            } else if (
-              fresh &&
-              Date.now() - (ctx.lastFreshRespawnAt.get(sessionName) || 0) <
-                FRESH_RESPAWN_THROTTLE_MS
-            ) {
-              // idle ペインへの fresh remount storm (再マウント毎に新 request_id) を 1 回へ collapse。
-              // 直近 fresh respawn から閾値内の fresh は再送とみなし skip (new セッション乱造を防ぐ)。
-              rebind = { ok: true, skipped: true }
-              logger?.info(
-                { session: sessionName },
-                "tui rebind: throttled fresh respawn (idempotent remount within window)",
-              )
-            } else {
-              rebind = await rebindClaudeSession(sessionName, targetId, {
-                cwd,
-                model: ctx.config?.claude_model || "",
-                permissionMode: ctx.config?.claude_permission_mode || "",
-                fresh,
-                busy,
-                logger,
-              })
-              if (rebind.ok) {
-                ctx.tuiReboundSessions.set(sessionName, bindKey)
-                if (fresh) ctx.lastFreshRespawnAt.set(sessionName, Date.now())
-              } else if (rebind.skipped && rebind.reason === "busy" && fresh) {
-                // チョークポイントが busy で弾いた (probe が false でも実行直前にターン開始した競合)。
-                // defer に載せて +新規 を取りこぼさない。
-                recordDeferredFresh()
-              }
-            }
-          }
-          reply({
-            session_id: targetId,
-            fresh,
-            stopped_sdk: stoppedSdk,
-            rebound: !!rebind.ok,
-            skipped: !!rebind.skipped,
-            error: rebind.ok ? undefined : rebind.error,
-          })
-          // 取りこぼし回復 (2026-06-07): 直近のターン境界が `stop` ならファイル正本から
-          // 再配信する。fs.watch 由来の session.event push は揮発性 (WS 切断・remount 中の
-          // broadcast は失われる) で、stop を取りこぼした frontend は三点リーダーが回り
-          // 続ける。bind は TUI ビューのマウントごとに来るので、ここで最新 stop を返せば
-          // 再表示時に必ずターン終了が伝わる。prompt_submit は再配信しない (stale な
-          // 「処理中」を誤って点灯させないため。点灯は jsonl エコー / 実 hook が担う)。
-          if (sessionName) {
-            const lastEvent = await readSessionEventFile(sessionName)
-            if (lastEvent && lastEvent.event === "stop") {
-              ctx.client.send({
-                type: "session.event",
-                session_name: sessionName,
-                event: lastEvent.event,
-                at: lastEvent.at,
-                replay: true,
-                // この再配信は bind(=フォーカス) 契機の status 復旧専用。並び順は絶対に
-                // 動かさない (フォーカスで浮上させない現象B 根治の一部)。
-                sort_affecting: false,
-              })
-            }
-          }
-          // 即時ステータススナップショット (#2): session.state は差分送信なので、アイドル
-          // セッションへ切替えても現在値が届かず、ペイン由来の三点リーダー補正が次の poll
-          // (~8-10s) まで遅れる。bind は TUI ビューのマウントごとに来るので、ここで現在状態
-          // を 1 回 push して初回サンプルを即届け、偽点灯/消灯確定を早める (noCache で実測)。
-          if (sessionName) {
-            try {
-              const snap = await detectSessionState(sessionName, {
-                noCache: true,
-                logger,
-              })
-              // bind が確定している復帰は、capture-pane の見た目や cwd 最新ファイルでなく
-              // **指定 session_id の JSONL** から context% を即時解決する。fresh はまだ実 ID
-              // が無いため 0% と fresh:<request_id> を対にして送る。
-              const contextSessionId = fresh ? bindKey : targetId
-              const boundContext =
-                targetId && cwd
-                  ? await jsonlContextForCwd(cwd, targetId).catch(() => null)
-                  : null
-              const contextPct = fresh
-                ? 0
-                : typeof boundContext?.percent === "number"
-                  ? boundContext.percent
-                  : snap.context_pct
-              // 【問題1 根治 2026-06-22】配る status はプロセス実体の busy を権威に解決する
-              // (resolveBindSnapshotStatus)。capture(SPINNER_LINE_RE)の偽陽性に勝たせる。
-              // - busy=true (ターン進行中): capture gap で snap.status が waiting に化けても
-              //   processing を強制 = 症状C(再マウントで生成中の三点リーダーが消える偽陰性)の masking。
-              // - busy=false (プロセス実体 idle): snap.status が processing でも、それは静的完了行の
-              //   偽陽性(無生成時の誤点灯=問題1)なので processing を配らず waiting へ降格する。bind は
-              //   noCache 単発読みで freeze 履歴が無く偽陽性を弾けないため、ここで busy を権威にする。
-              // generating(capture 由来)でなく busy(isArmed + 子孫数>baseline)を使うのが肝。
-              // proc_busy は配らない: outputActive(出力残り火)を含み真 idle でも true になり高速消灯
-              // (症状B)を再発させるため。
-              const snapStatus = resolveBindSnapshotStatus(busy, snap.status)
-              ctx.client.send({
-                type: "session.state",
-                session_name: sessionName,
-                status: snapStatus,
-                context_pct: contextPct,
-                context_session_id: contextSessionId ?? null,
-                permission_mode: snap.permission_mode,
-                stable:
-                  !busy && snapStatus !== "processing" && snap.stable === true,
-              })
-            } catch (err) {
-              logger?.warn(
-                { err: err?.message, sessionName },
-                "claude.tui.bind status snapshot failed",
-              )
-            }
-          }
-        } catch (err) {
-          logger?.warn(
-            { err: err?.message, sessionName, cwd },
-            "claude.tui.bind failed",
-          )
-          reply({ session_id: null, error: err?.message || String(err) })
-        }
-        return
-      }
       case "terminal.mirror.start": {
         // Cockpit Codex 両対応 Stream C (2026-07-03): チャット(SDK/app-server)の会話を
         // 変えずに、ターミナルのペイン (普通のシェルのまま) へ読み取り専用の実況を
@@ -4790,11 +3807,67 @@ async function dispatch(msg, ctx) {
         }
         return
       }
-      case "claude.queue.cancel":
+      case "claude.queue.cancel": {
         // 送信待ち (pending) メッセージを id 指定で取り消す (0.6.26)。
-        if (!ctx.claudeBridge) return
-        ctx.claudeBridge.cancelQueued({ stream_id: msg.stream_id, id: msg.id })
+        // T06603 cross-review 4 巡目: 取り消せなかった (stream 不在) ときは browser へ
+        // 失敗を返す。browser は要求時にチップを消さず「取消中」印を付けて権威の確認を
+        // 待つため、無応答だと印が外れず固着する。request_id をエコーして相関させる。
+        // T06603 cross-review 5 巡目: 結末 (cancelled / already_started / stream_missing) を
+        // **必ず** 返す。「pending から消えた」だけでは取消成功と実行開始済みを区別できず、
+        // 特に drain の started フレームを取りこぼしていると、browser は取消成功に見せかけた
+        // まま実行を続行してしまう (発言バブルも欠けたまま)。request_id + input_id で相関させる。
+        const cancelRes = {
+          type: "claude.queue.response",
+          stream_id: msg.stream_id,
+          request_id: msg.request_id || null,
+          input_id: msg.id || null,
+        }
+        if (!ctx.claudeBridge) {
+          ctx.client.send({ ...cancelRes, outcome: "stream_missing" })
+          return
+        }
+        const canceled = ctx.claudeBridge.cancelQueued({
+          stream_id: msg.stream_id,
+          id: msg.id,
+        })
+        // ⚠️ T06603 cross-review 6 巡目: **outcome を先に送る**。キュー snapshot の再表明を
+        // 先に流すと、backend は到着順に relay するため browser は空 snapshot で
+        // 「キューに無い ＋ 受理済み = 実行完了」と判定してチップを消し、後続の outcome は
+        // 対象不在で no-op になる (already_started のバブル補償が発火しない)。
+        ctx.client.send({
+          ...cancelRes,
+          outcome: canceled?.outcome || "stream_missing",
+        })
+        canceled?.flush?.()
+        return
+      }
+      case "claude.queue.request": {
+        // pull 型再同期 (T06603, 2026-07-25): browser が権威キュー snapshot を引きにくる。
+        // 従来キュー表示の是正手段は「agent が turn settle 毎に force 再送する queue_state」
+        // だけで、その配信が 1 通落ちると browser には自己修復の手段が無く送信待ちチップが
+        // 恒久固着した。ここで「いつでも引き直せる」経路を与えるのが根治の中核。
+        // 応答は要求元 stream へ返す (backend が cockpit_stream_<stream_id> へ relay)。
+        const queueReq = {
+          type: "claude.queue.response",
+          stream_id: msg.stream_id,
+          request_id: msg.request_id || null,
+        }
+        if (!ctx.claudeBridge) {
+          ctx.client.send({ ...queueReq, error: "stream_missing" })
+          return
+        }
+        const got = ctx.claudeBridge.queueSnapshot({ stream_id: msg.stream_id })
+        if (!got) {
+          ctx.client.send({ ...queueReq, error: "stream_missing" })
+          return
+        }
+        ctx.client.send({
+          ...queueReq,
+          session_id: got.session_id,
+          event: got.snapshot,
+        })
         return
+      }
       case "claude.detach":
         if (!ctx.claudeBridge) return
         ctx.claudeBridge.detach({ stream_id: msg.stream_id })
@@ -5025,18 +4098,27 @@ async function dispatch(msg, ctx) {
         const stream_id = msg.stream_id
         const cwd = msg.cwd || ""
         const limit = typeof msg.limit === "number" ? msg.limit : undefined
+        // Read-plane 案C ①②: read は自己記述。読む対象はリクエストの profile_id で固定し
+        // (env の揮発値に依存しない)、epoch と解決済み文脈をエコーして frontend の
+        // 単一 read ゲートが stale/逆順/別プロファイル応答を判別できるようにする。
+        const epoch = typeof msg.epoch === "number" ? msg.epoch : undefined
+        const { sessionsDir, profileId } = await codexProfiles.resolveSessionsDir(
+          msg.profile_id,
+        )
         if (!ctx.codexBridge) {
           ctx.client.send({
             type: "codex.sessions.response",
             stream_id,
             cwd,
+            epoch,
+            profile_id: profileId,
             sessions: [],
             error: "codex_unavailable: codex CLI が agent の PATH に見つかりません",
           })
           return
         }
         try {
-          const sessions = await ctx.codexBridge.listThreads({ cwd, limit })
+          const sessions = await ctx.codexBridge.listThreads({ cwd, limit, sessionsDir })
           // Stage 5 ③: 各 thread に「hub-agent 側で app-server が live か / busy か」を付す。
           // rollout 由来の一覧（listThreads）は live 状態を知らないため、describeLiveSessions
           // の thread_id → {live, busy} を併合する。browser は sidebar に live/reaped ドットを出す。
@@ -5053,6 +4135,8 @@ async function dispatch(msg, ctx) {
             type: "codex.sessions.response",
             stream_id,
             cwd,
+            epoch,
+            profile_id: profileId,
             sessions: withLive,
           })
         } catch (err) {
@@ -5060,6 +4144,8 @@ async function dispatch(msg, ctx) {
             type: "codex.sessions.response",
             stream_id,
             cwd,
+            epoch,
+            profile_id: profileId,
             sessions: [],
             error: err.message,
           })
@@ -5074,8 +4160,11 @@ async function dispatch(msg, ctx) {
         const cwd = msg.cwd || ""
         const session_id = msg.session_id || ""
         const maxLines = typeof msg.max_lines === "number" ? msg.max_lines : undefined
-        // active プロファイルの projects/ から読む (アカウント別に履歴がサイロ化されているため)。
-        const projectsRoot = await getActiveProjectsRoot()
+        // Read-plane 案C ①: 読む projects/ は **リクエストの profile_id** から解決する
+        // (アカウント別に履歴がサイロ化されており、env 由来の active に頼ると切替中の
+        // in-flight read が別アカウントの履歴を返す)。profile_id 未指定は active へ縮退。
+        const epoch = typeof msg.epoch === "number" ? msg.epoch : undefined
+        const { projectsRoot, profileId } = await resolveProjectsRoot(msg.profile_id)
         const result = await fetchSessionHistory({
           cwd,
           session_id,
@@ -5093,6 +4182,10 @@ async function dispatch(msg, ctx) {
           // その結果、無条件 hydrate → session_id 上書き → 購読スワップ → localStorage 汚染の
           // 経路が残っていた (sessionScope.ts が stream_id 主軸で守るのは relay イベントのみ)。
           cwd,
+          // 案C ②: epoch と解決済み profile を必ずエコーする。frontend の単一 read ゲートは
+          // この 2 つで「今の問いへの最新の答えか」を判定し、stale/逆順/別プロファイルを drop する。
+          epoch,
+          profile_id: profileId,
           events: result.events,
           total_lines: result.total_lines,
           truncated: result.truncated,
@@ -5107,8 +4200,9 @@ async function dispatch(msg, ctx) {
         const stream_id = msg.stream_id
         const cwd = msg.cwd || ""
         const limit = typeof msg.limit === "number" ? msg.limit : undefined
-        // active プロファイルの projects/ からセッション一覧を読む。
-        const projectsRoot = await getActiveProjectsRoot()
+        // Read-plane 案C ①: 一覧もリクエストの profile_id から projects/ を解決する。
+        const epoch = typeof msg.epoch === "number" ? msg.epoch : undefined
+        const { projectsRoot, profileId } = await resolveProjectsRoot(msg.profile_id)
         const result = await listSessions({
           cwd,
           limit,
@@ -5119,6 +4213,8 @@ async function dispatch(msg, ctx) {
           type: "claude.sessions.response",
           stream_id,
           cwd,
+          epoch,
+          profile_id: profileId,
           sessions: result.sessions || [],
           error: result.error,
         })