@cocorograph/hub-agent 0.7.5 → 0.7.7

package/package.json

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

package/src/main.mjs

@@ -39,6 +39,7 @@ import {
   detectSessionState,
   invalidateSessionCache,
   listSessionStates,
+  resolveBindSnapshotStatus,
   StallTracker,
 } from "./state.mjs"
 import {
@@ -600,6 +601,41 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
   // claude.tui.bind ハンドラが「生成中か (isArmed)」を参照して、生成中 claude を rebind の
   // respawn-pane -k で kill する「謎停止」を防ぐ (生成中ガード)。
   ctx.readinessTracker = readinessTracker
+  // 【+新規 defer — 構造版 root 2026-06-22】busy (ターン進行中) のペインへ来た fresh (+新規) は
+  // respawn-pane -k で殺さず保留し、ready (ターン終了) で 1 回だけ実行する。
+  // session_name → {cwd, request_id, at, model, permissionMode}。
+  const pendingFreshRespawn = new Map()
+  ctx.pendingFreshRespawn = pendingFreshRespawn
+  // fresh respawn のスロットル: idle ペインへの remount storm (再マウント毎に新 request_id) で
+  // fresh が連打され new セッションを乱造するのを防ぐ。session_name → epoch ms。
+  const lastFreshRespawnAt = new Map()
+  ctx.lastFreshRespawnAt = lastFreshRespawnAt
+  // ready エッジで呼ばれ、保留中の +新規 を実行する (busy が解けたので非破壊)。
+  const flushDeferredFreshRespawn = async (name) => {
+    const pending = pendingFreshRespawn.get(name)
+    if (!pending) return
+    pendingFreshRespawn.delete(name)
+    if (Date.now() - pending.at > PENDING_FRESH_TTL_MS) {
+      logger.info({ session: name }, "tui rebind: deferred +new expired before ready, dropped")
+      return
+    }
+    try {
+      const rebind = await rebindClaudeSession(name, null, {
+        cwd: pending.cwd,
+        model: pending.model || "",
+        permissionMode: pending.permissionMode || "",
+        fresh: true,
+        busy: false,
+        logger,
+      })
+      if (rebind.ok) {
+        lastFreshRespawnAt.set(name, Date.now())
+        logger.info({ session: name }, "tui rebind: executed deferred +new after ready")
+      }
+    } catch (err) {
+      logger.warn({ session: name, err: err?.message }, "deferred +new respawn failed")
+    }
+  }
   const stateLoop = startStateLoop({
     client,
     plugins,
@@ -623,6 +659,7 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
     logger,
     tracker: readinessTracker,
     intervalMs: 700,
+    onReady: flushDeferredFreshRespawn,
   })
 
   // TUI 権限ブリッジ: 対話 TUI の PreToolUse フックが書く権限要求を fs.watch で
@@ -951,16 +988,51 @@ async function startSessionEventWatcher({ client, logger, readinessTracker }) {
   }
 }
 
+/**
+ * 【構造版 root 2026-06-22】idle ペインへの fresh remount storm を 1 回へ collapse する閾値。
+ * 直近 fresh respawn からこの時間内の同一セッションへの fresh は idempotent な再送とみなす。
+ */
+const FRESH_RESPAWN_THROTTLE_MS = 8_000
+/** busy で defer した +新規 の保留 TTL。ready が来ないまま席を立った等で破棄する。 */
+const PENDING_FRESH_TTL_MS = 600_000
+
+/**
+ * 【構造版 root 2026-06-22】bind 時の即時 busy プローブ (プロセス実体)。
+ * 「ターン進行中の claude を kill しない」判定の唯一の根拠にする。capture スクレイプや armed の
+ * 140s cap の脆さに依存しない:
+ *  - isArmed: prompt_submit→ready の間 true (生成中 + Stop フック中を含む)。一次シグナル。
+ *  - 補強: pane_pid 子孫数 > 学習 baseline を ps スナップショットで直接確認 (armed cap / 未観測の
+ *    隙間でも取りこぼさない)。baseline 未学習 (= ターン未観測の純 idle) は false (idle の +新規を妨げない)。
+ * 判定不能時は安全側 false (= kill 許可) で idle の +新規 を妨げない。armed が一次防御なので、
+ * 真にターン中なら isArmed=true でここに来る前に true を返す。
+ */
+async function isPaneBusyNow(readinessTracker, name) {
+  if (!name || !readinessTracker) return false
+  if (readinessTracker.isArmed(name) === true) return true
+  try {
+    const panePid = await getPanePid(name)
+    if (!panePid) return false
+    const procMap = await snapshotProcs()
+    if (procMap.size === 0) return false
+    const baseline = readinessTracker.getBaseline(name)
+    if (baseline === null) return false
+    return busyChildCount(panePid, procMap) > baseline
+  } catch {
+    return false
+  }
+}
+
 /**
  * arm 済みセッション (prompt_submit / stop を受けた or busy 観測中) の claude プロセスを
  * 高速 poll し、子プロセスが baseline へ復帰したエッジで event ファイルに 'ready' を書く。
  * 既存の startSessionEventWatcher がそれを `session.event` 'ready' として push し、frontend は
  * 「真に入力可能」になった瞬間として消灯 + キューフラッシュする (Stop フック中の誤フラッシュ
  * 根治)。tracker.getBusy() は state loop が proc_busy レベルとして相乗せする。
+ * onReady(name): ready エッジで呼ぶコールバック (busy で defer した +新規 の実行に使う)。
  *
  * 負荷: アイドル (armed/busy なし) のときは ps を spawn しない。claude pid は TTL キャッシュ。
  */
-function startReadinessLoop({ tracker, logger, intervalMs = 700 }) {
+function startReadinessLoop({ tracker, logger, intervalMs = 700, onReady }) {
   let stopped = false
   const PANE_PID_TTL_MS = 30_000
   const panePidByName = new Map() // name → {pid, at}
@@ -1016,6 +1088,12 @@ function startReadinessLoop({ tracker, logger, intervalMs = 700 }) {
         const { ready } = tracker.observe(name, count)
         if (ready) {
           await writeSessionEventFile(name, "ready", Date.now())
+          // busy で defer した +新規 をターン終了 (ready) のここで 1 回だけ実行する。
+          try {
+            await onReady?.(name)
+          } catch (err) {
+            logger?.warn({ err: err?.message }, "readiness onReady callback failed")
+          }
         }
       }
     } catch (err) {
@@ -2145,8 +2223,22 @@ async function dispatch(msg, ctx) {
           // (症状D 再発 D2: armed 140s cap / capture gap で generating=false に倒れ、--resume bind
           // でも実行中 claude を kill していた)を、capture/armed に依存しない pane_current_command で防ぐ。
           const paneRunningClaude = await isPaneRunningClaude(sessionName, { logger })
+          // 【構造版 root 2026-06-22】プロセス実体の busy (ターン進行中) を bind 時に確定する。
+          // 「動いている claude を kill しない」の唯一の判定基準。frontend が fresh:true を誤送しても
+          // 生成中 claude を殺さない (frontend 単独依存からの脱却)。
+          const busy = await isPaneBusyNow(ctx.readinessTracker, sessionName)
+          // 非 fresh (resume/auto) の bind = ユーザーが既存会話を選んだ → 保留中の +新規 defer は破棄。
+          if (!fresh) ctx.pendingFreshRespawn.delete(sessionName)
           let rebind = { ok: false, skipped: false }
           const bindKey = fresh ? `fresh:${request_id || ""}` : targetId
+          const recordDeferredFresh = () =>
+            ctx.pendingFreshRespawn.set(sessionName, {
+              cwd,
+              request_id,
+              at: Date.now(),
+              model: ctx.config?.claude_model || "",
+              permissionMode: ctx.config?.claude_permission_mode || "",
+            })
           if (bindKey && sessionName && (fresh || targetId)) {
             if (ctx.tuiReboundSessions.get(sessionName) === bindKey) {
               rebind = { ok: true, skipped: true }
@@ -2157,16 +2249,37 @@ async function dispatch(msg, ctx) {
                 targetId,
                 newestId,
                 paneRunningClaude,
+                busy,
               })
             ) {
-              // 生成中 claude を再接続/remount の bind で kill しない (謎停止対策)。respawn を抑止して
-              // 既存の生成中 claude を温存する。bindKey は記録して以降の remount を冪等化する
-              // (targetId === newestId = 動いているセッション本人なので記録は正しい)。
+              // busy (ターン進行中) または最新セッションへの再 bind → respawn を抑止し生成中 claude を温存。
+              rebind = { ok: true, skipped: true }
+              if (fresh && busy) {
+                // ユーザーの +新規 を ready (ターン終了) まで defer する (in-flight ターンを殺さない)。
+                recordDeferredFresh()
+                logger?.info(
+                  { session: sessionName },
+                  "tui rebind: deferred +new (pane busy) until turn ends",
+                )
+              } else {
+                // 非 fresh の冪等記録 (動いているセッション本人への再 bind)。
+                ctx.tuiReboundSessions.set(sessionName, bindKey)
+                logger?.info(
+                  { session: sessionName, session_id: targetId },
+                  "tui rebind: skipped respawn (turn in progress on the running session)",
+                )
+              }
+            } else if (
+              fresh &&
+              Date.now() - (ctx.lastFreshRespawnAt.get(sessionName) || 0) <
+                FRESH_RESPAWN_THROTTLE_MS
+            ) {
+              // idle ペインへの fresh remount storm (再マウント毎に新 request_id) を 1 回へ collapse。
+              // 直近 fresh respawn から閾値内の fresh は再送とみなし skip (new セッション乱造を防ぐ)。
               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)",
+                { session: sessionName },
+                "tui rebind: throttled fresh respawn (idempotent remount within window)",
               )
             } else {
               rebind = await rebindClaudeSession(sessionName, targetId, {
@@ -2174,9 +2287,17 @@ async function dispatch(msg, ctx) {
                 model: ctx.config?.claude_model || "",
                 permissionMode: ctx.config?.claude_permission_mode || "",
                 fresh,
+                busy,
                 logger,
               })
-              if (rebind.ok) ctx.tuiReboundSessions.set(sessionName, bindKey)
+              if (rebind.ok) {
+                ctx.tuiReboundSessions.set(sessionName, bindKey)
+                if (fresh) ctx.lastFreshRespawnAt.set(sessionName, Date.now())
+              } else if (rebind.skipped && rebind.reason === "busy" && fresh) {
+                // チョークポイントが busy で弾いた (probe が false でも実行直前にターン開始した競合)。
+                // defer に載せて +新規 を取りこぼさない。
+                recordDeferredFresh()
+              }
             }
           }
           reply({
@@ -2215,25 +2336,25 @@ async function dispatch(msg, ctx) {
                 noCache: true,
                 logger,
               })
-              // 症状C対策: 生成中(armed / pane=processing で判定済みの generating)に TUIビューを
-              // 再マウントすると、frontend は全 ref/state がリセットされ、capture 再描画ギャップで
-              // この noCache スナップショットの status が一瞬 'waiting' に化けると「生成中なのに
-              // 三点リーダーが消える」偽陰性になり、shouldQueue=false でメッセージが PTY(TUI
-              // ネイティブキュー)へ流入する。generating を真として status='processing' を配ることで
-              // capture 誤読を masking し、frontend の再点灯(turnActive)と shouldQueue 第1ゲートを
-              // 即座に効かせる。proc_busy は配らない: outputActive(出力残り火)を含むため、ターン
-              // 終了直後の真 idle セッションでも proc_busy=true となり高速消灯(症状B)を再発させる。
-              // 終了後(非 generating)は snap.status(waiting)で従来どおり高速消灯する。
+              // 【問題1 根治 2026-06-22】配る status はプロセス実体の busy を権威に解決する
+              // (resolveBindSnapshotStatus)。capture(SPINNER_LINE_RE)の偽陽性に勝たせる。
+              // - busy=true (ターン進行中): capture gap で snap.status が waiting に化けても
+              //   processing を強制 = 症状C(再マウントで生成中の三点リーダーが消える偽陰性)の masking。
+              // - busy=false (プロセス実体 idle): snap.status が processing でも、それは静的完了行の
+              //   偽陽性(無生成時の誤点灯=問題1)なので processing を配らず waiting へ降格する。bind は
+              //   noCache 単発読みで freeze 履歴が無く偽陽性を弾けないため、ここで busy を権威にする。
+              // generating(capture 由来)でなく busy(isArmed + 子孫数>baseline)を使うのが肝。
+              // proc_busy は配らない: outputActive(出力残り火)を含み真 idle でも true になり高速消灯
+              // (症状B)を再発させるため。
+              const snapStatus = resolveBindSnapshotStatus(busy, snap.status)
               ctx.client.send({
                 type: "session.state",
                 session_name: sessionName,
-                status: generating ? "processing" : snap.status,
+                status: snapStatus,
                 context_pct: snap.context_pct,
                 permission_mode: snap.permission_mode,
                 stable:
-                  !generating &&
-                  snap.status !== "processing" &&
-                  snap.stable === true,
+                  !busy && snapStatus !== "processing" && snap.stable === true,
               })
             } catch (err) {
               logger?.warn(

package/src/proc-introspect.mjs

@@ -324,6 +324,12 @@ export class ReadinessTracker {
     return this.byName.get(name)?.busy ?? false
   }
 
+  /** 学習済み idle baseline (子孫プロセス数の床)。null=未学習。bind ハンドラの即時 busy
+   *  プローブ (count > baseline で「ターン進行中」を実プロセスから判定) に使う。 */
+  getBaseline(name) {
+    return this.byName.get(name)?.baseline ?? null
+  }
+
   /** ターン進行中か (prompt_submit で arm 後、ready/cap で disarm するまで true)。
    *  生成中・Stop フック中の両方を含む。state loop が権威的な stall 判定に使う。 */
   isArmed(name) {

package/src/state.mjs

@@ -243,8 +243,13 @@ function workingSpinnerLine(text) {
  * 不変」なら凍結とみなす。閾値は capture キャッシュ TTL (2.5s) と state loop 周期 (5s) を跨ぐ
  * 6s に取り、ライブタイマーの 1 サンプル取りこぼしでは誤判定しないようにする。
  */
+// 静的な完了行 (● Updated…/⏺ Ran tool (2s) 等、ターン終了後もアイドル画面に残る) を
+// SPINNER_LINE_RE が誤検出して processing に張り付く「無生成時の三点リーダー誤点灯」(問題1) の
+// 滞留時間を短縮するため 6000→3500 に下げた (2026-06-22)。実スピナーは経過秒 (Ns) かグリフ
+// アニメで毎秒変化するため frozen には絶対ならず、閾値短縮で偽陰性(生成中の消失)は再発しない
+// (3500ms ≫ 1s アニメ周期で十分な余裕)。env で上書き可。
 const SPINNER_FREEZE_CONFIRM_MS = Number(
-  process.env.HUB_AGENT_SPINNER_FREEZE_MS ?? 6000,
+  process.env.HUB_AGENT_SPINNER_FREEZE_MS ?? 3500,
 )
 /** @type {Map<string, {line: string, at: number}>} session名 → 最初にその行を見た時刻 */
 const _spinnerFreezeByName = new Map()
@@ -277,6 +282,29 @@ export function detectStatusFromText(text) {
   return "idle"
 }
 
+/**
+ * 【問題1 根治 2026-06-22】bind 時の即時ステータススナップショットで配る status を、
+ * プロセス実体の busy を権威として解決する。capture (SPINNER_LINE_RE) の偽陽性に勝たせる。
+ *
+ * - busy=true (isArmed or pane_pid 子孫数 > baseline = ターン進行中): capture gap で
+ *   capturedStatus が waiting に化けても processing を強制 (症状C=再マウントで生成中の三点
+ *   リーダーが消える偽陰性の masking)。
+ * - busy=false (プロセス実体 idle): capturedStatus が processing でも、それは静的完了行の
+ *   SPINNER_LINE_RE 偽陽性であって生成中ではないので processing を配らない (= waiting へ降格)。
+ *   bind は noCache 単発読みで freeze 履歴が無く偽陽性を弾けないため、ここで busy を権威にする。
+ *   万一 no-hook セッションの無音生成中だった場合も、次の state loop tick(≤5s)が outputActive で
+ *   processing に復帰させるので実害は限定的。
+ *
+ * @param {boolean} busy プロセス実体の busy (isArmed or 子孫数>baseline)
+ * @param {string} capturedStatus detectSessionState の status
+ * @returns {string}
+ */
+export function resolveBindSnapshotStatus(busy, capturedStatus) {
+  if (busy) return "processing"
+  if (capturedStatus === "processing") return "waiting"
+  return capturedStatus
+}
+
 export function detectContextPctFromText(text) {
   for (const re of CONTEXT_PATTERNS) {
     const m = text.match(re)

package/src/tmux.mjs

@@ -1331,20 +1331,40 @@ export function shouldSkipRebindRespawn({
   targetId,
   newestId,
   paneRunningClaude,
+  busy = false,
 } = {}) {
+  // 【最優先・無条件の安全弁 — 構造版 根治 2026-06-22】ペインが現にターン進行中 (busy) なら、
+  // fresh / resume / switch のいずれであっても respawn-pane -k で実行中 claude を kill しない。
+  // busy は呼び出し側がプロセス実体 (ReadinessTracker.isArmed = prompt_submit→ready の間、
+  // または pane_pid 子孫数 > 学習 baseline) で算出する堅い信号で、capture スクレイプや
+  // armed 140s cap の脆さに依存しない。これにより「動いている claude は誰の要求でも殺さない」を
+  // 唯一の破壊点 (rebindClaudeSession) の手前で構造的に保証する。
+  // 旧バグ: `if (fresh) return false` が fresh:true を無条件に respawn(=kill) へ通し、防御を完全に
+  // frontend (fresh を送らない前提) 単独依存にしていた。frontend の 1 経路でも fresh が漏れると
+  // 生成中 claude が死ぬ事故 (症状D) が再発した。busy ゲートで前提依存を断つ。
+  // fresh の +新規 要求が busy で抑止された場合、呼び出し側は busy 解消 (ready) まで defer する。
+  if (busy) return true
   if (fresh) return false
-  // 実行中 claude を kill しない最優先ガード（症状D / 再発 D2 の根治）: ペインが現に claude を
-  // 実行中で、最新セッション（= 今動いている会話）への再 bind（remount/reconnect）なら、respawn
-  // (respawn-pane -k) は破壊的なだけで不要。generating の脆い検出（isArmed 140s cap / capture gap）
-  // で false に倒れても、実プロセス由来の paneRunningClaude が守る。targetId 未指定（= newest 解決前）
-  // も「最新への再 bind」とみなす。明示的な別会話への切替（targetId !== newestId）と +新規（fresh）は
-  // 従来どおり respawn する。
+  // 実行中 claude を kill しない補助ガード: ペインが現に claude を実行中で、最新セッション
+  // （= 今動いている会話）への再 bind（remount/reconnect）なら respawn は破壊的なだけで不要。
+  // busy が false に倒れても (cap/未観測)、pane_current_command 由来の paneRunningClaude が守る。
   if (paneRunningClaude && (!targetId || targetId === newestId)) return true
   if (!generating) return false
   return !!targetId && targetId === newestId
 }
 
 export async function rebindClaudeSession(name, sessionId, opts = {}) {
+  // 【破壊点チョークポイント — 最終安全弁 2026-06-22】respawn-pane -k を実行する唯一の関数。
+  // busy=true (ターン進行中) なら shouldSkipRebindRespawn を経由せず直接呼ばれても respawn を
+  // 絶対に発行しない。これで「動いている claude を kill しない」不変条件を実行地点 1 箇所で
+  // 保証する (呼び出し側の判定漏れに対する多層防御)。呼び出し側が ready まで defer する。
+  if (opts.busy === true) {
+    opts.logger?.info(
+      { session: name, fresh: !!opts.fresh },
+      "tui rebind: skipped respawn at chokepoint (pane busy, deferred)",
+    )
+    return { ok: false, skipped: true, reason: "busy" }
+  }
   let cmd
   try {
     // fresh=新規起動 (--resume 無し)。それ以外は session_id 検証込みの resume。