@cocorograph/hub-agent 0.7.20 → 0.7.21

package/package.json

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

package/src/jsonl-live-watchers.mjs

@@ -48,12 +48,22 @@ export class JsonlLiveWatchers {
    * @param {() => Promise<string|undefined>|string|undefined} args.getProjectsRoot
    *   - ~/.claude/projects の実効ルート解決 (アカウント切替を反映)
    * @param {number} [args.ttlMs]
+   * @param {(info: {session_id: string, cwd: string, toolName: string, tool_use_id: string}) => void} [args.onToolResolved]
+   *   - jsonl に tool_result が着弾し「あるツールが解決された」と検知したときのコールバック
+   *     (症状1b 根治: ターミナルのネイティブメニューで回答 / 承認された pending カードを畳む)。
    * @param {import('pino').Logger} [args.logger]
    */
-  constructor({ send, getProjectsRoot, ttlMs = WATCHER_TTL_MS, logger } = {}) {
+  constructor({
+    send,
+    getProjectsRoot,
+    ttlMs = WATCHER_TTL_MS,
+    onToolResolved,
+    logger,
+  } = {}) {
     this.send = send
     this.getProjectsRoot = getProjectsRoot
     this.ttlMs = ttlMs
+    this.onToolResolved = onToolResolved
     this.logger = logger
     /** @type {Map<string, {watcher: {stop: () => void}, cwd: string, expiresAt: number}>} */
     this._entries = new Map()
@@ -96,14 +106,33 @@ export class JsonlLiveWatchers {
       // フックを通さず jsonl を直接 tail するため、ここで独自にマスクしないと素通しになる。
       // tail は fromEnd=true で監視開始後の追記のみを拾うので、開始前に書かれた tool_use の
       // id→name を既存 jsonl から事前シードし、スキル tool_result の判定取りこぼしを防ぐ。
-      const masker = MASK_ENABLED
-        ? createEventMasker(await this._seedToolNames(filePath))
-        : null
+      // tool_use(id→name) の事前シード。マスカーとネイティブ回答検知が共用する
+      // (tail は fromEnd=true で開始後の追記のみ拾うため、開始前の tool_use 名を先に流し込む)。
+      const detect = typeof this.onToolResolved === "function"
+      const seed =
+        MASK_ENABLED || detect ? await this._seedToolNames(filePath) : new Map()
+      const masker = MASK_ENABLED ? createEventMasker(seed) : null
+      // 検知用は別 Map (マスカー内部 Map と相互に汚染しないようコピー)。
+      const detectNames = detect ? new Map(seed) : null
       const watcher = watchSessionFile({
         filePath,
         fromEnd: true,
         logger: this.logger,
         onEvent: (event) => {
+          // ネイティブ回答検知 (症状1b 根治): browser を経由せずターミナルのネイティブメニューで
+          // 回答 / 承認されたケースを jsonl の tool_result 着弾で検知する。.decision は browser
+          // 回答でしか書かれずネイティブ回答には効かないため、jsonl tool_result が唯一の権威
+          // ソース (resume が読む実体と同じ)。マスク前の素 event を見る (構造のみ参照)。
+          if (detectNames) {
+            try {
+              this._detectResolved(event, detectNames, session_id, cwd)
+            } catch (err) {
+              this.logger?.debug?.(
+                { err: err?.message },
+                "jsonl tool_result detect failed",
+              )
+            }
+          }
           try {
             this.send?.({
               type: "claude.jsonl.event",
@@ -175,6 +204,36 @@ export class JsonlLiveWatchers {
     return seed
   }
 
+  /**
+   * 1 イベントを走査し、(1) assistant の tool_use(id→name) を蓄積、(2) user の tool_result
+   * 着弾を検知して onToolResolved を発火する。tool_use と tool_result は別イベントで届くので、
+   * id→name を貯めながら tool_use_id 一致で「そのツールが解決された」と判定する
+   * (collectToolUseNames はマスカーと共用の純関数)。
+   *
+   * @param {object} event normalizeHistoryEvent 済みイベント (type + message を持つ)
+   * @param {Map<string,string>} toolNames tool_use_id→tool_name の蓄積 Map
+   * @param {string} session_id
+   * @param {string} cwd
+   */
+  _detectResolved(event, toolNames, session_id, cwd) {
+    // 新規 tool_use(id→name) を吸収する (assistant イベントのみ反応)。
+    collectToolUseNames(event, toolNames)
+    if (event?.type !== "user" || !Array.isArray(event.message?.content)) return
+    for (const b of event.message.content) {
+      if (b && b.type === "tool_result" && typeof b.tool_use_id === "string") {
+        const toolName = toolNames.get(b.tool_use_id)
+        if (toolName) {
+          this.onToolResolved?.({
+            session_id,
+            cwd,
+            toolName,
+            tool_use_id: b.tool_use_id,
+          })
+        }
+      }
+    }
+  }
+
   async _resolveProjectsRoot() {
     try {
       const r = this.getProjectsRoot?.()

package/src/main.mjs

@@ -768,6 +768,33 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
     send: (obj) => client.send(obj),
     getProjectsRoot: getActiveProjectsRoot,
     logger,
+    // ネイティブ回答検知 (症状1b 根治): tail 中の jsonl に tool_result が着弾し「あるツールが
+    // ターミナル側で解決された」と分かったら、その session の同名ツールの pending 権限カードを
+    // 畳み、browser へ claude.permission.cancel を送って残存カードを消す。browser が先に
+    // resolve() 済みなら _pending は既に空で dropBySession は [] を返す (= no-op、cancel も出ない)。
+    onToolResolved: ({ session_id, cwd, toolName }) => {
+      const dropped =
+        tuiPermissionBridge.dropBySession({ session_id, cwd, toolName }) || []
+      for (const request_id of dropped) {
+        try {
+          client.send({
+            type: "claude.permission.cancel",
+            request_id,
+            session_id,
+            cwd,
+            reason: "answered_in_terminal",
+          })
+        } catch {
+          /* ignore */
+        }
+      }
+      if (dropped.length) {
+        logger.info(
+          { session_id, cwd, tool: toolName, count: dropped.length },
+          "tui permission resolved natively → cancelled browser card",
+        )
+      }
+    },
   })
   jsonlLiveWatchers.start()
   ctx.jsonlLiveWatchers = jsonlLiveWatchers
@@ -2238,6 +2265,28 @@ async function dispatch(msg, ctx) {
                 ctx.readinessTracker?.forget(viewName)
                 invalidateSessionCache(viewName)
               }
+              // 回転 = 旧 session_id 境界。旧 session に紐づく pending 権限カードは orphan に
+              // なる (claude は新会話へ移った) ので畳み、browser へ cancel して残存カードを消す
+              // (症状1b 根治)。旧 session_id 完全一致で drop するため、回転直後に新 session で
+              // 出たばかりのカード (payload.session_id === newSessionId) は誤って巻き込まない。
+              if (ctx.tuiPermissionBridge) {
+                const dropped = ctx.tuiPermissionBridge.dropBySession({
+                  session_id: viewSid,
+                })
+                for (const request_id of dropped) {
+                  try {
+                    ctx.client.send({
+                      type: "claude.permission.cancel",
+                      request_id,
+                      session_id: viewSid,
+                      cwd: viewCwd,
+                      reason: "session_rotated",
+                    })
+                  } catch {
+                    /* ignore */
+                  }
+                }
+              }
               logger.info(
                 { session: viewName, cwd: viewCwd, old: viewSid, new: newSessionId },
                 "tui session rotated (/clear) → notified browser",

package/src/tui-permission-bridge.mjs

@@ -147,6 +147,42 @@ export class TuiPermissionBridge extends EventEmitter {
     this._seen.delete(request_id)
   }
 
+  /**
+   * セッションに紐づく pending を **まとめて** 落とす (set/clear 非対称の解消)。
+   *
+   * `_pending` を畳む経路は元々 `resolve()`(browser 回答) と `drop(request_id)` の 2 本しか
+   * 無く、(a) ターミナルでネイティブ回答された / (b) `/clear` で session が回転した /
+   * (c) kill された、という「browser を経由しない終端」では pending が 6h TTL まで残り、
+   * 復帰時 `listPending`→rehydrate が古いカードを反復再 push していた (症状1b)。本メソッドは
+   * その終端を session 同一性で一括 drop するためのもの。
+   *
+   * マッチ規則は `listPending` (L134-142) と同じ OR セマンティクス: payload.session_id ===
+   * session_id **または** payload.cwd === cwd。さらに `toolName` を渡すと payload.tool_name 一致
+   * のものだけに絞る (ネイティブ回答検知で「いま解決したツールのカードだけ」を畳む用途)。
+   * 落とした request_id を返すので、呼び出し側は browser へ `claude.permission.cancel` を
+   * 送ってカードを消せる。
+   *
+   * `drop(request_id)` との違い: drop は request_id 既知の 1 件 (resume 経路)、dropBySession は
+   * session 同一性で選んだ **集合** を落とし、落とした id 一覧を返す。
+   *
+   * @param {{session_id?: string|null, cwd?: string|null, toolName?: string|null}} q
+   * @returns {string[]} 落とした request_id の配列
+   */
+  dropBySession({ session_id = null, cwd = null, toolName = null } = {}) {
+    const dropped = []
+    if (!session_id && !cwd) return dropped
+    for (const [request_id, { payload }] of this._pending) {
+      const sidOk = session_id && payload.session_id === session_id
+      const cwdOk = cwd && payload.cwd === cwd
+      if (!(sidOk || cwdOk)) continue
+      if (toolName && payload.tool_name !== toolName) continue
+      this._pending.delete(request_id)
+      this._seen.delete(request_id)
+      dropped.push(request_id)
+    }
+    return dropped
+  }
+
   /**
    * browser の決定をフックへ返す。対象 request_id なら `.decision` を atomic
    * 書き込みし、要求ファイルを掃除して true を返す。対象外なら false