@cocorograph/hub-agent 0.8.76 → 0.8.77

package/src/codex-stream-bridge.mjs

@@ -43,6 +43,7 @@
 import { EventEmitter } from "node:events"
 import { randomUUID } from "node:crypto"
 import path from "node:path"
+import { isUnderRemoval } from "./chat-removal-guard.mjs"
 
 import { lookupInjectSource, recordInjectSourcePersistent } from "./inject-source-store.mjs"
 
@@ -800,6 +801,7 @@ export class CodexStreamBridge extends EventEmitter {
     if (this.sessions.has(stream_id)) {
       throw new Error(`stream_id already attached: ${stream_id}`)
     }
+    if (isUnderRemoval(cwd)) throw new Error(`worktree removal in progress: ${cwd}`)
     // 計測 (2026-07-31): attach 1 回 = 1 行の内訳ログ (`codex attach timing`)。
     // frontend の attach_sent→ready_received は 1 つの数字でしか見えず、その中身が
     // 「app-server の cold spawn + initialize」なのか「thread/resume の rollout 読み込み」なのか、
@@ -923,6 +925,11 @@ export class CodexStreamBridge extends EventEmitter {
       }
     }
 
+    // ⚠️ attach の入口でも同じ検査をしているが、そこから **_tryReattach の await** を挟んで
+    // ここへ来る（既存 session の thread 確定待ち）。その間に削除が始まっていることがあるので、
+    // プロセスを起こす直前にもう一度見る。ここを外すと「停止対象を列挙し終えたあとに新しい
+    // プロセスが生まれる」経路が残り、削除された cwd を指す会話ができる。
+    if (isUnderRemoval(cwd)) throw new Error(`worktree removal in progress: ${cwd}`)
     const client = this._clientFactory({
       cwd,
       codexCmd: this.codexCmd,
@@ -1974,6 +1981,14 @@ export class CodexStreamBridge extends EventEmitter {
     return addCodexSessionTitles(sessions, sessionsDir)
   }
 
+  /** 指定 stream の live 会話を停止する。履歴ファイルは削除しない。 */
+  stopSessionForStream({ stream_id, reason }) {
+    const session = this.sessions.get(stream_id)
+    if (!session || session.dead) return 0
+    this._reapSession(session, Date.now(), reason || "explicit-stop")
+    return 1
+  }
+
   async operateSession(options) {
     const invalid = validateCodexSessionOperation(options)
     if (invalid) return { ok: false, error: invalid }
@@ -4730,7 +4745,12 @@ export class CodexStreamBridge extends EventEmitter {
       producer_seq: session.seq,
       thread_id: session.threadId,
       code: 0,
-      reason: reason === "session-deleted" ? "session-deleted" : "idle-reaped",
+      // ⚠️ ここは「明示的に止めた理由」の許可リスト。載っていない理由はすべて "idle-reaped"
+      // へ丸められ、利用者には「放置されて片付いた」と通知される。明示停止を足したら必ず
+      // ここへも足すこと（足し忘れても停止自体は動くので、通知だけが静かに嘘になる）。
+      reason: ["session-deleted", "chat-stop", "chat-stop-all", "worktree-remove"].includes(reason)
+        ? reason
+        : "idle-reaped",
     })
   }
 

package/src/dispatch-scheduler.mjs

@@ -83,8 +83,14 @@ function globalMutationMode(type) {
   return null
 }
 
-function attachLaneKey(mode, msg) {
-  const cwd = typeof msg?.cwd === "string" ? msg.cwd.trim() : ""
+// ⚠️ cwd を省略した attach は、ハンドラ側で config.claude_cwd に補われ、さらに claude では
+// bridge が HOME へ補完して「その cwd の会話」になる (main.mjs の claude.attach / codex.attach
+// と claude-stream-bridge の attach)。レーン分類がその補完を知らないと、同じ会話への attach が
+// stream レーンへ、個別停止 (cwd を持つ) が cwd レーンへ散り、直列化されないまま同時に走る。
+// scheduler へ設定も HOME も読ませず、補完後の既定 cwd を呼び出し側から mode 別に渡してもらう
+// (補完の規則は CLI 種別で違うため、mode を知らない scheduler 側では決められない)。
+function attachLaneKey(mode, msg, defaultCwd = "") {
+  const cwd = (typeof msg?.cwd === "string" ? msg.cwd.trim() : "") || defaultCwd
   if (cwd) return `${mode}:cwd:${cwd}`
   const resumeId =
     mode === "claude"
@@ -100,14 +106,18 @@ function attachLaneKey(mode, msg) {
  *   run: (msg: object) => Promise<void>|void,
  *   logger?: {debug?: Function, warn?: Function, error?: Function},
  *   shouldBypass?: (type: string|undefined) => boolean,
+ *   defaultCwd?: (mode: "claude"|"codex") => string,
  * }} options
  */
 export class DispatchScheduler {
-  constructor({ run, logger, shouldBypass }) {
+  constructor({ run, logger, shouldBypass, defaultCwd }) {
     if (typeof run !== "function") throw new TypeError("DispatchScheduler run is required")
     this.run = run
     this.logger = logger
     this.shouldBypass = typeof shouldBypass === "function" ? shouldBypass : () => false
+    // cwd 省略時にハンドラ／bridge が使う既定 cwd を CLI 種別ごとに返す関数。展開済みの値を
+    // 返すこと (scheduler は `~` 展開も HOME 参照もしない)。
+    this.defaultCwd = typeof defaultCwd === "function" ? defaultCwd : () => ""
     this.generation = 0
     this.sequence = 0
     this.laneTails = new Map()
@@ -154,6 +164,21 @@ export class DispatchScheduler {
     }
   }
 
+  /**
+   * cwd 省略時にハンドラ／bridge が使う既定 cwd を、CLI 種別ごとに引く。
+   * ⚠️ レーン分類は全メッセージが通る経路なので、設定の読み取りが失敗しても dispatch を
+   * 止めない。取れなければ省略時の従来分類 (stream / control) へ戻す。
+   * @param {"claude"|"codex"} mode
+   */
+  _resolveDefaultCwd(mode) {
+    try {
+      const cwd = this.defaultCwd(mode)
+      return typeof cwd === "string" ? cwd.trim() : ""
+    } catch {
+      return ""
+    }
+  }
+
   _laneFor(msg) {
     const type = msg?.type
     const mutationMode = globalMutationMode(type)
@@ -163,20 +188,35 @@ export class DispatchScheduler {
     // frontend の 10 秒打ち切りで捨てられていたため分離する (2026-09-04 本番計測)。
     if (type === "usage.request") return "usage"
 
+    if (type === "chat.session.stop") {
+      if (msg.cli_kind === "claude") {
+        const cwd = typeof msg.cwd === "string" ? msg.cwd.trim() : ""
+        return cwd ? `claude:cwd:${cwd}` : "control"
+      }
+      if (msg.cli_kind === "codex" && msg.stream_id) {
+        return this.streamLaneKeys.get("codex:" + msg.stream_id) || `codex:stream:${msg.stream_id}`
+      }
+      return "control"
+    }
+    // chat.stop_all は全レーンに跨るため control に置く。その時点で live な会話だけを
+    // 止める契約であり、接続処理中のまだ live でない会話は対象外。sessions.request も control。
     const mode = chatMode(type)
     if (!mode) return "control"
 
     const streamId = typeof msg?.stream_id === "string" ? msg.stream_id : ""
     const streamKey = streamId ? `${mode}:${streamId}` : ""
+    const fallbackCwd = this._resolveDefaultCwd(mode)
     if (type === `${mode}.attach`) {
-      const laneKey = attachLaneKey(mode, msg)
+      const laneKey = attachLaneKey(mode, msg, fallbackCwd)
       this._rememberStreamLane(streamId, laneKey)
       return laneKey
     }
     if (streamKey && this.streamLaneKeys.has(streamKey)) {
       return this.streamLaneKeys.get(streamKey)
     }
-    const cwd = typeof msg?.cwd === "string" ? msg.cwd.trim() : ""
+    // attach と同じ補完を使う。片方だけ既定 cwd を見ると、同じ会話宛の upload / history 等が
+    // attach とは別レーンへ散り、attach で直したはずの取り違えが型ごと再発する。
+    const cwd = (typeof msg?.cwd === "string" ? msg.cwd.trim() : "") || fallbackCwd
     if (cwd) return `${mode}:cwd:${cwd}`
     if (streamId) return `${mode}:stream:${streamId}`
     // codex.profile.list 等の stream 非依存 read は main 側の read-only bypass

package/src/main.mjs

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

package/src/sibling-inject.mjs

@@ -80,6 +80,7 @@ import path from "node:path"
 import { verifySiblingTokenAny, siblingTokenCwd } from "./sibling-token.mjs"
 import { describeLiveSessionsUnion } from "./live-sessions.mjs"
 import { ReviewEventStore, validReviewEvent } from "./review-event-store.mjs"
+import { listChatTargets } from "./chat-targets.mjs"
 
 export const SIBLING_REQUESTS_DIR =
   process.env.COCKPIT_SIBLING_REQUESTS_DIR || "/tmp/cockpit_sibling_requests"
@@ -431,6 +432,7 @@ export class SiblingInjectBridge {
     pidStartedAt = defaultPidStartedAt,
     onRestartRequested,
     isInputBlocked,
+    starter,
     watchFn = watch,
   } = {}) {
     this.dir = dir
@@ -447,6 +449,7 @@ export class SiblingInjectBridge {
     this._pidStartedAt = pidStartedAt
     this._onRestartRequested = onRestartRequested
     this._isInputBlocked = isInputBlocked
+    this._starter = starter
     this._watchFn = watchFn
     this._newTurnInFlight = 0
     /** @type {Map<string, Map<string, {event: object, recordedAt: number}>>} cwd+session ごとの進行中委譲。 */
@@ -932,7 +935,10 @@ export class SiblingInjectBridge {
         result = { ok: false, error: "invalid_token" }
       } else {
         // 判定は live-sessions.mjs に一本化する (tmux.list_sessions の warm と同じ関数)。
-        result = { ok: true, live_sessions: describeLiveSessionsUnion(this._bridges()) }
+        const live_sessions = describeLiveSessionsUnion(this._bridges())
+        const { targets, errors } = await listChatTargets({ logger: this.logger })
+        const registered_targets = targets.map(({ cwd, kind, name }) => ({ cwd, kind, name }))
+        result = { ok: true, live_sessions, registered_targets, errors }
       }
     } else if (!cwd || (!isDelegateEvent && badKind) || badBody) {
       result = { ok: false, error: "invalid_request" }
@@ -1113,7 +1119,29 @@ export class SiblingInjectBridge {
         //    **実配送先 (r.session)** を返す。
         const r = bridge?.sendToCwd
           ? await this._sendNewTurn(
-            () => bridge.sendToCwd(cwd, text, injectSource, request_id),
+            async () => {
+              const first = await bridge.sendToCwd(cwd, text, injectSource, request_id)
+              if (first.status !== "not_found" || target_session_id || !this._starter) return first
+              const started = await this._starter({ cwd, cliKind: target_cli_kind })
+              // ⚠️ 起動側の失敗理由をここで捨てない。捨てると送信元には最後の
+              // `no_live_session_for_cwd` しか届かず、「準備中でもう一度送れば届く」と
+              // 「その cwd には恒久的に会話が無い」を区別できない。配送結果そのものは
+              // not_found のままなので、診断情報として添えて下流の応答へ持ち上げる。
+              if (!started?.ok) {
+                return started?.error
+                  ? { ...first, startup_error: started.error, startup_retryable: started.retryable === true }
+                  : first
+              }
+              // ⚠️ 起動側は cwd を展開・解決してから会話を作る (chat-session-starter の
+              // expandTilde と prepareChatWorkspace)。ここで展開前の cwd のまま引き直すと、
+              // 実際に作られた会話 (解決後 cwd) と一致せず、起こした直後に not_found へ落ちる。
+              // 解決後の cwd は起動側だけが知っているので、その戻り値を使う。
+              const startedCwd = typeof started.cwd === "string" && started.cwd ? started.cwd : cwd
+              const retry = await bridge.sendToCwd(startedCwd, text, injectSource, request_id)
+              // 起動後の曖昧さは候補案内へ渡し、不在のときだけ最初の診断へ戻す。
+              if (retry.status === "not_found") return first
+              return retry
+            },
             { request_id, cwd, target_cli_kind, op: "normal" },
           )
           : { status: "not_found" }
@@ -1159,7 +1187,16 @@ export class SiblingInjectBridge {
             ...ambiguousTargetOutcome(target_cli_kind, undefined, r.candidates),
           }
         } else {
-          result = { ok: false, error: "no_live_session_for_cwd", ...this._diagnose(cwd, target_cli_kind) }
+          result = {
+            ok: false,
+            error: "no_live_session_for_cwd",
+            ...this._diagnose(cwd, target_cli_kind),
+            // ⚠️ `retryable` を載せるのは自動起動が「配送前に」失敗した場合だけ。配送を試みた
+            // 結果が不明な要求に再試行印を付けると、送信元の自動再送で二重配送になる。
+            ...(r.startup_error
+              ? { startup_error: r.startup_error, retryable: r.startup_retryable === true }
+              : {}),
+          }
         }
       }
     }