@cocorograph/hub-agent 0.8.32 → 0.8.34

package/package.json

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

package/src/codex-stream-bridge.mjs

@@ -183,6 +183,10 @@ const TURN_START_TIMEOUT_MS = readPositiveIntEnv(
 // 直近 input_id を bounded ring で保持する (Claude queue_state.accepted と同じ契約)。
 const ACCEPTED_INPUT_ID_RING_MAX = 256
 
+// cold resume で復元する子 thread/read の同時実行上限。履歴上の子は欠落させず全件読むが、
+// 長期 thread で一斉 RPC を発行して app-server を圧迫しないよう固定 worker pool にする。
+const SUBAGENT_READ_CONCURRENCY = 8
+
 // sibling-inject の turn RPC が成功した後、app-server が同じ userMessage を
 // item/completed で echo するまで待つ上限。RPC accepted と userMessage delivered を
 // 分離し、旧 stream / 初期化競合で rollout に残らない入力を成功扱いしない。
@@ -381,6 +385,40 @@ function userInputFromMessage(message) {
   return [{ type: "text", text: String(content ?? "") }]
 }
 
+function subagentFallbackName(agentPath) {
+  if (typeof agentPath !== "string" || !agentPath) return "subagent"
+  return agentPath.split("/").filter(Boolean).at(-1) || "subagent"
+}
+
+function parseDynamicToolArguments(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) return value
+  if (typeof value !== "string") return null
+  try {
+    const parsed = JSON.parse(value)
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null
+  } catch {
+    return null
+  }
+}
+
+function terminalSubagentPhase(status) {
+  switch (status) {
+    case "completed":
+      return "completed"
+    case "failed":
+      return "failed"
+    case "interrupted":
+    case "stopped":
+    case "cancelled":
+    case "canceled":
+      return "stopped"
+    case "killed":
+      return "killed"
+    default:
+      return null
+  }
+}
+
 export class CodexStreamBridge extends EventEmitter {
   constructor({
     codexCmd,
@@ -583,6 +621,7 @@ export class CodexStreamBridge extends EventEmitter {
             // 由来で表示がリセットされ得るため、live セッションが保持する高忠実度履歴を返す。
             history,
             historyTruncated: existing.historyTruncated === true,
+            subagents: this._subagentSnapshots(existing, history),
           }
         }
         if (r.status === "superseded") {
@@ -709,6 +748,11 @@ export class CodexStreamBridge extends EventEmitter {
        *  deliveryId: string, sourceStreamId: string, deliveryPending: boolean,
        *  deliveryPromise: Promise<object>, settleDelivery: Function}>} */
       pendingInjectSources: [],
+      /** 組み込み collaboration subagent の表示用台帳。ライフサイクルの安定キーは
+       * agentThreadId（item.id は dynamicToolCall とのメタデータ結合にだけ使う）。 */
+      subagents: new Map(),
+      /** dynamicToolCall(spawn_agent) の item.id -> 表示メタデータ。 */
+      subagentSpawnMetadata: new Map(),
       /** 実行中の背景コマンド（commandExecution）の台帳。claude 側 `_liveTasks` と同型。
        *  key = `item.id`（`item/started` / `item/completed` の両方に載る唯一の安定 ID）、
        *  value = { threadId, startedAt, lastSeenAt }。
@@ -807,6 +851,7 @@ export class CodexStreamBridge extends EventEmitter {
       session.historyItems = history.slice()
       session.historyBytes = history.reduce((n, it) => n + estimateItemBytes(it), 0)
       session.historyTruncated = historyTruncated
+      if (resuming) await this._restoreSubagentsFromHistory(session, history)
       // 案C: 権威的なターン状態を resume 応答から取り出してフロントへ渡す。
       // これによりフロントは会話末尾からの推測をやめ、Thread.status で turnActive を
       // 決められる (生成中スピナー固着バグの根治)。新規スレッドは常に idle 相当。
@@ -863,6 +908,7 @@ export class CodexStreamBridge extends EventEmitter {
         threadId: session.threadId,
         history,
         historyTruncated,
+        subagents: this._subagentSnapshots(session, history),
         threadStatus: turnState.threadStatus,
         lastTurnStatus: turnState.lastTurnStatus,
         turnActive: turnState.turnActive,
@@ -1524,6 +1570,266 @@ export class CodexStreamBridge extends EventEmitter {
     }
   }
 
+  _emitSubagentState(session, record, { force = false } = {}) {
+    if (!session || !record || session.dead) return
+    if (!force && record.lastEmittedPhase === record.phase) return
+    record.lastEmittedPhase = record.phase
+    this.emit("event", {
+      stream_id: session.stream_id,
+      producer_seq: session.seq,
+      thread_id: session.threadId,
+      cwd: session.cwd,
+      notification: {
+        method: "cockpit/subagent_state",
+        params: {
+          delegationId: record.agentThreadId,
+          agentThreadId: record.agentThreadId,
+          agentPath: record.agentPath,
+          phase: record.phase,
+          agent: record.agent,
+          description: record.description,
+          prompt: record.prompt,
+          atMs: record.atMs,
+        },
+      },
+    })
+  }
+
+  _setSubagentPhase(
+    session,
+    agentThreadId,
+    phase,
+    details = {},
+    { force = false, emit = true } = {},
+  ) {
+    if (typeof agentThreadId !== "string" || !agentThreadId) return null
+    const previous = session.subagents.get(agentThreadId)
+    const agentPath =
+      typeof details.agentPath === "string" && details.agentPath
+        ? details.agentPath
+        : previous?.agentPath || ""
+    const metadata = details.metadata || null
+    const transitionAtMs =
+      previous?.phase === phase
+        ? previous.atMs
+        : typeof details.atMs === "number"
+          ? details.atMs
+          : Date.now()
+    const record = {
+      agentThreadId,
+      agentPath,
+      phase,
+      agent: metadata?.agent || previous?.agent || subagentFallbackName(agentPath),
+      description:
+        metadata?.description || previous?.description || subagentFallbackName(agentPath),
+      prompt: metadata?.prompt || previous?.prompt || "",
+      // background は spawn 時に確定する属性。後続通知に metadata が無くても true を失わない。
+      background: metadata?.background === true || previous?.background === true,
+      atMs: transitionAtMs,
+      startedAtMs:
+        phase === "started" && terminalSubagentPhase(previous?.phase)
+          ? transitionAtMs
+          : previous?.startedAtMs ?? transitionAtMs,
+      terminalAtMs: terminalSubagentPhase(phase) ? transitionAtMs : null,
+      lastEmittedPhase: previous?.lastEmittedPhase || null,
+    }
+    session.subagents.set(agentThreadId, record)
+    if (emit) this._emitSubagentState(session, record, { force })
+    return record
+  }
+
+  _observeSubagentItem(session, item, atMs = Date.now(), { emit = true } = {}) {
+    if (!item || typeof item !== "object") return
+    if (item.type === "dynamicToolCall") {
+      const namespace = item.namespace
+      if (namespace !== "collaboration" || item.tool !== "spawn_agent" || !item.id) return
+      const args = parseDynamicToolArguments(item.arguments)
+      if (!args) return
+      const metadata = {
+        agent: typeof args.agent_type === "string" && args.agent_type ? args.agent_type : null,
+        description: typeof args.task_name === "string" && args.task_name ? args.task_name : null,
+        prompt: typeof args.message === "string" ? args.message : null,
+        background: args.background === true,
+      }
+      session.subagentSpawnMetadata.set(item.id, metadata)
+      while (session.subagentSpawnMetadata.size > 256) {
+        session.subagentSpawnMetadata.delete(session.subagentSpawnMetadata.keys().next().value)
+      }
+      return
+    }
+    if (item.type !== "subAgentActivity") return
+    const agentThreadId = item.agentThreadId
+    if (typeof agentThreadId !== "string" || !agentThreadId) return
+    if (agentThreadId === session.threadId || item.agentPath === "/root") return
+    const previous = session.subagents.get(agentThreadId)
+    let phase = null
+    if (item.kind === "interrupted") phase = "stopped"
+    if ((item.kind === "started" || item.kind === "interacted") && !terminalSubagentPhase(previous?.phase)) {
+      phase = "started"
+    }
+    if (!phase) return
+    const metadata = session.subagentSpawnMetadata.get(item.id) || null
+    this._setSubagentPhase(
+      session,
+      agentThreadId,
+      phase,
+      {
+        agentPath: item.agentPath,
+        metadata,
+        atMs,
+      },
+      { emit },
+    )
+  }
+
+  _observeSubagentTurn(session, msg) {
+    const threadId = msg?.params?.threadId
+    if (typeof threadId !== "string" || threadId === session.threadId) return false
+    const record = session.subagents.get(threadId)
+    if (!record) return true
+    const turn = msg.params?.turn
+    const atMs =
+      typeof msg.params?.completedAtMs === "number"
+        ? msg.params.completedAtMs
+        : typeof msg.params?.startedAtMs === "number"
+          ? msg.params.startedAtMs
+          : typeof turn?.completedAt === "number"
+            ? Math.round(turn.completedAt * 1000)
+            : typeof turn?.startedAt === "number"
+              ? Math.round(turn.startedAt * 1000)
+              : Date.now()
+    if (msg.method === "turn/started") {
+      this._setSubagentPhase(session, threadId, "started", {
+        agentPath: record.agentPath,
+        atMs,
+      })
+    } else if (msg.method === "turn/completed") {
+      const phase = terminalSubagentPhase(msg.params?.turn?.status)
+      if (phase) {
+        this._setSubagentPhase(session, threadId, phase, {
+          agentPath: record.agentPath,
+          atMs,
+        })
+      }
+    }
+    return true
+  }
+
+  _subagentSnapshots(session, history = session?.historyItems) {
+    const items = Array.isArray(history) ? history : []
+    const startedIndexByThread = new Map()
+    for (let index = 0; index < items.length; index += 1) {
+      const item = items[index]
+      if (
+        item?.type === "subAgentActivity" &&
+        item.kind === "started" &&
+        typeof item.agentThreadId === "string" &&
+        item.agentPath !== "/root" &&
+        item.agentThreadId !== session?.threadId &&
+        !startedIndexByThread.has(item.agentThreadId)
+      ) {
+        startedIndexByThread.set(item.agentThreadId, index)
+      }
+    }
+    const snapshots = []
+    for (const record of session?.subagents?.values?.() || []) {
+      const startedHistoryIndex = startedIndexByThread.get(record.agentThreadId)
+      if (startedHistoryIndex === undefined) continue
+      snapshots.push({
+        delegationId: record.agentThreadId,
+        agentThreadId: record.agentThreadId,
+        agentPath: record.agentPath,
+        agent: record.agent,
+        description: record.description,
+        prompt: record.prompt,
+        background: record.background === true,
+        startedHistoryIndex,
+        phase: record.phase,
+        startedAtMs: record.startedAtMs,
+        terminalAtMs: record.terminalAtMs,
+      })
+    }
+    return snapshots
+  }
+
+  async _restoreSubagentsFromHistory(session, history) {
+    // ready に載せる表示用 history と同じ範囲だけを復元元にする。truncate 外の開始
+    // anchor を拾うと、対応する履歴が無い lifecycle card が末尾へ浮くため全履歴は走査しない。
+    for (const item of Array.isArray(history) ? history : []) {
+      if (item?.type === "dynamicToolCall" || item?.kind === "started") {
+        this._observeSubagentItem(session, item, item?.at_ms, { emit: false })
+      }
+    }
+    const records = [...session.subagents.values()]
+    let nextRecord = 0
+    const readWorker = async () => {
+      while (nextRecord < records.length) {
+        const record = records[nextRecord++]
+        try {
+          const result = await session.client.request("thread/read", {
+            threadId: record.agentThreadId,
+            includeTurns: true,
+          })
+          // RPC 待ち中に live lifecycle が進んだ場合、stale read で上書き・削除しない。
+          if (session.subagents.get(record.agentThreadId) !== record) continue
+          const thread = result?.thread
+          const turns = Array.isArray(thread?.turns) ? thread.turns : []
+          const lastTurn = turns.at(-1)
+          const phase = terminalSubagentPhase(lastTurn?.status)
+          const lastTurnAtMs =
+            typeof lastTurn?.completedAt === "number"
+              ? Math.round(lastTurn.completedAt * 1000)
+              : typeof lastTurn?.startedAt === "number"
+                ? Math.round(lastTurn.startedAt * 1000)
+                : Date.now()
+          if (phase) {
+            this._setSubagentPhase(
+              session,
+              record.agentThreadId,
+              phase,
+              { agentPath: record.agentPath, atMs: lastTurnAtMs },
+              { emit: false },
+            )
+          } else if (
+            thread?.status?.type === "active" &&
+            (!lastTurn || lastTurn.status === "inProgress")
+          ) {
+            this._setSubagentPhase(
+              session,
+              record.agentThreadId,
+              "started",
+              {
+                agentPath: record.agentPath,
+                atMs: record.startedAtMs,
+              },
+              { emit: false },
+            )
+          } else {
+            session.subagents.delete(record.agentThreadId)
+          }
+        } catch (err) {
+          if (session.subagents.get(record.agentThreadId) === record) {
+            session.subagents.delete(record.agentThreadId)
+          }
+          this.logger?.warn?.(
+            {
+              err: err?.message || String(err),
+              thread_id: session.threadId,
+              subagent_thread_id: record.agentThreadId,
+            },
+            "codex subagent thread/read failed during resume; excluded from ready snapshot",
+          )
+        }
+      }
+    }
+    await Promise.all(
+      Array.from(
+        { length: Math.min(SUBAGENT_READ_CONCURRENCY, records.length) },
+        () => readWorker(),
+      ),
+    )
+  }
+
   /** 実行中の背景コマンドを持つか（warm 境界の保護判定用）。**先に失効エントリを掃除してから**
    *  判定する。失効は「最後に生存を確認してから CODEX_EXEC_PROTECT_TTL_MS」。
    *  ⚠️ 失効させる = そのセッションは kill されうる、という意味なので必ず warn を残す
@@ -1573,10 +1879,34 @@ export class CodexStreamBridge extends EventEmitter {
     // (タグ済み or 素) を history と emit の両方で使う。一致しなければ null → 素の params のまま。
     // ※ hub-agent 再起動 (cold resume) では historyItems が揮発するため青バブルへ戻る (claude の
     //    jsonl at-rest と同じ許容範囲。source 永続マップは TTL/ID 再利用の複雑さに見合わないため不採用)。
+    const eventThreadId = msg?.params?.threadId
+    const backgroundChildItemNotification =
+      typeof eventThreadId === "string" &&
+      typeof msg?.method === "string" &&
+      msg.method.startsWith("item/") &&
+      session.subagents.get(eventThreadId)?.background === true
+    if (backgroundChildItemNotification) {
+      // 背景子の item は root の履歴・バブルへ混ぜない。子自身の lifecycle は
+      // turn 通知と root 側 subAgentActivity が正本なので、子 item から孫を登録しない。
+      // foreground / background 不明（spawn record 生成前の短い窓を含む）は fail-open で
+      // 既存どおり root へ通す。背景出力の過剰抑止より既存表示の維持を優先する。
+      return
+    }
     const taggedParams = this._tagInjectSourceOnItem(session, msg)
     const effectiveParams = taggedParams || msg.params
+    if (msg.method === "item/started" || msg.method === "item/completed") {
+      this._observeSubagentItem(
+        session,
+        effectiveParams?.item,
+        effectiveParams?.completedAtMs || Date.now(),
+      )
+    }
+    const childTurnNotification =
+      (msg.method === "turn/started" || msg.method === "turn/completed") &&
+      this._observeSubagentTurn(session, msg)
     switch (msg.method) {
       case "turn/started":
+        if (childTurnNotification) break
         session.activeTurnId = msg.params?.turn?.id || null
         // round4 major#2: 世代を前進させる (pump が fast-turn を activeTurnId だけでなく世代前進でも検知)。
         session.turnGeneration += 1
@@ -1595,6 +1925,7 @@ export class CodexStreamBridge extends EventEmitter {
         )
         break
       case "turn/completed":
+        if (childTurnNotification) break
         {
           const completedTurnId = msg.params?.turn?.id || null
           // App Server の対象 turn と現在の権威 activeTurnId が一致したときだけ idle 化する。
@@ -1644,6 +1975,9 @@ export class CodexStreamBridge extends EventEmitter {
       default:
         break
     }
+    // 子 turn lifecycle は cockpit/subagent_state へ正規化済み。raw turn 通知まで frontend へ流すと
+    // root の turnActive/heal_turn と chat activity を子の状態で誤更新するため、ここで止める。
+    if (childTurnNotification) return
     this.emit("event", {
       stream_id,
       // producer_seq: この通知を出した **session(producer) の immutable ID**（生成時に振る

package/src/main.mjs

@@ -2052,6 +2052,43 @@ export function buildCodexChatPatch(status, contextPct, threadId, isAuthority) {
   return patch
 }
 
+/** codex.ready の wire payload を組み立てる。history は同じ配列参照を保持し、
+ * started_history_index が指す位置を main 側の加工でずらさない。表示を保持する reconnect
+ * (`info.subagents` 未定義) では subagents キー自体を省略し、空 snapshot で既存表示を消さない。 */
+export function buildCodexReadyPayload(streamId, info, queueState) {
+  const history = Array.isArray(info?.history) ? info.history : []
+  const payload = {
+    type: "codex.ready",
+    stream_id: streamId,
+    resuming: info?.resuming === true,
+    thread_id: info?.threadId || null,
+    history,
+    history_truncated: info?.historyTruncated === true,
+    turn_active: info?.turnActive === true,
+    thread_status: info?.threadStatus || null,
+    last_turn_status: info?.lastTurnStatus || null,
+    queue_state: queueState,
+  }
+  if (Array.isArray(info?.subagents)) {
+    payload.subagents = info.subagents.map((subagent) => ({
+      // 現契約では delegation_id と agent_thread_id は同じ child thread ID の alias。
+      delegation_id: subagent.delegationId,
+      agent_thread_id: subagent.agentThreadId,
+      agent_path: subagent.agentPath,
+      agent: subagent.agent,
+      // description は spawn_agent.task_name の既存 alias（人物の表示名ではない）。
+      description: subagent.description,
+      prompt: subagent.prompt,
+      background: subagent.background === true,
+      started_history_index: subagent.startedHistoryIndex,
+      phase: subagent.phase,
+      started_at_ms: subagent.startedAtMs,
+      terminal_at_ms: subagent.terminalAtMs,
+    }))
+  }
+  return payload
+}
+
 /**
  * T06407 増分2 (codex-review round2 major#2): usage.response の codexSessions を、集計に
  * 使った producer が **今なお cwd の権威**である entry だけへ絞る post-await ガード。
@@ -4131,30 +4168,9 @@ async function dispatch(msg, ctx) {
             // すると bridge が rebind し、fresh の二重生成を防ぐ (browser の stream_id は都度変わる)。
             attachId: msg.attach_id || undefined,
           })
-          ctx.client.send({
-            type: "codex.ready",
-            stream_id,
-            resuming: info.resuming,
-            thread_id: info.threadId,
-            // Slice 6: 履歴 hydrate。resume 時のみ非空 (thread/start は常に [])。
-            // consumers.py の per-stream relay は content-blind なので backend 側の
-            // 変更は不要 (_AGENT_PER_STREAM_TYPES の codex.ready がそのまま運ぶ)。
-            history: info.history || [],
-            // T06499: 巨大スレッドで末尾 N ターンに絞った場合 true。browser は
-            // 「以前の履歴は省略されています」バナーを出す (会話は resume 済みで継続可)。
-            history_truncated: info.historyTruncated === true,
-            // 案C (権威的ターン状態): フロントは会話末尾からの推測 (deriveTurnActive
-            // FromHistory) をやめ、Codex が明示する Thread.status で turnActive を決める。
-            // resume 後は新プロセスで実行中ターンが無く thread_status='idle' が返るため、
-            // 生成中スピナー固着 (中断/ツールのみ終了ターンで末尾が user メッセージになる
-            // ケース) が根治する。
-            turn_active: info.turnActive === true,
-            thread_status: info.threadStatus || null,
-            last_turn_status: info.lastTurnStatus || null,
-            // Codex の通常送信 FIFO。ready と同じ封筒に初期 snapshot を載せ、
-            // reattach / reload でも送信待ち表示を即時復元する。
-            queue_state: ctx.codexBridge.queueState(stream_id),
-          })
+          ctx.client.send(
+            buildCodexReadyPayload(stream_id, info, ctx.codexBridge.queueState(stream_id)),
+          )
           // S1 (2026-07): claude.attach と対称の identity 正本化。Codex は thread/start
           // 応答時点で threadId が確定するため (Claude の fresh とは異なり)、fresh でも
           // 既に分かっている threadId を sessionId として記録する (直後の turn/started が