@cocorograph/hub-agent 0.7.99 → 0.7.100

package/package.json

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

package/src/claude-stream-bridge.mjs

@@ -2442,27 +2442,62 @@ export class ClaudeStreamBridge extends EventEmitter {
    * @returns {Array<{kind: string, cwd: string, session_id: string|null, idle_ms: number}>}
    */
   describeLiveSessions(cwd) {
-    const now = Date.now()
+    return this._liveCandidatesForCwd(cwd, false).map(({ session, attached }) =>
+      this._describeCandidate(session, attached),
+    )
+  }
+
+  /**
+   * cwd 内の live セッション候補を `{session, attached}` の配列で返す共通スキャン。
+   * this.sessions (attached=browser 接続中) と _liveBySession (attached=false=soft-detached の warm)
+   * の **union** を走査し、両 Map に載り得る同一セッションは seen で重複排除する。attached は
+   * 「this.sessions に在籍しているか」で決める。
+   *
+   * ⚠️ describeLiveSessions(計数) と sendToCwd/sendToStream(配送) をこの同一集合に揃えることで、
+   * 従来「this.sessions のみ計数 / union 配送」の非対称が生んでいた undercount 由来のサイレント
+   * 誤配送 (detached-busy な旧セッションへ配送しつつ計数上は1本に見える TOCTOU) を排除する。
+   *
+   * @param {string} [cwd] 指定時はその cwd のみ
+   * @param {boolean} [requireSessionId=false] sessionId 未確定の fresh を除外するか
+   * @returns {Array<{session: object, attached: boolean}>}
+   */
+  _liveCandidatesForCwd(cwd, requireSessionId = false) {
     const out = []
     const seen = new Set()
-    for (const session of this.sessions.values()) {
-      if (seen.has(session)) continue
-      seen.add(session)
-      if (cwd && session.cwd !== cwd) continue
-      let at = 0
-      for (const t of session.lastActivityByStream?.values?.() ?? []) {
-        if (t > at) at = t
+    const collect = (iter, attached) => {
+      for (const session of iter) {
+        if (seen.has(session)) continue
+        // reap 済み (_closed) セッションは _liveBySession に残留し得るため除外する。union 走査で
+        // これを拾うと、reconcileWarmBounds で畳まれた古い session が宛先として復活してしまう。
+        if (session._closed) continue
+        if (cwd && session.cwd !== cwd) continue
+        if (requireSessionId && !session.sessionId) continue
+        seen.add(session)
+        out.push({ session, attached })
       }
-      out.push({
-        kind: "claude",
-        cwd: session.cwd,
-        session_id: session.sessionId || null,
-        idle_ms: at ? now - at : -1,
-      })
     }
+    // attached を先に走査して attached=true で登録、その後 warm を attached=false で補完する。
+    collect(this.sessions.values(), true)
+    collect(this._liveBySession.values(), false)
     return out
   }
 
+  /** describeLiveSessions と同形の 1 セッション記述子 (sendToCwd/sendToStream の結果整形に共用)。 */
+  _describeCandidate(session, attached) {
+    const now = Date.now()
+    let at = 0
+    for (const t of session.lastActivityByStream?.values?.() ?? []) {
+      if (t > at) at = t
+    }
+    return {
+      kind: "claude",
+      cwd: session.cwd,
+      session_id: session.sessionId || null,
+      idle_ms: at ? now - at : -1,
+      attached,
+    }
+  }
+
   /**
    * 指定 cwd で現在ライブな (browser 接続中、または detach 猶予内の) SDK チャット
    * session_id を返す。無ければ null。
@@ -2563,24 +2598,40 @@ export class ClaudeStreamBridge extends EventEmitter {
    * ⚠️ このメソッド自体は認証を行わない (呼び出し元の sibling-inject.mjs が
    * src/sibling-token.mjs の capability トークンで入力元を検証する前提)。
    *
+   * ⚠️ 宛先解決 (2026-07-23, 統一再設計 1-1): 従来の「最終活性が最も新しいものを選ぶ」
+   * ヒューリスティックを廃止し、**attached (前面=browser 接続中) 優先 + 曖昧は fail-safe** に
+   * 変更した。union 候補のうち attached があれば attached 層、無ければ warm 層から選び、層内が
+   * 1 本なら配送・複数なら推測せず ambiguous を返す。これにより「detached-busy な旧セッション A と
+   * 同 cwd の新規 attached B が併存するとき、計数上は B 1本に見えつつ配送は活性の新しい A に
+   * 落ちる」サイレント誤配送を、B (前面) への確定配送へ是正する (真に曖昧な稀ケースのみ
+   * ambiguous で fail-safe。誤配送はしない)。返り値は sendToStream と同形の status オブジェクト。
+   *
    * @param {string} cwd
    * @param {string} text
-   * @returns {boolean} 送信できたか (対象セッションが見つからなければ false)
+   * @returns {{status:"delivered", session:object} | {status:"not_found"} | {status:"ambiguous", candidates:object[]}}
    */
   sendToCwd(cwd, text) {
-    if (!cwd || !text) return false
-    // P5 (T06570): warm (soft-detached) セッションも対象にするため union 走査へ委譲する
-    // (従来は this.sessions のみで、detach 済みだが生きているセッションへ sibling-inject できず
-    // no_live_session_for_cwd になっていた)。sessionId 未確定の fresh も対象にするため false。
-    const best = this._liveSessionForCwd(cwd, false)
-    if (!best) return false
-    best.sendMessage({ role: "user", content: text }).catch((err) => {
+    if (!cwd || !text) return { status: "not_found" }
+    // sessionId 未確定の fresh も配送対象にするため requireSessionId=false。
+    const cands = this._liveCandidatesForCwd(cwd, false)
+    if (cands.length === 0) return { status: "not_found" }
+    const attached = cands.filter((c) => c.attached)
+    // attached があれば attached 層のみ、無ければ warm 層で解決する (前面優先)。
+    const tier = attached.length ? attached : cands
+    if (tier.length > 1) {
+      return {
+        status: "ambiguous",
+        candidates: tier.map((c) => this._describeCandidate(c.session, c.attached)),
+      }
+    }
+    const { session, attached: att } = tier[0]
+    session.sendMessage({ role: "user", content: text }).catch((err) => {
       this.logger?.error(
         { cwd, err: err?.message },
         "sendToCwd: sendMessage threw unexpectedly",
       )
     })
-    return true
+    return { status: "delivered", session: this._describeCandidate(session, att) }
   }
 
   /**
@@ -2608,34 +2659,28 @@ export class ClaudeStreamBridge extends EventEmitter {
    */
   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)
-    }
+    // union 走査 (2026-07-23, 統一再設計 1-1): warm (soft-detached) セッションも session_id
+    // ピンの対象にする。従来は this.sessions のみで、detach 済みだが生きているセッションを
+    // 明示 session_id で指しても not_found になっていた (describeLiveSessions/sendToCwd と非対称)。
+    const matches = this._liveCandidatesForCwd(cwd, false).filter(
+      (c) => c.session.sessionId === sessionId,
+    )
     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) }
+      return {
+        status: "ambiguous",
+        candidates: matches.map((c) => this._describeCandidate(c.session, c.attached)),
+      }
     }
-    matches[0].sendMessage({ role: "user", content: text }).catch((err) => {
+    const { session, attached } = matches[0]
+    session.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]) }
+    return { status: "delivered", session: this._describeCandidate(session, attached) }
   }
 
   /**

package/src/codex-stream-bridge.mjs

@@ -1407,19 +1407,30 @@ export class CodexStreamBridge extends EventEmitter {
    * ⚠️ このメソッド自体は認証を行わない (呼び出し元の sibling-inject.mjs が
    * src/sibling-token.mjs の capability トークンで入力元を検証する前提)。
    *
+   * ⚠️ 返り値 (2026-07-23, 統一再設計 1-1): claude 版と契約を揃えるため boolean から status
+   * オブジェクトへ変更した。codex は計数(describeLiveSessions)と配送が同一集合 (_liveSessions())
+   * を見るため claude のような undercount 由来のサイレント誤配送は構造的に起きず、宛先選定は
+   * 従来どおり「会話ターン境界時刻が最新」のヒューリスティックを維持する (挙動不変)。
+   *
    * @param {string} cwd
    * @param {string} text
-   * @returns {boolean} 送信できたか (対象セッションが見つからなければ false)
+   * @returns {{status:"delivered", session:object} | {status:"not_found"}}
    */
   sendToCwd(cwd, text) {
-    if (!cwd || !text) return false
+    if (!cwd || !text) return { status: "not_found" }
+    // 案B: distinct session で走査（多対一 Map の重複を除く）。
+    const cands = this._liveSessions().filter((s) => s.cwd === cwd)
+    // attached (前面=detach 未要求) 優先 (2026-07-23 統一再設計 1-1, cross-review 指摘4):
+    // detach 済み warm セッションが lastTurnAtMs 上たまたま新しくても、attached な現行セッションが
+    // あればそちらへ配送する (browser を離れた/畳まれかけの旧会話 ghost への誤配送を防ぐ)。
+    // claude と違い codex は同一 cwd に複数 attached が併存し得る (別スレッドの新会話 / ターン
+    // 実行中) ため fail-safe ambiguous にはせず、tier 内は会話ターン境界時刻が最新のものを選ぶ
+    // (閲覧 keepalive で動く lastActivityMs は使わない = 見ているだけの古い会話が本命を追い越さない)。
+    const attached = cands.filter((s) => !s.detachRequested)
+    const tier = attached.length ? attached : cands
     let best = null
     let bestAt = -1
-    // 案B: distinct session で走査（多対一 Map の重複を除く）。
-    for (const session of this._liveSessions()) {
-      if (session.cwd !== cwd) continue
-      // 宛先選定の「最新」は会話ターン境界時刻で判定する（閲覧 keepalive で動く
-      // lastActivityMs を使うと「見ているだけの古い会話」が本命を追い越す）。
+    for (const session of tier) {
       const at = session.lastTurnAtMs ?? session.lastActivityMs ?? 0
       if (at >= bestAt) {
         bestAt = at
@@ -1431,7 +1442,7 @@ export class CodexStreamBridge extends EventEmitter {
         { cwd, live_sessions: this.describeLiveSessions() },
         "codex sendToCwd: no live session for cwd (ask-sibling will fail)",
       )
-      return false
+      return { status: "not_found" }
     }
     // detach 済み warm セッションでも、ask-sibling が使うなら「新しい持ち主が付いた」とみなして
     // detachRequested を解除し touch する（LRU 先頭へ）。this.input が改めて _touch するが、注入前に
@@ -1456,7 +1467,7 @@ export class CodexStreamBridge extends EventEmitter {
         )
       },
     )
-    return true
+    return { status: "delivered", session: this._describe(best) }
   }
 
   /**

package/src/sibling-inject.mjs

@@ -10,10 +10,15 @@
  * ファイル IPC 前例 (tui-permission-bridge.mjs 等、`/tmp/cockpit_*` + fs.watch +
  * atomic write) と同じパターンに揃える。
  *
- * ⚠️ セキュリティ設計 (2026-07-04 セッションでユーザー承認済み): この機構は
+ * ⚠️ セキュリティ設計 (2026-07-04 承認 / 2026-07-23 統一再設計 1-2 で緩和): この機構は
  * 「生きている自律エージェント (シェル/API/MCP ツールへのフルアクセス権を持つ)
  * へ外部プロセスから新規指示を注入する」という強い書き込み権限を持つため、
- * `src/sibling-token.mjs` の cwd スコープ capability トークンによる検証を必須とする。
+ * `src/sibling-token.mjs` の capability トークンによる検証を必須とする。
+ * 認可粒度は当初「ターゲット cwd 所有」だったが、claude↔claude / codex↔codex を含む
+ * クロス cwd 連携を可能にするため「**いずれかの cwd の有効トークン所有 (= 同一ユーザーの
+ * spawn 済みセッション)**」へ緩和した (`verifySiblingTokenAny`)。無認証プロセス (npm
+ * postinstall 等) はどの cwd のトークンも持たないため排除される核心は維持。ターゲット
+ * 解決は引き続き要求の cwd でスコープする (誤 cwd 着弾・別 workspace 情報漏洩を防ぐ)。
  * トークンが一致しない要求は無視し (実行せず削除)、warn ログのみ残す。
  *
  * 契約: request file `<request_id>.json` は op で 3 形態 (2026-07-19 / T06271):
@@ -25,6 +30,8 @@
  *       新 agent だけが処理する (probe を挟まず単一リクエストで TOCTOU を排除)。
  *       宛先は session_id(claude) / stream_id・thread_id(codex) を cwd 一致下に確定解決。
  *   - 一覧: `{op:"list", cwd, target_cli_kind, token}` → `{ok, live_sessions}` (--list 用)。
+ *   - 全一覧: `{op:"list-all", token}` → `{ok, live_sessions}` (全 cwd・両 CLI。クロス cwd
+ *       宛先探索用、2026-07-23。cwd/target_cli_kind 不要、token のみ必須)。
  * 処理後は必ず削除し (成否問わず)、呼び出し側が待ち受けられるよう
  * `<request_id>.result.json` = `{ok, error?, delivered_to?, candidates?, live_sessions?, hint?}` を書く。
  */
@@ -33,7 +40,7 @@ import { watch } from "node:fs"
 import { mkdir, readFile, writeFile, rename, unlink, readdir } from "node:fs/promises"
 import path from "node:path"
 
-import { verifySiblingToken } from "./sibling-token.mjs"
+import { verifySiblingTokenAny, siblingTokenCwd } from "./sibling-token.mjs"
 
 export const SIBLING_REQUESTS_DIR =
   process.env.COCKPIT_SIBLING_REQUESTS_DIR || "/tmp/cockpit_sibling_requests"
@@ -117,6 +124,7 @@ export class SiblingInjectBridge {
     //    未知フィールドを無視して sendToCwd 推測注入する事故が **単一リクエストで原理的に
     //    起きない** (probe→注入の TOCTOU を排除)。
     const { op, cwd, target_cli_kind, text, message, token, target_session_id } = body || {}
+    const isListAll = op === "list-all"
     const isList = op === "list"
     const isExplicit = op === "inject"
     let result
@@ -126,12 +134,47 @@ export class SiblingInjectBridge {
       : isExplicit
         ? !target_session_id || !message // 明示は id と message 必須 (空指定 fail-open を防ぐ)
         : !text // 通常は top-level text 必須 (＝旧契約)
-    if (!cwd || badKind || badBody) {
+    if (isListAll) {
+      // op:"list-all" (2026-07-23 統一再設計 1-2: クロス cwd 宛先探索): 全 cwd・両 CLI の
+      // ライブセッションを列挙する。cwd / target_cli_kind / 本文は不要 (token のみ必須)。
+      // 認可は verifySiblingTokenAny (同一ユーザーの spawn 済みセッションであれば全 cwd を
+      // 見渡せる。orchestrate リーダーが別プロジェクトの sub の宛先アドレスを得るため)。
+      if (!token) {
+        result = { ok: false, error: "invalid_request" }
+      } else if (!verifySiblingTokenAny(token)) {
+        this.logger?.warn({ request_id }, "sibling-inject: invalid sibling token (list-all)")
+        result = { ok: false, error: "invalid_token" }
+      } else {
+        result = {
+          ok: true,
+          live_sessions: [
+            ...(this.claudeBridge?.describeLiveSessions?.() ?? []),
+            ...(this.codexBridge?.describeLiveSessions?.() ?? []),
+          ],
+        }
+      }
+    } else 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")
+    } else if (!verifySiblingTokenAny(token)) {
+      // 2026-07-23 統一再設計 1-2: 認可を「ターゲット cwd 所有」→「いずれかの cwd の有効トークン
+      // 所有 (= 同一ユーザーの spawn 済みセッション)」へ緩和し、クロス cwd 連携を解禁する。
+      // cwd は引き続きターゲット解決のスコープとして使う (誤 cwd 着弾・情報漏洩は解決側で担保)。
+      this.logger?.warn({ cwd, request_id }, "sibling-inject: invalid sibling token, request denied")
       result = { ok: false, error: "invalid_token" }
     } else {
+      // クロス cwd 監査 (2026-07-23, cross-review round2 minor): 認可は同一ユーザーの any-cwd
+      // トークンで通るが、注入先の cwd がトークン発行元の cwd と異なる (= クロス cwd 注入) 場合は
+      // 「どの cwd のセッションから来たか」を info ログに残す (認可判定には使わない、追跡用)。
+      // op:list / list-all は非破壊なので対象外、注入系 (op:inject / 通常) のみ記録する。
+      if (!isList) {
+        const fromCwd = siblingTokenCwd(token)
+        if (fromCwd && fromCwd !== cwd) {
+          this.logger?.info?.(
+            { request_id, from_cwd: fromCwd, to_cwd: cwd, target_cli_kind, op: op || "normal" },
+            "sibling-inject: cross-cwd injection (audit)",
+          )
+        }
+      }
       const bridge = target_cli_kind === "codex" ? this.codexBridge : this.claudeBridge
       if (isList) {
         // 宛先候補の列挙 (cockpit_orch.py --list 用)。この cwd の同種セッションを返す。
@@ -177,21 +220,27 @@ export class SiblingInjectBridge {
           }
         }
       } else {
-        // 宛先省略 (通常): 同一 cwd の生きたセッション数で分岐。
-        //   0 本 → no_live_session / 1 本 → 注入 / 複数 → 黙って推測せず ambiguous_target。
-        const sameCwd = bridge?.describeLiveSessions?.(cwd) ?? []
-        if (sameCwd.length > 1) {
+        // 宛先省略 (通常): sendToCwd が union 候補から attached 優先で 1 本に確定解決する。
+        //   status:"delivered" → 注入 / "ambiguous" → 複数候補で fail-safe / "not_found" → 0 本。
+        //
+        // ⚠️ アトミック化 (2026-07-23, 統一再設計 1-1): 旧実装は describeLiveSessions.length の
+        //    計数ゲートと sendToCwd の配送を分離しており、warm セッションを取りこぼす計数
+        //    (claude: this.sessions のみ) をすり抜けて配送だけが warm へ落ちる TOCTOU
+        //    (サイレント誤配送 + delivered_to に実配送先でない sameCwd[0] を報告する成功偽装) が
+        //    あった。sendToCwd を status 返却にして解決と配送を 1 呼び出しに統合し、delivered_to は
+        //    **実配送先 (r.session)** を返す。
+        const r = bridge?.sendToCwd?.(cwd, text) ?? { status: "not_found" }
+        if (r.status === "delivered") {
+          result = { ok: true, delivered_to: r.session ?? null }
+        } else if (r.status === "ambiguous") {
           result = {
             ok: false,
             error: "ambiguous_target",
-            candidates: sameCwd,
-            live_sessions: sameCwd,
+            candidates: r.candidates,
+            live_sessions: r.candidates,
           }
         } 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) }
+          result = { ok: false, error: "no_live_session_for_cwd", ...this._diagnose(cwd, target_cli_kind) }
         }
       }
     }

package/src/sibling-token.mjs

@@ -56,6 +56,50 @@ export function verifySiblingToken(cwd, token) {
   return typeof expected === "string" && expected === token
 }
 
+/**
+ * 提示されたトークンが **いずれかの cwd** の有効な sibling トークンと一致するか検証する
+ * (2026-07-23, 統一再設計 1-2: クロス cwd 連携の認可緩和)。
+ *
+ * 従来の `verifySiblingToken(cwd, token)` は「ターゲット cwd 自身のトークン」を要求するため
+ * 同一 cwd 内の相互依頼しか通せなかった。claude↔claude / codex↔codex を含むクロス cwd 連携
+ * (orchestrate のリーダー→別プロジェクトのサブ等) を可能にするため、認可の粒度を
+ * 「**ターゲット cwd 所有**」から「**この hub-agent が spawn したいずれかのセッション所有**
+ * (= 同一ユーザー)」へ緩和する。
+ *
+ * ⚠️ トレードオフ (ユーザー承認済み 2026-07-23): 注入先の cwd 境界を越えられるようになるが、
+ * hub-agent は 1 ユーザー専用デーモンであり、全 cwd のセッションは同一ユーザー自身のもの
+ * なので信頼境界を跨がない。守るべき核心 = 「hub-agent が env にのみ渡したトークンを持たない
+ * 無認証プロセス (npm postinstall 等) の注入を防ぐ」は、**いずれかの cwd の有効トークン一致**を
+ * 必須にすることで維持される (無関係プロセスはどの cwd のトークンも持てない)。ターゲット
+ * セッションの解決自体は呼び出し側が渡す cwd で引き続きスコープされる (誤 cwd 着弾防止・
+ * 別 workspace の情報漏洩防止は sendToStream/_diagnose 側で担保)。
+ *
+ * @param {string} token
+ * @returns {boolean}
+ */
+export function verifySiblingTokenAny(token) {
+  if (!token || typeof token !== "string") return false
+  for (const expected of tokensByCwd.values()) {
+    if (expected === token) return true
+  }
+  return false
+}
+
+/**
+ * 提示されたトークンがどの cwd に発行されたものかを逆引きする (2026-07-23, クロス cwd 監査用)。
+ * 一致する cwd が無ければ null。verifySiblingTokenAny でクロス cwd 注入を許した際、
+ * 「どの cwd のセッションから来たか」を監査ログに残すために使う (認可の可否判定には使わない)。
+ * @param {string} token
+ * @returns {string|null}
+ */
+export function siblingTokenCwd(token) {
+  if (!token || typeof token !== "string") return null
+  for (const [cwd, expected] of tokensByCwd.entries()) {
+    if (expected === token) return cwd
+  }
+  return null
+}
+
 /** テスト用: トークンストアを全クリアする。 */
 export function _resetSiblingTokens() {
   tokensByCwd.clear()