@cocorograph/hub-agent 0.7.74 → 0.7.75

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocorograph/hub-agent",
-  "version": "0.7.74",
+  "version": "0.7.75",
   "description": "Hub Hosted Cockpit のローカル常駐 agent。Hub と outbound WSS で接続し、ローカルの tmux/pty を中継する。",
   "type": "module",
   "license": "UNLICENSED",

package/src/claude-stream-bridge.mjs

@@ -1729,6 +1729,13 @@ export class ClaudeStreamBridge extends EventEmitter {
     this._mcpControlStarting = null
   }
 
+  /** _liveBySession の複合キー (T06271): cwd を含めることで、別 workspace の同一 session_id を
+   *  別エントリに分離し、resume/reattach が cwd 境界を越えないことを保証する。session_id は
+   *  本来ユニークだが、異常系 (別 cwd で同一 id) でも越境させないための機構キー。 */
+  _liveKeyFor(cwd, sessionId) {
+    return cwd && sessionId ? cwd + "\u0000" + sessionId : null
+  }
+
   /** 多端末共有: あるセッションに紐づく全端末 stream_id を sessions Map から外し、
    *  session_id 索引も掃除する。撤去 (reap / idle / shutdown) で 1 端末分だけ消すと
    *  他端末キーが Map に残って孤児化するため、まとめて消す。 */
@@ -1741,8 +1748,9 @@ export class ClaudeStreamBridge extends EventEmitter {
     if (this.sessions.get(session.stream_id) === session) {
       this.sessions.delete(session.stream_id)
     }
-    if (session.sessionId && this._liveBySession.get(session.sessionId) === session) {
-      this._liveBySession.delete(session.sessionId)
+    const curKey = this._liveKeyFor(session.cwd, session.sessionId)
+    if (curKey && this._liveBySession.get(curKey) === session) {
+      this._liveBySession.delete(curKey)
     }
     // SDK-P0-4 (2026-07-13): session_id 回転前に登録した旧キーも外す (現 sessionId しか見ないと
     // 旧 id → 死んだ session のエントリが残り、attach が孤児を引き当てる)。
@@ -1765,8 +1773,25 @@ export class ClaudeStreamBridge extends EventEmitter {
   stopSessionsFor({ cwd, session_id } = {}) {
     const victims = new Set()
     if (session_id) {
-      const s = this._liveBySession.get(session_id)
-      if (s) victims.add(s)
+      // 複合キー化 (T06271) で session_id 単独では引けないため values を走査して拾う。
+      // ⚠️ cwd 境界 (T06271 レビュー6): cwd 指定時は session_id 照合も **同 cwd に限定** する。
+      //    複合キー化後も別 cwd に同一 session_id の session が併存し得るため、全 cwd を union
+      //    すると A の cwd bind で B (別 cwd) の同一 R まで停止してしまう (実再現 stopped=2)。
+      const idMatches = []
+      for (const s of this._liveBySession.values()) {
+        if (s.sessionId !== session_id) continue
+        if (cwd && s.cwd !== cwd) continue
+        idMatches.push(s)
+      }
+      if (!cwd && idMatches.length > 1) {
+        // cwd 未指定で session_id が複数 cwd に一致 = どれを止めるべきか曖昧。推測停止しない。
+        this.logger?.warn?.(
+          { session_id, matches: idMatches.length },
+          "stopSessionsFor: session_id が複数 cwd に一致。cwd 未指定のため停止をスキップ (曖昧)",
+        )
+      } else {
+        for (const s of idMatches) victims.add(s)
+      }
     }
     if (cwd) {
       for (const s of this._liveBySession.values()) {
@@ -1827,12 +1852,19 @@ export class ClaudeStreamBridge extends EventEmitter {
     if (this.sessions.has(stream_id)) {
       throw new Error(`stream_id "${stream_id}" は既に attach 済みです`)
     }
+    // cwd を 1 回だけ解決し、reattach lookup / session 生成 / 索引登録で同じ値を使う
+    // (複合キーの整合性を保つため)。
+    const scwd = cwd || process.env.HOME || process.cwd()
     // 常駐化: resume_session_id が示すセッションが (走行中 / idle 問わず) まだ生存していれば、
     // 新規 query を起動せずそのセッションへ再アタッチする。これにより端末スリープ/再接続でも
     // ターンは落ちず、以降のイベントは新しい stream_id 経由でライブに流れる
     // (= 通常の生成中表示と同じ)。再接続前の確定分は browser の jsonl hydrate で復元する。
     if (resumeSessionId) {
-      const live = this._liveBySession.get(resumeSessionId)
+      // ⚠️ cwd 境界 (T06271): _liveBySession は **複合キー (cwd+session_id)** なので、別 cwd の
+      //    同一 session_id は別エントリに分離される。よって cwd=A の resume を cwd=B から
+      //    attach しても引き当たらず、越境 reattach が原理的に起きない (session_id は本来
+      //    ユニークだが異常系でも cwd を跨がない)。
+      const live = this._liveBySession.get(this._liveKeyFor(scwd, resumeSessionId))
       if (live && !live._closed) {
         // 多端末共有 (CHAT_SHARED_ENABLED): 旧 stream_id を Map から消さない。同一セッションを
         // 複数端末が購読する状態を作り、どの端末の input/permission/interrupt も解決できるように
@@ -1868,7 +1900,7 @@ export class ClaudeStreamBridge extends EventEmitter {
     }
     const session = new ClaudeStreamSession({
       stream_id,
-      cwd: cwd || process.env.HOME || process.cwd(),
+      cwd: scwd,
       model: model || null,
       permissionMode: permissionMode || null,
       maxTurns: typeof maxTurns === "number" ? maxTurns : null,
@@ -1894,14 +1926,17 @@ export class ClaudeStreamBridge extends EventEmitter {
         // 意図しない live session を引き当てる (+ Map リーク)。登録済みキーを覚えておき、
         // 回転を検知したら旧キーを外してから張り替える。
         if (session.sessionId) {
+          // 複合キー (cwd+session_id)。別 cwd の同一 session_id は別キーになるため、B の onEvent が
+          // A の索引を奪わない (T06271 レビュー5: cwd ガードだけでは onEvent の無条件 set が穴だった)。
+          const key = this._liveKeyFor(session.cwd, session.sessionId)
           const prevKey = session._liveKey
-          if (prevKey && prevKey !== session.sessionId) {
+          if (prevKey && prevKey !== key) {
             if (this._liveBySession.get(prevKey) === session) {
               this._liveBySession.delete(prevKey)
             }
           }
-          session._liveKey = session.sessionId
-          this._liveBySession.set(session.sessionId, session)
+          session._liveKey = key
+          this._liveBySession.set(key, session)
         }
       },
       onPermission: ({ tool_name, input, request_id }) => {
@@ -1955,6 +1990,18 @@ export class ClaudeStreamBridge extends EventEmitter {
       },
     })
     this.sessions.set(stream_id, session)
+    // ⚠️ resume 索引を attach 時に **同期登録** する (T06271 レビュー3 major①)。従来は onEvent
+    // (SDK が session_id を確定させた後) でしか _liveBySession に載せていなかったため、input 前に
+    // 同一 resumeSessionId で 2 回 attach すると「索引が空の窓」で上の reattach 判定 (1835) をすり抜け、
+    // 同じ session_id の別 session が 2 本でき、sendToStream が先頭へ推測注入していた。attach は
+    // get(reattach)→set まで await を挟まず同期なので、ここで登録すれば 2 本目の attach は必ず
+    // reattach 経路に入り重複が生じない。session_id が回転 (clear/compaction) したら onEvent が張り替える。
+    // ⚠️ 複合キー (cwd+session_id) で登録するため、別 cwd の同一 session_id を奪わない (T06271)。
+    if (resumeSessionId) {
+      const key = this._liveKeyFor(scwd, resumeSessionId)
+      session._liveKey = key
+      this._liveBySession.set(key, session)
+    }
     this.logger?.info(
       { stream_id, cwd: session.cwd, model: session.model, resume: !!resumeSessionId },
       "claude stream attached",
@@ -2303,6 +2350,61 @@ export class ClaudeStreamBridge extends EventEmitter {
     return true
   }
 
+  /**
+   * 指定 session_id のライブセッションへメッセージを直接注入する (sibling-inject の
+   * **明示宛先指定** 用、2026-07-19 / T06271)。sendToCwd は「cwd 内で最終活性が最新の
+   * もの」をヒューリスティックに選ぶため、同一 cwd に複数の生きた claude セッションが
+   * 同居すると意図しないセッション (詰まった巨大セッション等) へ誤爆する。呼び出し側が
+   * describeLiveSessions で得た session_id を明示すれば、この曖昧さを回避できる。
+   *
+   * ⚠️ セキュリティ (cwd 境界): 呼び出し元 sibling-inject.mjs のトークンは **cwd スコープ**
+   * (`verifySiblingToken(cwd, token)`) のため、cwd=A のトークンで cwd=B の session_id を
+   * 指定した越境注入を防ぐには、**このメソッド側で cwd 一致を必須化する**必要がある
+   * (session_id だけで全 sessions を走査すると、別 cwd のセッションへ注入できてしまう)。
+   * よって cwd と session_id の **両方** が一致した場合のみ注入する。
+   *
+   * ⚠️ 一意性 (T06271 レビュー3): session_id は「1 論理セッションに一意」なはずだが、resume
+   * 索引 (`_liveBySession`) を **attach 時に同期登録**するようにして初めて成立する不変条件。
+   * それでも競合の防御網として、同一 cwd で session_id が複数一致したら **推測せず ambiguous**
+   * を返す (codex の thread_id 重複と対称)。
+   *
+   * @param {string} cwd 呼び出し元がトークン検証した cwd (この cwd のセッションにのみ注入)
+   * @param {string} sessionId 宛先 session_id (describeLiveSessions の session_id)
+   * @param {string} text
+   * @returns {{status: "delivered", session: object} | {status: "not_found"} | {status: "ambiguous", candidates: object[]}}
+   */
+  sendToStream(cwd, sessionId, text) {
+    if (!cwd || !sessionId || !text) return { status: "not_found" }
+    const now = Date.now()
+    const seen = new Set()
+    const matches = []
+    for (const session of this.sessions.values()) {
+      if (seen.has(session)) continue
+      seen.add(session)
+      if (session.cwd !== cwd || session.sessionId !== sessionId) continue
+      matches.push(session)
+    }
+    if (matches.length === 0) return { status: "not_found" }
+    const describe = (s) => {
+      let at = 0
+      for (const t of s.lastActivityByStream?.values?.() ?? []) {
+        if (t > at) at = t
+      }
+      return { kind: "claude", cwd: s.cwd, session_id: s.sessionId, idle_ms: at ? now - at : -1 }
+    }
+    if (matches.length > 1) {
+      // 同一 session_id の別 session が複数 = resume 競合。推測せず ambiguous (誤爆防止)。
+      return { status: "ambiguous", candidates: matches.map(describe) }
+    }
+    matches[0].sendMessage({ role: "user", content: text }).catch((err) => {
+      this.logger?.error(
+        { session_id: sessionId, err: err?.message },
+        "sendToStream: sendMessage threw unexpectedly",
+      )
+    })
+    return { status: "delivered", session: describe(matches[0]) }
+  }
+
   /**
    * `mcpServerStatus()` の結果に、needs-auth キャッシュにあるが結果へ含まれない
    * サーバーを `needs-auth` として補完する。

package/src/codex-stream-bridge.mjs

@@ -894,6 +894,80 @@ export class CodexStreamBridge extends EventEmitter {
     return true
   }
 
+  /**
+   * 指定した id (stream_id もしくは thread_id) のライブセッションへ直接注入する
+   * (sibling-inject の **明示宛先指定** 用、2026-07-19 / T06271)。sendToCwd は cwd 内で
+   * 最終活性が最新のものを選ぶヒューリスティックのため、同一 cwd に複数の生きた codex
+   * セッションが同居すると誤爆する。呼び出し側が describeLiveSessions で得た id を明示
+   * すれば曖昧さを回避できる。
+   *
+   * stream_id は WS 再接続 / in-memory reattach で付け替わる (不安定) 一方、thread_id は
+   * 会話に固定 (安定) なので、**両方を受け付け** どちらで指定しても解決できるようにする。
+   * Claude 版 `sendToStream` の対。
+   *
+   * ⚠️ セキュリティ (cwd 境界): 呼び出し元 sibling-inject.mjs のトークンは **cwd スコープ**
+   * のため、cwd=A のトークンで cwd=B の stream_id/thread_id を指定した越境注入を防ぐには、
+   * **このメソッド側で cwd 一致を必須化する** (id だけで全 sessions を走査すると別 cwd の
+   * セッションへ注入できてしまう)。cwd と id の **両方** が一致した場合のみ注入する。
+   *
+   * ⚠️ 一意性 (T06271 レビュー major③): stream_id は各 live app-server で一意だが、
+   * **thread_id は一意でない** — 同一 thread を複数回 resume/handover すると同じ thread_id を
+   * 持つ live セッションが同一 cwd に複数併存し得る。そのため:
+   *   1. まず stream_id の完全一致を優先 (常に一意に定まる)
+   *   2. stream_id で当たらなければ thread_id で照合し、**複数一致なら注入せず ambiguous を返す**
+   *      (Map 先頭を選ぶと明示指定が再び推測になるため)
+   *
+   * @param {string} cwd 呼び出し元がトークン検証した cwd (この cwd のセッションにのみ注入)
+   * @param {string} id 宛先 stream_id (一意・推奨) または thread_id
+   * @param {string} text
+   * @returns {{status: "delivered", session: object} | {status: "not_found"} | {status: "ambiguous", candidates: object[]}}
+   */
+  sendToStream(cwd, id, text) {
+    if (!cwd || !id || !text) return { status: "not_found" }
+    let bySid = null
+    const byThread = []
+    for (const session of this.sessions.values()) {
+      if (session.dead || session.cwd !== cwd) continue
+      if (session.stream_id === id) {
+        bySid = session
+        break // stream_id は一意なので即確定
+      }
+      if (session.threadId === id) byThread.push(session)
+    }
+    let target = bySid
+    if (!target) {
+      if (byThread.length > 1) {
+        return { status: "ambiguous", candidates: byThread.map((s) => this._describe(s)) }
+      }
+      target = byThread[0] || null
+    }
+    if (!target) return { status: "not_found" }
+    // detach 済み warm セッションでも、明示指定で使うなら「新しい持ち主が付いた」とみなす
+    // (sendToCwd と同じ扱い)。
+    target.detachRequested = false
+    this._touch(target)
+    this.input({ stream_id: target.stream_id, message: { role: "user", content: text } }).catch(
+      (err) => {
+        this.logger?.error(
+          { id, stream_id: target.stream_id, err: err?.message },
+          "sendToStream: input threw unexpectedly",
+        )
+      },
+    )
+    return { status: "delivered", session: this._describe(target) }
+  }
+
+  /** describeLiveSessions と同形の 1 セッション記述子 (sendToStream の結果整形に共用)。 */
+  _describe(session) {
+    return {
+      kind: "codex",
+      cwd: session.cwd,
+      stream_id: session.stream_id,
+      thread_id: session.threadId || null,
+      busy: !!session.activeTurnId,
+    }
+  }
+
   /**
    * Stage 5: セッションが「保護対象（reap 不可）」か。= **healthy な running turn**。
    * activeTurnId が立っており、かつ app-server 通知が STUCK_TTL 以内に届いている（＝生きている

package/src/sibling-inject.mjs

@@ -16,9 +16,17 @@
  * `src/sibling-token.mjs` の cwd スコープ capability トークンによる検証を必須とする。
  * トークンが一致しない要求は無視し (実行せず削除)、warn ログのみ残す。
  *
- * 契約: request file `<request_id>.json` = `{cwd, target_cli_kind, text, token}`。
+ * 契約: request file `<request_id>.json` は op で 3 形態 (2026-07-19 / T06271):
+ *   - 通常注入 (op 無し): `{cwd, target_cli_kind, text, token}`
+ *       cwd 内が 1 本なら注入、複数なら黙って推測せず `ambiguous_target` + 候補一覧。
+ *   - 明示注入: `{op:"inject", cwd, target_cli_kind, token, target_session_id, message}`
+ *       本文は **top-level text ではなく `message`** に入れる。これにより旧 hub-agent は
+ *       `!text` で `invalid_request` を返し (推測注入せず fail-closed)、明示宛先を解釈できる
+ *       新 agent だけが処理する (probe を挟まず単一リクエストで TOCTOU を排除)。
+ *       宛先は session_id(claude) / stream_id・thread_id(codex) を cwd 一致下に確定解決。
+ *   - 一覧: `{op:"list", cwd, target_cli_kind, token}` → `{ok, live_sessions}` (--list 用)。
  * 処理後は必ず削除し (成否問わず)、呼び出し側が待ち受けられるよう
- * `<request_id>.result.json` = `{ok, error?}` を書く。
+ * `<request_id>.result.json` = `{ok, error?, delivered_to?, candidates?, live_sessions?, hint?}` を書く。
  */
 
 import { watch } from "node:fs"
@@ -100,23 +108,104 @@ export class SiblingInjectBridge {
       return
     }
 
-    const { cwd, target_cli_kind, text, token } = body || {}
+    // 契約の 3 形態を op で判別する:
+    //   - op:"list"   → 候補列挙 (top-level text 無し)
+    //   - op:"inject" → 明示宛先 (target_session_id + message、top-level text は **持たない**)
+    //   - op 無し     → 通常 (cwd 最新、top-level text あり) ← 旧 agent と後方互換
+    // ⚠️ 明示宛先を「op:inject + message (top-level text 無し)」にするのが fail-closed の肝
+    //    (T06271 レビュー major①): 旧 hub-agent は `!text` で invalid_request を返すため、
+    //    未知フィールドを無視して sendToCwd 推測注入する事故が **単一リクエストで原理的に
+    //    起きない** (probe→注入の TOCTOU を排除)。
+    const { op, cwd, target_cli_kind, text, message, token, target_session_id } = body || {}
+    const isList = op === "list"
+    const isExplicit = op === "inject"
     let result
-    if (!cwd || !text || (target_cli_kind !== "claude" && target_cli_kind !== "codex")) {
+    const badKind = target_cli_kind !== "claude" && target_cli_kind !== "codex"
+    const badBody = isList
+      ? false
+      : isExplicit
+        ? !target_session_id || !message // 明示は id と message 必須 (空指定 fail-open を防ぐ)
+        : !text // 通常は top-level text 必須 (＝旧契約)
+    if (!cwd || badKind || badBody) {
       result = { ok: false, error: "invalid_request" }
     } else if (!verifySiblingToken(cwd, token)) {
       this.logger?.warn({ cwd, request_id }, "sibling-inject: token mismatch, request denied")
       result = { ok: false, error: "invalid_token" }
     } else {
       const bridge = target_cli_kind === "codex" ? this.codexBridge : this.claudeBridge
-      const sent = bridge?.sendToCwd?.(cwd, text) ?? false
-      result = sent
-        ? { ok: true }
-        : { ok: false, error: "no_live_session_for_cwd", ...this._diagnose(cwd, target_cli_kind) }
+      if (isList) {
+        // 宛先候補の列挙 (cockpit_orch.py --list 用)。この cwd の同種セッションを返す。
+        result = { ok: true, live_sessions: bridge?.describeLiveSessions?.(cwd) ?? [] }
+      } else if (isExplicit) {
+        // 明示宛先: session_id (claude) / stream_id|thread_id (codex) で cwd 一致下に確定解決。
+        // sendToStream は {status:"delivered"|"not_found"|"ambiguous"} を返す。
+        const r = bridge?.sendToStream?.(cwd, target_session_id, message) ?? { status: "not_found" }
+        if (r.status === "delivered") {
+          result = { ok: true, delivered_to: r.session }
+        } else if (r.status === "ambiguous") {
+          // 宛先 id が同一 cwd の複数 live セッションに一致し一意に定まらない。
+          // ⚠️ 解消手段は CLI で異なる (T06271 レビュー4 minor):
+          //   - codex: stream_id は一意なので stream_id で名指しできる
+          //   - claude: 一意な宛先指定子が無い (session_id は重複、stream_id は非公開) ため
+          //     --to では解消不能。Cockpit で該当チャットを開き直す / 再一覧を案内する
+          result = {
+            ok: false,
+            error: "ambiguous_target",
+            candidates: r.candidates,
+            live_sessions: r.candidates,
+            hint:
+              target_cli_kind === "codex"
+                ? `指定した id (${target_session_id}) はこの cwd で複数の live セッションに一致します。` +
+                  `stream_id で名指ししてください (--list で確認)。`
+                : `指定した session_id (${target_session_id}) がこの cwd で複数の live セッションに ` +
+                  `一致します。Claude は一意な宛先指定子が無いため --to では解消できません。Cockpit で` +
+                  `対象 cwd の Claude チャットを開き直して1本に整理してから再送してください` +
+                  `(通常は attach 時の重複解消で発生しません)。`,
+          }
+        } else {
+          result = {
+            ok: false,
+            error: "target_session_not_found",
+            target_session_id,
+            // ⚠️ _diagnose の hint は「対象 CLI 不在」前提で id 不一致 (別 cwd 指定含む) では矛盾
+            //    する ("claude は無い" と誤表示) ため、id 不一致専用の hint に差し替える。
+            live_sessions: this._diagnose(cwd, target_cli_kind).live_sessions,
+            hint:
+              `指定した宛先 id (${target_session_id}) はこの cwd (${cwd}) の生きた ` +
+              `${target_cli_kind} セッションに見つかりません (別 cwd の id は越境注入できません)。` +
+              `--list で候補を確認してください。`,
+          }
+        }
+      } else {
+        // 宛先省略 (通常): 同一 cwd の生きたセッション数で分岐。
+        //   0 本 → no_live_session / 1 本 → 注入 / 複数 → 黙って推測せず ambiguous_target。
+        const sameCwd = bridge?.describeLiveSessions?.(cwd) ?? []
+        if (sameCwd.length > 1) {
+          result = {
+            ok: false,
+            error: "ambiguous_target",
+            candidates: sameCwd,
+            live_sessions: sameCwd,
+          }
+        } else {
+          const sent = bridge?.sendToCwd?.(cwd, text) ?? false
+          result = sent
+            ? { ok: true, delivered_to: sameCwd[0] ?? null }
+            : { ok: false, error: "no_live_session_for_cwd", ...this._diagnose(cwd, target_cli_kind) }
+        }
+      }
     }
 
     this.logger?.[result.ok ? "info" : "warn"]?.(
-      { request_id, cwd, target_cli_kind, ...(result.ok ? {} : { error: result.error, live_sessions: result.live_sessions }) },
+      {
+        request_id,
+        cwd,
+        target_cli_kind,
+        op: op || "normal",
+        ...(result.ok
+          ? { delivered_to: result.delivered_to }
+          : { error: result.error, live_sessions: result.live_sessions }),
+      },
       result.ok ? "sibling-inject delivered" : "sibling-inject failed",
     )
     await this._writeResult(request_id, result)
@@ -136,22 +225,26 @@ export class SiblingInjectBridge {
    * ⚠️ ここに出るのは hub-agent が spawn した **チャットセッションのみ**。tmux 配下で
    * 動く TUI codex は ask-sibling の宛先にならないため、一覧が空でも「codex は画面上
    * 動いている」ことは普通に起きる。その旨を hint に明記する。
+   *
+   * ⚠️ セキュリティ (T06271 レビュー3 major②): 返す live_sessions は **この cwd のものだけ**に
+   * 限定する。呼び出し元トークンは cwd スコープなので、全 cwd の session id を返すと別
+   * workspace の cwd/セッション存在を漏らす (cwd scoped token での越境情報漏洩)。cwd 指定で
+   * describeLiveSessions を呼び、同一 cwd のみを材料にする。
    * @param {string} cwd
    * @param {string} targetKind
    */
   _diagnose(cwd, targetKind) {
-    const all = [
-      ...(this.claudeBridge?.describeLiveSessions?.() ?? []),
-      ...(this.codexBridge?.describeLiveSessions?.() ?? []),
+    const sameCwd = [
+      ...(this.claudeBridge?.describeLiveSessions?.(cwd) ?? []),
+      ...(this.codexBridge?.describeLiveSessions?.(cwd) ?? []),
     ]
-    const sameCwd = all.filter((s) => s.cwd === cwd)
     const hint = sameCwd.length
       ? `この cwd には ${sameCwd.map((s) => s.kind).join("/")} のチャットセッションはあるが ${targetKind} は無い。`
       : `この cwd には hub-agent 管理下のチャットセッションが 1 本も無い。` +
         `tmux の TUI codex は ask-sibling の宛先にならない (hub-agent が spawn した` +
         ` Cockpit のチャットセッションのみが対象)。Cockpit のブラウザで対象 cwd の` +
         ` ${targetKind} チャットを開き直してから再送すること。`
-    return { live_sessions: all, hint }
+    return { live_sessions: sameCwd, hint }
   }
 
   /** 結果ファイルを atomic write する (呼び出し側 CLI がポーリングする)。 */