@cocorograph/hub-agent 0.8.83 → 0.8.85

package/src/main.mjs

@@ -5,7 +5,6 @@
  * - plugin discovery + onAgentStart broadcast
  * - WS メッセージのディスパッチ:
  *   - claude.* / codex.* → ClaudeStreamBridge / CodexStreamBridge (チャット)
- *   - tmux.* → tmux module (セッション一覧・作成・削除)
  *
  * 仕様書: ナレッジ/インフラ/cockpit-hub-hosted-integration-spec (id=6080)
  */
@@ -69,11 +68,6 @@ import {
 import { listAgents } from "./agents.mjs"
 import { listSkills } from "./skills.mjs"
 import { readSidebarMessageSnapshot } from "./sidebar-message-snapshot.mjs"
-import {
-  invalidateSessionCache,
-  listSessionStates,
-  StallTracker,
-} from "./state.mjs"
 import {
   DEFAULT_PROFILE_ID,
   defaultConfigDir,
@@ -98,49 +92,29 @@ import {
   profileHasKeychainCredentials,
   deleteKeychainCredentials,
 } from "./claude-credentials.mjs"
-import {
-  buildClaudeCmd,
-  buildCodexCmd,
-  buildWorktreeIndex,
-  createSession as createTmuxSession,
-  createWorktreeDir,
-  killManySessions,
-  killSession as killTmuxSession,
-  listSessions as listTmuxSessions,
-  listWorktreeNameHistory,
-  listWorktreeStubs,
-  paneClaudeAliveOrUnknown,
-  removeWorktree as removeWorktreeDir,
-  setTmuxGlobalEnv,
-  shouldLaunchPaneCli,
-  validateInitialPrompt,
-} from "./tmux.mjs"
+import { createWorktreeDir, listWorktreeNameHistory, removeWorktree as removeWorktreeDir } from "./tmux.mjs"
 import { expandTilde, prepareChatWorkspace, isCwdUnavailableError } from "./chat-workspace.mjs"
 import { buildChatSessionsSnapshot, refreshChatSessionsSignals } from "./chat-sessions-snapshot.mjs"
 import { chatTargetsCache } from "./chat-targets.mjs"
 import { ensureChatSession } from "./chat-session-starter.mjs"
 import { beginRemoval } from "./chat-removal-guard.mjs"
 import { SiblingInjectBridge } from "./sibling-inject.mjs"
-import { describeLiveSessionsUnion, isSessionWarm } from "./live-sessions.mjs"
-import { applyPointerContexts, resolvePointerContexts } from "./pointer-context.mjs"
+import { describeLiveSessionsUnion } from "./live-sessions.mjs"
 import {
   boundSessionId,
   codexUsageFromAccountRateLimits,
   codexLiveContextForProducer,
   codexSessionUsages,
-  codexTurnActiveForThread,
   codexUsageForThread,
   contextWindowSize,
   forgetCodexLiveTokenUsage,
   getSessionUsages,
   getUsage,
-  isFreshUnboundBind,
   recordChatRateLimit,
   recordChatUsageSnapshot,
   readAccountUsageSnapshot,
   recordAccountUsageSnapshot,
   recordCodexLiveTokenUsage,
-  turnActiveForCwd,
 } from "./usage.mjs"
 import {
   getPromptAcceptedAt,
@@ -153,12 +127,6 @@ import {
   hasRepresentativeRow,
 } from "./chat-signals.mjs"
 import { cliKindForSessionName, sessionNameFor } from "./session-names.mjs"
-import {
-  ReadinessTracker,
-  busyChildCount,
-  getPanePid,
-  snapshotProcs,
-} from "./proc-introspect.mjs"
 import { hydrateProcessEnvFromShell } from "./shell-env.mjs"
 
 export function resolveCodexLoginCommand(configDir, { isDefault = false, _resolveCodexBinary = resolveCodexBinary } = {}) {
@@ -203,127 +171,6 @@ export function resolveClaudeAttachOptions(config, msg = {}) {
   }
 }
 
-/**
- * `~/.hub/agent.json` の Claude CLI 設定から claude コマンド文字列を組み立てる。
- *
- * - enrollment 時に Hub から取得した `claude_model` / `claude_permission_mode` が
- *   入っていれば、それを使って `claude --continue --model ... || claude --model ...` を生成
- * - 両方空なら `undefined` を返す (createSession 内で DEFAULT_CLAUDE_CMD =
- *   環境変数 HUB_CLAUDE_CMD か最小デフォルト `claude --continue || claude` が使われる)
- *
- * cockpit 管理画面でユーザーが Hub 側で model / permission-mode を変更すると、
- * 次の enrollment / 再起動時に新しい値で組み立てられる。
- */
-function claudeCmdFromAgentConfig(config) {
-  const cmd = buildClaudeCmd({
-    model: config?.claude_model,
-    permissionMode: config?.claude_permission_mode,
-  })
-  // buildClaudeCmd は config も env も空なら最小デフォルトを返す。
-  // ここでは「明示的に Hub 側で何か指定されていた場合のみ上書き、なければ
-  // createSession 側の DEFAULT_CLAUDE_CMD に委ねる」挙動にするため、
-  // model も mode も空なら undefined を返す。
-  const model = (config?.claude_model || "").trim()
-  const mode = (config?.claude_permission_mode || "").trim()
-  if (!model && !mode) return undefined
-  return cmd
-}
-
-/**
- * `~/.hub/agent.json` の Codex CLI 設定 (codex_model / codex_effort) から
- * createTmuxSession の model/effort opts へのデフォルト値を取得する
- * (claudeCmdFromAgentConfig の Codex 版)。
- *
- * tmux.create_session / worktree.create の browser 側 msg.model / msg.effort が
- * 明示指定されていればそちらを優先し (呼び出し側で判定済み)、未指定のときだけ
- * このデフォルトにフォールバックする。空文字は「未指定」として undefined を返す
- * (buildCodexCmd 側は undefined を渡されても既定値へフォールバックするため安全)。
- */
-function codexDefaultsFromAgentConfig(config) {
-  return {
-    model: (config?.codex_model || "").trim() || undefined,
-    effort: (config?.codex_effort || "").trim() || undefined,
-  }
-}
-
-/**
- * プロファイル切替用: 全 tmux セッションを kill → 同名・同 cwd で再作成する。
- *
- * 再作成された pane は **既定では素のシェル** (createSession が CLI を起動しない)。
- * アカウント切替は SDK チャット側の process.env と、tmux サーバーのグローバル環境
- * (syncTmuxProfileEnv の `set-environment -g`) で追従する。
- * `HUB_AGENT_TMUX_LAUNCH_CLI=1` で TUI を起動する運用の場合のみ、createSession 内の
- * injectConfigDirEnv が新しい CLAUDE_CONFIG_DIR をコマンドへ焼き込む。
- * initial prompt (leader の /orchestrate 等) までは復元しない — アカウントが
- * 変わる以上、前アカウントの文脈でスキルを自動発火させない方が安全。
- * cwd が取れないセッションは kill のみ行い、再作成はスキップして failed に積む。
- * tmux サーバー未起動なら何もしない。
- */
-export async function restartAllTmuxSessionsForProfileSwitch(ctx) {
-  const result = { killed: [], recreated: [], failed: [] }
-  const listSessionsForRestart = ctx._listTmuxSessions || listTmuxSessions
-  const killSessionsForRestart = ctx._killManySessions || killManySessions
-  const createSessionForRestart = ctx._createTmuxSession || createTmuxSession
-  let sessions = []
-  try {
-    sessions = await listSessionsForRestart({ plugins: ctx.plugins, logger: ctx.logger })
-  } catch (err) {
-    ctx.logger?.debug?.(
-      { err: err?.message || String(err) },
-      "tmux list failed during profile switch (server not running?)",
-    )
-    return result
-  }
-  if (!sessions.length) return result
-  const codexDefaults = codexDefaultsFromAgentConfig(ctx.config)
-  let prebuiltCodexCmd
-  const codexSessions = sessions.filter((s) => cliKindForSessionName(s.name) === "codex")
-  let sessionsToRestart = sessions
-  if (shouldLaunchPaneCli() && codexSessions.length) {
-    try {
-      prebuiltCodexCmd = buildCodexCmd({
-        ...codexDefaults,
-        _resolveCodexBinary: ctx._resolveCodexBinary,
-      })
-    } catch (err) {
-      const reason = err?.message || String(err)
-      result.failed.push(...codexSessions.map((s) => ({ name: s.name, reason })))
-      const blocked = new Set(codexSessions.map((s) => s.name))
-      sessionsToRestart = sessions.filter((s) => !blocked.has(s.name))
-    }
-  }
-  if (!sessionsToRestart.length) return result
-  const { killed } = await killSessionsForRestart(
-    sessionsToRestart.map((s) => s.name),
-    { logger: ctx.logger },
-  )
-  result.killed = killed
-  for (const s of sessionsToRestart) {
-    if (!killed.includes(s.name)) continue
-    if (!s.cwd) {
-      result.failed.push({ name: s.name, reason: "cwd unknown" })
-      continue
-    }
-    try {
-      const cliKind = cliKindForSessionName(s.name)
-      await createSessionForRestart(s.name, s.cwd, {
-        // cliKind はセッション名 (`<dir>__codex` か否か) だけで決まる。渡し忘れると
-        // createSession が既定の claude として扱い、codex セッションの再生成でも
-        // AGENTS.md ではなく CLAUDE.md を同期対象にしてしまう。
-        cliKind,
-        claudeCmd: claudeCmdFromAgentConfig(ctx.config),
-        codexCmd: cliKind === "codex" ? prebuiltCodexCmd : undefined,
-        ...codexDefaults,
-        logger: ctx.logger,
-      })
-      result.recreated.push(s.name)
-    } catch (err) {
-      result.failed.push({ name: s.name, reason: err?.message || String(err) })
-    }
-  }
-  return result
-}
-
 /**
  * `~/.claude/scripts/manifest.json` から Hub AI bundle の version を読む。
  * 未セットアップなら null を返す。
@@ -506,27 +353,6 @@ export function applyActiveProfileEnv(profile, log) {
   )
 }
 
-/**
- * active プロファイルの CLAUDE_CONFIG_DIR を tmux サーバーのグローバル環境にも同期する。
- * tmux pane のシェルは hub-agent の process.env を見ないため、set-environment -g で流し込む。
- * pane は既定で素のシェル (CLI を自動起動しない) なので、ユーザーが pane 内で直接
- * `claude` を打つケースにはこれが主経路になる
- * (`HUB_AGENT_TMUX_LAUNCH_CLI=1` で CLI を pane 起動するときだけ、createSession 内の
- *  injectConfigDirEnv によるコマンド焼き込みが併用される)。
- * tmux サーバー未起動でも失敗しない。
- */
-export async function syncTmuxProfileEnv(profile, log) {
-  const isDefault =
-    !profile ||
-    profile.id === DEFAULT_PROFILE_ID ||
-    profile.configDir === defaultConfigDir()
-  await setTmuxGlobalEnv(
-    "CLAUDE_CONFIG_DIR",
-    isDefault ? null : profile.configDir,
-    { logger: log },
-  )
-}
-
 /**
  * active Codex プロファイルの configDir を process.env.CODEX_HOME へ反映する。
  * 既定 (`~/.codex`) のときは変数を消して Codex 既定パスに戻す。codex app-server は
@@ -552,20 +378,6 @@ export function applyActiveCodexEnv(profile, log) {
   )
 }
 
-/**
- * active Codex プロファイルの CODEX_HOME を tmux サーバーのグローバル環境へ同期する。
- * tmux pane で直接 `codex` を打つケースや respawn の保険。tmux 未起動でも失敗しない。
- */
-export async function syncTmuxCodexEnv(profile, log) {
-  const isDefault =
-    !profile ||
-    profile.id === codexProfiles.DEFAULT_CODEX_PROFILE_ID ||
-    profile.configDir === codexProfiles.defaultCodexDir()
-  await setTmuxGlobalEnv("CODEX_HOME", isDefault ? null : profile.configDir, {
-    logger: log,
-  })
-}
-
 /**
  * `setup_hub_ai.py --silent` を best-effort でキックし、全プロファイルの settings.json へ
  * bundle hooks (cockpit_permission_bridge 等) を反映させる。
@@ -930,7 +742,6 @@ export async function startDaemon({ version, claudeSdk } = {}) {
   try {
     const activeProfile = await getActiveProfile()
     applyActiveProfileEnv(activeProfile, logger)
-    await syncTmuxProfileEnv(activeProfile, logger)
   } catch (err) {
     logger.warn(
       { err: err.message },
@@ -942,7 +753,6 @@ export async function startDaemon({ version, claudeSdk } = {}) {
   try {
     const activeCodex = await codexProfiles.getActiveProfile()
     applyActiveCodexEnv(activeCodex, logger)
-    await syncTmuxCodexEnv(activeCodex, logger)
   } catch (err) {
     logger.warn(
       { err: err.message },
@@ -1213,58 +1023,15 @@ export async function startDaemon({ version, claudeSdk } = {}) {
     // no-op. ref されていることだけが重要。
   }, 60_000)
 
-  // 5s 周期で全 tmux session の状態を捕捉し、変化したものだけ session.state を push。
-  // browser がフォーカスしていない session でも常時更新するためのバックグラウンド職人。
-  // ready-for-input 判定: claude プロセスの子プロセスを内省し「Stop フック/ツール実行が
-  // 終わって真に入力可能になった」エッジを検出する (proc-introspect.mjs)。capture-pane は
-  // Stop フック実行中を観測できないため、これが「stop の早期消灯/誤フラッシュ」の根治。
-  // 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()
-  ctx.readinessTracker = readinessTracker
-  const stateLoop = startStateLoop({
-    client,
-    plugins,
-    logger,
-    intervalMs: 5_000,
-    claudeBridge,
-    // 背景 Codex チャットセッションの状態を state loop へ渡す。
-    codexBridge,
-    readinessTracker,
-    // tmux session_name → bind 中の session_id。turn_active を「そのペインが実際に走らせている
-    // セッションの jsonl」で判定するために渡す (cwd dir 内の別 jsonl 取り違え=メタ欠陥#1 の根治)。
-    boundSessions: ctx.tuiReboundSessions,
-  })
-  // T1: tmux.list_sessions poll fallback で turn_active/proc_busy/child_busy/stalled を
-  // 同梱できるよう、state loop の最新値スナップショット accessor を ctx に晒す。
-  // push 専用の 4 信号を poll でも回復可能にする (生産点は state loop で単一のまま、
-  // 取り出し口を 2 つに増やすだけ = §5 の用途別出し分けを侵さない)。
-  ctx.getSessionStateSnapshot = stateLoop.getSnapshot
+  // 会話の回収と常駐数制限を定期実行する。
+  const stateLoop = startStateLoop({ client, logger, intervalMs: 5_000, claudeBridge, codexBridge })
   // bundle hook (cockpit_session_event_hook.py) が /tmp/cockpit_session_events/<name>.json
   // に書き出す UserPromptSubmit / Stop / ready の event を fs.watch で拾って WS push する。
   // text マーカー判定 (detectStatusFromText) より精度が高い「ターン境界」の signal。
-  // prompt_submit / stop で readinessTracker を arm し、ready の settle 検出に繋ぐ。
   const sessionEventLoop = await startSessionEventWatcher({
     client,
     logger,
-    readinessTracker,
-  })
-  // arm 済みセッションの子プロセスを高速 poll し、baseline 復帰で event ファイルに 'ready'
-  // を書く (既存 watcher が session.event 'ready' を push)。アイドル時は ps を spawn しない。
-  const readinessLoop = startReadinessLoop({
-    logger,
-    tracker: readinessTracker,
-    intervalMs: 700,
   })
-
-
   // sibling-inject (ask-sibling スキル, 2026-07-04): 同一 cwd の claude⇄codex
   // 相互依頼のためのローカル IPC 受信口。cwd スコープ capability トークン
   // (src/sibling-token.mjs) で検証した要求のみ claudeBridge/codexBridge.sendToCwd()
@@ -1315,7 +1082,6 @@ export async function startDaemon({ version, claudeSdk } = {}) {
     logger.info({ signal }, "agent stop hooks completed")
     stateLoop.stop()
     sessionEventLoop?.stop?.()
-    readinessLoop?.stop?.()
     restartCoordinator?.stop?.()
     claudeBridge?.shutdown?.()
     codexBridge?.shutdown?.()
@@ -1773,11 +1539,6 @@ async function readAllSessionEvents() {
   return out
 }
 
-// 複数 Cockpit タブは各自 8 秒 poll を持つため、位相がずれると agent は同じ
-// tmux/worktree/jsonl スナップショットを数秒おきに再構築してしまう。5 秒だけ成功値を
-// 共有し、同時要求は single-flight に畳む。create/kill/worktree 変更時は明示 clear する。
-export const tmuxSessionsSnapshotCache = new AsyncTtlCache({ ttlMs: 5_000 })
-
 /**
  * `/tmp/cockpit_session_events/<tmux_session>.json` を fs.watch して
  * UserPromptSubmit / Stop の event を `session.event` 型で Hub に push する。
@@ -1880,7 +1641,6 @@ export async function publishSessionEvent(
       sort_affecting: sortAffecting,
     }, "session.event push")
   }
-  tmuxSessionsSnapshotCache.clear()
   client.send({
     type: "session.event",
     session_name: sessionName,
@@ -1891,125 +1651,11 @@ export async function publishSessionEvent(
   return { sortAffecting }
 }
 
-
-/**
- * arm 済みセッション (prompt_submit / stop を受けた or busy 観測中) の claude プロセスを
- * 高速 poll し、子プロセスが baseline へ復帰したエッジで event ファイルに 'ready' を書く。
- * 既存の startSessionEventWatcher がそれを `session.event` 'ready' として push し、frontend は
- * 「真に入力可能」になった瞬間として消灯 + キューフラッシュする (Stop フック中の誤フラッシュ
- * 根治)。tracker.getBusy() は state loop が proc_busy レベルとして相乗せする。
- * onReady(name): ready エッジで呼ぶコールバック (busy で defer した +新規 の実行に使う)。
- *
- * 負荷: アイドル (armed/busy なし) のときは ps を spawn しない。claude pid は TTL キャッシュ。
- */
-function startReadinessLoop({ tracker, logger, intervalMs = 700, onReady }) {
-  let stopped = false
-  const PANE_PID_TTL_MS = 30_000
-  const panePidByName = new Map() // name → {pid, at}
-  const unresolvedStreak = new Map() // name → 連続解決失敗回数 (SDK チャット等の掃除用)
-
-  // busy 子数のカウント基点は claude 本体 PID ではなく tmux の **pane_pid** にする。
-  // 理由: (1) クロスプラットフォーム安全 — claude を comm 名で同定する方式は Linux/WSL で
-  // claude が `node .../cli.js` として起動し comm が 'node' になり同定に失敗する。pane_pid
-  // 基点なら子孫を数えるだけで claude の同定が不要。(2) /clear 耐性 — claude PID は /clear で
-  // 変わるが pane_pid (ペインの shell) は不変なので再解決が要らない。baseline (rolling-min) が
-  // 「claude 本体 + 常駐 MCP」を吸収するので、基点が pane_pid でも busy=「一過性の子増加」で正しい。
-  const resolvePanePid = async (name, procMap) => {
-    const hit = panePidByName.get(name)
-    if (hit && procMap.has(hit.pid) && Date.now() - hit.at < PANE_PID_TTL_MS) {
-      return hit.pid
-    }
-    const panePid = await getPanePid(name)
-    if (panePid && procMap.has(panePid)) {
-      panePidByName.set(name, { pid: panePid, at: Date.now() })
-      return panePid
-    }
-    panePidByName.delete(name)
-    return null
-  }
-
-  const tick = async () => {
-    if (stopped) return
-    try {
-      const names = []
-      for (const n of tracker.byName.keys()) {
-        if (tracker.isActive(n)) names.push(n)
-      }
-      if (names.length === 0) return
-      const procMap = await snapshotProcs()
-      if (procMap.size === 0) return // ps 失敗時は据え置き (spurious ready 防止)
-      for (const name of names) {
-        const root = await resolvePanePid(name, procMap)
-        if (!root) {
-          // 解決失敗は observe しない (count=0 を注入すると誤って ready が出るため)。
-          // SDK チャット等で tmux セッションが無いものは連続失敗で tracker から忘れる。
-          const k = (unresolvedStreak.get(name) ?? 0) + 1
-          if (k >= 8) {
-            tracker.forget(name)
-            unresolvedStreak.delete(name)
-            panePidByName.delete(name)
-          } else {
-            unresolvedStreak.set(name, k)
-          }
-          continue
-        }
-        unresolvedStreak.delete(name)
-        const count = busyChildCount(root, procMap)
-        const { ready } = tracker.observe(name, count)
-        if (ready) {
-          await writeSessionEventFile(name, "ready", Date.now())
-          // busy で defer した +新規 をターン終了 (ready) のここで 1 回だけ実行する。
-          try {
-            await onReady?.(name)
-          } catch (err) {
-            logger?.warn({ err: err?.message }, "readiness onReady callback failed")
-          }
-        }
-      }
-    } catch (err) {
-      logger?.warn({ err: err?.message }, "readiness loop tick failed")
-    }
-  }
-
-  const ti = setInterval(tick, intervalMs)
-  ti.unref?.()
-  return {
-    stop() {
-      stopped = true
-      clearInterval(ti)
-    },
-  }
-}
-
-/**
- * 全 tmux session の状態を定期 capture し、変化したものだけ Hub に push する。
- *
- * - 前回値との比較で status / context_pct のどちらかが変化したら送る
- * - 新規 session は無条件 push、消えた session は無視 (browser 側は
- *   セッション一覧の更新で消滅を検知する)
- * - tmux 自体が動いてない場合 (listSessionStates → []) は何も push しない
- */
-// (i) 出力フロー検知の有効窓。ペイン出力領域の署名 (output_sig) が直近この時間内に変化して
-// いれば「出力ストリーミング中」とみなし proc_busy に OR する。state loop は 5s 周期なので、
-// 連続生成中は毎 tick 署名が変わり常時 true、出力が止まれば次 tick (≤5s) で署名不変になり
-// 窓経過後に false へ落ちる (ターン終了後のスピナー固着=症状A を悪化させない短さ)。
-// 出力フロー検知窓。state loop tick(5000ms)の整数倍にして、出力が止まった後の outputActive が
-// 5s tick 境界で true↔false フラッピングするのを防ぐ(8000 は非整数倍で proc_busy 単独反転 push が
-// 多発していた=perf監査。10000=2tick で安定側、影響は『出力停止とみなす猶予 8s→10s』のみ)。
-const OUTPUT_ACTIVE_MS = Number(process.env.HUB_AGENT_OUTPUT_ACTIVE_MS ?? 10000)
-
 // 状態信号の計装ログ(session.state/event push)を出すか。既定 OFF。障害解析時に
 // HUB_AGENT_STATE_TRACE=1 で一時的に有効化する(常時 info 出力はログ肥大の主因=perf監査で
 // 直近1h ログの約半分を占めると実測。挙動には一切影響しない純ログ)。
 const STATE_TRACE = process.env.HUB_AGENT_STATE_TRACE === "1"
 
-// 権威的な「応答停止 (ハング)」判定の無進捗しきい値。ターン進行中 (armed) なのに、実際の
-// 進捗 (子プロセス実行中 / 出力フロー / ペインのライブ processing) がこの時間継続して観測
-// されなければ stalled とする。frontend 側の jsonl 無音タイマー (長時間ツールで誤検知し、
-// 本当のハングでは turnActive クリアにより見逃す) を置き換える正本。frontend の
-// TURN_STALL_WARN_MS と揃える。
-const STALL_WARN_MS = Number(process.env.HUB_AGENT_STALL_WARN_MS ?? 90000)
-
 /**
  * tmux.list_sessions 応答に同梱する session オブジェクトを組み立てる純関数。
  *
@@ -2086,14 +1732,6 @@ export function applyChatOverlay(paneStatus, paneContextPct, chat) {
   return { status, contextPct }
 }
 
-function codexRowSession(bridge, cwd) {
-  // 代表行（終了印を含む）は代表実体だけを見る。背景会話へ落ちると終了後も履歴 I/O が走る。
-  if (hasRepresentativeRow(cwd, "codex")) {
-    const rep = getRepresentativeConversation(cwd, "codex")
-    return rep && !rep.dead ? rep : null
-  }
-  return bridge?.liveSessionForCwd?.(cwd) ?? null
-}
 
 /**
  * codex 行の使用率を、行の代表会話の live 値で上書きするかを決める。
@@ -2235,116 +1873,6 @@ export function filterCodexSessionsByAuthority(codexSessions, producerByCwd, seq
   return codexSessions.filter((e) => seqForCwd(e.cwd) === producerByCwd.get(e.cwd))
 }
 
-/**
- * S1 (2026-07): claude.attach / codex.attach の直後に、その cwd に対応する session.state を
- * 1 回だけ即時 push する。startStateLoop の周期 (既定 5s) を待つと、エンジン切替や新規
- * セッション選択の直後もサイドバーのドーナツ/ステータスドットが前セッションの値のまま
- * 数秒間残ってしまう (症状③④)。claude.tui.bind が既に持つ「即時ステータススナップショット」
- * (main.mjs 内 detectSessionState 直後の push) と同じ発想で、チャット (SDK/app-server) 側にも
- * 対称の即時 push を用意する。
- *
- * cwd → session_name の解決: claude.attach / codex.attach は tmux の session_name を知らない
- * (browser は cwd/stream_id しか送らない) ため、listSessionStates で全 tmux session を走査し
- * cwd が一致するものへ push する。tmux 自体が無い / 一致が無ければ何もしない (安全側、次の
- * poll 系フォールバックに委ねる)。
- *
- * ⚠️ T05945: 同一 cwd に claude 行 (`<dir>`) と codex 行 (`<dir>__codex`) が並ぶため、cwd 一致
- * だけで push すると **attach した CLI のゼロ値/実値が反対側の CLI 行にも書き込まれる**
- * (codex を新規 attach した瞬間に claude 行のドーナツが 0% に落ちる)。行のセッション名から
- * 導いた cli_kind が attach 中の CLI と一致する行にだけ push する。
- *
- * `listSessionStatesFn` は単体テスト用の DI ポイント (既定は実 `listSessionStates`、tmux を
- * 起動する)。実運用では省略してよい。
- *
- * @param {{ client: object, plugins: object, logger?: object, cwd: string, cliKind: 'claude'|'codex', sessionId: string|null, streamId?: string|null, contextPct?: number|null, listSessionStatesFn?: Function }} args
- */
-export async function pushImmediateChatState({
-  client,
-  plugins,
-  logger,
-  cwd,
-  cliKind,
-  sessionId,
-  streamId,
-  contextPct = 0,
-  listSessionStatesFn = listSessionStates,
-}) {
-  if (!cwd || !client) return
-  try {
-    const states = await listSessionStatesFn({ plugins, logger })
-    for (const s of states) {
-      if (s.cwd !== cwd) continue
-      if (cliKindForSessionName(s.session_name) !== cliKind) continue
-      const status = "waiting"
-      // 代表行は直後の applyRowChatState が代表会話の実 ID で上書きする。
-      const contextSessionId = sessionId ?? null
-      tmuxSessionsSnapshotCache.clear()
-      client.send(applyRowChatState({
-        type: "session.state",
-        session_name: s.session_name,
-        status,
-        context_pct: typeof contextPct === "number" ? contextPct : null,
-        stable: status !== "processing",
-        proc_busy: false,
-        child_busy: false,
-        stalled: false,
-        turn_active: status == null ? null : status === "processing",
-        cli_kind: cliKind,
-        // context_pct がどの会話の値かを明示する。frontend は ID が変わったときだけ
-        // 0% を採用し、同一会話の一時的な 0/null は直近の確定値を保持する。
-        context_session_id: contextSessionId,
-        chat_session_id: contextSessionId,
-      }, cwd, cliKind))
-    }
-  } catch (err) {
-    logger?.warn?.({ err: err?.message, cwd }, "pushImmediateChatState failed")
-  }
-}
-
-/**
- * チャット入力の受付時刻を、対応する tmux 行の prompt_submit として **in-process で** publish する。
- *
- * state loop の 5 秒 tick だけでは、5 秒未満で完了するターンや、終了と次の開始の間に tick が
- * 入らない連続ターンを取りこぼし、観測できても送信時刻ではなく assistant event の時刻になる。
- * そこで handler が入力を受け付けた瞬間 (dispatch 前) に、cwd と CLI 種別が一致する tmux 行へ
- * publishSessionEvent(prompt_submit, 受付時刻, fresh) を流す。
- *
- * ファイルは書かない。並び順の正本は ingestSessionEventForSort の sidecar (poll の
- * sort_affecting_at で復元される) で、event ファイルは status 復元用に state loop が従来どおり
- * 書く (その prompt_submit の at は chatSessionEventForTick が受付時刻へ揃える)。直接経路が
- * ファイルを書かないので、fs.watch の読み落とし・並行 rename・kill 中の保留書き込みといった
- * ファイル由来の競合そのものが無い。
- *
- * bridge が入力を拒否した場合 (empty / queue dead 等) も publish 済みのまま取り消さない:
- * 並び順の定義は「最後に人間が送った順」で、送信操作自体は起きているため (仕様)。
- */
-export async function notifyChatPromptSubmit({
-  cwd,
-  cliKind,
-  at,
-  client,
-  readinessTracker,
-  plugins,
-  logger,
-  listSessionStatesFn = listSessionStates,
-  publishFn = publishSessionEvent,
-}) {
-  if (!cwd || !client) return
-  try {
-    const states = await listSessionStatesFn({ plugins, logger })
-    for (const s of states) {
-      if (s.cwd !== cwd || cliKindForSessionName(s.session_name) !== cliKind) continue
-      try {
-        await publishFn({ client, readinessTracker, logger }, s.session_name, "prompt_submit", at, { fresh: true })
-      } catch (err) {
-        logger?.warn?.({ err: err?.message, cwd, cliKind, session_name: s.session_name }, "notifyChatPromptSubmit publish failed")
-      }
-    }
-  } catch (err) {
-    logger?.warn?.({ err: err?.message, cwd, cliKind }, "notifyChatPromptSubmit failed")
-  }
-}
-
 /**
  * chat signal から、この tick で書く session-event を導出する。
  * FIFO で前ターンの stop 後に次ターンの processing を観測しても、prompt_submit の at は
@@ -2432,17 +1960,7 @@ export function decideTurnActiveSource({
   return "none"
 }
 
-export function startStateLoop({ client, plugins, logger, intervalMs, claudeBridge, codexBridge, readinessTracker, boundSessions, listSessionStatesFn = listSessionStates, writeSessionEventFileFn = writeSessionEventFile }) {
-  const lastByName = new Map() // session_name → {status, context_pct}
-  const lastTurnAtByName = new Map() // session_name → 最後に event ファイル化した turnAt
-  // session_name → 最後に書いた chat 由来 event 種別。エッジ駆動 (種別遷移時のみ書く) にして
-  // 生成中の prompt_submit 連打を防ぐ (並行生成でサイドバーが揺れる原因)。
-  const lastChatEventByName = new Map()
-  // (i) session_name → {sig, changedAt}: 出力領域署名の最終変化時刻 (出力フロー検知用)。
-  const outputFlowByName = new Map()
-  // 権威的 stall 判定 (arm 非依存・cap 非依存)。state loop が観測する signal だけで turn の開閉と
-  // 無進捗を判定する。旧 lastProgressAtByName + armed ゲートの「フック依存 + cap 140s で消える」死角を解消。
-  const stallTracker = new StallTracker({ stallWarnMs: STALL_WARN_MS })
+export function startStateLoop({ client, logger, intervalMs, claudeBridge, codexBridge }) {
   // 総 live 上限 M のログ抑制状態。⚠️ **この state loop インスタンスが所有する**（module-global に
   // 置くと、複数インスタンスや並行テストが互いのログを抑制してしまう）。「超過しているが全部
   // 保護されていて刈れない」tick は 5 秒ごとに同じ行を出し続けるので、状態が変わったときと
@@ -2450,17 +1968,6 @@ export function startStateLoop({ client, plugins, logger, intervalMs, claudeBrid
   const warmBoundsLogState = { lastUnresolved: 0, lastLoggedAtMs: 0 }
   let stopped = false
 
-  // RC-8: WS 再接続のたびに差分送信の基準 (lastByName) をクリアし、次 tick で全 session.state を
-  // 再 push する。差分送信のままだと、切断中に起きた status 遷移 (processing→stop 等) の push が
-  // 失われ、再接続後も frontend が古い processing に固着する (zombie WS の検知が遅れると最大数十秒)。
-  // client は (再)接続ごとに "open" を emit する。フロントの tmux.list_sessions poll でも回復するが、
-  // これで再接続直後の次 tick (≤intervalMs) に短縮する。初回接続時は空 Map の clear で no-op。
-  const onReopen = () => {
-    lastByName.clear()
-    tmuxSessionsSnapshotCache.clear()
-  }
-  client.on("open", onReopen)
-
   const tick = async () => {
     if (stopped) return
     try {
@@ -2505,232 +2012,6 @@ export function startStateLoop({ client, plugins, logger, intervalMs, claudeBrid
       // 実コンテキスト窓サイズ (1M ベータ等) を反映。contextPctFromUsage の分母を
       // 5s ごとに最新化し、ドーナツが 200k 固定で振り切れるのを防ぐ。
       await refreshContextWindow()
-      const states = await listSessionStatesFn({ plugins, logger })
-      for (const s of states) {
-        // T05945: この行がどの CLI のセッションかは **セッション名から構造的に決まる**
-        // (`<dir>` = claude / `<dir>__codex` = codex)。chat 信号の読み出し・turn_active の
-        // 判定源・session.state に載せる cli_kind はすべてこの 1 値から導く (正本一本化)。
-        const sessionCliKind = cliKindForSessionName(s.session_name)
-        // チャットモード補完: tmux ペインのスクレイプは TUI 前提で効かないため、
-        // session の cwd に一致する新鮮なチャット信号があれば status/context% を
-        // 上書きする (Hub ホスト型 Cockpit のステータスドット/各行ドーナツ用)。
-        // 代表が設定済みなら、その会話の値だけを使い、欠けた値は null とする。
-        // 代表未設定の行は従来の applyChatOverlay / pane processing ガードを使う。
-        // (cwd, cliKind) キーで自 CLI のチャット信号だけを読む。同一 cwd の別 CLI 行が
-        // 立てた status/context_pct を拾わない (交差汚染の遮断)。
-        const representative = hasRepresentativeRow(s.cwd, sessionCliKind)
-        const chat = s.cwd ? readRowChatState(s.cwd, sessionCliKind) : null
-        const overlay = applyChatOverlay(s.status, s.context_pct, chat)
-        let status = representative ? chat?.status ?? null : overlay.status
-        let contextPct = representative ? chat?.context_pct ?? null : overlay.contextPct
-        // 内容安定で「確実に停止」と判定できたか (frontend が 2 サンプル消灯確認を省いて
-        // 即消灯するためのフラグ)。chat 信号で processing へ上書きされた場合は false。
-        let stable = status !== "processing" && s.stable === true
-        // プロセス内省由来の busy レベル (Stop フック/ツール実行中=true)。frontend は
-        // これでペイン由来の早期消灯を抑止し、tool/Stop フック中もスピナーを保つ。
-        // 高速 readiness loop が維持する値をそのまま相乗せする (この loop では計算しない)。
-        const childBusy = readinessTracker ? readinessTracker.getBusy(s.session_name) : false
-        // (i) 出力フロー検知: proc 内省は pane_pid 子孫の「プロセス数」で busy を見るため、
-        // ツールを起動しない純テキスト生成 (モデルが出力を流すだけ) を busy として検出できない。
-        // その間に capture-pane のスピナー検出が 1 フレーム取りこぼすと frontend がアイドルと
-        // 誤読してスピナーを消す (生成中なのに消える=症状B)。出力領域の署名が直近変化していれば
-        // 「出力中」とみなし proc_busy に OR する。childBusy=false の純テキスト生成中も
-        // proc_busy=true となり frontend のペイン由来消灯が抑止される。出力が止まれば署名が
-        // 不変になり窓経過後に false へ落ちるので、ターン終了後のスピナー固着は悪化させない。
-        let outputActive = false
-        if (typeof s.output_sig === "string") {
-          const prevFlow = outputFlowByName.get(s.session_name)
-          let changedAt = prevFlow ? prevFlow.changedAt : 0
-          if (!prevFlow || prevFlow.sig !== s.output_sig) changedAt = Date.now()
-          outputFlowByName.set(s.session_name, { sig: s.output_sig, changedAt })
-          outputActive = Date.now() - changedAt < OUTPUT_ACTIVE_MS
-        }
-        const procBusy = childBusy || outputActive
-        // 権威的 stall 判定 (StallTracker, arm 非依存・cap 非依存)。armed (バンドルフックが効く
-        // セッション) は OR で常に turn 開扱い (従来挙動の上位互換)。フック未発火/旧世代hookセッション
-        // でも観測した processing で turnOpen を立て、frozen スピナー (spinner_present) を維持して proc 子も
-        // 出力も止まったハングを拾う。proc 内省の cap(140s) disarm に依存しないので 140s 以後も消えない。
-        // 旧実装の「armed 依存 + cap で消える」二重死角を解消。frontend はこれを応答停止バナーの正本に使う。
-        const armed = readinessTracker
-          ? readinessTracker.isArmed(s.session_name)
-          : false
-        const nowMs = Date.now()
-        const { stalled } = stallTracker.observe(s.session_name, {
-          armed,
-          processing: status === "processing",
-          procBusy,
-          spinnerPresent: s.spinner_present === true,
-          stable,
-          now: nowMs,
-        })
-
-        // 代表行は下の同期読み出しが turn_active も確定する。
-        // 代表未設定の行だけ、従来の履歴・pane probe を使う。
-        let turnActive = null
-        // codex 行のときだけ rollout ベース判定の材料を引く (claude 行では常に null)。
-        // 行の**代表会話の session** を 1 度だけ引き、threadId(turn_active 判定用・会話 ID) と
-        // seq(context% の live source 参照キー) の両方を同一 session から取る。⚠️ 別々に引くと
-        // 「背景会話の使用率に代表会話の ID が付く」不整合になる。usage.response と同じ
-        // codexRowSession を使い、代表が live でなければ null（別会話の値で埋めない）。
-        const codexAuthSession =
-          s.cwd && sessionCliKind === "codex"
-            ? codexRowSession(codexBridge, s.cwd)
-            : null
-        const codexThreadId = codexAuthSession?.threadId || null
-        // T06407 増分2 (axis3): codex 行の context%(ドーナツ) は TTL 非依存の live store
-        // (thread/tokenUsage/updated 由来) を権威 producer(seq) で引き、chat overlay より優先して
-        // 恒久収束させる。代表未設定の行だけ、従来の pane processing ガードを使う。
-        const paneIsProcessing = !representative && s.status === "processing"
-        if (sessionCliKind === "codex") {
-          const liveCtx = typeof codexAuthSession?.seq === "number" && !paneIsProcessing
-            ? codexLiveContextForProducer(codexAuthSession.seq)
-            : null
-          contextPct = resolveCodexRowContextPct({
-            contextPct, paneIsProcessing, rowSession: codexAuthSession, liveContextPct: liveCtx,
-          })
-        }
-        // fresh bind は実 session_id がまだ確定していない。tmux.list の statusLine / cwd 最新
-        // JSONL は直前会話の値を返し得るため、この間は必ず 0% を正本にする。これをしないと
-        // bind の即時 0% snapshot の直後に state loop が旧値を同じ fresh:<id> で再送して
-        // ドーナツを復活させる。
-        const freshUnbound =
-          sessionCliKind === "claude" && isFreshUnboundBind(boundSessions?.get(s.session_name))
-        if (freshUnbound && !representative) contextPct = 0
-        const turnActiveSource = representative ? "representative" : decideTurnActiveSource({
-          chatStatus: chat?.status,
-          cwd: s.cwd,
-          isFreshUnbound: freshUnbound && !representative,
-          codexThreadId,
-          sessionCliKind,
-        })
-        switch (turnActiveSource) {
-          case "chat-active":
-            turnActive = true
-            break
-          case "chat-inactive":
-            turnActive = false
-            break
-          case "fresh-unbound":
-            // 症状2b 根治: fresh bind プレースホルダの間は、別アクティビティ jsonl を mtime 最新で
-            // 取り違える汚染を避けて turn_active を出さない (null=不明)。実セッション id へ adopt
-            // されれば下の通常経路に乗る。青を出さない安全側にのみ倒すため固着青は生まない。
-            turnActive = null
-            break
-          case "codex":
-            turnActive = await codexTurnActiveForThread(codexThreadId)
-            break
-          case "claude": {
-            // P5 (T06570 症状3): チャットセッションは、そのセッションの SDK query ライフサイクル由来の
-            // 権威フラグ _busy を最優先する (Codex の rollout flag 優先と対称)。これにより browser を
-            // 離れて detach され this.sessions から外れた warm セッションでも、稼働中ターンの turn_active
-            // が維持され、非選択行のドットが赤へ誤落ちしない。加えて bare-shell pane を dead 判定して
-            // 赤へ倒す paneAliveProbe 経路 (チャットは実体が SDK 子プロセスで pane は素のシェル) も回避する。
-            // 代表があれば、その会話の busy だけを読む。不在なら null のままにする。
-            // 代表未設定の行だけ、従来の cwd 最新 / jsonl / pane probe を使う。
-            const chatActive = claudeBridge?.chatTurnActiveForCwd?.(s.cwd)
-            if (representative || chatActive === true || chatActive === false) {
-              turnActive = chatActive
-            } else {
-              turnActive = await turnActiveForCwd(
-                s.cwd,
-                resolveStateLoopBoundSessionId(boundSessions, s.session_name, s.cwd, claudeBridge),
-                s.session_name,
-                { paneAliveProbe: paneClaudeAliveOrUnknown },
-              )
-            }
-            break
-          }
-          default:
-            turnActive = null
-        }
-
-        // cli_kind (T05945): **セッション名から導いた構造的な値**を常に載せる。旧実装は
-        // 「チャット信号があればその cliKind、無ければ null」だったため、TUI 専用行や
-        // チャット未接続行で null になり、frontend が行の CLI を知る術が無かった。
-        // (cwd, cliKind) キー化により「チャット信号の cliKind == 行の cliKind」が恒真に
-        // なったので、常に非 null の構造値を送る方が真に厳しい (= 情報量が多い) 上位互換。
-        //
-        // context_session_id は「この context_pct がどの会話の値か」。チャットの session/thread を
-        // 優先し、Claude TUI 専用行では bind 済みの session_id（fresh は fresh:<request_id>）を使う。
-        // frontend はこれを境界として、新規会話の 0% と同一会話の一時的な 0/null を区別する。
-        const chatCliKind = sessionCliKind
-        const contextSessionId =
-          chat?.sessionId ??
-          (sessionCliKind === "claude"
-            ? boundSessions?.get(s.session_name) ?? `unbound:${s.session_name}`
-            : codexThreadId)
-
-        // 履歴・pane の非同期処理が終わった後に、現在の実体を同期で読む。
-        const payload = applyRowChatState({
-          status, context_pct: contextPct, stable, proc_busy: procBusy, child_busy: childBusy,
-          stalled, turn_active: turnActive, cli_kind: chatCliKind,
-          context_session_id: contextSessionId, chat_session_id: contextSessionId,
-        }, s.cwd, sessionCliKind)
-        const currentChat = readRowChatState(s.cwd, sessionCliKind)
-        if (currentChat) {
-          // チャットのターン境界を sort / 状態用 session-event に橋渡しする。
-          // tmux ペインが動かず bundle hook が発火しないため、ここで代替発火する。
-          //
-          // ⚠️ **エッジ駆動** (種別が変わったときだけ書く)。旧実装は turnAt が前進するたびに
-          // 書いており、turnAt は assistant イベント毎に前進するため **生成中ずっと
-          // prompt_submit を書き続けていた**。並行生成中のセッション同士が assistant の
-          // 到着順で入れ替わり、サイドバーが揺れる原因になる (2026-07-29)。
-          // 種別遷移でのみ書けば、prompt_submit は生成開始の 1 回だけになる。
-          //
-          // 確認待ち (inputPending) は専用 event "input_required"、生成中は "prompt_submit"、
-          // それ以外は "stop"。並び順に効くのは computeSortAffecting により prompt_submit だけ。
-          const prevTurnAt = lastTurnAtByName.get(s.session_name) || 0
-          const prevEv = lastChatEventByName.get(s.session_name)
-          const eventForTick = chatSessionEventForTick({
-            chat: currentChat,
-            prevEv,
-            prevTurnAt,
-            directAt: s.cwd ? getPromptAcceptedAt(s.cwd, sessionCliKind) : undefined,
-          })
-          if (eventForTick) {
-            const { ev, at } = eventForTick
-            lastTurnAtByName.set(s.session_name, currentChat.turnAt)
-            lastChatEventByName.set(s.session_name, ev)
-            writeSessionEventFileFn(s.session_name, ev, at).catch(() => {})
-          }
-        }
-        const prev = lastByName.get(s.session_name)
-        if (!prev || Object.keys(payload).some((key) => prev[key] !== payload[key])) {
-          lastByName.set(s.session_name, payload)
-          if (STATE_TRACE) logger?.info({ session_name: s.session_name, ...payload }, "session.state push")
-          tmuxSessionsSnapshotCache.clear()
-          client.send({ type: "session.state", session_name: s.session_name, ...payload })
-        }
-        // 消滅セッションの GC (perf監査/メモリリーク対策): tmux から消えたセッションの状態 Map を
-        // まとめて解放する。clear() は再接続時(onReopen)のみのため、worktree 案件の生成/破棄で
-        // 各 per-session Map が線形増加し RSS が無入力時も成長していた。tmux が一時的に空応答
-        // (states=[]) のときは全消去しないよう states.length>0 をガードにする。
-        if (states.length > 0) {
-          const liveNames = new Set(states.map((s) => s.session_name))
-          for (const name of [...lastByName.keys()]) {
-            if (liveNames.has(name)) continue
-            // 終端を能動 broadcast (症状3 根治): tmux から消えた = crash/外部 kill/別経路
-            // 終了。explicit kill は kill_session ハンドラが session.gone を出すが、それ以外
-            // の消滅はここが唯一の検知点。frontend が states/lastEvent を忘れてドットを
-            // 'down' に倒せるよう、ローカル Map を forget する前に通知する。
-            try {
-              tmuxSessionsSnapshotCache.clear()
-              client.send({ type: "session.gone", session_name: name })
-            } catch {
-              /* ignore */
-            }
-            invalidateSessionCache(name) // capture/cwd/statusGate/spinnerFreeze/stability (state.mjs)
-            stallTracker.forget(name) // StallTracker.byName
-            readinessTracker?.forget?.(name) // ReadinessTracker.byName
-            forgetSortAffectingState(name) // sawUserTurn / sort_affecting_at / lastEventAt (リーク防止)
-            lastByName.delete(name)
-            outputFlowByName.delete(name)
-            lastTurnAtByName.delete(name)
-            // 死んだセッションの bind 記録も掃除する (同名再作成時は claude.tui.bind が再登録)。
-            boundSessions?.delete(name)
-          }
-        }
-      }
     } catch (err) {
       logger?.warn({ err: err.message }, "state loop tick failed")
     }
@@ -2748,24 +2029,6 @@ export function startStateLoop({ client, plugins, logger, intervalMs, claudeBrid
       stopped = true
       clearInterval(ti)
       clearTimeout(t0)
-      client.off?.("open", onReopen)
-    },
-    /**
-     * tmux.list_sessions poll fallback 用の session.state snapshot を返す。
-     *
-     * 背景: session.state push は差分送信(prev 比較で変化時のみ送信)のため、WS 再接続
-     * 直後や push 取りこぼし時にドット権威信号(turn_active/proc_busy/child_busy/stalled)が
-     * 古値固着し得る(2026-06-28 ワークフローで検出した「事故的非対称」)。tmux.list_sessions
-     * poll の応答にこれら 4 信号を同梱することで、status/context_pct と同じ精度で poll 経路
-     * からも最新化できるようにする(T1)。
-     *
-     * shallow copy で返却して呼び出し側の mutate が lastByName を汚染するのを防ぐ
-     * (state loop の差分送信ロジックが prev 比較で誤判定するのを避ける = 症状A/B 再発防止)。
-     * 名前が未知 or まだ tick が走っていなければ null(frontend は legacy フォールバックへ)。
-     */
-    getSnapshot(name) {
-      const entry = lastByName.get(name)
-      return entry ? { ...entry } : null
     },
   }
 }
@@ -3030,25 +2293,10 @@ export function handleClaudeChatInput(msg, ctx) {
     }
     return undefined
   }
-  // cwd は dispatch 前に確定する (Promise 解決後に引くと、その間に stream が別 cwd へ再 attach
-  // された場合に別行へ記録する)。受付時刻の記録と並び順の publish も dispatch **前** に行う:
-  // Claude の resident reconcile / Codex の turn/start RPC が未解決の間に assistant / turn/started
-  // が先に届いて state loop が processing を観測しても、記録済みなら観測時刻ではなく受付時刻で
-  // 書かれる。bridge が拒否しても取り消さない (仕様。notifyChatPromptSubmit の JSDoc)。
+  // 非同期の入力処理へ渡す前に cwd と受付時刻を確定する。
   const cwdSnapshot = ctx.claudeBridge.getCwd?.(stream_id) ?? null
   if (cwdSnapshot) {
     recordPromptAccepted(cwdSnapshot, "claude", acceptedAt, ctx.claudeBridge.sessions?.get(stream_id), ctx.claudeBridge)
-    notifyChatPromptSubmit({
-      cwd: cwdSnapshot,
-      cliKind: "claude",
-      at: acceptedAt,
-      plugins: ctx.plugins,
-      logger: ctx.logger,
-      client: ctx.client,
-      readinessTracker: ctx.readinessTracker,
-      listSessionStatesFn: ctx._listSessionStates || listSessionStates,
-      publishFn: ctx._publishSessionEvent || publishSessionEvent,
-    }).catch(() => {})
   }
   const p = ctx.claudeBridge
     .input({
@@ -3264,17 +2512,6 @@ export function handleCodexChatInput(msg, ctx) {
   const cwdSnapshot = ctx.codexBridge.getCwd?.(stream_id) ?? null
   if (cwdSnapshot) {
     recordPromptAccepted(cwdSnapshot, "codex", acceptedAt, ctx.codexBridge.sessions?.get(stream_id), ctx.codexBridge)
-    notifyChatPromptSubmit({
-      cwd: cwdSnapshot,
-      cliKind: "codex",
-      at: acceptedAt,
-      plugins: ctx.plugins,
-      logger: ctx.logger,
-      client: ctx.client,
-      readinessTracker: ctx.readinessTracker,
-      listSessionStatesFn: ctx._listSessionStates || listSessionStates,
-      publishFn: ctx._publishSessionEvent || publishSessionEvent,
-    }).catch(() => {})
   }
   const p = ctx.codexBridge
     .input({
@@ -3384,72 +2621,6 @@ export async function handleCodexInterrupt(msg, ctx) {
   })
 }
 
-/**
- * tmux.kill_session の処理 (症状3 根治)。要求された session を kill し、要求元へ
- * tmux.kill_session.result を返したうえで、kill できた各 session について
- * **session.gone を能動 broadcast** する。
- *
- * 不変条件: session の終端 (kill/crash/外部終了) は、同一ホストで実体を観測できる
- * agent が正本として能動 push する。これが無いと frontend は kill 時点の turn_active=true
- * を keep-last したままステータスドットが青で固着する。最後の 1 セッションを kill した
- * 場合 state loop の GC は states.length>0 ガードで発火しないため、explicit kill 経路の
- * ここから session.gone を出すのが確実 (GC は crash/外部 kill の補完)。
- *
- * テストから直接呼べるよう export。kill 実体 (killManySessions) は ctx で差し替え可能。
- */
-export async function handleKillSession(msg, ctx) {
-  const killFn = ctx.killManySessions || killManySessions
-  const names = Array.isArray(msg.session_names)
-    ? msg.session_names
-    : msg.session_name
-      ? [msg.session_name]
-      : []
-  if (names.length === 0) {
-    ctx.client.send({
-      type: "tmux.kill_session.result",
-      request_id: msg.request_id,
-      killed: [],
-      failed: [{ name: "", reason: "session_name(s) required" }],
-    })
-    return
-  }
-  // ⚠️ kill の受信・完了は必ずログに残す (2026-07-31 追加)。
-  // 「停止に 10 秒経っても応答が返らない」の調査で、agent 側に kill の痕跡が
-  // 1 行も無く、遅いのか・届いていないのか・返事が捨てられたのかを**判別できなかった**。
-  // kill は低頻度なのでログ量の懸念は無い。速かった場合も記録する
-  // (速いことの記録が無いと「agent は詰まっていない」を示せない)。
-  ctx.logger?.info?.({ names, request_id: msg.request_id }, "tmux kill_session received")
-  const killStartedAt = Date.now()
-  const r = await killFn(names)
-  const killMs = Date.now() - killStartedAt
-  const sent = ctx.client.send({
-    type: "tmux.kill_session.result",
-    request_id: msg.request_id,
-    killed: r.killed,
-    failed: r.failed,
-  })
-  // 送信できたか自体を残す。ws が閉じていると result は黙って捨てられるため、
-  // 「kill は成功したのに要求元へ返っていない」を後から特定できるようにする。
-  ctx.logger?.info?.(
-    {
-      request_id: msg.request_id,
-      killed: r.killed.length,
-      failed: r.failed.length,
-      kill_ms: killMs,
-      result_sent: sent === true,
-    },
-    "tmux kill_session done",
-  )
-  for (const name of r.killed) {
-    try {
-      ctx.client.send({ type: "session.gone", session_name: name })
-    } catch {
-      /* ignore */
-    }
-    forgetSortAffectingState(name) // sort_affecting 状態のリーク防止 (kill 経路)
-  }
-}
-
 /** usage.response の中身を共有する TTL (ms)。frontend の poll は既定 60 秒周期。 */
 export const USAGE_RESPONSE_TTL_MS = 4_000
 
@@ -3704,78 +2875,12 @@ export async function handleUsageRequest(msg, ctx, deps = {}) {
 }
 
 /**
- * `tmux.create_session` ハンドラ。指定名・cwd で detached の tmux セッションを作る。
- *
- * ⚠️ pane に CLI (claude / codex) を起動するかは **createSession 内の
- * shouldLaunchPaneCli() が一元判定**する (既定は起動しない)。ここで渡す cliKind /
- * claudeCmd / codexCmd / initialPrompt 等は、`HUB_AGENT_TMUX_LAUNCH_CLI=1` で
- * CLI を起動するときにだけ使われる。呼び出し元ごとに既定を変えないため、
- * このハンドラ側で起動可否を判断しないこと。
- *
- * dispatch から切り出して export しているのは、実際に tmux へ渡る引数を
- * テストから検査できるようにするため (test/tmux-pane-cli-launch.test.mjs)。
- */
-export async function handleTmuxCreateSession(msg, ctx) {
-  const name = (msg.session_name || "").trim()
-  const cwd = (msg.cwd || process.env.HOME || "/").trim()
-  if (!name) {
-    ctx.client.send({
-      type: "tmux.create_session.result",
-      request_id: msg.request_id,
-      ok: false,
-      error: "session_name is required",
-    })
-    return
-  }
-  try {
-    await createTmuxSession(name, cwd, {
-      // cli_kind: 'codex' なら codex を、それ以外は claude を pane 起動する (既定 claude)。
-      cliKind: msg.cli_kind === "codex" ? "codex" : "claude",
-      claudeCmd:
-        typeof msg.claude_cmd === "string"
-          ? msg.claude_cmd
-          : claudeCmdFromAgentConfig(ctx.config),
-      codexCmd: typeof msg.codex_cmd === "string" ? msg.codex_cmd : undefined,
-      // codex 用設定 (claude 経路では claudeCmd を直接使うため無視される)。
-      model:
-        typeof msg.model === "string"
-          ? msg.model
-          : codexDefaultsFromAgentConfig(ctx.config).model,
-      sandbox: typeof msg.sandbox === "string" ? msg.sandbox : undefined,
-      approvalPolicy:
-        typeof msg.approval_policy === "string" ? msg.approval_policy : undefined,
-      effort:
-        typeof msg.effort === "string"
-          ? msg.effort
-          : codexDefaultsFromAgentConfig(ctx.config).effort,
-      initialPrompt:
-        typeof msg.initial_prompt === "string" ? msg.initial_prompt : undefined,
-      logger: ctx.logger,
-    })
-    tmuxSessionsSnapshotCache.clear()
-    ctx.client.send({
-      type: "tmux.create_session.result",
-      request_id: msg.request_id,
-      ok: true,
-      session_name: name,
-    })
-  } catch (err) {
-    ctx.client.send({
-      type: "tmux.create_session.result",
-      request_id: msg.request_id,
-      ok: false,
-      error: err.message,
-    })
-  }
-}
-
-/**
- * `worktree.create` ハンドラ。git worktree を作ってから、その dir で tmux セッションを作る。
+ * `worktree.create` ハンドラ。git worktree とチャット行の識別子を作る。
  * body: { request_id, dir, branch, cli_kind?, claude_cmd?, codex_cmd?, model?, sandbox?,
  *         approval_policy?, effort?, initial_prompt? }
  *
- * ⚠️ pane の CLI 起動可否は handleTmuxCreateSession と同じく createSession 側の
- * 一元判定に従う (既定は起動しない)。
+ * worktree 作成後にワークスペースの準備・同期を待ってから応答する。
+ * CLI 起動用の旧フィールドは互換のため受け付けるが使用しない。
  */
 export async function handleWorktreeCreate(msg, ctx) {
   const dir = (msg.dir || "").trim()
@@ -3800,53 +2905,23 @@ export async function handleWorktreeCreate(msg, ctx) {
   }
   try {
     const worktreeCreate = ctx._createWorktreeDir || createWorktreeDir
-    const tmuxCreate = ctx._createTmuxSession || createTmuxSession
     const wtCliKind = msg.cli_kind === "codex" ? "codex" : "claude"
-    const launchPaneCli = shouldLaunchPaneCli()
-    const codexDefaults = codexDefaultsFromAgentConfig(ctx.config)
-    const tmuxOptions = {
-      cliKind: wtCliKind,
-      claudeCmd:
-        typeof msg.claude_cmd === "string"
-          ? msg.claude_cmd
-          : claudeCmdFromAgentConfig(ctx.config),
-      codexCmd: typeof msg.codex_cmd === "string" ? msg.codex_cmd : undefined,
-      model: typeof msg.model === "string" ? msg.model : codexDefaults.model,
-      sandbox: typeof msg.sandbox === "string" ? msg.sandbox : undefined,
-      approvalPolicy:
-        typeof msg.approval_policy === "string" ? msg.approval_policy : undefined,
-      effort: typeof msg.effort === "string" ? msg.effort : codexDefaults.effort,
-      initialPrompt:
-        typeof msg.initial_prompt === "string" ? msg.initial_prompt : undefined,
-      logger: ctx.logger,
-      _resolveCodexBinary: ctx._resolveCodexBinary,
-    }
-    if (launchPaneCli) validateInitialPrompt(tmuxOptions.initialPrompt)
-    // 下流 createSession と同じ options・優先順位で command を1回だけ生成する。
-    // 失敗はこの try の catch へ流れ、worktree / tmux の副作用前に ok:false となる。
-    if (launchPaneCli && wtCliKind === "codex") {
-      tmuxOptions.codexCmd = tmuxOptions.codexCmd ?? buildCodexCmd(tmuxOptions)
-    }
     const { wtName, wtPath, createdBranch } = await worktreeCreate(dir, branch)
-    // ⚠️ 宛先一覧の無効化を tmux 作成の成否に依存させない。この一覧の正本はローカルの
-    // ディレクトリ実体なので、worktree ができた時点で既に古い。後続の tmux 作成が失敗しても
-    // worktree dir は残るため、ここで捨てないと残り TTL のあいだ実在する宛先が一覧から欠ける。
     chatTargetsCache.clear()
-    // worktree dir で tmux session を作成。tmux.create_session と同じく cli_kind を
-    // 解釈し、codex なら codex を pane 起動する（既定 claude）。
-    // T05945: セッション名は cli_kind に応じて `<wt>` / `<wt>__codex` へ分ける。これで
-    // 同一 worktree でも claude と codex を独立に起動/終了できる (旧実装は cli_kind に
-    // 関わらず `<wt>` 固定だったため、片方しか立てられなかった)。
     const wtSessionName = sessionNameFor(wtName, wtCliKind)
-    await tmuxCreate(wtSessionName, wtPath, tmuxOptions)
-    tmuxSessionsSnapshotCache.clear()
+    await prepareChatWorkspace({
+      cwd: wtPath,
+      session: wtSessionName,
+      cliKind: wtCliKind,
+      logger: ctx.logger,
+    })
     ctx.client.send({
       type: "worktree.create.result",
       request_id: msg.request_id,
       ok: true,
       // wt_name は従来どおり **ベース名** (dir 名)。frontend のツリー構築キーに使う。
       wt_name: wtName,
-      // session_name は実際に作った tmux セッション名 (codex なら __codex 付き)。
+      // session_name は画面が選択するチャット行の名前 (codex なら __codex 付き)。
       // 旧 frontend はこのフィールドを見ないため後方互換 (wt_name で選択する)。
       session_name: wtSessionName,
       wt_path: wtPath,
@@ -4076,12 +3151,9 @@ export async function dispatch(msg, ctx) {
             })
           const session = ctx.claudeBridge.sessions?.get(stream_id)
           const resolvedCwd = session?.cwd || cwdArg || process.env.HOME || process.cwd()
-          const push = () => pushImmediateChatState({ client: ctx.client, plugins: ctx.plugins,
-            logger: ctx.logger, cwd: resolvedCwd, cliKind: "claude" })
           if (session && resumeSessionId) {
-            void loadResumeChatContext(session, "claude").then(push).catch(() => {})
+            void loadResumeChatContext(session, "claude").catch(() => {})
           }
-          void push().catch(() => {})
 
         } catch (err) {
           ctx.client.send({
@@ -4468,12 +3540,9 @@ export async function dispatch(msg, ctx) {
             ctx.logger?.warn?.({ err: err?.message }, "failed to replay review events")
           }
           const session = ctx.codexBridge.sessions?.get(stream_id)
-          const push = () => pushImmediateChatState({ client: ctx.client, plugins: ctx.plugins,
-            logger: ctx.logger, cwd: resolvedCwd, cliKind: "codex" })
           if (session && info.resuming) {
-            void loadResumeChatContext(session, "codex").then(push).catch(() => {})
+            void loadResumeChatContext(session, "codex").catch(() => {})
           }
-          void push().catch(() => {})
 
         } catch (err) {
           ctx.client.send({
@@ -4907,8 +3976,8 @@ export async function dispatch(msg, ctx) {
         return
       }
       case "profile.switch": {
-        // アカウント切替。active 永続化 → env 反映 (process/tmux) → 全 Claude セッション
-        // 強制再起動 (SDK チャット + tmux TUI)。走行中ターンも中断する。
+        // アカウント切替。active 永続化 → env 反映 (process) → 全 Claude セッション
+        // 強制再起動 (SDK チャット)。走行中ターンも中断する。
         //
         // WHY 認証スワップ廃止 (B案, 2026-07): Claude Code 2.1.x は OAuth トークンを
         // `Claude Code-credentials-<sha256(CLAUDE_CONFIG_DIR)>` に config ディレクトリ別
@@ -4920,13 +3989,9 @@ export async function dispatch(msg, ctx) {
         try {
           const target = await setActiveProfile(id)
           applyActiveProfileEnv(target, ctx.logger)
-          await syncTmuxProfileEnv(target, ctx.logger)
           // 全セッションを撤去 (frontend は exit 通知でセッション一覧をリロードする)。
           const before = ctx.claudeBridge ? ctx.claudeBridge.list().length : 0
           ctx.claudeBridge?.shutdown()
-          // tmux TUI セッションも旧アカウントのまま残さない: kill → 同名・同 cwd で再作成。
-          const tmuxResult = await restartAllTmuxSessionsForProfileSwitch(ctx)
-          tmuxSessionsSnapshotCache.clear()
           // アカウントが変わったので、旧アカウントの利用量・認証在否を TTL の残り時間だけ
           // 見せ続けないよう明示的に捨てる (直後の needs_login 判定も実測値になる)。
           usageResponseCache.clear()
@@ -4940,9 +4005,6 @@ export async function dispatch(msg, ctx) {
             {
               profile_id: target.id,
               reaped: before,
-              tmux_killed: tmuxResult.killed.length,
-              tmux_recreated: tmuxResult.recreated.length,
-              tmux_failed: tmuxResult.failed.length,
               needs_login: needsLogin,
             },
             "claude profile switched; all sessions reaped",
@@ -4959,7 +4021,6 @@ export async function dispatch(msg, ctx) {
               config_dir: target.configDir,
             },
             reaped: before,
-            tmux_restarted: tmuxResult.recreated.length,
             needs_login: needsLogin,
             login_command: needsLogin
               ? isDefaultTarget
@@ -5083,7 +4144,7 @@ export async function dispatch(msg, ctx) {
         return
       }
       case "codex.profile.switch": {
-        // Codex アカウント切替。active 永続化 → CODEX_HOME を env/tmux に反映 → Codex
+        // Codex アカウント切替。active 永続化 → CODEX_HOME を env に反映 → Codex
         // app-server セッションのみ再起動 (Claude 側は独立なので触らない)。認証はファイル
         // 分離のため CODEX_HOME 切替だけでアカウントが変わる (スワップ不要)。
         const id = msg.profile_id || msg.id || ""
@@ -5091,11 +4152,9 @@ export async function dispatch(msg, ctx) {
           const profileApi = ctx.codexProfiles || codexProfiles
           const target = await profileApi.setActiveProfile(id)
           ;(ctx.applyActiveCodexEnv || applyActiveCodexEnv)(target, ctx.logger)
-          await (ctx.syncTmuxCodexEnv || syncTmuxCodexEnv)(target, ctx.logger)
           // Codex セッションだけ撤去 (Claude セッションは残す = 独立切替)。
           const before = ctx.codexBridge?.sessions?.size ?? 0
           ctx.codexBridge?.shutdown()
-          tmuxSessionsSnapshotCache.clear()
           // Codex アカウントが変わったので、旧アカウントの 5h/7d を TTL の残り時間だけ
           // 見せ続けない (rate limits 自体は profileId 別キャッシュなので混ざらないが、
           // usage.response の中身は両アカウントを束ねているため明示的に捨てる)。
@@ -5301,85 +4360,6 @@ export async function dispatch(msg, ctx) {
         }
         return
       }
-      case "tmux.list_sessions": {
-        try {
-          const snapshot = await tmuxSessionsSnapshotCache.get(async () => {
-            // worktree index は listSessions の親判定と stub 列挙で共用する。従来は同じ
-            // 全 workspace + git branch 走査を 1 応答内で 2 回直列実行していた。
-            const worktreeIndex = await buildWorktreeIndex()
-            // boundSessions: 各行の context% (ドーナツ) を bound session の jsonl から引く
-            // (cwd dir 内の別セッション jsonl を最新と取り違える=メタ欠陥#1 の根治)。
-            const sessions = await listTmuxSessions({
-              plugins: ctx.plugins,
-              logger: ctx.logger,
-              boundSessions: ctx.tuiReboundSessions,
-              claudeBridge: ctx.claudeBridge,
-              worktreeIndex,
-            })
-            const lastEventByName = await readAllSessionEvents()
-            const enriched = enrichTmuxSessionsForListResponse(
-              sessions,
-              lastEventByName,
-              (name) => {
-                const row = sessions.find((item) => item.name === name)
-                if (hasRepresentativeRow(row?.cwd, cliKindForSessionName(name))) return null
-                return ctx.getSessionStateSnapshot?.(name)
-              },
-              // warm = このセッションへ依頼 (cockpit_orch.py send) を送れるか。sibling-inject の
-              // 宛先候補列挙と同一関数 (live-sessions.mjs) を通す。
-              (row) =>
-                isSessionWarm(
-                  { claudeBridge: ctx.claudeBridge, codexBridge: ctx.codexBridge },
-                  row,
-                ),
-            )
-            const liveNames = new Set(enriched.map((s) => s.name))
-            let worktreeStubs = []
-            try {
-              worktreeStubs = await listWorktreeStubs(liveNames, { worktreeIndex })
-            } catch (err) {
-              ctx.logger?.warn?.({ err: err?.message }, "listWorktreeStubs failed")
-            }
-            return { sessions: enriched, worktree_stubs: worktreeStubs }
-          })
-          // 行ごとの「次に開く会話」の context% (任意)。宛先 (context_targets) は要求ごとに
-          // 違うため、共有される snapshot キャッシュの**外**で解決し、触る行だけ複製して
-          // 載せる (他クライアントの応答を汚さない)。context_targets が無ければ従来どおりの
-          // 応答 (後方互換)。
-          let sessions = snapshot.sessions
-          if (Array.isArray(msg.context_targets) && msg.context_targets.length > 0) {
-            try {
-              const pointerByName = await resolvePointerContexts(
-                msg.context_targets,
-                sessions,
-                { logger: ctx.logger },
-              )
-              sessions = applyPointerContexts(sessions, pointerByName)
-            } catch (err) {
-              // pointer context はあくまで付加情報。失敗してもセッション一覧は返す。
-              ctx.logger?.warn?.(
-                { err: err?.message },
-                "resolvePointerContexts failed",
-              )
-            }
-          }
-          ctx.client.send({
-            type: "tmux.sessions",
-            request_id: msg.request_id,
-            ...snapshot,
-            sessions: sessions.map((row) => applyRowChatState(row, row.cwd, cliKindForSessionName(row.name))),
-          })
-        } catch (err) {
-          ctx.client.send({
-            type: "tmux.sessions",
-            request_id: msg.request_id,
-            sessions: [],
-            worktree_stubs: [],
-            error: err.message,
-          })
-        }
-        return
-      }
       case "chat.sidebar_snapshot.request": {
         try {
           const messages = await readSidebarMessageSnapshot(msg.targets, {
@@ -5403,10 +4383,6 @@ export async function dispatch(msg, ctx) {
         }
         return
       }
-      case "tmux.create_session": {
-        await handleTmuxCreateSession(msg, ctx)
-        return
-      }
       case "worktree.create": {
         await handleWorktreeCreate(msg, ctx)
         return
@@ -5485,7 +4461,6 @@ export async function dispatch(msg, ctx) {
             releaseRemoval?.()
           }
           if (result.dirty !== true) {
-            tmuxSessionsSnapshotCache.clear()
             chatTargetsCache.clear()
           }
           ctx.client.send({
@@ -5513,11 +4488,6 @@ export async function dispatch(msg, ctx) {
         }
         return
       }
-      case "tmux.kill_session": {
-        await handleKillSession(msg, ctx)
-        tmuxSessionsSnapshotCache.clear()
-        return
-      }
       case "skills.request": {
         try {
           // Cockpit Codex 両対応 (Stream A3, 2026-07-02): browser が cli_kind を