@cocorograph/hub-agent 0.7.49 → 0.7.52

package/package.json

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

package/src/claude-stream-bridge.mjs

@@ -145,6 +145,50 @@ const CHAT_SHARED_ENABLED = process.env.HUB_AGENT_CHAT_SHARED === "1"
 const DEAD_TERMINAL_TTL_MS =
   Number(process.env.HUB_AGENT_DEAD_TERMINAL_TTL_MS) || 60 * 60 * 1000
 
+/**
+ * モデル能力レジストリ (2026-07-11): モデル名 → { supportsEffort, supportsXhighEffort }。
+ *
+ * 【なぜ SDK 由来にするか】旧実装は effort 対応可否を正規表現
+ * `/claude-fable-5|claude-opus-4-[678]/` でハードコードしていた。これは Hub のモデル
+ * マスタとも frontend の正規表現とも独立した第 3 の SoT で、新モデルが出るたびに
+ * 取りこぼす (2026-07-02 に fable-5 で実際に発生)。SDK の `supportedModels()` は
+ * `ModelInfo.supportsEffort` / `supportedEffortLevels` を権威的に返すので、それを
+ * 起動時に 1 回引いてここへ載せ、以降の effort 判定に使う。
+ *
+ * 空 (SDK 未取得 / 一覧に無いカスタムモデル) の場合は「browser が effort を明示送信
+ * してきたか」にフォールバックする (frontend は Hub マスタの supports_effort で判定して
+ * から送るため信頼できる)。詳細は ClaudeStreamSession._isEffortModel。
+ *
+ * @type {Map<string, { supportsEffort: boolean, supportsXhighEffort: boolean }>}
+ */
+const _modelCapabilities = new Map()
+
+/** SDK `supportedModels()` の戻り値 (ModelInfo[]) をレジストリへ載せる。 */
+export function setModelCapabilities(models) {
+  _modelCapabilities.clear()
+  for (const m of models || []) {
+    const name = m?.value
+    if (typeof name !== "string" || !name) continue
+    const levels = Array.isArray(m.supportedEffortLevels) ? m.supportedEffortLevels : []
+    _modelCapabilities.set(name, {
+      supportsEffort: m.supportsEffort === true,
+      supportsXhighEffort: levels.includes("xhigh") || levels.includes("max"),
+    })
+  }
+  return _modelCapabilities.size
+}
+
+/** モデル名の能力を返す。未知 (未登録 / 一覧に無い) なら null。 */
+export function getModelCapability(model) {
+  if (typeof model !== "string" || !model) return null
+  return _modelCapabilities.get(model) ?? null
+}
+
+/** テスト用: レジストリをクリアする。 */
+export function _resetModelCapabilities() {
+  _modelCapabilities.clear()
+}
+
 /** 文字列を SDK streaming input の SDKUserMessage に包む。
  *  SDKUserMessage は parent_tool_use_id: string|null が必須フィールド。現行 SDK は入力側で
  *  寛容なので省略しても動くが、将来の型厳格化に備えて明示する。トップレベルのユーザー入力
@@ -209,6 +253,24 @@ function extractPromptText(message) {
   return ""
 }
 
+/**
+ * SDK-P0-3 (2026-07-10): SDK の権威的ターン終了シグナル。
+ * sdk.d.ts (SDKSessionStateChangedMessage) いわく
+ *   "'idle' fires after heldBackResult flushes and the bg-agent do-while exits
+ *    — authoritative turn-over signal."
+ * つまり result が流れるターンでは `result` → `idle` の順で届き、result が届かない
+ * ターン (held back のまま終わる等) でも idle は届く。frontend は SDK-P0-1 で既に
+ * idle をターン終端として扱っているが、agent 側 (resident query) は result しか見て
+ * おらず _busy が固着していた。その非対称を解消するための判定。
+ */
+function isSessionIdleEvent(msg) {
+  return (
+    msg?.type === "system" &&
+    msg?.subtype === "session_state_changed" &&
+    msg?.state === "idle"
+  )
+}
+
 /**
  * 1 stream に対応する Claude セッション (per-message query モデル)。
  */
@@ -227,6 +289,7 @@ class ClaudeStreamSession {
     logger,
     onEvent,
     onPermission,
+    onPermissionCancel,
     onExit,
     onError,
     onReap,
@@ -257,6 +320,8 @@ class ClaudeStreamSession {
     this.logger = logger
     this.onEvent = onEvent
     this.onPermission = onPermission
+    /** 未応答 permission を内部 deny した際に browser へカード撤去を伝えるコールバック。 */
+    this.onPermissionCancel = onPermissionCancel
     this.onExit = onExit
     this.onError = onError
     /** ターン完走後に遅延クローズする際、manager にセッション撤去を依頼するコールバック */
@@ -331,6 +396,18 @@ class ClaudeStreamSession {
     this._permissionResolvers = new Map()
     /** 現在ターン実行中か (多重 query 防止) */
     this._busy = false
+    /** SDK-P0-3 (2026-07-10): 現ターンが既に終端処理済みか (result / idle / abort の
+     *  いずれか 1 回だけ _busy=false + drain させるための冪等ガード)。resident query は
+     *  1 ターンにつき `result` と `session_state_changed:idle` の**両方**が流れうるため、
+     *  素朴に両方で drain すると二重 drain (FIFO 崩れ) を起こす。ターン開始時
+     *  (_beginResidentTurn) に false へ戻す。 */
+    this._turnSettled = false
+    /** SDK-P0-3: 現ターンが 1 件でもストリームイベントを出したか。
+     *  「前ターンの遅延 idle が、drain で始まったばかりの次ターンを誤終了させる」レースの
+     *  ガードに使う。generator のイベント順序は保証される (turn N の idle は turn N+1 の
+     *  最初のイベントより必ず先に届く) ため、`idle 到着時に現ターンがまだ何も出していない`
+     *  = その idle は前ターンのもの、と判定できる。ターン開始時に false へ戻す。 */
+    this._turnProgressed = false
     /** detach 済みフラグ (新規ターン受付停止) */
     this._closed = false
     /** 実行中ターンの完走を待ってからクローズする予約フラグ (graceful detach 用)。
@@ -435,6 +512,20 @@ class ClaudeStreamSession {
     })
   }
 
+  /**
+   * SDK options.stderr: CLI サブプロセスの stderr を logger へ流す (2026-07-11 監査)。
+   *
+   * 未設定だと認証エラー・MCP 起動失敗・内部警告といったサブプロセスの一次情報が完全に
+   * 破棄され、「SDK チャットが無音で挙動がおかしい」系の障害調査で手掛かりが残らない。
+   * onError は generator が throw したときしか発火しないため、それとは別に stderr を拾う。
+   * デバッグ用途なので debug レベルで出す (通常運用のログを汚さない)。
+   */
+  _stderrHandler(data) {
+    const text = typeof data === "string" ? data.trim() : ""
+    if (!text) return
+    this.logger?.debug({ stream_id: this.stream_id, cwd: this.cwd, stderr: text }, "claude cli stderr")
+  }
+
   /** SDK options.canUseTool: tool 起動を許可するかを browser に問い合わせる。 */
   async _canUseTool(toolName, input) {
     if (!this.onPermission) return { behavior: "allow", updatedInput: input }
@@ -458,6 +549,46 @@ class ClaudeStreamSession {
     })
   }
 
+  /**
+   * 未応答の permission をすべて内部 deny し、その request_id を browser へ通知する。
+   *
+   * 【なぜ通知が要るか】(2026-07-10 監査)
+   * ターン終了 / 中断 (abort) / セッション close の際、SDK の `canUseTool` Promise を
+   * 宙吊りにしないため deny で解決していた。しかし **browser には何も送っていなかった**
+   * ため、承認カードだけが画面に残り続ける (孤児カード)。ユーザーはそれをクリックする
+   * まで消せず、既に終わったターンのツールを承認/拒否したかのような UI になる。
+   *
+   * `claude.permission.cancel` は既に agent → backend → browser の型として存在する
+   * (TUI 由来カードの撤去に使われている) ので、SDK チャットの内部 deny でも同じ型で
+   * 撤去を伝える。request_id は browser 側で照合され、未知 id は no-op になる。
+   *
+   * @param {string} reason "turn ended" | "aborted" | "closed" 等
+   * @returns {string[]} deny した request_id 群
+   */
+  _denyAllPendingPermissions(reason) {
+    const cancelled = []
+    for (const [request_id, resolver] of this._permissionResolvers) {
+      cancelled.push(request_id)
+      try {
+        resolver.resolve({ behavior: "deny", message: reason })
+      } catch {
+        /* ignore */
+      }
+    }
+    this._permissionResolvers.clear()
+    if (cancelled.length && this.onPermissionCancel) {
+      try {
+        this.onPermissionCancel({ request_ids: cancelled, reason })
+      } catch (err) {
+        this.logger?.warn(
+          { err: err?.message, reason },
+          "onPermissionCancel callback threw",
+        )
+      }
+    }
+    return cancelled
+  }
+
   /** browser からの permission 応答を該当 request_id の Promise に渡す。 */
   resolvePermission(request_id, decision) {
     const r = this._permissionResolvers.get(request_id)
@@ -602,26 +733,28 @@ class ClaudeStreamSession {
     }
   }
 
-  /** モデルが effort / adaptive thinking 対応 (Opus 4.6+ / Fable 5) かどうか。
-   *  budget 方式 (maxThinkingTokens) は Opus 4.7+ で廃止扱いのため、effort モデルでは
-   *  effort + thinking:{type:'adaptive'} に切り替える。
-   *  ⚠️ frontend の isEffortModelByPattern (types/cockpit.ts) と同一パターンを維持する
-   *  こと。旧実装は fable-5 を含まず、frontend が effort を送っても bridge が非 effort
-   *  分岐に入り「effort も budget も未適用」になる不整合があった (2026-07-02 修正)。 */
+  /** モデルが effort / adaptive thinking 対応かどうか。
+   *
+   *  判定順 (2026-07-11、正規表現ハードコードを廃止):
+   *   1. SDK `supportedModels()` 由来の能力レジストリに this.model があればそれを使う
+   *      (権威。新モデルも取りこぼさない)。
+   *   2. レジストリに無い (SDK 未取得 / 一覧に無いカスタムモデル / model 未指定) 場合は、
+   *      **browser が effort を明示送信してきたか**にフォールバックする。frontend は
+   *      Hub マスタの supports_effort で判定してから effort を送るため、「effort を
+   *      送ってきた ≒ そのモデルは effort 対応」が成り立つ。これにより正規表現による
+   *      モデル名の当てずっぽうを排し、能力を引けない起動直後も安全側に倒れる。 */
   _isEffortModel() {
-    return (
-      typeof this.model === "string" && /claude-fable-5|claude-opus-4-[678]/.test(this.model)
-    )
+    const cap = getModelCapability(this.model)
+    if (cap) return cap.supportsEffort
+    return !!this.effort
   }
 
   /** 思考関連オプション (effort / adaptive thinking / 旧 budget) を options へ適用する。
    *  per-message / 常駐 query の両方から呼ぶ共通ロジック (分岐の二重定義を避ける)。 */
   _applyThinkingOptions(options) {
-    // model 未指定 (= browser が agent/アカウント既定モデルへ委任) でも、browser が
-    // effort を明示送信してきた場合は effort 分岐に入れる。frontend は system/init の
-    // 実効モデル (runtimeModel) で capability 判定してから effort を送るため、ここでは
-    // その判断を信頼する (2026-07-02)。
-    if (this._isEffortModel() || (!this.model && this.effort)) {
+    // effort 対応判定は _isEffortModel に一元化 (レジストリ → browser effort フォールバック)。
+    // model 未指定 (= browser が既定モデルへ委任) でも effort 送信時は effort 分岐に入る。
+    if (this._isEffortModel()) {
       // effort モデル: adaptive thinking を明示 ON にし、effort で深さを指定する。
       // budget 方式 (maxThinkingTokens) は使わない (Opus 4.7+ で非対応)。
       options.thinking = { type: "adaptive" }
@@ -721,7 +854,7 @@ class ClaudeStreamSession {
         this._emitQueueState()
         return { accepted: true }
       }
-      this._busy = true
+      this._beginResidentTurn()
       // 改修4 (A): 死亡ガード。常駐 query が未起動 or (エラー等で) 終了済み (_residentQuery=null)
       // なら (再)起動する。_runResidentQuery は起動時 options.resume=this.sessionId で文脈を
       // 復元するため、途中死からの復活でも過去コンテキストは失われない。
@@ -794,6 +927,7 @@ class ClaudeStreamSession {
       canUseTool: (toolName, input) => this._canUseTool(toolName, input),
       includePartialMessages: true,
       abortController: this._abortController,
+      stderr: (data) => this._stderrHandler(data),
     }
     if (this.model) options.model = this.model
     if (this.permissionMode) options.permissionMode = this.permissionMode
@@ -858,15 +992,8 @@ class ClaudeStreamSession {
       }
     } finally {
       this._abortController = null
-      // 未解決 permission は閉じる
-      for (const [, resolver] of this._permissionResolvers) {
-        try {
-          resolver.resolve({ behavior: "deny", message: "turn ended" })
-        } catch {
-          /* ignore */
-        }
-      }
-      this._permissionResolvers.clear()
+      // 未解決 permission は閉じ、browser の孤児カードも撤去する
+      this._denyAllPendingPermissions("turn ended")
       // このターンで jsonl に書かれた行は query stream で既に push 済みなので、
       // watcher の offset を末尾に飛ばして二重 push を防ぐ。busy=true のまま
       // skipToEnd を待ち、完了後に busy=false にすることで、その間に watcher poll が
@@ -1067,6 +1194,40 @@ class ClaudeStreamSession {
     }
   }
 
+  /** SDK-P0-3 (2026-07-10): resident の「ターン開始」を 1 箇所に集約する。
+   *  _busy を立てるのと同時に、そのターンの終端フラグ (_turnSettled) と進行フラグ
+   *  (_turnProgressed) を必ずリセットする。ターン開始は 3 箇所ある
+   *  (sendMessage の直接 push / _drainResidentPending / _runResidentQuery finally の
+   *  異常再起動 push) ので、リセット漏れを構造的に防ぐためのヘルパー。 */
+  _beginResidentTurn() {
+    this._busy = true
+    this._turnSettled = false
+    this._turnProgressed = false
+  }
+
+  /** SDK-P0-3 (2026-07-10): resident の「ターン終端」を 1 箇所に集約する (result / idle 共通)。
+   *  同一ターンで 2 回以上呼ばれても最初の 1 回しか作用しない (_turnSettled ガード)。
+   *  これにより `result` → `idle` の順で両方届く通常ケースでも drain は 1 回だけになる。
+   *  @param {string} reason "result" | "idle" — ログ用
+   *  @param {(msg: string) => void} [denyPending] 未解決 permission を閉じるクロージャ
+   */
+  _settleResidentTurn(reason, denyPending) {
+    if (this._turnSettled) return
+    this._turnSettled = true
+    denyPending?.("turn ended")
+    this._busy = false
+    // 改修4 (A): シリアライズした pending があれば次の 1 件を InputQueue へ流す。
+    // ultracode (0.6.28): _drainResidentPending は applyFlagSettings を await するため
+    // async。for await ループ内からは fire-and-forget で呼ぶ (最初の await より前に
+    // _beginResidentTurn が同期実行されるので、以降の sendMessage は busy を正しく観測する)。
+    this._drainResidentPending().catch((err) =>
+      this.logger?.warn(
+        { stream_id: this.stream_id, err: err?.message, reason },
+        "drainResidentPending threw",
+      ),
+    )
+  }
+
   /** 改修4 (A): ターン完了時に pending の先頭 1 件を InputQueue へ流す (ターンのシリアライズ)。
    *  queue_state を更新して送信待ちチップを drain させる (frontend がバブル昇格する)。
    *  ultracode (0.6.28): 次ターンの目標 ultracode 状態へ reconcile してから push する
@@ -1082,7 +1243,7 @@ class ClaudeStreamSession {
     // _busy=true のまま残り、以降の drain が全て弾かれて pending が永久に積み上がる
     // デッドロックになる。失敗時は取り出したメッセージを先頭へ戻し _busy を解除して、
     // 次の drain がやり直せる状態に必ず回復する (例外は既存方針通り warn で握る)。
-    this._busy = true
+    this._beginResidentTurn()
     try {
       // ultracode reconcile (0.6.28) も await で例外を投げうるので try の中に含める。
       await this._reconcileResidentUltracode(next.ultracode === true)
@@ -1100,8 +1261,10 @@ class ClaudeStreamSession {
 
   /** 改修2+4: 常駐 query を 1 回だけ起動し、streaming input キューから複数ターンを処理する。
    *  system/init は最初の 1 回のみ (毎ターン init = 文脈/キャッシュ温め直しを解消)。各ターンは
-   *  result で _busy=false にするが query は継続し次 input を待つ。close (inputQueue.close) で
-   *  generator が終わり query が完走する。
+   *  終端シグナル (result / session_state_changed:idle) で _busy=false にするが query は継続し
+   *  次 input を待つ。close (inputQueue.close) で generator が終わり query が完走する。
+   *  SDK-P0-3 (2026-07-10): 終端を result だけに頼ると、SDK が idle でターンを終えたときに
+   *  _busy が固着し、以降の送信が pending へ永久滞留する (T06052)。
    *  改修4: resume セッションも対象。query 起動時 options.resume に過去 session_id を渡して
    *  文脈を引き継ぐ (init は初回 1 回のみ)。continue は使わない (自動継続の暴走回避)。初回 input は
    *  sendMessage が積むユーザーの実メッセージなので「Continue from where you left off」は発生しない。
@@ -1113,6 +1276,7 @@ class ClaudeStreamSession {
       env: siblingEnvFor(this.cwd),
       canUseTool: (toolName, input) => this._canUseTool(toolName, input),
       includePartialMessages: true,
+      stderr: (data) => this._stderrHandler(data),
     }
     if (this.model) options.model = this.model
     if (this.permissionMode) options.permissionMode = this.permissionMode
@@ -1129,16 +1293,7 @@ class ClaudeStreamSession {
     // 改修4: 起動時に sessionId (= resumeSessionId) があれば resume チェーンで文脈を引き継ぐ。
     // query 起動時点の値のみ有効 (起動後に確定/変化する session_id は同一 query 内で継続される)。
     if (this.sessionId) options.resume = this.sessionId
-    const denyPending = (reason) => {
-      for (const [, resolver] of this._permissionResolvers) {
-        try {
-          resolver.resolve({ behavior: "deny", message: reason })
-        } catch {
-          /* ignore */
-        }
-      }
-      this._permissionResolvers.clear()
-    }
+    const denyPending = (reason) => this._denyAllPendingPermissions(reason)
     try {
       const q = this.sdk.query({ prompt: this._inputQueue, options })
       this._residentQuery = q
@@ -1153,17 +1308,34 @@ class ClaudeStreamSession {
         if (msg?.type === "result") {
           if (typeof msg.session_id === "string") this.sessionId = msg.session_id
           // ターン完了: 未解決 permission を閉じ、次 input 受付へ (query は継続)。
-          denyPending("turn ended")
-          this._busy = false
-          // 改修4 (A): シリアライズした pending があれば次の 1 件を InputQueue へ流す。
-          // ultracode (0.6.28): _drainResidentPending は applyFlagSettings を await するため
-          // async。result ハンドラ (for await ループ内) からは fire-and-forget で呼ぶ。
-          this._drainResidentPending().catch((err) =>
-            this.logger?.warn(
-              { stream_id: this.stream_id, err: err?.message },
-              "drainResidentPending threw",
-            ),
-          )
+          this._settleResidentTurn("result", denyPending)
+        } else if (isSessionIdleEvent(msg)) {
+          // SDK-P0-3 (2026-07-10): result が届かずに idle でターンが終わるケースの救済。
+          // これを見ていなかったため _busy が true で固着し、以降の送信が
+          // _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) {
+            this._settleResidentTurn("idle", denyPending)
+            // per-message の RC-4 と対称に、チャット信号 (サイドバードット) を
+            // processing→waiting へ落とす。result 経由なら main.mjs が result を見て
+            // waiting にするが、idle 単独ではその契機が無く 90s TTL まで固着するため。
+            try {
+              this.onTurnSettled?.()
+            } catch {
+              /* ignore */
+            }
+          }
+        } else {
+          // 現ターンが「進行した」証跡。init / assistant / stream_event / user、および
+          // session_state_changed の running / requires_action もここに含む。
+          this._turnProgressed = true
         }
         try {
           this._emit(msg)
@@ -1207,7 +1379,7 @@ class ClaudeStreamSession {
         // close() するだけで参照を持ち越さないので、ここで差し替えても整合する。
         this._inputQueue = new InputQueue()
         const next = this._pendingMessages.shift()
-        this._busy = true
+        this._beginResidentTurn()
         this._residentStarted = true
         // ultracode (0.6.29): query を先に起動して _residentQuery を確定させてから
         // reconcile → push する (sendMessage の通常経路と同順)。push してから起動すると
@@ -1237,7 +1409,19 @@ class ClaudeStreamSession {
       } catch {
         /* ignore */
       }
+      // SDK-P0-3 (2026-07-10): 中断も「このターンの終端」なので settled を立てる。
+      // interrupt() 後に SDK が session_state_changed:idle を流しても、_turnSettled=true
+      // (pending 無しで drain が早期 return するケース) か _turnProgressed=false
+      // (drain が次ターンを開始したケース) のどちらかで必ず無視される。
+      this._turnSettled = true
       this._busy = false
+      // 孤児カード防止 (2026-07-10 監査): 中断したターンに紐づく未応答 permission は
+      // もう誰も応答しない。deny で canUseTool の Promise を解放し、browser のカードも
+      // 撤去する。これが無いと (a) 画面に承認カードが残り続け (b) _permissionResolvers に
+      // 残った古い request_id が reattach 時の replayPendingPermissions で再送されて
+      // 「終わったターンのカード」が蘇る。close() 経由の abort では下流の close() が
+      // "closed" で再度呼ぶが、map は空なので no-op (二重通知しない)。
+      this._denyAllPendingPermissions("aborted_by_user")
       // SDK-P0-2 (2026-07-07): resident 経路のターン終端イベント非対称の解消。
       // per-message の abort (_runPerMessage finally) は合成 result (aborted_by_user) を
       // frontend へ emit + onTurnSettled を呼んで UI (turnActive/interrupting) とサイドバー
@@ -1248,8 +1432,9 @@ class ClaudeStreamSession {
       // - 実行中ターンがあった (wasBusy) ときだけ emit する (未走行での空 abort に
       //   「中断しました」フッターを出さない)。
       // - close()/reap 経由の abort (_closed=true) では browser は既に離脱しているため抑止する。
-      // - drain タイミングは変更しない (既存の同期 drain を維持し、result+idle 二重 drain や
-      //   中断ターンの遅延 idle が新ターンを誤終了させる新種レースを持ち込まない)。
+      // - drain タイミングは変更しない (既存の同期 drain を維持する)。result+idle の二重 drain と
+      //   中断ターンの遅延 idle による新ターン誤終了は、SDK-P0-3 の _turnSettled /
+      //   _turnProgressed ガードで潰してある (上の _turnSettled=true もその一部)。
       // - 合成 result の uuid は重複排除 (isDuplicateEvent の result 署名判定) 回避のため必須。
       if (wasBusy && !this._closed) {
         try {
@@ -1343,14 +1528,7 @@ class ClaudeStreamSession {
       }
       this._watcher = null
     }
-    for (const [, resolver] of this._permissionResolvers) {
-      try {
-        resolver.resolve({ behavior: "deny", message: "closed" })
-      } catch {
-        /* ignore */
-      }
-    }
-    this._permissionResolvers.clear()
+    this._denyAllPendingPermissions("closed")
     // マスク (2026-06-23): アイドル close (走行ターン無し = CLI が jsonl を掴んでいない) は
     // ここで即マスクする。走行中 close (abortTurn 経由) は CLI 終了を待つため run-loop の
     // finally 側でマスクする (上の _maskJsonlAtRest 冪等ガードで二重実行は防がれる)。
@@ -1558,6 +1736,16 @@ export class ClaudeStreamBridge extends EventEmitter {
           input,
         })
       },
+      onPermissionCancel: ({ request_ids, reason }) => {
+        // 内部 deny した承認カードを browser から撤去する (孤児カード防止)。
+        this.emit("permissioncancel", {
+          stream_id: session.stream_id,
+          session_id: session.sessionId,
+          cwd: session.cwd,
+          request_ids,
+          reason,
+        })
+      },
       onError: (err) => {
         this.emit("error", {
           stream_id: session.stream_id,
@@ -1756,6 +1944,39 @@ export class ClaudeStreamBridge extends EventEmitter {
     return this._mergeNeedsAuthCache(servers)
   }
 
+  /**
+   * SDK `supportedModels()` を control-only query 経由で 1 回引き、モデル能力レジストリ
+   * (_modelCapabilities) を更新する。起動時に 1 回呼ぶ想定 (能力はセッション中不変なので
+   * attach ごとに引き直さない)。
+   *
+   * `supportedModels()` は公開 Query インターフェース (sdk.d.ts) のメソッドだが、念のため
+   * typeof ガードし、失敗 (未実装 SDK / 一時エラー) は握って false を返す。取得できなければ
+   * レジストリは空のままで、effort 判定は「browser が effort を送ってきたか」へフォールバック
+   * するため安全側に倒れる。
+   *
+   * @returns {Promise<number|false>} 載せたモデル数 / 失敗時 false
+   */
+  async refreshModelCapabilities() {
+    try {
+      const q = await this._ensureMcpControlQuery()
+      this._armMcpControlIdle()
+      if (typeof q.supportedModels !== "function") {
+        this.logger?.warn({}, "SDK に supportedModels() が無い (能力レジストリ未更新)")
+        return false
+      }
+      const models = await q.supportedModels()
+      const n = setModelCapabilities(models)
+      this.logger?.info({ count: n }, "model capabilities loaded from SDK")
+      return n
+    } catch (err) {
+      this.logger?.warn(
+        { err: err?.message },
+        "refreshModelCapabilities failed (effort 判定は browser effort へフォールバック)",
+      )
+      return false
+    }
+  }
+
   /**
    * アカウント全体の 5h/7d rate-limit 使用率 + プラン種別を返す (usage.mjs
    * recordChatUsageSnapshot に渡す想定)。mcpStatus と同じ control-only query を共有する
@@ -1948,10 +2169,36 @@ export class ClaudeStreamBridge extends EventEmitter {
     return { servers, targeted }
   }
 
+  /**
+   * SDK の control query が指定メソッドを実装しているか検査して返す。
+   *
+   * `mcpAuthenticate` / `mcpSubmitOAuthCallbackUrl` / `mcpClearAuth` は **公開
+   * `Query` インターフェース (sdk.d.ts) に型が存在しない**内部 API で、ランタイム
+   * (sdk.mjs) にのみ実装がある。SDK 側でリネーム/削除されても TypeScript は警告
+   * できないため、`usage_EXPERIMENTAL_...` と同じく呼ぶ前に typeof で確かめる。
+   *
+   * 未実装なら `mcp_method_unsupported:<name>` を throw する。呼び出し側 (main.mjs の
+   * `claude.mcp.*` ハンドラ) の try/catch がこれを掴んで `claude.mcp.response` の
+   * error として browser へ返すので、`q.mcpAuthenticate is not a function` という
+   * 診断不能なメッセージではなく「SDK がこの API を持っていない」と分かる形になる。
+   */
+  _requireMcpMethod(q, name) {
+    if (!q || typeof q[name] !== "function") {
+      const err = new Error(`mcp_method_unsupported:${name}`)
+      this.logger?.warn(
+        { method: name },
+        "SDK control query に MCP メソッドが存在しない (SDK バージョン差異の可能性)",
+      )
+      throw err
+    }
+    return q
+  }
+
   /** 指定 MCP サーバーの OAuth 認証を開始する。認可 URL を含む応答を返す。 */
   async mcpAuthenticate(serverName, redirectUri) {
     const q = await this._ensureMcpControlQuery()
     this._armMcpControlIdle()
+    this._requireMcpMethod(q, "mcpAuthenticate")
     return await q.mcpAuthenticate(serverName, redirectUri)
   }
 
@@ -1959,6 +2206,7 @@ export class ClaudeStreamBridge extends EventEmitter {
   async mcpSubmitOAuthCallback(serverName, callbackUrl) {
     const q = await this._ensureMcpControlQuery()
     this._armMcpControlIdle()
+    this._requireMcpMethod(q, "mcpSubmitOAuthCallbackUrl")
     return await q.mcpSubmitOAuthCallbackUrl(serverName, callbackUrl)
   }
 
@@ -1966,6 +2214,7 @@ export class ClaudeStreamBridge extends EventEmitter {
   async mcpClearAuth(serverName) {
     const q = await this._ensureMcpControlQuery()
     this._armMcpControlIdle()
+    this._requireMcpMethod(q, "mcpClearAuth")
     return await q.mcpClearAuth(serverName)
   }
 

package/src/main.mjs

@@ -597,7 +597,9 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
       // assistant / result はターンの進行/完了 = permission 応答後に必ず流れるため、
       // ここで inputPending を落として「確認待ち」ドット/通知を自己解消させる。
       if (event?.type === "assistant") {
-        const pct = event.message?.usage ? contextPctFromUsage(event.message.usage) : null
+        // 分母は result で学習したセッション固有の窓サイズ (無ければグローバル概算)。
+        // マシン全体で 1 個の statusLine 値を使うと、別モデルの並走で 5 倍ずれる。
+        const pct = resolveChatContextPct(cwd, "claude", event)
         try {
           // cliKind は chat-signals のキーの一部 (T05945)。同一 cwd で走る codex の信号と
           // 混ざらないよう、claude 由来のイベントは必ず "claude" バケットへ書く。
@@ -612,6 +614,8 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
           /* ignore */
         }
       } else if (event?.type === "result") {
+        // SDK の権威的な窓サイズ (result.modelUsage[model].contextWindow) をここで学習する。
+        resolveChatContextPct(cwd, "claude", event)
         try {
           recordChatActivity(cwd, "claude", {
             status: "waiting",
@@ -659,6 +663,36 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
         input,
       })
     })
+    claudeBridge.on(
+      "permissioncancel",
+      ({ stream_id, session_id, cwd, request_ids, reason }) => {
+        // SDK チャットの未応答 permission をターン終了/中断/close で内部 deny したとき、
+        // browser に残っている承認カードを撤去する (孤児カード防止, 2026-07-10 監査)。
+        // TUI 由来カードの撤去と同じ `claude.permission.cancel` 型を使う。
+        for (const request_id of request_ids || []) {
+          try {
+            client.send({
+              type: "claude.permission.cancel",
+              stream_id,
+              session_id,
+              cwd,
+              request_id,
+              reason,
+            })
+          } catch {
+            /* ignore */
+          }
+        }
+        if (cwd && request_ids?.length) {
+          // 確認待ちドットも落とす (次の assistant/result を待たずに自己解消させる)。
+          try {
+            recordChatActivity(cwd, "claude", { inputPending: false })
+          } catch {
+            /* ignore */
+          }
+        }
+      },
+    )
     claudeBridge.on("exit", ({ stream_id, code, reason, session_id }) => {
       client.send({ type: "claude.exit", stream_id, code, reason, session_id })
     })
@@ -1016,6 +1050,26 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
   jsonlLiveWatchers.start()
   ctx.jsonlLiveWatchers = jsonlLiveWatchers
 
+  // モデル能力レジストリ (2026-07-11): SDK supportedModels() を起動時に引き、effort
+  // 対応可否の判定を正規表現ハードコードから権威データへ置き換える。能力はセッション中
+  // 不変なので attach ごとには引き直さない。ただし control-only query は cold start 直後に
+  // 失敗しうるため、起動フェーズ内で数回だけリトライする (成功したら打ち切り)。全滅しても
+  // effort 判定は「browser effort 送信」へフォールバックするので致命ではない。
+  // fire-and-forget で起動をブロックしない。
+  if (claudeBridge) {
+    ;(async () => {
+      const delaysMs = [0, 3000, 15000]
+      for (const d of delaysMs) {
+        if (d) await new Promise((r) => setTimeout(r, d))
+        const n = await claudeBridge.refreshModelCapabilities()
+        if (n) return // 1 件でも載れば成功
+      }
+      logger.warn({}, "model capability を起動フェーズで取得できず (browser effort へフォールバック)")
+    })().catch((err) =>
+      logger.warn({ err: err?.message }, "model capability 取得ループが例外終了"),
+    )
+  }
+
   // T04784 会話継続バインディングの冪等性ガード: tmux セッション名 → 最後に --resume で
   // 載せ替えた Claude session_id。TUI ビューが remount のたびに claude.tui.bind を送っても、
   // 同じ id への再 respawn (= claude 再起動) を抑止する。
@@ -1098,13 +1152,76 @@ export async function refreshContextWindow() {
   }
 }
 
+/**
+ * セッション単位で学習した context 窓サイズ (トークン)。
+ * キーは `${cliKind}\u0000${cwd}` (chat-signals と同じ粒度)。
+ *
+ * 【なぜセッション単位が要るか】(2026-07-10 監査)
+ * 旧実装は分子 (SDK assistant.usage = セッション単位) に対し、分母を
+ * resolvedContextWindow = statusLine cache (`~/.hub/usage/latest.json`) 由来の
+ * **マシン全体で 1 個のグローバル値**にしていた。同ファイルは「最後に statusLine を
+ * 書いた任意のセッション」の値なので、1M 窓の Opus と 200k 窓の Sonnet を同時に
+ * 走らせると、分母が取り違わってドーナツが 5 倍ずれる (分子と分母のスケール不一致)。
+ *
+ * SDK は `result.modelUsage[model].contextWindow` として **そのターンで実際に使われた
+ * モデルの窓サイズ**を毎ターン渡してくる。これが唯一の権威なので、result のたびに
+ * ここへ学習し、以降の assistant イベントの分母に使う。
+ */
+const contextWindowByChatKey = new Map()
+
+/** 直近の assistant メッセージのモデル名。result の modelUsage から主対話モデルを選ぶ手掛かり。 */
+const lastAssistantModelByChatKey = new Map()
+
+/** chat-signals と同じ (cwd, cliKind) 粒度のキーを作る。 */
+export function chatKey(cwd, cliKind) {
+  return `${cliKind || "claude"}\u0000${cwd || ""}`
+}
+
+/**
+ * SDK `result` の `modelUsage` から、そのセッションの context 窓サイズを選ぶ。
+ *
+ * `modelUsage` は `Record<モデル名, ModelUsage>` で、1 ターンに複数モデルが乗りうる
+ * (サブエージェントの haiku 等)。ドーナツが表すべきは **主対話モデル**の窓なので、
+ *   1. 直近 assistant メッセージのモデル名に完全一致するもの
+ *   2. 無ければ入力トークン (input + cache_read) が最大のもの = 会話本体を読んだモデル
+ * の順に選ぶ。どれも窓サイズを持たなければ null (呼び出し側がグローバル値へフォールバック)。
+ *
+ * @param {Record<string, {contextWindow?:number, inputTokens?:number, cacheReadInputTokens?:number}>|null|undefined} modelUsage
+ * @param {string|null|undefined} preferredModel 直近 assistant の model 名
+ * @returns {number|null}
+ */
+export function pickContextWindow(modelUsage, preferredModel) {
+  if (!modelUsage || typeof modelUsage !== "object") return null
+  const entries = Object.entries(modelUsage).filter(
+    ([, v]) => v && typeof v.contextWindow === "number" && v.contextWindow > 0,
+  )
+  if (entries.length === 0) return null
+  if (preferredModel) {
+    const hit = entries.find(([name]) => name === preferredModel)
+    if (hit) return hit[1].contextWindow
+  }
+  const inputOf = (v) => (v.inputTokens || 0) + (v.cacheReadInputTokens || 0)
+  let best = entries[0]
+  for (const e of entries) {
+    if (inputOf(e[1]) > inputOf(best[1])) best = e
+  }
+  return best[1].contextWindow
+}
+
 /**
  * SDK assistant メッセージの usage から context 使用率 (%) を概算する。
  * context = input + cache_read + cache_creation + output(直近応答)。
  * プロンプトキャッシュ有効時は cache_* に大半が乗るため 4 種を合算する。
- * 分母は resolvedContextWindow (実窓サイズ。1M ベータ等を自動反映)。
+ *
+ * 分母は `contextWindow` 引数 (= SDK result の modelUsage から学習したセッション固有の
+ * 窓サイズ) を最優先し、未学習なら resolvedContextWindow (statusLine cache 由来の
+ * グローバル概算) にフォールバックする。セッションの初回ターンだけは result 未着で
+ * フォールバックになるが、初回はトークンが少なくドーナツもほぼ 0 のため実害は無い。
+ *
+ * @param {object|null} u assistant.message.usage
+ * @param {number|null|undefined} contextWindow セッション固有の窓サイズ (省略時グローバル)
  */
-export function contextPctFromUsage(u) {
+export function contextPctFromUsage(u, contextWindow) {
   if (!u) return null
   const tokens =
     (u.input_tokens || 0) +
@@ -1112,7 +1229,43 @@ export function contextPctFromUsage(u) {
     (u.cache_creation_input_tokens || 0) +
     (u.output_tokens || 0)
   if (tokens <= 0) return null
-  return Math.min(100, Math.round((tokens / resolvedContextWindow) * 1000) / 10)
+  const win =
+    typeof contextWindow === "number" && contextWindow > 0
+      ? contextWindow
+      : resolvedContextWindow
+  return Math.min(100, Math.round((tokens / win) * 1000) / 10)
+}
+
+/**
+ * SDK チャットの assistant / result イベントから context% を解決し、
+ * 併せて `result.modelUsage` の窓サイズを (cwd, cliKind) 単位で学習する。
+ *
+ * ハンドラ本体から切り出して単体テスト可能にしている (学習 → 次ターンで反映、
+ * という状態遷移こそがこの機能の本体であり、純関数だけでは配線を検証できないため)。
+ *
+ * @returns {number|null} assistant のとき context% / それ以外は null
+ */
+export function resolveChatContextPct(cwd, cliKind, event) {
+  const key = chatKey(cwd, cliKind)
+  if (event?.type === "assistant") {
+    const model = event.message?.model || null
+    if (model) lastAssistantModelByChatKey.set(key, model)
+    return event.message?.usage
+      ? contextPctFromUsage(event.message.usage, contextWindowByChatKey.get(key))
+      : null
+  }
+  if (event?.type === "result") {
+    // モデル切替やセッション回転が起きても次の result で必ず上書きされる (自己修復)。
+    const win = pickContextWindow(event.modelUsage, lastAssistantModelByChatKey.get(key))
+    if (win) contextWindowByChatKey.set(key, win)
+  }
+  return null
+}
+
+/** テスト用: 学習済みの窓サイズ / モデル名をリセットする。 */
+export function _resetContextWindowLearning() {
+  contextWindowByChatKey.clear()
+  lastAssistantModelByChatKey.clear()
 }
 
 /**