@cocorograph/hub-agent 0.8.42 → 0.8.44

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocorograph/hub-agent",
-  "version": "0.8.42",
+  "version": "0.8.44",
   "description": "Hub Hosted Cockpit のローカル常駐 agent。Hub と outbound WSS で接続し、ローカルの Claude / Codex チャットと tmux セッションを中継する。",
   "type": "module",
   "license": "UNLICENSED",

package/src/claude-stream-bridge.mjs

@@ -439,6 +439,7 @@ export class ClaudeStreamSession {
     onPermissionCancel,
     onExit,
     onError,
+    onOptions,
     onReap,
     onTurnSettled,
   }) {
@@ -481,6 +482,7 @@ export class ClaudeStreamSession {
     this.onPermissionCancel = onPermissionCancel
     this.onExit = onExit
     this.onError = onError
+    this.onOptions = onOptions
     /** ターン完走後に遅延クローズする際、manager にセッション撤去を依頼するコールバック */
     this.onReap = onReap
     /** RC-4: result を届けずにターンが終わった (abort/異常終了) ときに呼ぶコールバック。
@@ -551,6 +553,11 @@ export class ClaudeStreamSession {
     /** この session オブジェクトの世代 (T06603)。上記 nextQueueGeneration の説明を参照。
      *  **同一プロセス内の順序のみ**を保証する (プロセス間は backend の接続フェンスが担う)。 */
     this._queueGeneration = nextQueueGeneration()
+    /** model / permissionMode の「次ターン desired」authority identity。
+     * UUID は同一 session object の一致確認だけに使い、大小・生成順は比較しない。 */
+    this._optionsInstanceId = randomUUID()
+    /** 上記instance内だけで比較するCAS revision。queue seq/generationとは独立。 */
+    this._optionsRevision = 0
     /** 配達確認の再表明用 (T06603): この session が受理 (キュー投入 or 直接配送) した
      *  input_id の直近リング。`claude.input.ack` は一度きりのユニキャストで、WS 切断が
      *  30s を超えると ws-client の ctrl バッファから破棄され二度と再送されない。その結果
@@ -988,12 +995,9 @@ export class ClaudeStreamSession {
    *  browser 接続へライブに流れる (= 通常の生成中表示と同じ)。再アタッチ前の確定分は
    *  browser 側の jsonl hydrate (history.request) で復元するため、ここでは replay しない。
    *
-   *  改修5 (2026-05-29): モデル/権限/拡張思考のターン切替。再アタッチ時に opts で
-   *  新しい値が渡され、現在値と異なれば applyRuntimeOptions で反映する。これにより
-   *  入力欄下バッジの変更が「同一セッション(常駐 query)を維持したまま次ターンから」
-   *  効くようになる。従来は reattach が stream_id だけ差し替えていたため、起動済み
-   *  query の model/permission/thinking は初期値のまま変わらなかった (バッジが効かない
-   *  不具合の原因)。 */
+   *  通常 attach は購読 + current snapshot 取得専用。model / permissionMode は CAS request
+   *  (`claude.session.options.set`) だけが変更できる。maxThinkingTokens / effort は今回の
+   *  authority 対象外なので、既存 attach 反映を維持する。 */
   reattach(stream_id, opts = undefined) {
     this.stream_id = stream_id
     // 多端末共有: この端末を購読集合に追加 (無効時は未使用)。旧端末の stream_id は
@@ -1005,7 +1009,12 @@ export class ClaudeStreamSession {
       clearTimeout(this._idleTimer)
       this._idleTimer = null
     }
-    if (opts) this.applyRuntimeOptions(opts)
+    if (opts) {
+      this.applyRuntimeOptions({
+        maxThinkingTokens: opts.maxThinkingTokens,
+        effort: opts.effort,
+      })
+    }
     // キュー再表示バグ修正 (0.6.30): 再アタッチした端末は queue_state のライブ配信を
     // 取りこぼしている (jsonl hydrate にはキュー状態が含まれない)。現在の pending を
     // force で再 emit し、再表示端末・後から接続した端末の送信待ちチップを復元する。
@@ -1064,11 +1073,13 @@ export class ClaudeStreamSession {
    *  maxThinkingTokens に 0/null が来たら次 spawn 時に budget オフ (thinking 未指定) となる。 */
   applyRuntimeOptions({ model, permissionMode, maxThinkingTokens, effort } = {}) {
     const q = this._residentQuery
+    let desiredOptionsChanged = false
     // モデル
     if (model !== undefined) {
       const next = model || null
       if (next !== this.model) {
         this.model = next
+        desiredOptionsChanged = true
         if (q && typeof q.setModel === "function") {
           q.setModel(next || undefined).catch((err) =>
             this.logger?.warn(
@@ -1084,6 +1095,7 @@ export class ClaudeStreamSession {
       const next = permissionMode || null
       if (next !== this.permissionMode) {
         this.permissionMode = next
+        desiredOptionsChanged = true
         // setPermissionMode は有効な mode を要求する。null/空 (=未指定へ戻す) は
         // SDK 側に「解除」API が無いため、保持値の更新のみ (次回 spawn で既定に従う)。
         if (next && q && typeof q.setPermissionMode === "function") {
@@ -1116,6 +1128,84 @@ export class ClaudeStreamSession {
     if (effort !== undefined) {
       this.effort = effort || null
     }
+    if (desiredOptionsChanged) {
+      this._optionsRevision += 1
+      try {
+        this.onOptions?.(this.optionsSnapshot())
+      } catch (err) {
+        this.logger?.warn?.(
+          { err: err?.message, stream_id: this.stream_id },
+          "onOptions callback threw",
+        )
+      }
+    }
+  }
+
+  /** Exact-base CAS で model / permissionMode の次ターン desired を変更する。 */
+  setSessionOptions({ baseOptionsInstanceId, baseOptionsRevision, patch }) {
+    const current = () => this.optionsSnapshot()
+    const hasModel = patch && Object.hasOwn(patch, "model")
+    const hasPermissionMode =
+      patch && Object.hasOwn(patch, "permission_mode")
+    if (
+      !patch ||
+      typeof patch !== "object" ||
+      Array.isArray(patch) ||
+      Object.keys(patch).length === 0 ||
+      Object.keys(patch).some(
+        (key) => key !== "model" && key !== "permission_mode",
+      ) ||
+      !(hasModel || hasPermissionMode) ||
+      (hasModel &&
+        !(patch.model === null || typeof patch.model === "string")) ||
+      (hasPermissionMode &&
+        !(
+          patch.permission_mode === null ||
+          typeof patch.permission_mode === "string"
+        ))
+    ) {
+      return { outcome: "invalid_patch", current: current() }
+    }
+    if (
+      baseOptionsInstanceId !== this._optionsInstanceId ||
+      !Number.isSafeInteger(baseOptionsRevision) ||
+      baseOptionsRevision !== this._optionsRevision
+    ) {
+      return { outcome: "conflict", current: current() }
+    }
+
+    // attach/configと同じく空文字はdefault(null)。比較前に正規化してnull状態のnoopを保つ。
+    const normalizedPatch = {
+      ...(hasModel ? { model: patch.model || null } : {}),
+      ...(hasPermissionMode
+        ? { permission_mode: patch.permission_mode || null }
+        : {}),
+    }
+    const nextModel = hasModel ? normalizedPatch.model : this.model
+    const nextPermissionMode =
+      hasPermissionMode
+        ? normalizedPatch.permission_mode
+        : this.permissionMode
+    if (nextModel === this.model && nextPermissionMode === this.permissionMode) {
+      return { outcome: "noop", current: current() }
+    }
+    this.applyRuntimeOptions({
+      ...(hasModel ? { model: normalizedPatch.model } : {}),
+      ...(hasPermissionMode
+        ? { permissionMode: normalizedPatch.permission_mode }
+        : {}),
+    })
+    return { outcome: "applied", current: current() }
+  }
+
+  /** 次ターンに使う desired options。SDK setter の成功実測値ではない。 */
+  optionsSnapshot() {
+    return {
+      model: this.model,
+      permission_mode: this.permissionMode,
+      options_instance_id: this._optionsInstanceId,
+      options_revision: this._optionsRevision,
+    }
   }
 
   /** モデルが effort / adaptive thinking 対応かどうか。
@@ -2534,12 +2624,10 @@ export class ClaudeStreamBridge extends EventEmitter {
         // 多端末共有 (T06542 で常時): 旧 stream_id を Map から消さない。同一セッションを複数端末が
         // 購読する状態を作り、どの端末の input/permission/interrupt も解決できるようにする
         // (旧端末は reattach.streamIds に足され、backend が session group へ fan-out する)。
-        // 改修5: 再アタッチ時に model/permission/maxThinkingTokens を引き継ぎ反映する。
-        // browser はバッジ変更時に新しい値を載せた claude.attach を同一 resume で送る
-        // ため、ここで適用すると常駐 query を維持したまま次ターンから切り替わる。
+        // 通常 attach は購読 + current snapshot 取得だけ。旧 frontend は capability flag を
+        // 送らず model/permission を載せるが、新 agent は live session では fail-closed で無視する。
+        // maxThinkingTokens / effort は model/permission authority の対象外なので既存反映を維持。
         live.reattach(stream_id, {
-          model,
-          permissionMode,
           maxThinkingTokens:
             typeof maxThinkingTokens === "number" ? maxThinkingTokens : null,
           effort,
@@ -2562,6 +2650,7 @@ export class ClaudeStreamBridge extends EventEmitter {
           resuming: true,
           reattached: true,
           turn_active: live._busy === true,
+          ...live.optionsSnapshot(),
         }
       }
     }
@@ -2635,6 +2724,14 @@ export class ClaudeStreamBridge extends EventEmitter {
           error: err?.message || String(err),
         })
       },
+      onOptions: (snapshot) => {
+        // bridge 内部イベントは wire type を持たない。wire 契約は main builder に閉じる。
+        this.emit("sessionoptions", {
+          stream_id: session.stream_id,
+          session_id: session.sessionId,
+          ...snapshot,
+        })
+      },
       onReap: (info) => {
         // ターン完走後の遅延クローズ、または R1(a) 子プロセス死亡時の即 evict。Map / 索引から
         // 撤去し exit を emit する。多端末共有では複数端末キーが Map に載っているのでまとめて外す。
@@ -2680,9 +2777,39 @@ export class ClaudeStreamBridge extends EventEmitter {
       stream_id,
       resuming: !!resumeSessionId,
       turn_active: session._busy === true,
+      ...session.optionsSnapshot(),
     }
   }
 
+  /** browser の session options CAS request。常に current snapshot 付き outcome を返す。 */
+  setSessionOptions({
+    stream_id,
+    session_id,
+    base_options_instance_id,
+    base_options_revision,
+    patch,
+  }) {
+    const session = this.sessions.get(stream_id)
+    if (!session) {
+      return { outcome: "stream_missing", current: null }
+    }
+    // CAS操作もpermission reply/inputと同じユーザー活性。dead-terminal GCとwarm LRUを更新する。
+    session.touch(stream_id)
+    // fresh は SDK init 前だけ sessionId=null。同じ stream なら CAS 可能だが、session group の
+    // identity がまだ無いため他端末はこの fresh session を購読できない。
+    if (session.sessionId !== session_id) {
+      return {
+        outcome: "session_mismatch",
+        current: session.optionsSnapshot(),
+      }
+    }
+    return session.setSessionOptions({
+      baseOptionsInstanceId: base_options_instance_id,
+      baseOptionsRevision: base_options_revision,
+      patch,
+    })
+  }
+
   /**
    * browser → claude の user メッセージ。1 件 = 1 query (resume チェーン)。
    *

package/src/main.mjs

@@ -978,6 +978,9 @@ export async function startDaemon({ version, claudeSdk } = {}) {
     claudeBridge.on("exit", ({ stream_id, code, reason, session_id }) => {
       client.send({ type: "claude.exit", stream_id, code, reason, session_id })
     })
+    claudeBridge.on("sessionoptions", (message) => {
+      client.send(buildClaudeSessionOptionsPayload(message))
+    })
     claudeBridge.on("turnsettled", ({ cwd }) => {
       // RC-4: result を届けずにターンが終わった (abort/異常終了)。チャット信号の
       // status=processing を waiting に落として三点リーダー/ステータスドットの固着を防ぐ
@@ -2052,6 +2055,58 @@ export function buildCodexChatPatch(status, contextPct, threadId, isAuthority) {
   return patch
 }
 
+/** 次ターンに使う desired options。現在ターンの setter 成功を観測した値ではない。 */
+function desiredOptionsWire(snapshot) {
+  // stream_missing はcurrent不明。null(default)と偽装せずoptions fields自体を省く。
+  if (!snapshot) return {}
+  return {
+    model: snapshot?.model ?? null,
+    permission_mode: snapshot?.permission_mode ?? null,
+    options_instance_id: snapshot?.options_instance_id,
+    options_revision: snapshot?.options_revision,
+  }
+}
+
+/** claude.ready の wire payload。bridge attach info の options snapshot を透過する。 */
+export function buildClaudeReadyPayload(streamId, info) {
+  return {
+    type: "claude.ready",
+    stream_id: streamId,
+    resuming: info?.resuming === true,
+    ...desiredOptionsWire(info),
+    turn_active: info?.turn_active === true,
+    history_pushed: info?.resuming === true,
+    supports_queue_input_id: true,
+    supports_queue_snapshot: true,
+    supports_session_options_cas: true,
+  }
+}
+
+/** bridge internal options event → session fanout wire。 */
+export function buildClaudeSessionOptionsPayload(message) {
+  return {
+    type: "claude.session.options",
+    stream_id: message.stream_id,
+    session_id: message.session_id ?? null,
+    ...desiredOptionsWire(message),
+  }
+}
+
+/** options CAS result は要求元 stream だけへ返す。 */
+export function buildClaudeSessionOptionsResultPayload(
+  streamId,
+  requestId,
+  result,
+) {
+  return {
+    type: "claude.session.options.result",
+    stream_id: streamId,
+    request_id: requestId,
+    outcome: result.outcome,
+    ...desiredOptionsWire(result.current),
+  }
+}
+
 /** codex.ready の wire payload を組み立てる。history は同じ配列参照を保持し、
  * started_history_index が指す位置を main 側の加工でずらさない。表示を保持する reconnect
  * (`info.subagents` 未定義) では subagents キー自体を省略し、空 snapshot で既存表示を消さない。 */
@@ -3768,34 +3823,14 @@ async function dispatch(msg, ctx) {
             effort: msg.effort || ctx.config?.claude_effort || null,
             resumeSessionId,
           })
-          ctx.client.send({
-            type: "claude.ready",
-            stream_id,
-            resuming: info.resuming,
-            // 再接続時の生成状態は resident session を保持する hub-agent が正本。
-            // jsonl 履歴末尾の推測だけでは「実際は busy なのに UI は idle」となり、
-            // 送信ボタンが楽観バブルを作る一方 agent はキューへ積む二重表示が起きる。
-            turn_active: info.turn_active === true,
-            history_pushed: resumeSessionId !== null,
-            // id 空間統一 (2026-07-08): この agent は browser の input_id をキュー id として
-            // 採用し、楽観送信待ちアイテムの確認前キャンセルに対応することを通知する capability。
-            // 旧 agent にはこのフラグが無く、browser は楽観アイテムの×を出さない (ゴースト
-            // 実行防止のフォールバック)。
-            supports_queue_input_id: true,
-            // pull 型再同期 capability (T06603, 2026-07-25): この agent は
-            // claude.queue.request に claude.queue.response で答え、queue_state に
-            // 版番号 (seq) と受理済み input_id (accepted) を載せることを通知する。
-            // 旧 agent はこのフラグが無く、browser は従来の「配信到達に依存する」
-            // 挙動へフォールバックする (混在期間も安全に段階デプロイできる)。
-            supports_queue_snapshot: true,
-          })
+          ctx.client.send(buildClaudeReadyPayload(stream_id, info))
           if (resumeSessionId) {
             void ctx.siblingInjectBridge
-              ?.replayActiveDelegations(cwdArg || process.env.HOME || process.cwd(), resumeSessionId)
+              ?.replayDelegations(cwdArg || process.env.HOME || process.cwd(), resumeSessionId)
               .catch((err) => {
                 ctx.logger?.warn?.(
                   { err: err?.message || String(err), stream_id, session_id: resumeSessionId },
-                  "failed to replay active delegations after Claude attach",
+                  "failed to replay delegations after Claude attach",
                 )
               })
           }
@@ -3874,6 +3909,23 @@ async function dispatch(msg, ctx) {
         }
         return
       }
+      case "claude.session.options.set": {
+        const result = ctx.claudeBridge?.setSessionOptions({
+          stream_id: msg.stream_id,
+          session_id: msg.session_id ?? null,
+          base_options_instance_id: msg.base_options_instance_id,
+          base_options_revision: msg.base_options_revision,
+          patch: msg.patch,
+        }) || { outcome: "stream_missing", current: null }
+        ctx.client.send(
+          buildClaudeSessionOptionsResultPayload(
+            msg.stream_id,
+            msg.request_id,
+            result,
+          ),
+        )
+        return
+      }
       case "claude.input":
         // message: { role: 'user', content: string | Array } を期待
         handleClaudeChatInput(msg, ctx)

package/src/sibling-inject.mjs

@@ -75,20 +75,68 @@ export const ACTIVE_DELEGATIONS_PER_SESSION_LIMIT = 100
 export const DELEGATION_LEDGER_RETENTION_MS = 24 * 60 * 60 * 1000
 const SIBLING_REQUEST_MAX_BYTES = 1024 * 1024
 const DELEGATE_PROMPT_MAX_LENGTH = 64_000
+const TERMINAL_DELEGATE_PROMPT_MAX_LENGTH = 2_000
+const TERMINAL_DELEGATE_AGENT_MAX_LENGTH = 200
+const TERMINAL_DELEGATE_DESCRIPTION_MAX_LENGTH = 2_000
+const DELEGATION_ID_MAX_LENGTH = 200
 
 const execFile = promisify(execFileCallback)
 
-function truncateDelegatePrompt(prompt) {
-  if (prompt.length <= DELEGATE_PROMPT_MAX_LENGTH) return prompt
-  let end = DELEGATE_PROMPT_MAX_LENGTH
-  const lastCodeUnit = prompt.charCodeAt(end - 1)
+function truncateString(value, maxLength, truncationNote) {
+  if (value.length <= maxLength) return value
+  let end = maxLength
+  const lastCodeUnit = value.charCodeAt(end - 1)
   if (lastCodeUnit >= 0xd800 && lastCodeUnit <= 0xdbff) end -= 1
-  return (
-    prompt.slice(0, end) +
-    `\n\n[依頼本文はここで打ち切られています（全 ${prompt.length} 文字）]`
+  return value.slice(0, end) + truncationNote(value.length)
+}
+
+function truncateDelegatePrompt(prompt) {
+  return truncateString(
+    prompt,
+    DELEGATE_PROMPT_MAX_LENGTH,
+    (length) => `\n\n[依頼本文はここで打ち切られています（全 ${length} 文字）]`,
   )
 }
 
+function compactTerminalEvent(event, includePrompt = false) {
+  const storedEvent = {}
+  for (const field of [
+    "type",
+    "subtype",
+    "delegation_id",
+    "phase",
+    "background",
+    "timestamp",
+  ]) {
+    if (event[field] !== undefined) storedEvent[field] = event[field]
+  }
+
+  if (typeof event.agent === "string") {
+    storedEvent.agent = truncateString(
+      event.agent,
+      TERMINAL_DELEGATE_AGENT_MAX_LENGTH,
+      (length) => `\n\n[エージェント名はここで打ち切られています（全 ${length} 文字）]`,
+    )
+  }
+  if (typeof event.description === "string") {
+    storedEvent.description = truncateString(
+      event.description,
+      TERMINAL_DELEGATE_DESCRIPTION_MAX_LENGTH,
+      (length) => `\n\n[説明はここで打ち切られています（全 ${length} 文字）]`,
+    )
+  }
+  if (includePrompt && typeof event.prompt === "string") {
+    storedEvent.prompt = truncateString(
+      event.prompt,
+      TERMINAL_DELEGATE_PROMPT_MAX_LENGTH,
+      (length) =>
+        `\n\n[終了済み委譲の依頼本文はここで打ち切られています（全 ${length} 文字）]`,
+    )
+  }
+
+  return storedEvent
+}
+
 /**
  * `ps` の起動時刻を送受信双方で比較する契約形へ正規化する。
  * 先頭・末尾の Unicode 空白だけを除去し、日時本体の内部空白は変更しない。
@@ -312,7 +360,7 @@ export class SiblingInjectBridge {
     this._pidStartedAt = pidStartedAt
     /** @type {Map<string, Map<string, {event: object, recordedAt: number}>>} cwd+session ごとの進行中委譲。 */
     this._activeDelegations = new Map()
-    /** @type {Map<string, Map<string, number>>} 終端→開始の逆転で遅着 started を復活させない墓標。 */
+    /** @type {Map<string, Map<string, {startedEvent?: object, terminalEvent: object, startedAt?: number, recordedAt: number}>>} 終了済み委譲の再送情報を兼ねた墓標。 */
     this._terminalDelegations = new Map()
   }
 
@@ -329,8 +377,8 @@ export class SiblingInjectBridge {
       if (entries.size === 0) this._activeDelegations.delete(sessionKey)
     }
     for (const [sessionKey, entries] of this._terminalDelegations) {
-      for (const [delegationId, recordedAt] of entries) {
-        if (recordedAt < cutoff) entries.delete(delegationId)
+      for (const [delegationId, entry] of entries) {
+        if (entry.recordedAt < cutoff) entries.delete(delegationId)
       }
       if (entries.size === 0) this._terminalDelegations.delete(sessionKey)
     }
@@ -340,6 +388,10 @@ export class SiblingInjectBridge {
     this._pruneDelegations()
     const sessionKey = this._delegationSessionKey(cwd, sessionId)
     if (event.phase !== "started") {
+      const activeEntry = this._activeDelegations.get(sessionKey)?.get(event.delegation_id)
+      const existingTerminalEntry = this._terminalDelegations
+        .get(sessionKey)
+        ?.get(event.delegation_id)
       this._activeDelegations.get(sessionKey)?.delete(event.delegation_id)
       if (this._activeDelegations.get(sessionKey)?.size === 0) {
         this._activeDelegations.delete(sessionKey)
@@ -350,7 +402,21 @@ export class SiblingInjectBridge {
         this._terminalDelegations.set(sessionKey, terminalEntries)
       }
       terminalEntries.delete(event.delegation_id)
-      terminalEntries.set(event.delegation_id, this._now())
+      terminalEntries.set(event.delegation_id, {
+        ...(activeEntry
+          ? {
+              startedEvent: compactTerminalEvent(activeEntry.event, true),
+              startedAt: activeEntry.recordedAt,
+            }
+          : existingTerminalEntry?.startedEvent && existingTerminalEntry.startedAt !== undefined
+            ? {
+                startedEvent: existingTerminalEntry.startedEvent,
+                startedAt: existingTerminalEntry.startedAt,
+              }
+            : {}),
+        terminalEvent: compactTerminalEvent(event),
+        recordedAt: this._now(),
+      })
       while (terminalEntries.size > ACTIVE_DELEGATIONS_PER_SESSION_LIMIT) {
         terminalEntries.delete(terminalEntries.keys().next().value)
       }
@@ -394,14 +460,35 @@ export class SiblingInjectBridge {
     }
   }
 
-  /** attach/再接続時に同じ cwd+session の進行中委譲だけを再送する。 */
-  async replayActiveDelegations(cwd, sessionId) {
+  /** attach/再接続時に同じ cwd+session の進行中・終了済み委譲を開始順で再送する。 */
+  async replayDelegations(cwd, sessionId) {
     if (!cwd || !sessionId) return
     this._pruneDelegations()
     const sessionKey = this._delegationSessionKey(cwd, sessionId)
-    const entries = this._activeDelegations.get(sessionKey)
-    if (!entries) return
-    for (const [delegationId, entry] of [...entries]) {
+    const replayEntries = [
+      ...[...(this._activeDelegations.get(sessionKey) || [])].map(([delegationId, entry]) => ({
+        delegationId,
+        entry,
+        kind: "active",
+        startedAt: entry.recordedAt,
+      })),
+      ...[...(this._terminalDelegations.get(sessionKey) || [])]
+        .filter(([, entry]) => entry.startedEvent && entry.startedAt !== undefined)
+        .map(([delegationId, entry]) => ({
+          delegationId,
+          entry,
+          kind: "terminal",
+          startedAt: entry.startedAt,
+        })),
+    ].sort((a, b) => a.startedAt - b.startedAt)
+
+    for (const { delegationId, entry, kind } of replayEntries) {
+      if (kind === "terminal") {
+        if (this._terminalDelegations.get(sessionKey)?.get(delegationId) !== entry) continue
+        this.claudeBridge?.emitToStream?.(cwd, sessionId, entry.startedEvent)
+        this.claudeBridge?.emitToStream?.(cwd, sessionId, entry.terminalEvent)
+        continue
+      }
       const alive = await this._delegateProcessAlive(entry.event)
       // 生存確認中に終端が届いた場合、古い snapshot の started/stopped を後から流さない。
       if (this._activeDelegations.get(sessionKey)?.get(delegationId) !== entry) continue
@@ -571,6 +658,7 @@ export class SiblingInjectBridge {
       phase,
       agent,
       description,
+      background,
       prompt,
       timestamp,
       pid,
@@ -590,10 +678,12 @@ export class SiblingInjectBridge {
     const badDelegateBody =
       typeof delegation_id !== "string" ||
       !delegation_id ||
+      delegation_id.length > DELEGATION_ID_MAX_LENGTH ||
       !delegatePhases.has(phase) ||
       (phase === "started" && (typeof agent !== "string" || !agent)) ||
       (agent !== undefined && typeof agent !== "string") ||
       (description !== undefined && typeof description !== "string") ||
+      (background !== undefined && typeof background !== "boolean") ||
       (prompt !== undefined && typeof prompt !== "string") ||
       (pid !== undefined && (!Number.isInteger(pid) || pid <= 0)) ||
       (pid_started_at !== undefined && typeof pid_started_at !== "string") ||
@@ -656,6 +746,7 @@ export class SiblingInjectBridge {
             phase,
             ...(agent !== undefined ? { agent } : {}),
             ...(description !== undefined ? { description } : {}),
+            ...(background !== undefined ? { background } : {}),
             ...(phase === "started" && prompt ? { prompt: truncateDelegatePrompt(prompt) } : {}),
             ...(pid !== undefined ? { pid } : {}),
             ...(pid_started_at !== undefined ? { pid_started_at } : {}),

package/src/ws-client.mjs

@@ -56,6 +56,9 @@ const MIN_BACKOFF_AFTER_5XX_MS = 5_000
 //     「送信待ち(未配信)」が消えない (S1/S3)。再接続 flush で遅れて届けば即解消する。
 //   - claude/codex の event / ready / exit / error / permission:
 //     喪失すると新規セッションの楽観バブルが本物へ昇格できず、再 attach も固着する。
+//   - claude.session.options.result: options.set は再要求型RPCではなく明示intentの終端。
+//     agent→Hub切断中のapplied resultも保持し、request_idで同streamへ戻す。frontend側の
+//     stale-stream/request mismatch/10s timeoutが遅延結果を無害化する（LWW圧縮はしない）。
 //   - claude.jsonl.event / session.event: TUI と一覧の確定状態を復元する。
 // 高頻度の delta 系はここに積まず (下の isEphemeral*DeltaEvent で除外)、低頻度な
 // ack/event がリング evict されるのを防ぐ (ack/event は 1 件ずつ意味を持つ)。
@@ -63,6 +66,8 @@ const BUFFERED_CTRL_TYPES = new Set([
   "claude.jsonl.event",
   "claude.event",
   "claude.ready",
+  "claude.session.options",
+  "claude.session.options.result",
   "claude.exit",
   "claude.error",
   "claude.permission.request",