@cocorograph/hub-agent 0.6.27 → 0.6.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocorograph/hub-agent",
-  "version": "0.6.27",
+  "version": "0.6.29",
   "description": "Hub Hosted Cockpit のローカル常駐 agent。Hub と outbound WSS で接続し、ローカルの tmux/pty を中継する。",
   "type": "module",
   "license": "UNLICENSED",
@@ -20,7 +20,8 @@
     "start": "node bin/hub-agent.mjs start",
     "test": "node --test test/*.test.mjs",
     "postinstall": "node scripts/fix-node-pty-perms.mjs",
-    "prepublishOnly": "npm test"
+    "check:publish-on-main": "node scripts/check-publish-on-main.mjs",
+    "prepublishOnly": "node scripts/check-publish-on-main.mjs && npm test"
   },
   "files": [
     "bin/",

package/scripts/check-publish-on-main.mjs

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+// パブリッシュ前ガード: いま publish しようとしている HEAD が origin/main に
+// マージ済みであることを確認する。
+//
+// 背景 (恒久対策): hub-agent には CI/CD デプロイフローが無く、publish は手元から
+// 手動で行う。過去に feature/ローカルブランチから直接 publish した結果、main の
+// バージョンが publish 済みより古いまま取り残され (例: main=0.6.26 なのに 0.6.28 が
+// publish 済み)、次にその古い main から派生したブランチで「バージョン巻き戻り」が
+// 発生した。これを防ぐため「publish する前に必ず main へマージする」を機械的に強制する。
+//
+// ルール: npm publish (= prepublishOnly) 時に、HEAD のコミットが origin/main から
+// 到達可能 (= main にマージ済み) かつ作業ツリーがクリーンでなければ exit 1 で止める。
+//
+// 緊急時の回避: どうしても main 未マージで publish する必要がある場合のみ
+//   ALLOW_PUBLISH_OFF_MAIN=1 npm publish
+// で明示的にバイパスできる (記録が残るよう env を必須にしている)。
+
+import { execFileSync } from "node:child_process"
+
+const GREEN = "\x1b[32m"
+const RED = "\x1b[31m"
+const YELLOW = "\x1b[33m"
+const RESET = "\x1b[0m"
+
+/**
+ * git コマンドを同期実行して trim 済み stdout を返す。
+ *
+ * @param {string[]} args git に渡す引数
+ * @param {{ allowFail?: boolean }} [opts] allowFail=true なら失敗時に null を返す
+ * @returns {string | null} stdout (trim 済み)、失敗かつ allowFail なら null
+ */
+function git(args, opts = {}) {
+  try {
+    return execFileSync("git", args, {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim()
+  } catch (err) {
+    if (opts.allowFail) return null
+    throw err
+  }
+}
+
+function fail(message) {
+  console.error(`${RED}✖ publish ガード: ${message}${RESET}`)
+  console.error(
+    `${YELLOW}  → 正しい手順: PR を origin/main にマージ → main を pull → ` +
+      `main 上で npm publish。${RESET}`,
+  )
+  console.error(
+    `${YELLOW}  → 緊急回避 (記録が残ります): ` +
+      `ALLOW_PUBLISH_OFF_MAIN=1 npm publish${RESET}`,
+  )
+  process.exit(1)
+}
+
+function main() {
+  if (process.env.ALLOW_PUBLISH_OFF_MAIN === "1") {
+    console.warn(
+      `${YELLOW}⚠ ALLOW_PUBLISH_OFF_MAIN=1: main マージ確認をバイパスして ` +
+        `publish します (緊急回避)。${RESET}`,
+    )
+    return
+  }
+
+  // git リポジトリ外なら判定不能 → 安全側で止める。
+  const inRepo = git(["rev-parse", "--is-inside-work-tree"], { allowFail: true })
+  if (inRepo !== "true") {
+    fail("git リポジトリ内で実行されていません (main マージ確認ができません)。")
+  }
+
+  // 作業ツリーがクリーンか (未コミットの変更を含んだまま publish しない)。
+  const dirty = git(["status", "--porcelain"], { allowFail: true })
+  if (dirty) {
+    fail(
+      "作業ツリーに未コミットの変更があります。コミット & main マージしてから " +
+        "publish してください。",
+    )
+  }
+
+  // origin/main を最新化する (オフライン時はローカルの追跡参照で判定)。
+  const fetched = git(["fetch", "origin", "main", "--quiet"], {
+    allowFail: true,
+  })
+  if (fetched === null) {
+    console.warn(
+      `${YELLOW}⚠ origin/main の fetch に失敗しました。ローカルの ` +
+        `origin/main 参照で判定します (古い可能性あり)。${RESET}`,
+    )
+  }
+
+  const mainRef = git(["rev-parse", "--verify", "origin/main"], {
+    allowFail: true,
+  })
+  if (!mainRef) {
+    fail("origin/main が見つかりません (remote 設定を確認してください)。")
+  }
+
+  // HEAD が origin/main から到達可能か = main にマージ済みか。
+  const head = git(["rev-parse", "HEAD"])
+  const isMerged =
+    git(["merge-base", "--is-ancestor", "HEAD", "origin/main"], {
+      allowFail: true,
+    }) !== null
+  // merge-base --is-ancestor は exit code で結果を返す (0=ancestor / 1=not)。
+  // allowFail で 1 のとき null になるため、null=未マージと判定する。
+
+  if (!isMerged) {
+    const headShort = head.slice(0, 8)
+    const mainShort = mainRef.slice(0, 8)
+    fail(
+      `現在の HEAD (${headShort}) は origin/main (${mainShort}) に未マージです。` +
+        "publish は main にマージしてから行ってください。",
+    )
+  }
+
+  console.log(
+    `${GREEN}✔ publish ガード: HEAD は origin/main にマージ済み。publish を続行します。${RESET}`,
+  )
+}
+
+main()

package/src/claude-stream-bridge.mjs

@@ -62,6 +62,14 @@ const CHAT_RESIDENT_RESUME_ENABLED =
  *  単一 stream_id 挙動と完全に一致する (this.streamIds は未使用のまま)。 */
 const CHAT_SHARED_ENABLED = process.env.HUB_AGENT_CHAT_SHARED === "1"
 
+/** B11: 多端末共有時、一定期間 input/permission 等の活性が無い購読端末キーを死端末とみなして
+ *  GC する閾値 (ミリ秒)。端末がクラッシュして claude.detach を送らず消えると streamIds /
+ *  sessions に stream_id が永久残留し、最後の 1 台が外れないと idle softDetach が起動しない。
+ *  正常に開いている端末は input が無くても WS heartbeat 等で活性更新されないため、閾値は
+ *  長め (既定 1 時間) にして「明らかに死んだ」端末のみを掃除する。env で調整可能。 */
+const DEAD_TERMINAL_TTL_MS =
+  Number(process.env.HUB_AGENT_DEAD_TERMINAL_TTL_MS) || 60 * 60 * 1000
+
 /** 文字列を SDK streaming input の SDKUserMessage に包む。
  *  SDKUserMessage は parent_tool_use_id: string|null が必須フィールド。現行 SDK は入力側で
  *  寛容なので省略しても動くが、将来の型厳格化に備えて明示する。トップレベルのユーザー入力
@@ -153,6 +161,12 @@ class ClaudeStreamSession {
      *  参照され、reattach で増え detach で減る。最後の 1 台が外れると idle softDetach に入る。
      *  this.stream_id は「最も新しく attach した端末」= legacy emit / primary 用に残す。 */
     this.streamIds = new Set([stream_id])
+    /** B11: 購読端末ごとの最終アクティビティ時刻 (epoch ms)。attach / reattach / input /
+     *  permission 応答で更新する。CHAT_SHARED_ENABLED 時に「死端末 GC」が参照し、一定期間
+     *  無活動の購読端末キーを掃除する。これが無いと端末がクラッシュして claude.detach を
+     *  送らず消えると stream_id が streamIds/sessions に永久残留し、最後の 1 台が外れないと
+     *  idle softDetach が起動しないため死端末がセッションを永久に生かしてしまう。 */
+    this.lastActivityByStream = new Map([[stream_id, Date.now()]])
     this.cwd = cwd
     this.model = model || null
     this.permissionMode = permissionMode || null
@@ -209,6 +223,11 @@ class ClaudeStreamSession {
     /** 改修3: 直近 browser へ通知した queue 署名 (件数 + id 列)。変化時のみ emit する。
      *  空キューの署名 ("0:") で初期化し、空→空の冗長 emit を抑止する。 */
     this._lastEmittedQueueSig = "0:"
+    /** ultracode (0.6.28): 常駐 query へ現在適用済みの ultracode 状態。ターン単位の
+     *  ワンショット適用を applyFlagSettings で reconcile する際の差分判定に使う。
+     *  query を (再)起動すると flag settings は既定に戻るため、_runResidentQuery 冒頭で
+     *  false に戻す。 */
+    this._ultracodeCurrent = false
 
     /** @type {Map<string, {resolve: (decision: object) => void}>} permission 応答待ち */
     this._permissionResolvers = new Map()
@@ -290,6 +309,8 @@ class ClaudeStreamSession {
     const r = this._permissionResolvers.get(request_id)
     if (!r) return false
     this._permissionResolvers.delete(request_id)
+    // B11: 現 primary 端末からの permission 応答を活性として記録する。
+    this.touch(this.stream_id)
     r.resolve(decision)
     return true
   }
@@ -310,6 +331,7 @@ class ClaudeStreamSession {
     // 多端末共有: この端末を購読集合に追加 (無効時は未使用)。旧端末の stream_id は
     // bridge.attach 側で sessions Map に残されるため、ここでは増やすだけでよい。
     this.streamIds.add(stream_id)
+    this.touch(stream_id) // B11: 死端末 GC 用の最終アクティビティ更新
     this._detached = false
     if (this._idleTimer) {
       clearTimeout(this._idleTimer)
@@ -318,6 +340,13 @@ class ClaudeStreamSession {
     if (opts) this.applyRuntimeOptions(opts)
   }
 
+  /** B11: 端末の最終アクティビティ時刻を更新する (死端末 GC の生存判定に使う)。 */
+  touch(stream_id) {
+    if (stream_id && this.streamIds.has(stream_id)) {
+      this.lastActivityByStream.set(stream_id, Date.now())
+    }
+  }
+
   /** 改修5: モデル/権限/拡張思考をランタイムに切り替える。
    *
    *  - 保持フィールド (this.model/permissionMode/maxThinkingTokens) を更新する。これは
@@ -445,20 +474,35 @@ class ClaudeStreamSession {
    * 既存ターン実行中 (busy) は破棄せず pending キューへ退避し、現ターン完了時に drain する
    * (改修3)。常駐 query 対象 (新規セッション) は InputQueue へ積む (改修2)。
    */
-  async sendMessage(message) {
+  async sendMessage(message, opts = {}) {
     if (this._closed) return
     const prompt = extractPromptText(message)
     if (!prompt) return
 
+    // ultracode ワンショット (0.6.28): このターンのみ xhigh effort + 常時 dynamic-workflow
+    // オーケストレーションを有効化する。セッション既定としては持たず (トークン消費が
+    // 桁違いになるため)、ターン単位でトグルし、完了後は通常状態へ戻す。
+    // per-message では options.settings に乗せ、resident では applyFlagSettings で
+    // ターン前に ON / 次ターン前に OFF へ reconcile する (詳細は _reconcileResidentUltracode)。
+    const ultracode = opts.ultracode === true
+
     // 改修2+4: 常駐query対象セッション。
     if (this._residentEligible) {
-      if (!this._inputQueue) this._inputQueue = new InputQueue()
+      // B6: 死亡後の (再)起動経路。既に query を起動した実績があり (_residentStarted)、かつ
+      // 現在 query が無い (_residentQuery=null = 異常終了済み) 場合、既存 _inputQueue は前 query で
+      // consume し切った (generator return 済み) インスタンス。同じものを次の sdk.query に渡すと
+      // _q/_wake の残留が新 generator と競合し得るため、push 前に必ず作り直す。
+      if (this._residentStarted && !this._residentQuery) {
+        this._inputQueue = new InputQueue()
+      } else if (!this._inputQueue) {
+        this._inputQueue = new InputQueue()
+      }
       // 改修4 (A): ターンのシリアライズ。実行中ターン (busy) は InputQueue へ即 push せず
       // pending へ退避し、現ターンの result 後に 1 件ずつ drain する。前ターン未完了のまま
       // 次を push すると SDK streaming-input で割り込み扱いになり得るため (公式 interrupt 警告)。
       // pending は queue_state で UI (送信待ちチップ) に出す (per-message と同じ体験)。
       if (this._busy) {
-        this._enqueuePending(prompt)
+        this._enqueuePending(prompt, ultracode)
         this.logger?.info(
           { stream_id: this.stream_id, queued: this._pendingMessages.length },
           "resident busy, message queued",
@@ -467,14 +511,18 @@ class ClaudeStreamSession {
         return
       }
       this._busy = true
-      this._inputQueue.push(toSDKUserMessage(prompt))
       // 改修4 (A): 死亡ガード。常駐 query が未起動 or (エラー等で) 終了済み (_residentQuery=null)
       // なら (再)起動する。_runResidentQuery は起動時 options.resume=this.sessionId で文脈を
       // 復元するため、途中死からの復活でも過去コンテキストは失われない。
+      // ultracode のとき: query を先に起動 (空 InputQueue なので入力待ちでブロック) し、
+      // applyFlagSettings を await してから push することで、設定適用前にターンが
+      // 消費されるレースを防ぐ。
       if (!this._residentQuery) {
         this._residentStarted = true
         this._startResidentQuery()
       }
+      await this._reconcileResidentUltracode(ultracode)
+      this._inputQueue.push(toSDKUserMessage(prompt))
       return
     }
 
@@ -482,7 +530,7 @@ class ClaudeStreamSession {
     // 改修3: busy 中の送信は破棄せず pending キューへ退避し、現ターン完了時に drain する
     // (ターミナル流の「積む→待機→順次実行」)。常駐 query 化はしないので暴走リスクは増えない。
     if (this._busy) {
-      this._enqueuePending(prompt)
+      this._enqueuePending(prompt, ultracode)
       this.logger?.info(
         { stream_id: this.stream_id, queued: this._pendingMessages.length },
         "claude busy, message queued",
@@ -490,12 +538,12 @@ class ClaudeStreamSession {
       this._emitQueueState()
       return
     }
-    return this._runPerMessage(prompt)
+    return this._runPerMessage(prompt, { ultracode })
   }
 
   /** per-message 1 ターンを実行する (resume チェーン)。busy 中に届いた送信は sendMessage
    *  が pending キューへ退避し、本メソッドの finally で drain する。 */
-  async _runPerMessage(prompt) {
+  async _runPerMessage(prompt, opts = {}) {
     this._busy = true
     this._abortController = new AbortController()
     let aborted = false
@@ -512,6 +560,16 @@ class ClaudeStreamSession {
     if (this.maxTurns != null) options.maxTurns = this.maxTurns
     // 思考オプション (effort / adaptive thinking / 旧 budget) はモデルに応じて切替。
     this._applyThinkingOptions(options)
+    // ultracode ワンショット (0.6.28): per-message は 1 query = 1 ターンなので、
+    // このターンの options.settings (= --settings 相当 / flag settings 層) に乗せるだけで
+    // 自然に 1 ターン限定になる。次ターンは options を作り直すため通常状態に戻る。
+    if (opts.ultracode === true) {
+      options.settings = {
+        ...(options.settings || {}),
+        ultracode: true,
+        enableWorkflows: true,
+      }
+    }
     // 直前ターンまでの session_id があれば resume チェーン
     if (this.sessionId) options.resume = this.sessionId
 
@@ -613,18 +671,21 @@ class ClaudeStreamSession {
     }
     const next = this._pendingMessages.shift()
     this._emitQueueState([next.text])
-    this._runPerMessage(next.text).catch((err) => {
-      this.logger?.error(
-        { stream_id: this.stream_id, err: err?.message },
-        "drain runPerMessage threw",
-      )
-    })
+    this._runPerMessage(next.text, { ultracode: next.ultracode === true }).catch(
+      (err) => {
+        this.logger?.error(
+          { stream_id: this.stream_id, err: err?.message },
+          "drain runPerMessage threw",
+        )
+      },
+    )
   }
 
-  /** キャンセル機能 (0.6.26): pending キューへ安定 id 付きで 1 件積む。 */
-  _enqueuePending(prompt) {
+  /** キャンセル機能 (0.6.26): pending キューへ安定 id 付きで 1 件積む。
+   *  ultracode (0.6.28): ワンショット ultracode フラグもエントリに保持し、drain 時に伝播する。 */
+  _enqueuePending(prompt, ultracode = false) {
     const id = `q${++this._queueSeq}`
-    this._pendingMessages.push({ id, text: prompt })
+    this._pendingMessages.push({ id, text: prompt, ultracode: ultracode === true })
     return id
   }
 
@@ -685,18 +746,62 @@ class ClaudeStreamSession {
     })
   }
 
+  /** ultracode (0.6.28): 常駐 query の ultracode 状態を目標値へ寄せる (差分時のみ
+   *  applyFlagSettings を発行)。push の前に await して、設定適用前にターンが消費される
+   *  レースを防ぐ。query 未起動 / applyFlagSettings 非対応 SDK では no-op。 */
+  async _reconcileResidentUltracode(desired) {
+    const want = desired === true
+    if (want === this._ultracodeCurrent) return
+    const q = this._residentQuery
+    if (!q || typeof q.applyFlagSettings !== "function") return
+    try {
+      await q.applyFlagSettings(
+        want
+          ? { ultracode: true, enableWorkflows: true }
+          : { ultracode: false },
+      )
+      this._ultracodeCurrent = want
+      this.logger?.info(
+        { stream_id: this.stream_id, ultracode: want },
+        "resident ultracode reconciled",
+      )
+    } catch (err) {
+      this.logger?.warn(
+        { stream_id: this.stream_id, err: err?.message },
+        "applyFlagSettings ultracode failed",
+      )
+    }
+  }
+
   /** 改修4 (A): ターン完了時に pending の先頭 1 件を InputQueue へ流す (ターンのシリアライズ)。
-   *  queue_state を更新して送信待ちチップを drain させる (frontend がバブル昇格する)。 */
-  _drainResidentPending() {
+   *  queue_state を更新して送信待ちチップを drain させる (frontend がバブル昇格する)。
+   *  ultracode (0.6.28): 次ターンの目標 ultracode 状態へ reconcile してから push する
+   *  (await するため async 化。result ハンドラからは fire-and-forget で呼ばれる)。 */
+  async _drainResidentPending() {
     if (this._closed) return
     if (this._pendingMessages.length === 0) {
       this._emitQueueState()
       return
     }
     const next = this._pendingMessages.shift()
+    // B5: busy をセットしてから reconcile / push / emit が例外を投げると
+    // _busy=true のまま残り、以降の drain が全て弾かれて pending が永久に積み上がる
+    // デッドロックになる。失敗時は取り出したメッセージを先頭へ戻し _busy を解除して、
+    // 次の drain がやり直せる状態に必ず回復する (例外は既存方針通り warn で握る)。
     this._busy = true
-    this._inputQueue.push(toSDKUserMessage(next.text))
-    this._emitQueueState([next.text])
+    try {
+      // ultracode reconcile (0.6.28) も await で例外を投げうるので try の中に含める。
+      await this._reconcileResidentUltracode(next.ultracode === true)
+      this._inputQueue.push(toSDKUserMessage(next.text))
+      this._emitQueueState([next.text])
+    } catch (err) {
+      this._busy = false
+      this._pendingMessages.unshift(next)
+      this.logger?.warn(
+        { stream_id: this.stream_id, err: err?.message },
+        "drainResidentPending failed, recovered busy state",
+      )
+    }
   }
 
   /** 改修2+4: 常駐 query を 1 回だけ起動し、streaming input キューから複数ターンを処理する。
@@ -718,6 +823,10 @@ class ClaudeStreamSession {
     if (this.permissionMode) options.permissionMode = this.permissionMode
     if (this.maxTurns != null) options.maxTurns = this.maxTurns
     this._applyThinkingOptions(options)
+    // ultracode (0.6.28): 新規 query は flag settings 既定 (ultracode=off) で始まる。
+    // 適用済み状態の追跡を false にリセットし、次ターンの reconcile が正しく差分判定できる
+    // ようにする (異常終了→resume 再起動時にも確実にリセット)。
+    this._ultracodeCurrent = false
     // 改修4: 起動時に sessionId (= resumeSessionId) があれば resume チェーンで文脈を引き継ぐ。
     // query 起動時点の値のみ有効 (起動後に確定/変化する session_id は同一 query 内で継続される)。
     if (this.sessionId) options.resume = this.sessionId
@@ -748,7 +857,14 @@ class ClaudeStreamSession {
           denyPending("turn ended")
           this._busy = false
           // 改修4 (A): シリアライズした pending があれば次の 1 件を InputQueue へ流す。
-          this._drainResidentPending()
+          // ultracode (0.6.28): _drainResidentPending は applyFlagSettings を await するため
+          // async。result ハンドラ (for await ループ内) からは fire-and-forget で呼ぶ。
+          this._drainResidentPending().catch((err) =>
+            this.logger?.warn(
+              { stream_id: this.stream_id, err: err?.message },
+              "drainResidentPending threw",
+            ),
+          )
         }
         try {
           this.onEvent?.(msg)
@@ -781,12 +897,25 @@ class ClaudeStreamSession {
       } else if (!this._closed && this._pendingMessages.length > 0) {
         // 改修4 (A): 異常終了 (close 以外) で pending が残っていれば resume 付きで再起動し
         // 取りこぼしを防ぐ。_runResidentQuery が options.resume=this.sessionId で文脈を復元する。
+        // B6: 既存 _inputQueue の generator は既に return 済み (この query で消費し切った)。
+        // 同じインスタンスを次の sdk.query に再利用すると _q/_wake の残留状態が新しい
+        // generator と競合し得るため、再起動前に必ず作り直す。close() は this._inputQueue を
+        // close() するだけで参照を持ち越さないので、ここで差し替えても整合する。
+        this._inputQueue = new InputQueue()
         const next = this._pendingMessages.shift()
         this._busy = true
         this._residentStarted = true
+        // ultracode (0.6.29): query を先に起動して _residentQuery を確定させてから
+        // reconcile → push する (sendMessage の通常経路と同順)。push してから起動すると
+        // applyFlagSettings を発行する先 (_residentQuery) がまだ無く、異常再起動の対象
+        // メッセージだけ ultracode フラグが落ちる (0.6.28 由来の取りこぼし) ため、ここで揃える。
+        // _startResidentQuery → _runResidentQuery は最初の await (for await) より前に
+        // 同期で _residentQuery と _ultracodeCurrent=false を確定するので、直後の reconcile が
+        // 正しく差分判定できる。_reconcileResidentUltracode は内部で例外を握るため throw しない。
+        this._startResidentQuery()
+        await this._reconcileResidentUltracode(next.ultracode === true)
         this._inputQueue.push(toSDKUserMessage(next.text))
         this._emitQueueState([next.text])
-        this._startResidentQuery()
       }
     }
   }
@@ -1030,14 +1159,16 @@ export class ClaudeStreamBridge extends EventEmitter {
   }
 
   /** browser → claude の user メッセージ。1 件 = 1 query (resume チェーン)。 */
-  input({ stream_id, message }) {
+  input({ stream_id, message, ultracode }) {
     const s = this.sessions.get(stream_id)
     if (!s) {
       this.logger?.warn({ stream_id }, "claude.input but stream missing")
       return false
     }
+    s.touch(stream_id) // B11: この端末の最終アクティビティを更新 (死端末 GC 用)
     // 非同期でターン実行 (完了は result イベント + onEvent 経由で browser に届く)
-    s.sendMessage(message).catch((err) => {
+    // ultracode (0.6.28): このメッセージのみ ultracode ワンショットを適用するフラグ。
+    s.sendMessage(message, { ultracode: ultracode === true }).catch((err) => {
       this.logger?.error(
         { stream_id, err: err?.message },
         "claude sendMessage threw unexpectedly",
@@ -1092,11 +1223,13 @@ export class ClaudeStreamBridge extends EventEmitter {
     // idle softDetach に進む。無効時は streamIds が常に 1 要素なので即 softDetach に落ちる。
     if (CHAT_SHARED_ENABLED) {
       s.streamIds.delete(stream_id)
+      s.lastActivityByStream.delete(stream_id) // B11: 活性記録も掃除
       if (this.sessions.get(stream_id) === s) this.sessions.delete(stream_id)
       if (s.streamIds.size > 0) {
         // primary を生存端末へ寄せ替え (legacy emit / softDetach 撤去ログ用)。
+        // 末尾 (最も新しく購読した端末) を .at(-1) で明示的に選ぶ。
         if (s.stream_id === stream_id) {
-          s.stream_id = Array.from(s.streamIds)[s.streamIds.size - 1]
+          s.stream_id = Array.from(s.streamIds).at(-1)
         }
         return true
       }
@@ -1117,6 +1250,45 @@ export class ClaudeStreamBridge extends EventEmitter {
     return true
   }
 
+  /** B11: 多端末共有時に「死端末」(一定期間 input/permission 等の活性が無い購読端末) を
+   *  GC する。端末がクラッシュして claude.detach を送らず消えた stream_id を掃除し、最後の
+   *  1 台が外れたら通常の idle softDetach (走行中は完走を待つ) に進ませる。state loop など
+   *  既存の定期ループから呼ぶ想定。CHAT_SHARED_ENABLED 無効時は何もしない。
+   *  @param {number} [ttlMs] 死端末とみなす無活性閾値 (テスト用に上書き可)。
+   *  @returns {number} GC した端末キー数。 */
+  gcDeadTerminals(ttlMs = DEAD_TERMINAL_TTL_MS) {
+    if (!CHAT_SHARED_ENABLED) return 0
+    const now = Date.now()
+    let removed = 0
+    for (const session of new Set(this.sessions.values())) {
+      if (session._closed) continue
+      // 複数端末が購読しているセッションのみ対象 (1 台しか居なければ idle softDetach に任せる)。
+      if (session.streamIds.size <= 1) continue
+      for (const sid of Array.from(session.streamIds)) {
+        const last = session.lastActivityByStream.get(sid) ?? 0
+        if (now - last < ttlMs) continue
+        // 死端末: 購読集合 / 活性記録 / sessions Map から外す。
+        session.streamIds.delete(sid)
+        session.lastActivityByStream.delete(sid)
+        if (this.sessions.get(sid) === session) this.sessions.delete(sid)
+        removed += 1
+        // primary が死端末だったら生存端末へ寄せ替える (.at(-1) で末尾を明示選択)。
+        if (session.stream_id === sid && session.streamIds.size > 0) {
+          session.stream_id = Array.from(session.streamIds).at(-1)
+        }
+        this.logger?.info(
+          { stream_id: sid, session_id: session.sessionId },
+          "claude dead terminal GC'd (no activity past TTL)",
+        )
+      }
+      // 全端末が死端末で空になったら、idle softDetach 経路に乗せる (走行中は完走を待つ)。
+      if (session.streamIds.size === 0) {
+        this.detach({ stream_id: session.stream_id })
+      }
+    }
+    return removed
+  }
+
   /** 全セッションを強制停止 (agent shutdown 用。実行中ターンも中断する)。 */
   shutdown() {
     for (const stream_id of Array.from(this.sessions.keys())) {

package/src/main.mjs

@@ -12,6 +12,7 @@
  */
 import { readFileSync, watch as fsWatch } from "node:fs"
 import { mkdir, readFile, readdir, rename, unlink, writeFile } from "node:fs/promises"
+import { randomUUID } from "node:crypto"
 import os from "node:os"
 import path from "node:path"
 
@@ -132,6 +133,16 @@ async function loadClaudeSdk(logger) {
   }
 }
 
+/**
+ * B7: 直列 dispatchChain をバイパスして即時処理してよい高頻度・低レイテンシ経路かを判定する。
+ * pty 出力データ (pty.data) と resize (pty.resize) のみ true。入力系 (claude.input)・制御系
+ * (tmux.exec / permission / cancel→paste 等) は WS 受信順 = pane 反映順を守るため false
+ * (= 直列キューに残す)。1 件の tmux.exec ハングで pty 入出力まで止まるのを防ぐ。
+ */
+export function isFastPathMessage(type) {
+  return type === "pty.data" || type === "pty.resize"
+}
+
 export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
   const config = await readConfig()
   if (!config) {
@@ -262,6 +273,22 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
   // (`ptyBridge.on("output")`) なのでこの直列化の影響を受けない。
   let dispatchChain = Promise.resolve()
   client.on("message", (msg) => {
+    // B7: pty 出力データ (pty.data) と resize (pty.resize) は順序保証が不要で高頻度な
+    // 低レイテンシ経路。これらを直列キュー (dispatchChain) に通すと、1 件の tmux.exec 等
+    // のハングで pty 入出力まで全停止してしまう。安全側に「pty 出力データと resize のみ」
+    // を直列キューからバイパスして即時処理する。入力系 (claude.input)・制御系 (tmux.exec /
+    // permission / cancel→paste 等) は WS 受信順 = pane 反映順を守るため dispatchChain に残す。
+    if (isFastPathMessage(msg?.type)) {
+      Promise.resolve(
+        dispatch(msg, { ...ctx, client, ptyBridge, claudeBridge, uploadManager }),
+      ).catch((err) => {
+        logger.error(
+          { err: err.message, type: msg?.type },
+          "dispatch threw (bypassed pty fast-path)",
+        )
+      })
+      return
+    }
     dispatchChain = dispatchChain
       .then(() => dispatch(msg, { ...ctx, client, ptyBridge, claudeBridge, uploadManager }))
       .catch((err) => {
@@ -286,7 +313,13 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
 
   // 5s 周期で全 tmux session の状態を捕捉し、変化したものだけ session.state を push。
   // browser がフォーカスしていない session でも常時更新するためのバックグラウンド職人。
-  const stateLoop = startStateLoop({ client, plugins, logger, intervalMs: 5_000 })
+  const stateLoop = startStateLoop({
+    client,
+    plugins,
+    logger,
+    intervalMs: 5_000,
+    claudeBridge,
+  })
   // bundle hook (cockpit_session_event_hook.py) が /tmp/cockpit_session_events/<name>.json
   // に書き出す UserPromptSubmit / Stop の event を fs.watch で拾って WS push する。
   // text マーカー判定 (detectStatusFromText) より精度が高い「ターン境界」の signal。
@@ -381,7 +414,8 @@ export function contextPctFromUsage(u) {
 async function writeSessionEventFile(sessionName, event, at) {
   if (!sessionName || /[/\\]/.test(sessionName)) return
   const fp = path.join(SESSION_EVENTS_DIR, `${sessionName}.json`)
-  const tmp = `${fp}.tmp.${process.pid}`
+  // tmp 名を randomUUID でユニーク化 (pid 固定だと同一 session への並行書込で衝突する)。
+  const tmp = `${fp}.tmp.${randomUUID()}`
   try {
     await mkdir(SESSION_EVENTS_DIR, { recursive: true })
     await writeFile(tmp, JSON.stringify({ event, at }))
@@ -509,7 +543,7 @@ async function startSessionEventWatcher({ client, logger }) {
  *   pty.exit 受信時に処理する)
  * - tmux 自体が動いてない場合 (listSessionStates → []) は何も push しない
  */
-function startStateLoop({ client, plugins, logger, intervalMs }) {
+function startStateLoop({ client, plugins, logger, intervalMs, claudeBridge }) {
   const lastByName = new Map() // session_name → {status, context_pct}
   const lastTurnAtByName = new Map() // session_name → 最後に event ファイル化した turnAt
   let stopped = false
@@ -517,6 +551,14 @@ function startStateLoop({ client, plugins, logger, intervalMs }) {
   const tick = async () => {
     if (stopped) return
     try {
+      // B11: 多端末共有時、クラッシュして detach を送らず消えた死端末を GC する
+      // (活性なし TTL 超過の購読端末キーを掃除し、最後の 1 台が外れたら idle softDetach へ)。
+      // CHAT_SHARED_ENABLED 無効時は no-op。例外は state loop 全体の try/catch が拾う。
+      try {
+        claudeBridge?.gcDeadTerminals?.()
+      } catch (err) {
+        logger?.warn({ err: err?.message }, "gcDeadTerminals failed")
+      }
       // 実コンテキスト窓サイズ (1M ベータ等) を反映。contextPctFromUsage の分母を
       // 5s ごとに最新化し、ドーナツが 200k 固定で振り切れるのを防ぐ。
       await refreshContextWindow()
@@ -781,6 +823,9 @@ async function dispatch(msg, ctx) {
         ctx.claudeBridge.input({
           stream_id: msg.stream_id,
           message: msg.message,
+          // ultracode (0.6.28): browser がこのメッセージ単位で送るワンショット指定。
+          // true のときだけそのターンを xhigh effort + dynamic-workflow で実行する。
+          ultracode: msg.ultracode === true,
         })
         return
       case "claude.upload": {

package/src/state.mjs

@@ -20,6 +20,37 @@ const execFileP = promisify(execFile)
 
 const STATUSES = Object.freeze(["processing", "waiting", "idle"])
 
+/**
+ * P1: tmux プロセス fork 削減用の短期/長期キャッシュ。
+ *
+ * 5s 周期の state loop が N セッション毎に capture-pane (pane scrape) +
+ * display-message (cwd) を spawn し、list_sessions も同様に二重取得していた。
+ * N セッションで毎 5s に 2N+1 プロセスを fork する負荷を、以下のキャッシュで抑える:
+ *   - capture-pane: 短期キャッシュ (CAPTURE_TTL_MS < state loop 周期)。state loop と
+ *     近接時刻の list_sessions が同じ pane scrape を共有する (状態検出の鮮度は維持)。
+ *   - getSessionCwd: cwd は変化が稀なので長期キャッシュ (CWD_TTL_MS)。毎 tick の
+ *     display-message spawn を排除し fork 数を半減させる。
+ * TTL は env で上書き可能 (テスト/チューニング用)。0 を渡すとキャッシュ無効。
+ */
+const CAPTURE_TTL_MS = Number(process.env.HUB_AGENT_CAPTURE_TTL_MS ?? 2500)
+const CWD_TTL_MS = Number(process.env.HUB_AGENT_CWD_TTL_MS ?? 60000)
+
+/** @type {Map<string, {at: number, value: string}>} session名 → capture-pane 結果 */
+const _captureCache = new Map()
+/** @type {Map<string, {at: number, value: string|null}>} session名 → cwd */
+const _cwdCache = new Map()
+
+/** キャッシュから無効化する (session 終了時等に呼べるよう export)。 */
+export function invalidateSessionCache(sessionName) {
+  if (sessionName == null) {
+    _captureCache.clear()
+    _cwdCache.clear()
+    return
+  }
+  _captureCache.delete(sessionName)
+  _cwdCache.delete(sessionName)
+}
+
 const CONTEXT_PATTERNS = [
   /(\d{1,3})\s*%\s*context\s*left/i,
   /context\s*[:\-]?\s*(\d{1,3})\s*%/i,
@@ -66,6 +97,12 @@ export async function listSessionNames(opts = {}) {
 
 export async function capturePane(sessionName, opts = {}) {
   const tmuxBin = opts.tmuxBin || "tmux"
+  // P1: 短期キャッシュ。state loop と近接時刻の list_sessions の二重 capture-pane を
+  // 同一結果で共有する。opts.noCache か TTL=0 でバイパス可能。
+  if (!opts.noCache && CAPTURE_TTL_MS > 0) {
+    const hit = _captureCache.get(sessionName)
+    if (hit && Date.now() - hit.at < CAPTURE_TTL_MS) return hit.value
+  }
   try {
     const { stdout } = await execFileP(tmuxBin, [
       "capture-pane",
@@ -77,7 +114,11 @@ export async function capturePane(sessionName, opts = {}) {
       "-E",
       "-",
     ])
-    return stripAnsi(stdout)
+    const value = stripAnsi(stdout)
+    if (!opts.noCache && CAPTURE_TTL_MS > 0) {
+      _captureCache.set(sessionName, { at: Date.now(), value })
+    }
+    return value
   } catch {
     return ""
   }
@@ -89,6 +130,12 @@ export async function capturePane(sessionName, opts = {}) {
  */
 export async function getSessionCwd(sessionName, opts = {}) {
   const tmuxBin = opts.tmuxBin || "tmux"
+  // P1: cwd は変化が稀なので長期キャッシュ。state loop の毎 tick spawn を排除する。
+  // opts.noCache か TTL=0 でバイパス可能。cwd 変化検知は CWD_TTL_MS 経過後の再取得で吸収。
+  if (!opts.noCache && CWD_TTL_MS > 0) {
+    const hit = _cwdCache.get(sessionName)
+    if (hit && Date.now() - hit.at < CWD_TTL_MS) return hit.value
+  }
   try {
     const { stdout } = await execFileP(tmuxBin, [
       "display-message",
@@ -99,7 +146,11 @@ export async function getSessionCwd(sessionName, opts = {}) {
       "#{pane_current_path}",
     ])
     const s = stdout.trim()
-    return s || null
+    const value = s || null
+    if (!opts.noCache && CWD_TTL_MS > 0) {
+      _cwdCache.set(sessionName, { at: Date.now(), value })
+    }
+    return value
   } catch {
     return null
   }

package/src/tmux.mjs

@@ -20,7 +20,7 @@ import path from "node:path"
 import { promisify } from "node:util"
 
 import { ensureClaudeMd } from "./claude-md.mjs"
-import { detectSessionState } from "./state.mjs"
+import { detectSessionState, getSessionCwd } from "./state.mjs"
 import { getSessionUsages } from "./usage.mjs"
 
 const execFileP = promisify(execFile)
@@ -356,22 +356,9 @@ export async function execTmux(args, opts = {}) {
   }
 }
 
-async function getSessionCwd(name, opts = {}) {
-  try {
-    const { stdout } = await execFileP(tmuxBin(opts), [
-      "display-message",
-      "-p",
-      "-t",
-      `${name}:`,
-      "-F",
-      "#{pane_current_path}",
-    ])
-    const s = stdout.trim()
-    return s || null
-  } catch {
-    return null
-  }
-}
+// P1 (重複排除): cwd 取得は state.mjs の getSessionCwd (キャッシュ付き) を共用する。
+// 旧 tmux.mjs 私有実装は display-message を毎回 spawn しており、state loop の
+// listSessionStates と list_sessions が別キャッシュ無しで二重 fork していた。
 
 const TMUX_LIST_FIELDS = [
   "#{session_name}",

package/src/usage.mjs

@@ -17,6 +17,7 @@
  * 仕様書: ナレッジ/インフラ/cockpit-hub-hosted-integration-spec (id=6080)
  */
 import { promises as fs } from "node:fs"
+import { randomUUID } from "node:crypto"
 import os from "node:os"
 import path from "node:path"
 
@@ -107,6 +108,49 @@ async function readOrNull(p) {
   }
 }
 
+/**
+ * P5(perf): ファイル末尾だけを読む (tail)。jsonl の末尾 assistant.usage 1 件だけが
+ * 欲しい latestJsonlContext 用。全文 readFile + split を避けて巨大 jsonl の再パース
+ * コストを削る。末尾 maxBytes を読み、最初の改行以降 (= 完全な行のみ) を返す。
+ * size <= maxBytes ならファイル全体を返す。失敗時は null。
+ */
+async function readTail(fp, maxBytes = 64 * 1024) {
+  let fh
+  try {
+    fh = await fs.open(fp, "r")
+    const st = await fh.stat()
+    const size = st.size
+    if (size === 0) return ""
+    const start = size > maxBytes ? size - maxBytes : 0
+    const len = size - start
+    const buf = Buffer.allocUnsafe(len)
+    await fh.read(buf, 0, len, start)
+    let text = buf.toString("utf-8")
+    // 途中から読んだ場合、先頭の不完全な行を捨てる (最初の改行まで)。
+    if (start > 0) {
+      const nl = text.indexOf("\n")
+      text = nl >= 0 ? text.slice(nl + 1) : text
+    }
+    return text
+  } catch {
+    return null
+  } finally {
+    try {
+      await fh?.close()
+    } catch {
+      /* ignore */
+    }
+  }
+}
+
+/** P5(perf): latestJsonlContext の結果を {mtimeMs,size} キーでメモ化し再パースを避ける。 */
+const _jsonlCtxMemo = new Map() // fp → { mtimeMs, size, result }
+
+/** P5(perf): readEstimate の per-file パース結果 (assistant.usage の {ts,tok} 配列) を
+ *  {mtimeMs,size} キーでメモ化する。時間窓 (5h/7d) への振り分けは呼び出し毎に now で
+ *  再計算するが、jsonl 全文の再パースは mtime 不変なら省ける (集計の重い部分はパース)。 */
+const _estimateFileMemo = new Map() // fp → { mtimeMs, size, records: [{ts,tok}] }
+
 // ---------------------------------------------------------------------------
 // チャット(SDK) の rate_limit_event から取得した最新 rate-limit (プロセス内共有)。
 // statusLine cache はターミナルでしか更新されないため、チャットモードでは
@@ -171,7 +215,9 @@ async function persistChatRateLimitsToCache() {
   } catch {
     /* ignore */
   }
-  const tmp = `${p}.tmp.${process.pid}`
+  // P5(bug): tmp 名を randomUUID でユニーク化する。pid 固定 (`${p}.tmp.${pid}`) だと
+  // 同一プロセス内で複数の persist が並行すると互いの tmp を上書き/unlink して破壊し合う。
+  const tmp = `${p}.tmp.${randomUUID()}`
   try {
     await fs.writeFile(tmp, JSON.stringify(base))
     await fs.rename(tmp, p)
@@ -205,8 +251,15 @@ export function recordChatRateLimit(info) {
   chatRateLimits[slot] = { percent, resetAtMs }
   chatRateLimits.updatedAtMs = Date.now()
   // webapp フッター (ファイルベース readOfficial) 用に latest.json へ書き戻す。
-  // fire-and-forget だが in-flight promise は保持 (flush 可能にする)。
-  _persistInFlight = persistChatRateLimitsToCache()
+  // P5(bug): 前の _persistInFlight を待ってから次を実行し write を直列化する。
+  // 直列化しないと複数の persist が同一 latest.json に read→write→rename を並行実行し、
+  // 後勝ちで中間状態を読んだり tmp を破壊し合う。chatRateLimits は最新値を共有参照する
+  // ので、待ち合わせ後に走る persist は常に最新スナップショットを書く (取りこぼし無し)。
+  // 失敗は persistChatRateLimitsToCache 内で握りつぶすので chain は切れない。
+  _persistInFlight = _persistInFlight.then(
+    () => persistChatRateLimitsToCache(),
+    () => persistChatRateLimitsToCache(),
+  )
 }
 
 /**
@@ -279,6 +332,38 @@ async function readEstimate(now) {
   let oldest5h = null
   let oldest7d = null
 
+  // P5(perf): per-file の assistant.usage レコード ({ts,tok}) を mtime+size でメモ化し、
+  // jsonl 全文の再パース (重い) を省く。時間窓への振り分けだけ now で都度再計算する。
+  const perFileRecords = async (fp, st) => {
+    const memo = _estimateFileMemo.get(fp)
+    if (memo && memo.mtimeMs === st.mtimeMs && memo.size === st.size) {
+      return memo.records
+    }
+    const text = await readOrNull(fp)
+    const records = []
+    if (text) {
+      for (const line of text.split("\n")) {
+        if (!line || line.length < 50) continue
+        if (!line.includes('"usage"')) continue
+        let d
+        try {
+          d = JSON.parse(line)
+        } catch {
+          continue
+        }
+        if (d.type !== "assistant") continue
+        const ts = d.timestamp ? Date.parse(d.timestamp) : 0
+        if (!ts) continue
+        const u = d.message?.usage
+        if (!u) continue
+        const tok = (u.output_tokens || 0) + (u.input_tokens || 0)
+        records.push({ ts, tok })
+      }
+    }
+    _estimateFileMemo.set(fp, { mtimeMs: st.mtimeMs, size: st.size, records })
+    return records
+  }
+
   await Promise.all(
     projects.map(async (p) => {
       const dir = path.join(projectsDir(), p)
@@ -286,29 +371,16 @@ async function readEstimate(now) {
       for (const f of files) {
         if (!f.endsWith(".jsonl")) continue
         const fp = path.join(dir, f)
+        let st
         try {
-          const st = await fs.stat(fp)
+          st = await fs.stat(fp)
           if (st.mtimeMs < t7d) continue
         } catch {
           continue
         }
-        const text = await readOrNull(fp)
-        if (!text) continue
-        for (const line of text.split("\n")) {
-          if (!line || line.length < 50) continue
-          if (!line.includes('"usage"')) continue
-          let d
-          try {
-            d = JSON.parse(line)
-          } catch {
-            continue
-          }
-          if (d.type !== "assistant") continue
-          const ts = d.timestamp ? Date.parse(d.timestamp) : 0
-          if (!ts || ts < t7d) continue
-          const u = d.message?.usage
-          if (!u) continue
-          const tok = (u.output_tokens || 0) + (u.input_tokens || 0)
+        const records = await perFileRecords(fp, st)
+        for (const { ts, tok } of records) {
+          if (ts < t7d) continue
           tokens7d += tok
           msgs7d += 1
           if (oldest7d === null || ts < oldest7d) oldest7d = ts
@@ -390,7 +462,7 @@ async function latestJsonlContext(now) {
   const projects = await fs.readdir(projectsDir()).catch(() => null)
   if (!projects) return null
   const recent = now - CONTEXT_JSONL_RECENT_MS
-  let best = null // { mtimeMs, fp }
+  let best = null // { mtimeMs, size, fp }
   await Promise.all(
     projects.map(async (p) => {
       const dir = path.join(projectsDir(), p)
@@ -401,7 +473,9 @@ async function latestJsonlContext(now) {
         try {
           const st = await fs.stat(fp)
           if (st.mtimeMs < recent) continue
-          if (!best || st.mtimeMs > best.mtimeMs) best = { mtimeMs: st.mtimeMs, fp }
+          if (!best || st.mtimeMs > best.mtimeMs) {
+            best = { mtimeMs: st.mtimeMs, size: st.size, fp }
+          }
         } catch {
           /* ignore */
         }
@@ -409,33 +483,50 @@ async function latestJsonlContext(now) {
     }),
   )
   if (!best) return null
+  // P5(perf): mtime+size が前回と同じなら再パースせずメモ結果を返す。
+  const memo = _jsonlCtxMemo.get(best.fp)
+  if (memo && memo.mtimeMs === best.mtimeMs && memo.size === best.size) {
+    return memo.result
+  }
   const windowSize = await contextWindowSize()
-  const text = await readOrNull(best.fp)
-  if (!text) return null
-  const lines = text.split("\n")
-  // 末尾から最初に見つかった assistant.usage を採用 (= 現在の文脈サイズ)
-  for (let i = lines.length - 1; i >= 0; i--) {
-    const line = lines[i]
-    if (!line || !line.includes('"usage"')) continue
-    let d
-    try {
-      d = JSON.parse(line)
-    } catch {
-      continue
+  // 末尾から最初に見つかった assistant.usage を tokens に変換する。見つからなければ null。
+  const scan = (text) => {
+    const lines = text.split("\n")
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const line = lines[i]
+      if (!line || !line.includes('"usage"')) continue
+      let d
+      try {
+        d = JSON.parse(line)
+      } catch {
+        continue
+      }
+      if (d.type !== "assistant") continue
+      const u = d.message?.usage
+      if (!u) continue
+      const tokens =
+        (u.input_tokens || 0) +
+        (u.cache_read_input_tokens || 0) +
+        (u.cache_creation_input_tokens || 0) +
+        (u.output_tokens || 0)
+      if (tokens <= 0) continue
+      return Math.min(100, Math.round((tokens / windowSize) * 1000) / 10)
     }
-    if (d.type !== "assistant") continue
-    const u = d.message?.usage
-    if (!u) continue
-    const tokens =
-      (u.input_tokens || 0) +
-      (u.cache_read_input_tokens || 0) +
-      (u.cache_creation_input_tokens || 0) +
-      (u.output_tokens || 0)
-    if (tokens <= 0) continue
-    const percent = Math.min(100, Math.round((tokens / windowSize) * 1000) / 10)
-    return { percent, mtimeMs: best.mtimeMs }
+    return null
   }
-  return null
+  // P5(perf): 末尾 assistant.usage 1 件だけ欲しいので tail 読みで全文 split を避ける。
+  // tail 内に見つからなかった稀なケースのみ全文 read にフォールバックする。
+  let percent = null
+  const tail = await readTail(best.fp)
+  if (tail != null) percent = scan(tail)
+  if (percent === null) {
+    const full = await readOrNull(best.fp)
+    if (full != null) percent = scan(full)
+  }
+  const result = percent === null ? null : { percent, mtimeMs: best.mtimeMs }
+  // mtime+size をキーにメモ化 (null 結果もキャッシュして再 tail/full read を避ける)。
+  _jsonlCtxMemo.set(best.fp, { mtimeMs: best.mtimeMs, size: best.size, result })
+  return result
 }
 
 /**

package/src/ws-client.mjs

@@ -202,21 +202,29 @@ export class WsClient extends EventEmitter {
   _flushPtyBuffer() {
     if (this.ptyOutboundBuffer.length === 0) return
     const now = Date.now()
+    // B10: バッファを退避してから処理する。送信失敗 (_sendJson が false) で break
+    // した場合、未送信の残りフレームを ptyOutboundBuffer の先頭へ戻して順序を保持する
+    // (空配列で上書きしたまま break すると残りが欠落する)。
     const buf = this.ptyOutboundBuffer
     this.ptyOutboundBuffer = []
     let sent = 0
     let expired = 0
-    for (const entry of buf) {
+    for (let i = 0; i < buf.length; i++) {
+      const entry = buf[i]
       if (now - entry.ts > PTY_BUFFER_MAX_AGE_MS) {
         expired += 1
         continue
       }
       const ok = this._sendJson(entry.obj)
-      if (!ok) break
+      if (!ok) {
+        // 未送信分 (現エントリ含む i 以降) を先頭へ戻す。次回 open / flush で再送する。
+        this.ptyOutboundBuffer = buf.slice(i).concat(this.ptyOutboundBuffer)
+        break
+      }
       sent += 1
     }
     this.logger?.info(
-      { sent, expired, total: buf.length },
+      { sent, expired, total: buf.length, requeued: this.ptyOutboundBuffer.length },
       "pty outbound buffer flushed"
     )
   }