@cocorograph/hub-agent 0.6.98 → 0.7.0

package/package.json

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

package/src/main.mjs

@@ -38,6 +38,7 @@ import {
   detectPermissionModeFromText,
   detectSessionState,
   listSessionStates,
+  StallTracker,
 } from "./state.mjs"
 import {
   DEFAULT_PROFILE_ID,
@@ -67,6 +68,7 @@ import {
   listWorktreeNameHistory,
   listWorktreeStubs,
   rebindClaudeSession,
+  shouldSkipRebindRespawn,
   recoverTuiInput,
   removeWorktree as removeWorktreeDir,
   resumeWithMessage,
@@ -592,6 +594,9 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
   // 終わって真に入力可能になった」エッジを検出する (proc-introspect.mjs)。capture-pane は
   // Stop フック実行中を観測できないため、これが「stop の早期消灯/誤フラッシュ」の根治。
   const readinessTracker = new ReadinessTracker()
+  // claude.tui.bind ハンドラが「生成中か (isArmed)」を参照して、生成中 claude を rebind の
+  // respawn-pane -k で kill する「謎停止」を防ぐ (生成中ガード)。
+  ctx.readinessTracker = readinessTracker
   const stateLoop = startStateLoop({
     client,
     plugins,
@@ -1050,8 +1055,9 @@ function startStateLoop({ client, plugins, logger, intervalMs, claudeBridge, rea
   const lastTurnAtByName = new Map() // session_name → 最後に event ファイル化した turnAt
   // (i) session_name → {sig, changedAt}: 出力領域署名の最終変化時刻 (出力フロー検知用)。
   const outputFlowByName = new Map()
-  // 権威的 stall 判定: session_name → 最後に「進捗あり」と観測した時刻 (ms)。
-  const lastProgressAtByName = new Map()
+  // 権威的 stall 判定 (arm 非依存・cap 非依存)。state loop が観測する signal だけで turn の開閉と
+  // 無進捗を判定する。旧 lastProgressAtByName + armed ゲートの「フック依存 + cap 140s で消える」死角を解消。
+  const stallTracker = new StallTracker({ stallWarnMs: STALL_WARN_MS })
   let stopped = false
 
   // RC-8: WS 再接続のたびに差分送信の基準 (lastByName) をクリアし、次 tick で全 session.state を
@@ -1138,20 +1144,23 @@ function startStateLoop({ client, plugins, logger, intervalMs, claudeBridge, rea
           outputActive = Date.now() - changedAt < OUTPUT_ACTIVE_MS
         }
         const procBusy = childBusy || outputActive
-        // 権威的 stall 判定。armed (ターン進行中=prompt_submit 受信後 stop/ready 未) なのに
-        // 進捗 (procBusy=子プロセス/出力フロー or ペインの live processing) が STALL_WARN_MS
-        // 継続して無いとき stalled=true。armed でない / 進捗ありのときは進捗時刻を更新して
-        // 無進捗カウントをリセットする。frontend はこれを応答停止バナーの正本に使う。
+        // 権威的 stall 判定 (StallTracker, arm 非依存・cap 非依存)。armed (バンドルフックが効く
+        // セッション) は OR で常に turn 開扱い (従来挙動の上位互換)。フック未発火/旧世代hookセッション
+        // でも観測した processing で turnOpen を立て、frozen スピナー (spinner_present) を維持して proc 子も
+        // 出力も止まったハングを拾う。proc 内省の cap(140s) disarm に依存しないので 140s 以後も消えない。
+        // 旧実装の「armed 依存 + cap で消える」二重死角を解消。frontend はこれを応答停止バナーの正本に使う。
         const armed = readinessTracker
           ? readinessTracker.isArmed(s.session_name)
           : false
         const nowMs = Date.now()
-        const progressing = procBusy || status === "processing"
-        if (progressing || !armed) {
-          lastProgressAtByName.set(s.session_name, nowMs)
-        }
-        const lastProgressAt = lastProgressAtByName.get(s.session_name) ?? nowMs
-        const stalled = armed && nowMs - lastProgressAt >= STALL_WARN_MS
+        const { stalled } = stallTracker.observe(s.session_name, {
+          armed,
+          processing: status === "processing",
+          procBusy,
+          spinnerPresent: s.spinner_present === true,
+          stable,
+          now: nowMs,
+        })
         const prev = lastByName.get(s.session_name)
         if (
           !prev ||
@@ -1957,12 +1966,16 @@ async function dispatch(msg, ctx) {
           // resume せず resume 無しの claude を起動する。session_id は起動後の初回送信で
           // 生成され、frontend は回転検知 / sessions 応答で拾う。
           const fresh = msg.fresh === true
-          // 1) 載せ替え先 session_id を確定 (fresh は解決しない = 新規起動)。
+          // 1) 載せ替え先 session_id を確定 (fresh は解決しない = 新規起動)。あわせて
+          //    現在動いているセッション (= cwd の最新 jsonl = newestId) も解決する。生成中ガードで
+          //    「再接続/remount による同一セッションへの再 bind」か「別 session への明示 switch」かを
+          //    区別するのに使う (前者は respawn を抑止して生成中 claude を温存する)。
           let targetId =
             typeof msg.session_id === "string" && msg.session_id
               ? msg.session_id
               : null
-          if (!fresh && !targetId && cwd) {
+          let newestId = null
+          if (!fresh && cwd) {
             const projectsRoot = await getActiveProjectsRoot()
             const { sessions } = await listSessions({
               cwd,
@@ -1970,7 +1983,20 @@ async function dispatch(msg, ctx) {
               limit: 1,
               logger,
             })
-            targetId = sessions?.[0]?.session_id || null
+            newestId = sessions?.[0]?.session_id || null
+            if (!targetId) targetId = newestId
+          }
+          // 生成中ガード (謎停止対策): respawn-pane -k は生成中 claude を強制 kill し in-flight 応答を失う。
+          // hub-agent 再起動直後は tuiReboundSessions が空で冪等ガードが効かず、ブラウザ再接続の bind が
+          // 生成中 claude を kill する。armed (ターン進行中) か pane=processing なら生成中とみなす。
+          let generating = ctx.readinessTracker?.isArmed?.(sessionName) === true
+          if (!generating && sessionName) {
+            try {
+              const snap = await detectSessionState(sessionName, {})
+              if (snap?.status === "processing") generating = true
+            } catch {
+              // capture 失敗時は据え置き (生成中とみなさない = 従来挙動)
+            }
           }
           // 2) SDK を停止 (cwd 全体 + 対象 id)。
           let stoppedSdk = 0
@@ -1997,6 +2023,18 @@ async function dispatch(msg, ctx) {
           if (bindKey && sessionName && (fresh || targetId)) {
             if (ctx.tuiReboundSessions.get(sessionName) === bindKey) {
               rebind = { ok: true, skipped: true }
+            } else if (
+              shouldSkipRebindRespawn({ generating, fresh, targetId, newestId })
+            ) {
+              // 生成中 claude を再接続/remount の bind で kill しない (謎停止対策)。respawn を抑止して
+              // 既存の生成中 claude を温存する。bindKey は記録して以降の remount を冪等化する
+              // (targetId === newestId = 動いているセッション本人なので記録は正しい)。
+              rebind = { ok: true, skipped: true }
+              ctx.tuiReboundSessions.set(sessionName, bindKey)
+              logger?.info(
+                { session: sessionName, session_id: targetId },
+                "tui rebind: skipped respawn (turn in progress on the running session)",
+              )
             } else {
               rebind = await rebindClaudeSession(sessionName, targetId, {
                 cwd,

package/src/state.mjs

@@ -597,6 +597,10 @@ export async function detectSessionState(sessionName, opts = {}) {
   }
   const defaultContextPct = detectContextPctFromText(text)
   const defaultPermissionMode = detectPermissionModeFromText(text)
+  // スピナー行 (ライブ or 凍結) が画面に在るか。frozen 降格で status が waiting に落ちても、
+  // スピナーが画面に残っている = ターンはクリーンに終わっていない (ハング候補)。StallTracker が
+  // 「クリーン idle (スピナー無し) でターンを閉じる」判定に使い、frozen スピナーのハングを拾う。
+  const spinnerPresent = workingSpinnerLine(text) !== null
 
   if (opts.plugins && opts.plugins.length) {
     const hookResult = await runHookChain(opts.plugins, "transformStatusDetection", {
@@ -616,6 +620,7 @@ export async function detectSessionState(sessionName, opts = {}) {
         permission_mode:
           hookResult.result.permission_mode ?? defaultPermissionMode,
         stable: _computeStable(sessionName, status, text),
+        spinner_present: spinnerPresent,
         // 出力領域 (揮発フッター除外) の署名。state loop が tick 間で比較し、純テキスト
         // 生成 (子プロセスを spawn しないため proc 内省が busy=false と見るケース) を
         // 「出力フロー中=busy」として検出するのに使う。
@@ -630,6 +635,7 @@ export async function detectSessionState(sessionName, opts = {}) {
     context_pct: defaultContextPct,
     permission_mode: defaultPermissionMode,
     stable: _computeStable(sessionName, status, text),
+    spinner_present: spinnerPresent,
     output_sig: _outputSignature(text),
   }
 }
@@ -648,4 +654,67 @@ export async function listSessionStates(opts = {}) {
   )
 }
 
+/**
+ * arm 非依存・cap 非依存の「応答停止 (stall)」判定ステート。
+ *
+ * 背景: 旧実装の stalled は (a) proc 内省の armed (= バンドルフックの prompt_submit 由来) に全依存し、
+ * フック未発火/旧世代hookセッションでは永久に false、(b) readiness loop の cap(≈140s)で disarm されると
+ * stalled が消える (90〜140s だけ表示で以後恒久消失)、という二重の死角があった。本トラッカーは state loop が
+ * 観測する signal だけで turn の開閉と無進捗を判定し、arm にも cap にも依存しない:
+ *   - turnOpen: processing/procBusy を観測したら true。クリーン idle (非progressing かつ スピナー行が画面に
+ *     無く stable) で false。armed (フックが効くセッション) は OR で常に開扱い (従来挙動の上位互換)。
+ *   - 進捗 (processing or procBusy) があれば lastProgressAt を更新。turn が閉じている間も更新し、次ターンの
+ *     クロックを毎 tick リセットする。
+ *   - stalled = turnOpen かつ 無進捗が stallWarnMs 継続。frozen スピナー (画面に在るが status は frozen 降格で
+ *     waiting) は spinnerPresent=true で turnOpen を維持するため、proc 子が無く出力も止まったハングを拾える。
+ *     cap に依存しないため 140s 以後も消えない。
+ */
+export class StallTracker {
+  constructor({ stallWarnMs = 90_000 } = {}) {
+    this.stallWarnMs = Math.max(1000, stallWarnMs)
+    /** @type {Map<string, {turnOpen: boolean, lastProgressAt: number|null}>} */
+    this.byName = new Map()
+  }
+
+  _get(name) {
+    let s = this.byName.get(name)
+    if (!s) {
+      s = { turnOpen: false, lastProgressAt: null }
+      this.byName.set(name, s)
+    }
+    return s
+  }
+
+  /**
+   * @param {string} name
+   * @param {{armed?: boolean, processing?: boolean, procBusy?: boolean,
+   *          spinnerPresent?: boolean, stable?: boolean, now: number}} sig
+   * @returns {{stalled: boolean, turnOpen: boolean}}
+   */
+  observe(name, { armed = false, processing = false, procBusy = false, spinnerPresent = false, stable = false, now }) {
+    const s = this._get(name)
+    const progressing = processing || procBusy
+    if (progressing) {
+      s.turnOpen = true
+    } else if (!spinnerPresent && stable) {
+      // クリーン idle: 生成中でなく proc 非busy、スピナーも画面に無く出力安定 = ターン正常終了。
+      // frozen スピナー (spinnerPresent=true) や stable 未確定の間は閉じない (ハング候補を維持)。
+      s.turnOpen = false
+    }
+    const turnOpen = armed || s.turnOpen
+    if (progressing || !turnOpen) {
+      // 進捗あり、または turn が閉じている間はクロックを前進させ続ける (次ターンのクロックを毎 tick 0 に保つ)。
+      s.lastProgressAt = now
+    } else if (s.lastProgressAt == null) {
+      s.lastProgressAt = now
+    }
+    const stalled = turnOpen && now - s.lastProgressAt >= this.stallWarnMs
+    return { stalled, turnOpen }
+  }
+
+  forget(name) {
+    this.byName.delete(name)
+  }
+}
+
 export { STATUSES }

package/src/tmux.mjs

@@ -1220,6 +1220,29 @@ export async function recoverTuiInput(name, expectText, opts = {}) {
  * @param {{cwd?:string,model?:string,permissionMode?:string,fresh?:boolean,logger?:object,tmuxBin?:string}} [opts]
  * @returns {Promise<{ok:boolean, cmd?:string, error?:string}>}
  */
+/**
+ * rebind (respawn-pane -k + claude --resume) を抑止すべきか判定する純ロジック。
+ *
+ * 背景 (謎停止対策): claude.tui.bind は TUI ビューの mount / 再接続のたびに来る。respawn-pane -k は
+ * 現 claude を強制 kill するため、生成中に走ると in-flight の応答が失われる (jsonl 未確定)。冪等ガード
+ * (tuiReboundSessions) は hub-agent 再起動直後は空で効かず、ブラウザ再接続の bind が生成中 claude を
+ * kill する事故 (謎停止) を起こす。
+ *
+ * 抑止条件: 生成中 (generating) かつ「今動いているセッション (= 最新 jsonl = newestId) への再 bind」。
+ * これは再接続/remount であり respawn は純粋に破壊的。逆に:
+ *  - fresh (+新規セッション要求) は明示操作なので respawn する。
+ *  - targetId !== newestId (別 session への明示 switch) は respawn する (生成中セッションは別ペイン文脈で温存)。
+ *  - 非生成中は従来どおり respawn する (idle claude の --resume 載せ替えは非破壊)。
+ *
+ * @param {{generating?: boolean, fresh?: boolean, targetId?: string|null, newestId?: string|null}} a
+ * @returns {boolean}
+ */
+export function shouldSkipRebindRespawn({ generating, fresh, targetId, newestId } = {}) {
+  if (fresh) return false
+  if (!generating) return false
+  return !!targetId && targetId === newestId
+}
+
 export async function rebindClaudeSession(name, sessionId, opts = {}) {
   let cmd
   try {