@cocorograph/hub-agent 0.7.4 → 0.7.6

package/package.json

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

package/src/main.mjs

@@ -74,6 +74,7 @@ import {
   recoverTuiInput,
   removeWorktree as removeWorktreeDir,
   resumeWithMessage,
+  pasteToSessionByName,
   setSessionMouse,
   setTmuxGlobalEnv,
   setTuiEffort,
@@ -599,6 +600,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,
@@ -622,6 +658,7 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
     logger,
     tracker: readinessTracker,
     intervalMs: 700,
+    onReady: flushDeferredFreshRespawn,
   })
 
   // TUI 権限ブリッジ: 対話 TUI の PreToolUse フックが書く権限要求を fs.watch で
@@ -950,16 +987,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}
@@ -1015,6 +1087,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) {
@@ -1433,6 +1511,13 @@ export function handleUntrackedPtyData(msg, ctx) {
   }
 }
 
+/**
+ * 離席中キュー投入 (claude.tui.queue.flush) の冪等化用に、処理済み flush_id を記憶する。
+ * WS 再送で同じ flush が二重に届いても二重 paste しないため。上限を超えたら全消去 (best-effort)。
+ */
+const _seenFlushIds = new Set()
+const _SEEN_FLUSH_CAP = 2000
+
 async function dispatch(msg, ctx) {
   const t = msg?.type || ""
   try {
@@ -1974,6 +2059,58 @@ async function dispatch(msg, ctx) {
         })()
         return
       }
+      case "claude.tui.queue.flush": {
+        // 離席中(非アクティブセッション)キュー自動投入 (案A の agent 側受け口)。
+        // ブラウザの常駐ドレイン (useCockpitTuiQueueDrainAll) が、表示していないセッションの
+        // 送信待ちキュー先頭 1 件をここへ送る。tmux send-keys (PTY 非依存) で投入するので、
+        // そのセッションのターミナルを誰も開いていなくても届く。結果を flush.ack で返し、
+        // ブラウザは ack を受けてはじめて localStorage から 1 件 dequeue する (冪等)。
+        const sessionName =
+          typeof msg.session_name === "string" ? msg.session_name : ""
+        const text = typeof msg.text === "string" ? msg.text : ""
+        const flushId = typeof msg.flush_id === "string" ? msg.flush_id : ""
+        const ackFail = (reason) => {
+          if (flushId && sessionName) {
+            ctx.client.send({
+              type: "claude.tui.queue.flush.ack",
+              session_name: sessionName,
+              flush_id: flushId,
+              ok: false,
+              error: reason,
+            })
+          }
+        }
+        if (!sessionName || !flushId || !text) {
+          ackFail("missing session_name / flush_id / text")
+          return
+        }
+        // 冪等化: 同一 flush_id を既に処理済みなら再 paste せず ok を返す (ブラウザは dequeue 済み
+        // を再確認するだけ)。WS 再送・ack 取りこぼしによる二重投入を防ぐ。
+        if (_seenFlushIds.has(flushId)) {
+          ctx.client.send({
+            type: "claude.tui.queue.flush.ack",
+            session_name: sessionName,
+            flush_id: flushId,
+            ok: true,
+          })
+          return
+        }
+        ;(async () => {
+          const result = await pasteToSessionByName(sessionName, text, { logger })
+          if (result.ok) {
+            if (_seenFlushIds.size >= _SEEN_FLUSH_CAP) _seenFlushIds.clear()
+            _seenFlushIds.add(flushId)
+          }
+          ctx.client.send({
+            type: "claude.tui.queue.flush.ack",
+            session_name: sessionName,
+            flush_id: flushId,
+            ok: !!result.ok,
+            error: result.ok ? undefined : result.error,
+          })
+        })()
+        return
+      }
       case "claude.tui.rehydratePermissions": {
         // セッション切替でビューが再マウントすると、その時点の承認/質問カードは React
         // state ごと消える (agent は claude.permission.request を 1 回しか push しない)。
@@ -2085,8 +2222,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 }
@@ -2097,16 +2248,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, {
@@ -2114,9 +2286,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({

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/tmux.mjs

@@ -796,6 +796,17 @@ export function isSafeSessionId(sessionId) {
   return typeof sessionId === "string" && /^[A-Za-z0-9_-]{8,128}$/.test(sessionId)
 }
 
+/** tmux セッション名として安全な形だけ許可する。`-t <name>` の引数に流すため、先頭ハイフン
+ *  (フラグ誤認) や予期せぬ文字を弾く。agent が作るセッション名は英数・`_`・`-`・`.` のみ。 */
+export function isSafeSessionName(name) {
+  return typeof name === "string" && /^[A-Za-z0-9_][A-Za-z0-9_.-]{0,127}$/.test(name)
+}
+
+/** bracketed paste マーカーと貼り付け確定の待ち時間 (pasteToSessionByName 用)。 */
+const PASTE_START = "\x1b[200~"
+const PASTE_END = "\x1b[201~"
+const PASTE_CONFIRM_DELAY_MS = 120
+
 /** agent 設定 (model / permissionMode) を claude のフラグ文字列に変換する ("" or "--model X ...")。 */
 export function composeClaudeFlags(opts = {}) {
   const model = (opts.model || "").trim()
@@ -953,6 +964,55 @@ export async function resumeWithMessage(name, text, opts = {}) {
   }
 }
 
+/**
+ * 離席中キュー投入: 送信待ちメッセージ 1 件を、ブラウザがそのセッションのターミナルを
+ * マウントしていなくても tmux send-keys で対話 claude TUI へ投入する (案A の agent 側実体)。
+ *
+ * resumeWithMessage は改行を空白へ畳む単一行用 (誤確定防止) でチャット本文の複数行を壊すため、
+ * こちらは **bracketed paste** (ESC[200~ … ESC[201~) で本文を「貼り付け」として送り、改行を
+ * 保ったまま入力欄へ入れてから、確定の Enter (CR) を別途送る。これは frontend の通常送信
+ * (`\x1b[200~${text}\x1b[201~` → CR) と同じ手順を agent 側で再現したもの。PTY 非依存
+ * (tmux send-keys) なので、当該セッションのターミナルを誰も開いていなくても届く。
+ *
+ * @param {string} name tmux セッション名
+ * @param {string} text 投入する本文 (複数行可)
+ * @param {{logger?:object,tmuxBin?:string}} [opts]
+ * @returns {Promise<{ok:boolean, error?:string}>}
+ */
+export async function pasteToSessionByName(name, text, opts = {}) {
+  const bin = tmuxBin(opts)
+  const body = String(text ?? "")
+  if (!body) return { ok: false, error: "empty paste text" }
+  if (!isSafeSessionName(name)) return { ok: false, error: "unsafe session name" }
+  try {
+    // copy-mode 等に入っているとキーが奪われるので先に抜ける (cyclePermission と同じ防御)。
+    try {
+      await execFileP(bin, ["send-keys", "-t", name, "-X", "cancel"])
+    } catch {
+      /* copy-mode でなければ "not in a mode" エラー = 無視 */
+    }
+    // bracketed paste の開始/終了マーカーと本文を literal (-l) で送る。改行を含む本文も
+    // 「貼り付け」として扱われ、Claude TUI は改行で確定しない (CR を別送するまで未確定)。
+    await execFileP(bin, ["send-keys", "-t", name, "-l", PASTE_START])
+    await execFileP(bin, ["send-keys", "-t", name, "-l", body])
+    await execFileP(bin, ["send-keys", "-t", name, "-l", PASTE_END])
+    // 貼り付けが入力欄へ反映される猶予を置いてから確定 (CR を本文より先着させない)。
+    await _delay(PASTE_CONFIRM_DELAY_MS)
+    await execFileP(bin, ["send-keys", "-t", name, "Enter"])
+    opts.logger?.info(
+      { session: name, len: body.length },
+      "tui queue flush: pasted queued message (headless)",
+    )
+    return { ok: true }
+  } catch (err) {
+    opts.logger?.warn(
+      { session: name, err: err?.message },
+      "pasteToSessionByName failed",
+    )
+    return { ok: false, error: err?.message || String(err) }
+  }
+}
+
 /**
  * 対話 claude TUI に shift+tab (BACKTAB) を 1 回送って権限モードを循環させる。
  *
@@ -1271,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。