@cocorograph/hub-agent 0.7.19 → 0.7.21

package/package.json

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

package/src/extract-paragraph.mjs

@@ -86,6 +86,31 @@ export function extractLastAssistantText(paneText) {
   return text
 }
 
+/**
+ * permission/質問カードに出す「直前アシスタント説明」の採用優先順位を決める純関数。
+ *
+ * 症状4 根治: フック (bundle) 由来の context_text は PreToolUse 発火時点で jsonl が
+ * 前ターン止まり (フックがブロック中は claude が現ターンを commit しない=デッドロック)
+ * のため「前ターンの古い説明」を掴む取り違えを起こす。一方 hub-agent が tmux
+ * capture-pane で抜く liveContext は「いま描画中の現ターン本文」なので回答前に
+ * 信頼できる唯一のソース。よって **liveContext を最優先**し、フック由来は後方互換の
+ * フォールバックとしてのみ採用する (旧 bundle が context_text を送ってきても汚染しない)。
+ * 両方とも空/非文字列なら null (= 説明なしで安全縮退)。
+ *
+ * @param {unknown} hookContextText フック (bundle) が同梱した context_text (旧経路)
+ * @param {unknown} liveContext capture-pane から抽出した現ターン説明
+ * @returns {string|null}
+ */
+export function pickContextText(hookContextText, liveContext) {
+  const live =
+    typeof liveContext === "string" && liveContext.trim() ? liveContext : null
+  const hook =
+    typeof hookContextText === "string" && hookContextText.trim()
+      ? hookContextText
+      : null
+  return live || hook || null
+}
+
 export const __test = {
   _MAX_CHARS,
   _MIN_CHARS,

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

@@ -20,7 +20,7 @@ import path from "node:path"
 import pino from "pino"
 
 import { detectPlatform, readConfig, writeConfig } from "./config.mjs"
-import { extractLastAssistantText } from "./extract-paragraph.mjs"
+import { extractLastAssistantText, pickContextText } from "./extract-paragraph.mjs"
 import { loadPlugins, runHookBroadcast, runHookChain } from "./plugin-loader.mjs"
 import { WsClient } from "./ws-client.mjs"
 import { PtyBridge } from "./pty-bridge.mjs"
@@ -92,6 +92,7 @@ import {
   contextWindowSize,
   getSessionUsages,
   getUsage,
+  isFreshUnboundBind,
   recordChatRateLimit,
   turnActiveForCwd,
 } from "./usage.mjs"
@@ -706,17 +707,18 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
           /* ignore */
         }
       }
-      // ── 直前アシスタント説明の抽出 (T05xxx 根治) ────────────────────────────
+      // ── 直前アシスタント説明の抽出 (症状4 根治) ─────────────────────────────
       // PreToolUse フック発火時点で jsonl はまだ前ターン止まり (フックがブロック
-      // している間 claude は jsonl を commit しない) のため、フック側の transcript
-      // 抽出は前ターンの古い説明を掴む「取り違え」を起こす。
-      // 代わりに hub-agent がここで tmux capture-pane を打ち、TUI のペイン上に
-      // 既に描画されている「現ターンの assistant 本文段落 (⏺ プレフィックス)」を
-      // 抜き出して context_text に注入する。フックが既に context_text を
-      // 持っている場合 (旧経路) はそれを尊重し、空 / null のときだけ上書きする。
-      // 抽出失敗時は null フォールバック (= 説明なし) で安全縮退。
+      // している間 claude は現ターンを jsonl に commit しない=デッドロック構造) の
+      // ため、フック側の transcript 抽出は前ターンの古い説明を掴む「取り違え」を
+      // 起こす。代わりに hub-agent がここで tmux capture-pane を打ち、TUI のペイン上
+      // に既に描画されている「現ターンの assistant 本文段落 (⏺ プレフィックス)」を
+      // 抜き出す。これが回答前に説明を届ける唯一の信頼ソースなので、フック由来の
+      // context_text の有無に関わらず **常に** capture-pane を試み、pickContextText で
+      // liveContext を最優先する (旧 bundle が古い context_text を送ってきても汚染
+      // しない)。抽出失敗時は null フォールバック (= 説明なし) で安全縮退。
       let liveContext = null
-      if (!context_text && cwd) {
+      if (cwd) {
         try {
           const sessions = await listTmuxSessions({ logger })
           const match = Array.isArray(sessions)
@@ -742,9 +744,9 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
         tool_name,
         input,
         // 質問/承認カードの直前アシスタント説明 (browser がカード上部に表示)。
-        // 優先順位: (1) フックが既に同梱した context_text、(2) hub-agent が
-        // tmux capture-pane で抽出した liveContext、(3) null。
-        context_text: context_text || liveContext || null,
+        // 優先順位: (1) capture-pane で抽出した現ターンの liveContext、(2) フック由来
+        // の context_text (後方互換フォールバック)、(3) null。pickContextText 参照。
+        context_text: pickContextText(context_text, liveContext),
       })
     },
   )
@@ -766,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
@@ -1366,6 +1395,11 @@ export function startStateLoop({ client, plugins, logger, intervalMs, claudeBrid
           turnActive = true
         } else if (chat?.status === "waiting" || chat?.status === "idle") {
           turnActive = false
+        } else if (s.cwd && isFreshUnboundBind(boundSessions?.get(s.session_name))) {
+          // 症状2b 根治: fresh bind プレースホルダの間は、別アクティビティ jsonl を mtime 最新で
+          // 取り違える汚染を避けて turn_active を出さない (null=不明)。実セッション id へ adopt
+          // されれば下の通常経路に乗る。青を出さない安全側にのみ倒すため固着青は生まない。
+          turnActive = null
         } else if (s.cwd) {
           turnActive = await turnActiveForCwd(
             s.cwd,
@@ -1442,6 +1476,15 @@ export function startStateLoop({ client, plugins, logger, intervalMs, claudeBrid
           const liveNames = new Set(states.map((s) => s.session_name))
           for (const name of [...lastByName.keys()]) {
             if (liveNames.has(name)) continue
+            // 終端を能動 broadcast (症状3 根治): tmux から消えた = crash/外部 kill/別経路
+            // 終了。explicit kill は kill_session ハンドラが session.gone を出すが、それ以外
+            // の消滅はここが唯一の検知点。frontend が states/lastEvent を忘れてドットを
+            // 'down' に倒せるよう、ローカル Map を forget する前に通知する。
+            try {
+              client.send({ type: "session.gone", session_name: name })
+            } catch {
+              /* ignore */
+            }
             invalidateSessionCache(name) // capture/cwd/statusGate/spinnerFreeze/stability (state.mjs)
             stallTracker.forget(name) // StallTracker.byName
             readinessTracker?.forget?.(name) // ReadinessTracker.byName
@@ -1752,6 +1795,51 @@ export async function handleQueueFlush(msg, ctx) {
   })
 }
 
+/**
+ * tmux.kill_session の処理 (症状3 根治)。要求された session を kill し、要求元へ
+ * tmux.kill_session.result を返したうえで、kill できた各 session について
+ * **session.gone を能動 broadcast** する。
+ *
+ * 不変条件: session の終端 (kill/crash/外部終了) は、同一ホストで実体を観測できる
+ * agent が正本として能動 push する。これが無いと frontend は kill 時点の turn_active=true
+ * を keep-last したままステータスドットが青で固着する。最後の 1 セッションを kill した
+ * 場合 state loop の GC は states.length>0 ガードで発火しないため、explicit kill 経路の
+ * ここから session.gone を出すのが確実 (GC は crash/外部 kill の補完)。
+ *
+ * テストから直接呼べるよう export。kill 実体 (killManySessions) は ctx で差し替え可能。
+ */
+export async function handleKillSession(msg, ctx) {
+  const killFn = ctx.killManySessions || killManySessions
+  const names = Array.isArray(msg.session_names)
+    ? msg.session_names
+    : msg.session_name
+      ? [msg.session_name]
+      : []
+  if (names.length === 0) {
+    ctx.client.send({
+      type: "tmux.kill_session.result",
+      request_id: msg.request_id,
+      killed: [],
+      failed: [{ name: "", reason: "session_name(s) required" }],
+    })
+    return
+  }
+  const r = await killFn(names)
+  ctx.client.send({
+    type: "tmux.kill_session.result",
+    request_id: msg.request_id,
+    killed: r.killed,
+    failed: r.failed,
+  })
+  for (const name of r.killed) {
+    try {
+      ctx.client.send({ type: "session.gone", session_name: name })
+    } catch {
+      /* ignore */
+    }
+  }
+}
+
 /**
  * claude.tui.interrupt の処理 (確認付き中断 = Phase3)。生 ESC を tracked pty.data で best-effort
  * 送出する旧経路 (stream 欠落で無言ドロップ + ESC 到達でも止まったか未検証) を、agent が ESC を
@@ -2177,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",
@@ -3191,27 +3301,7 @@ async function dispatch(msg, ctx) {
         return
       }
       case "tmux.kill_session": {
-        const names = Array.isArray(msg.session_names)
-          ? msg.session_names
-          : msg.session_name
-            ? [msg.session_name]
-            : []
-        if (names.length === 0) {
-          ctx.client.send({
-            type: "tmux.kill_session.result",
-            request_id: msg.request_id,
-            killed: [],
-            failed: [{ name: "", reason: "session_name(s) required" }],
-          })
-          return
-        }
-        const r = await killManySessions(names)
-        ctx.client.send({
-          type: "tmux.kill_session.result",
-          request_id: msg.request_id,
-          killed: r.killed,
-          failed: r.failed,
-        })
+        await handleKillSession(msg, ctx)
         return
       }
       case "skills.request": {

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

package/src/usage.mjs

@@ -603,6 +603,28 @@ export function boundSessionId(boundSessions, name) {
   return typeof v === "string" && v && !v.startsWith("fresh:") ? v : null
 }
 
+/**
+ * その tmux セッションが「fresh bind プレースホルダ (`fresh:<req>`)」の状態か判定する
+ * (症状2b 根治)。
+ *
+ * fresh bind は「新規セッションを開始する」意思表示で、まだ実セッション id へ adopt されて
+ * おらず、このペインが走らせている jsonl が確定していない。この状態で turn_active を
+ * `resolveTargetJsonl` の mtime 最新フォールバックから導くと、同一 cwd-encode dir に堆積した
+ * 別アクティビティ (headless `claude -p` / subagent / 並走セッション / 旧 jsonl) を「最新」と
+ * 取り違えて **偽の生成中 (青ドット) を出し、新規セッションで無操作なのに三点リーダーが固着** する。
+ *
+ * よって呼び出し側 (state loop) は fresh プレースホルダの間 turn_active を null (不明) に倒す。
+ * これは安全側 (青を出さない方向) にしか倒さないため、偽陽性の青固着を生むことはない。生成中の
+ * in-chat スピナーは frontend が turnOverride / session.event(prompt_submit) で別途駆動するため、
+ * fresh セッションの実生成中表示は保たれる (本判定はサイドバー/ヘッダーのドット権威のみに効く)。
+ *
+ * @param {string|null|undefined} boundVal `boundSessions.get(session_name)` の生値
+ * @returns {boolean}
+ */
+export function isFreshUnboundBind(boundVal) {
+  return typeof boundVal === "string" && boundVal.startsWith("fresh:")
+}
+
 /**
  * 指定 cwd の Claude セッション jsonl から context% (USED %) を算出する。
  *