@cocorograph/hub-agent 0.8.32 → 0.8.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocorograph/hub-agent",
-  "version": "0.8.32",
+  "version": "0.8.33",
   "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,
@@ -709,6 +747,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 +850,8 @@ 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, result?.thread)
+      if (resuming) this._scheduleSubagentReplay(session)
       // 案C: 権威的なターン状態を resume 応答から取り出してフロントへ渡す。
       // これによりフロントは会話末尾からの推測をやめ、Thread.status で turnActive を
       // 決められる (生成中スピナー固着バグの根治)。新規スレッドは常に idle 相当。
@@ -1033,6 +1078,7 @@ export class CodexStreamBridge extends EventEmitter {
     // 出したカードは remount/端末切替で失われ、応答が来ないとターンが永久 pending になる。新 stream へ
     // 再 emit してカードを復元させる (frontend は request_id で重複排除するので二重化しない)。
     this._replayPendingApprovals(session)
+    this._scheduleSubagentReplay(session)
     // 履歴は返さない: reconnect では frontend が表示を保持している (resetDisplay=false) ため
     // 再 hydrate 不要。turnActive は session が保持する activeTurnId から権威的に決める。
     return {
@@ -1524,6 +1570,228 @@ 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 || "",
+      atMs: transitionAtMs,
+      startedAtMs:
+        phase === "started" && terminalSubagentPhase(previous?.phase)
+          ? transitionAtMs
+          : previous?.startedAtMs ?? transitionAtMs,
+      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,
+      }
+      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
+    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
+  }
+
+  _replaySubagentStates(session) {
+    for (const record of session?.subagents?.values?.() || []) {
+      if (terminalSubagentPhase(record.phase)) {
+        this._emitSubagentState(
+          session,
+          { ...record, phase: "started", atMs: record.startedAtMs, lastEmittedPhase: null },
+          { force: true },
+        )
+      }
+      this._emitSubagentState(session, record, { force: true })
+    }
+  }
+
+  _scheduleSubagentReplay(session) {
+    // main.mjs は attach() resolve 後に codex.ready（history hydrate/reset）を送る。同期 emit すると
+    // state card が ready より先に届き、直後の hydrate で消えるため、必ず次 event-loop tick へ送る。
+    setImmediate(() => {
+      if (!session?.dead) this._replaySubagentStates(session)
+    })
+  }
+
+  async _restoreSubagentsFromHistory(session, thread) {
+    // 表示用 history は巨大スレッド対策で末尾だけに truncate されるため、復元元には使わない。
+    // root の全 turn を逐次走査し、subAgentActivity の安定 ID を取りこぼさない。
+    for (const turn of Array.isArray(thread?.turns) ? thread.turns : []) {
+      const atMs =
+        typeof turn?.completedAt === "number"
+          ? Math.round(turn.completedAt * 1000)
+          : typeof turn?.startedAt === "number"
+            ? Math.round(turn.startedAt * 1000)
+            : Date.now()
+      for (const item of Array.isArray(turn?.items) ? turn.items : []) {
+        this._observeSubagentItem(session, item, atMs, { 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,
+          })
+          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?.status === "inProgress") {
+            this._setSubagentPhase(
+              session,
+              record.agentThreadId,
+              "started",
+              { agentPath: record.agentPath, atMs: lastTurnAtMs },
+              { emit: false },
+            )
+          }
+        } catch (err) {
+          this.logger?.warn?.(
+            {
+              err: err?.message || String(err),
+              thread_id: session.threadId,
+              subagent_thread_id: record.agentThreadId,
+            },
+            "codex subagent thread/read failed during resume",
+          )
+        }
+      }
+    }
+    await Promise.all(
+      Array.from(
+        { length: Math.min(SUBAGENT_READ_CONCURRENCY, records.length) },
+        () => readWorker(),
+      ),
+    )
+  }
+
   /** 実行中の背景コマンドを持つか（warm 境界の保護判定用）。**先に失効エントリを掃除してから**
    *  判定する。失効は「最後に生存を確認してから CODEX_EXEC_PROTECT_TTL_MS」。
    *  ⚠️ 失効させる = そのセッションは kill されうる、という意味なので必ず warn を残す
@@ -1575,8 +1843,19 @@ export class CodexStreamBridge extends EventEmitter {
     //    jsonl at-rest と同じ許容範囲。source 永続マップは TTL/ID 再利用の複雑さに見合わないため不採用)。
     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 +1874,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 +1924,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**（生成時に振る