@cocorograph/hub-agent 0.7.54 → 0.7.56

package/package.json

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

package/src/claude-stream-bridge.mjs

@@ -271,6 +271,32 @@ function isSessionIdleEvent(msg) {
   )
 }
 
+/**
+ * SDK-P0-4 (2026-07-13): SDK の権威的な「ターン開始」シグナル。
+ * sdk.d.ts (SDKSessionStateChangedMessage) の state は 'idle' | 'running' | 'requires_action'。
+ * `running` は SDK が新しい input の処理を実際に開始したときにだけ流れるため、
+ * **前ターンの遅延イベントでは絶対に立たない**。これがターン帰属の唯一の確実な境界になる。
+ *
+ * なぜ必要か: 旧ガード `_turnProgressed` は「現ターンが 1 件でもイベントを出したか」だったが、
+ * これは「**現ターンの**イベントが来た」ことを保証しない。abort (interrupt) 直後に drain で
+ * 次ターンを開始すると、中断されたターンの in-flight イベント (stream_event の残り delta /
+ * 実行中だった tool の user メッセージ等) が 1 件届くだけで _turnProgressed=true になり、
+ * その直後に届く**前ターンの idle** が新ターンを終端扱いして撃ち抜いていた (二重 drain →
+ * 実行中ターンの InputQueue へ追加 push → FIFO 崩れ・応答取り違え)。
+ */
+function isSessionRunningEvent(msg) {
+  return (
+    msg?.type === "system" &&
+    msg?.subtype === "session_state_changed" &&
+    msg?.state === "running"
+  )
+}
+
+/** SDK-P0-4: 「前ターンの遅延 idle」を待つ猶予 (ms)。generator のイベント順序は保証されるので
+ *  遅延 idle は通常ミリ秒で届く。ここを過ぎても届かなければガードを解除し、現ターンの idle を
+ *  正しく終端として扱う (ガードが固着して _busy が永久 true になる = T06052 の再発を防ぐ安全弁)。 */
+const STALE_IDLE_GUARD_MS = 5000
+
 /**
  * 1 stream に対応する Claude セッション (per-message query モデル)。
  */
@@ -404,18 +430,40 @@ class ClaudeStreamSession {
     this._turnSettled = false
     /** SDK-P0-3: 現ターンが 1 件でもストリームイベントを出したか。
      *  「前ターンの遅延 idle が、drain で始まったばかりの次ターンを誤終了させる」レースの
-     *  ガードに使う。generator のイベント順序は保証される (turn N の idle は turn N+1 の
-     *  最初のイベントより必ず先に届く) ため、`idle 到着時に現ターンがまだ何も出していない`
-     *  = その idle は前ターンのもの、と判定できる。ターン開始時に false へ戻す。 */
+     *  一次ガード。generator のイベント順序保証から導けるのは **否定方向だけ** である点に注意:
+     *  「まだ 1 件も出ていない (=false) → この idle は前ターンのもの」は正しいが、逆の
+     *  「1 件出ている (=true) → この idle は現ターンのもの」は導けない (前ターンの遅延イベントでも
+     *  true になるため)。その穴は SDK-P0-4 の _staleIdleExpected / _turnRunningSeen で塞ぐ。
+     *  ターン開始時に false へ戻す。 */
     this._turnProgressed = false
+    /** SDK-P0-4 (2026-07-13): ターン連番。ログと帰属デバッグ用 (_beginResidentTurn で ++)。 */
+    this._turnSeq = 0
+    /** SDK-P0-4: 「直前ターンの idle がこれから 1 件届きうる」状態。result で settle したとき、
+     *  および abort (interrupt) でターンを畳んだときに arm する (SDK は result → idle の順で
+     *  流し、interrupt 後にも中断ターンの idle を流すため)。arm 中に届いた idle は
+     *  **前ターンのもの**として 1 件だけ握り潰し、現ターンを終端しない。
+     *  解除条件: (a) idle を 1 件消費した (b) SDK の running が届いた (= 前ターンの全イベントは
+     *  順序保証により既に通過済み) (c) 現ターンの result が届いた (d) STALE_IDLE_GUARD_MS 経過。 */
+    this._staleIdleExpected = false
+    /** SDK-P0-4: _staleIdleExpected の安全弁タイマー (固着による _busy 永久 true を防ぐ)。 */
+    this._staleIdleTimer = null
+    /** SDK-P0-4: 現ターンで SDK の session_state_changed:running を観測したか。
+     *  観測済みなら「以降に届く idle は確実に現ターンのもの」と断定できる。 */
+    this._turnRunningSeen = false
     /** detach 済みフラグ (新規ターン受付停止) */
     this._closed = false
     /** 実行中ターンの完走を待ってからクローズする予約フラグ (graceful detach 用)。
      *  端末スリープ / ネット断で browser が切れても、明示的な中断 (interrupt) が
      *  無い限りターンを落とさず最後まで走らせるために使う。 */
     this._reapAfterTurn = false
-    /** 現在ターンの AbortController (interrupt 用) */
+    /** 現在ターンの AbortController (per-message の interrupt 用) */
     this._abortController = null
+    /** SDK-P0-4 (2026-07-13): 常駐 query の AbortController (最終手段の強制終了用)。
+     *  常駐は interrupt() で「現ターンだけ」を中断するのが正規経路だが、control request が
+     *  失敗/無応答のとき (CLI ハング・control channel 断) に generator を畳む手段が無いと
+     *  close()/shutdown() で子プロセスが残留する。per-message と同じく AbortController を
+     *  options へ渡し、interrupt が reject したときと close() のときに最終手段として abort する。 */
+    this._residentAbortController = null
 
     /** jsonl ライブ追従 watcher (0.6.5)。外部 (tmux 等) の追記を拾う。 */
     this._watcher = null
@@ -477,8 +525,20 @@ class ClaudeStreamSession {
       )
   }
 
-  /** 現在の sessionId の jsonl を watch する (既に同じものを watch 中なら何もしない)。 */
+  /** 現在の sessionId の jsonl を watch する (既に同じものを watch 中なら何もしない)。
+   *
+   *  SDK-P0-4 (2026-07-13): **常駐 (resident) セッションでは watcher を張らない**。
+   *  _runResidentQuery の docstring が「常駐では query stream が唯一のイベント源のため
+   *  watcher は張らない」と宣言しているのに、コンストラクタの `if (this.sessionId) _ensureWatch()`
+   *  が resume セッション (= sessionId 非 null) で無条件に watcher を張っており、
+   *  HUB_AGENT_CHAT_RESIDENT_RESUME=1 のとき **SDK ストリームと jsonl watcher の二重ソース**に
+   *  なっていた。per-message は finally で `_busy=true` のまま skipToEnd() を待ってから
+   *  busy を落とすことで二重配信を防いでいるが (下の _runPerMessage 参照)、常駐の終端
+   *  (_settleResidentTurn) は同期で _busy=false にするだけで skipToEnd を持たないため、
+   *  ターン末尾の書き込みを watcher が読み直して二重配信しうる。宣言した不変条件をここで
+   *  機械的に強制する (将来 CHAT_RESIDENT_RESUME を既定 ON にする際のブロッカーだった)。 */
   _ensureWatch() {
+    if (this._residentEligible) return
     if (this._closed || !this.sessionId || !this.cwd) return
     if (this._watchedSessionId === this.sessionId && this._watcher) return
     // 旧 watcher を畳む
@@ -1203,6 +1263,34 @@ class ClaudeStreamSession {
     this._busy = true
     this._turnSettled = false
     this._turnProgressed = false
+    this._turnRunningSeen = false
+    this._turnSeq += 1
+    // ⚠️ _staleIdleExpected はここでリセットしない。ターン開始は「前ターンを settle した
+    // 直後の同期 drain」から呼ばれるため、ここでクリアすると前ターンの遅延 idle を握り潰す
+    // ガードが自ら消えてしまう (それが SDK-P0-3 の穴だった)。解除は _clearStaleIdleGuard()
+    // (idle 消費 / running 到着 / 現ターン result / タイムアウト) でのみ行う。
+  }
+
+  /** SDK-P0-4: 「直前ターンの遅延 idle を 1 件だけ握り潰す」ガードを張る。
+   *  安全弁として STALE_IDLE_GUARD_MS で自動解除する (ガード固着による _busy 永久 true を防ぐ)。 */
+  _armStaleIdleGuard() {
+    this._staleIdleExpected = true
+    if (this._staleIdleTimer) clearTimeout(this._staleIdleTimer)
+    this._staleIdleTimer = setTimeout(() => {
+      this._staleIdleTimer = null
+      this._staleIdleExpected = false
+    }, STALE_IDLE_GUARD_MS)
+    // Node の event loop を引き止めない (プロセス終了をブロックしない)。
+    this._staleIdleTimer?.unref?.()
+  }
+
+  /** SDK-P0-4: 遅延 idle ガードを解除する。 */
+  _clearStaleIdleGuard() {
+    this._staleIdleExpected = false
+    if (this._staleIdleTimer) {
+      clearTimeout(this._staleIdleTimer)
+      this._staleIdleTimer = null
+    }
   }
 
   /** SDK-P0-3 (2026-07-10): resident の「ターン終端」を 1 箇所に集約する (result / idle 共通)。
@@ -1216,6 +1304,11 @@ class ClaudeStreamSession {
     this._turnSettled = true
     denyPending?.("turn ended")
     this._busy = false
+    // SDK-P0-4: result で畳んだターンは、この後に自分の idle を必ず 1 件流す
+    // (sdk.d.ts: "'idle' fires after heldBackResult flushes … authoritative turn-over signal")。
+    // drain が同期で次ターンを開始するため、その idle が新ターンに誤帰属しないようガードを張る。
+    // idle 自身で畳んだ場合は既にその idle を消費済みなので張らない。
+    if (reason === "result") this._armStaleIdleGuard()
     // 改修4 (A): シリアライズした pending があれば次の 1 件を InputQueue へ流す。
     // ultracode (0.6.28): _drainResidentPending は applyFlagSettings を await するため
     // async。for await ループ内からは fire-and-forget で呼ぶ (最初の await より前に
@@ -1271,11 +1364,16 @@ class ClaudeStreamSession {
    *  常駐では query stream が唯一のイベント源のため watcher は張らない (過去確定分は browser が
    *  history.request で hydrate 済み。resume で query stream が過去行を replay しない前提)。 */
   async _runResidentQuery() {
+    // SDK-P0-4 (2026-07-13): 常駐にも AbortController を渡す (per-message には元からある)。
+    // 正規の中断は interrupt() だが、control request が失敗/無応答のときに generator を畳む
+    // 最終手段が無いと、close()/shutdown() で CLI 子プロセスが残留する。
+    this._residentAbortController = new AbortController()
     const options = {
       cwd: this.cwd,
       env: siblingEnvFor(this.cwd),
       canUseTool: (toolName, input) => this._canUseTool(toolName, input),
       includePartialMessages: true,
+      abortController: this._residentAbortController,
       stderr: (data) => this._stderrHandler(data),
     }
     if (this.model) options.model = this.model
@@ -1307,6 +1405,10 @@ class ClaudeStreamSession {
         }
         if (msg?.type === "result") {
           if (typeof msg.session_id === "string") this.sessionId = msg.session_id
+          // SDK-P0-4: 現ターンの result が届いた = 前ターンの遅延 idle は順序保証により
+          // 既に通過済み (届いたなら消費済み / 届かないなら二度と来ない)。ガードを解除してから
+          // settle する (settle が result 用のガードを張り直す)。
+          this._clearStaleIdleGuard()
           // ターン完了: 未解決 permission を閉じ、次 input 受付へ (query は継続)。
           this._settleResidentTurn("result", denyPending)
         } else if (isSessionIdleEvent(msg)) {
@@ -1315,13 +1417,18 @@ class ClaudeStreamSession {
           // _pendingMessages に退避されたまま (drain 契機の result が永久に来ないので)
           // 永久滞留していた ("resident busy, message queued" が出続ける / リロードで消える)。
           //
-          // ガード: 「前ターンの遅延 idle」で新ターンを誤終了させない。result で settle →
-          // drain → 次ターン開始 (_busy=true) の直後に、同じターンの idle が続けて届く
-          // (SDK は result → idle の順に流す) ため、素朴に _busy=false にすると新ターンを
-          // 撃ち抜き二重 drain / FIFO 崩れを起こす。generator のイベント順序は保証されるので
-          // 「現ターンがまだ 1 件もイベントを出していない (_turnProgressed=false)」なら
-          // その idle は前ターンのものと確定できる。
-          if (this._busy && this._turnProgressed) {
+          // SDK-P0-4 (2026-07-13) 帰属ガード: この idle は「現ターンのもの」か「前ターン
+          // (result で畳んだ / interrupt で中断した) の遅延分」か。
+          //  1) _staleIdleExpected=true → 前ターンの遅延 idle。1 件だけ握り潰して現ターンは
+          //     継続させる (旧実装はここで新ターンを撃ち抜いていた)。
+          //  2) それ以外で _busy かつ (running を観測済み or 何かイベントを出した) → 現ターンの終端。
+          if (this._staleIdleExpected) {
+            this._clearStaleIdleGuard()
+            this.logger?.debug?.(
+              { stream_id: this.stream_id, turn: this._turnSeq },
+              "stale idle from previous turn ignored",
+            )
+          } else if (this._busy && (this._turnRunningSeen || this._turnProgressed)) {
             this._settleResidentTurn("idle", denyPending)
             // per-message の RC-4 と対称に、チャット信号 (サイドバードット) を
             // processing→waiting へ落とす。result 経由なら main.mjs が result を見て
@@ -1333,8 +1440,15 @@ class ClaudeStreamSession {
             }
           }
         } else {
-          // 現ターンが「進行した」証跡。init / assistant / stream_event / user、および
-          // session_state_changed の running / requires_action もここに含む。
+          // SDK-P0-4: running は「SDK が新しい input の処理を実際に開始した」ことの権威的な
+          // 証跡で、前ターンの遅延イベントでは絶対に立たない。これを観測した時点で、
+          // 前ターン由来の遅延 idle はもう届かない (順序保証) のでガードを解除できる。
+          if (isSessionRunningEvent(msg)) {
+            this._turnRunningSeen = true
+            this._clearStaleIdleGuard()
+          }
+          // 現ターンが「進行した」証跡 (一次ガード)。init / assistant / stream_event / user、
+          // および session_state_changed の running / requires_action もここに含む。
           this._turnProgressed = true
         }
         try {
@@ -1404,17 +1518,42 @@ class ClaudeStreamSession {
     // 常駐 query は interrupt() で現ターンのみ中断する (query は継続、次 input 受付継続)。
     if (this._residentQuery && typeof this._residentQuery.interrupt === "function") {
       const wasBusy = this._busy
+      // SDK-P0-4 (2026-07-13): Query.interrupt() は control request の往復を伴う **async
+      // メソッド** (Promise を返す)。同期 try/catch では reject を捕まえられず unhandled
+      // rejection になっていた (同ファイルの setModel / setPermissionMode / setMaxThinkingTokens は
+      // すべて .catch() 済みで、interrupt だけが非対称だった)。
+      // さらに重要なのは「interrupt が届いたか確認する前に _busy=false にして drain する」点で、
+      // control request が失敗すると SDK 側のターンは走り続けているのにこちらは「終わった」と
+      // 判断し、次の pending を同じ InputQueue へ push してしまう (実行中ターンへの割り込み)。
+      // reject 時は AbortController で generator ごと畳む (finally が pending を resume 再起動で
+      // 拾い直すため、取りこぼしにはならない) 最終手段へフォールバックする。
       try {
-        this._residentQuery.interrupt()
-      } catch {
-        /* ignore */
+        const p = this._residentQuery.interrupt()
+        if (p && typeof p.catch === "function") {
+          p.catch((err) => {
+            this.logger?.warn(
+              { stream_id: this.stream_id, err: err?.message },
+              "resident interrupt() rejected; falling back to hard abort",
+            )
+            this._hardAbortResident()
+          })
+        }
+      } catch (err) {
+        this.logger?.warn(
+          { stream_id: this.stream_id, err: err?.message },
+          "resident interrupt() threw; falling back to hard abort",
+        )
+        this._hardAbortResident()
       }
       // SDK-P0-3 (2026-07-10): 中断も「このターンの終端」なので settled を立てる。
-      // interrupt() 後に SDK が session_state_changed:idle を流しても、_turnSettled=true
-      // (pending 無しで drain が早期 return するケース) か _turnProgressed=false
-      // (drain が次ターンを開始したケース) のどちらかで必ず無視される。
+      // SDK-P0-4: 中断されたターンも session_state_changed:idle を流しうる。drain が同期で
+      // 次ターンを開始するため、その遅延 idle が新ターンを撃ち抜かないようガードを張る
+      // (旧コメントは「_turnSettled か _turnProgressed のどちらかで必ず無視される」と断言して
+      //  いたが、中断ターンの in-flight イベントが _turnProgressed を立ててしまうため成立して
+      //  いなかった)。
       this._turnSettled = true
       this._busy = false
+      this._armStaleIdleGuard()
       // 孤児カード防止 (2026-07-10 監査): 中断したターンに紐づく未応答 permission は
       // もう誰も応答しない。deny で canUseTool の Promise を解放し、browser のカードも
       // 撤去する。これが無いと (a) 画面に承認カードが残り続け (b) _permissionResolvers に
@@ -1483,6 +1622,19 @@ class ClaudeStreamSession {
     }
   }
 
+  /** SDK-P0-4 (2026-07-13): 常駐 query の最終手段の強制終了。interrupt() (control request) が
+   *  失敗・無応答のときと close() から呼ぶ。AbortController を落とすと generator が終了し、
+   *  _runResidentQuery の finally が pending を resume 付きで再起動して取りこぼしを防ぐ。 */
+  _hardAbortResident() {
+    const ac = this._residentAbortController
+    if (!ac || ac.signal?.aborted) return
+    try {
+      ac.abort()
+    } catch {
+      /* ignore */
+    }
+  }
+
   /** このセッションの常駐 query 内で MCP サーバーを再接続する (動作中チャットへ波及)。
    *  常駐 query が無い (per-message セッション) 場合は false。per-message は毎ターン
    *  新プロセスで MCP を張り直すため、次メッセージで自動的に再接続される。
@@ -1516,6 +1668,15 @@ class ClaudeStreamSession {
     // 常駐 query は input キューを閉じて generator を終わらせ query を完走させる。
     if (this._inputQueue) this._inputQueue.close()
     this.abortTurn()
+    // SDK-P0-4 (2026-07-13): close は「もう使わない」宣言なので、常駐 query は最終手段で
+    // 確実に畳む。inputQueue.close() + interrupt() だけだと、CLI が control request に
+    // 応答しない/ハングしたときに generator が終わらず、SIGTERM 受信時 (shutdown) に子プロセスが
+    // 残留する。_closed=true 済みなので finally の pending 再起動経路には入らない。
+    this._hardAbortResident()
+    if (this._staleIdleTimer) {
+      clearTimeout(this._staleIdleTimer)
+      this._staleIdleTimer = null
+    }
     if (this._idleTimer) {
       clearTimeout(this._idleTimer)
       this._idleTimer = null
@@ -1583,6 +1744,12 @@ export class ClaudeStreamBridge extends EventEmitter {
     if (session.sessionId && this._liveBySession.get(session.sessionId) === session) {
       this._liveBySession.delete(session.sessionId)
     }
+    // SDK-P0-4 (2026-07-13): session_id 回転前に登録した旧キーも外す (現 sessionId しか見ないと
+    // 旧 id → 死んだ session のエントリが残り、attach が孤児を引き当てる)。
+    const prevKey = session._liveKey
+    if (prevKey && this._liveBySession.get(prevKey) === session) {
+      this._liveBySession.delete(prevKey)
+    }
   }
 
   /**
@@ -1722,7 +1889,20 @@ export class ClaudeStreamBridge extends EventEmitter {
           event,
         })
         // session_id 確定後は索引に登録 (冪等)。再接続時の再アタッチに使う。
-        if (session.sessionId) this._liveBySession.set(session.sessionId, session)
+        // SDK-P0-4 (2026-07-13): /clear や compaction で session_id が回転すると、旧 id →
+        // 生存 session のエントリが Map に永久残留し、attach(resume_session_id=旧 id) が
+        // 意図しない live session を引き当てる (+ Map リーク)。登録済みキーを覚えておき、
+        // 回転を検知したら旧キーを外してから張り替える。
+        if (session.sessionId) {
+          const prevKey = session._liveKey
+          if (prevKey && prevKey !== session.sessionId) {
+            if (this._liveBySession.get(prevKey) === session) {
+              this._liveBySession.delete(prevKey)
+            }
+          }
+          session._liveKey = session.sessionId
+          this._liveBySession.set(session.sessionId, session)
+        }
       },
       onPermission: ({ tool_name, input, request_id }) => {
         // 多端末共有: session_id を載せて backend が session group へ broadcast できるように

package/src/hub-bundle.mjs

@@ -300,7 +300,7 @@ function runOnce(argv, { logger } = {}) {
  * (Cockpit 用途では install.sh が事前に claude をインストールしている
  * 想定だが、独自運用環境への配慮で fail-soft にする)
  */
-export async function applyMcpServers(bundle, { logger } = {}) {
+export async function applyMcpServers(bundle, { agentId, agentToken, logger } = {}) {
   const servers = Array.isArray(bundle?.mcp_servers) ? bundle.mcp_servers : []
   if (servers.length === 0) return { added: [], skipped: [] }
 
@@ -328,9 +328,16 @@ export async function applyMcpServers(bundle, { logger } = {}) {
       transport,
       "--scope",
       scope,
-      s.name,
-      s.url,
     ]
+    // 越境制御 (2026-07): 一般向け `hub` MCP には、このホストの資格
+    // `X-Cockpit-Agent: <agentId>:<agentToken>` をヘッダで付与する。Hub backend は
+    // これを検証してホストのテナントを解決し、`hub` の acting tenant をそのテナントに
+    // **固定**する（クライアントホストは自テナントの外を触れない）。`hub_staff`（社内
+    // 横断）や外部 MCP には付けない。
+    if (s.name === "hub" && agentId && agentToken) {
+      argv.push("--header", `X-Cockpit-Agent: ${agentId}:${agentToken}`)
+    }
+    argv.push(s.name, s.url)
     try {
       await runOnce(argv, { logger })
       added.push(s.name)
@@ -428,7 +435,7 @@ export async function syncBundle({ hubUrl, agentId, agentToken, logger, fetchImp
   try {
     mcp = cliKind === "codex"
       ? await applyCodexMcpServers(bundle, { logger })
-      : await applyMcpServers(bundle, { logger })
+      : await applyMcpServers(bundle, { agentId, agentToken, logger })
   } catch (err) {
     logger?.warn({ err: err.message }, "applyMcpServers failed (continuing)")
   }

package/src/main.mjs

@@ -4076,6 +4076,12 @@ async function dispatch(msg, ctx) {
           type: "claude.history.response",
           stream_id,
           session_id,
+          // SDK-P0-4 (2026-07-13): 要求時の cwd をエコーバックする。claude.sessions.response は
+          // 元から cwd を載せており frontend が cwd 照合で「別ワークスペース宛の遅延応答」を
+          // 捨てられるのに、history.response だけ cwd が無く照合材料が存在しなかった。
+          // その結果、無条件 hydrate → session_id 上書き → 購読スワップ → localStorage 汚染の
+          // 経路が残っていた (sessionScope.ts が stream_id 主軸で守るのは relay イベントのみ)。
+          cwd,
           events: result.events,
           total_lines: result.total_lines,
           truncated: result.truncated,