@cocorograph/hub-agent 0.8.33 → 0.8.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocorograph/hub-agent",
-  "version": "0.8.33",
+  "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

@@ -621,6 +621,7 @@ export class CodexStreamBridge extends EventEmitter {
             // 由来で表示がリセットされ得るため、live セッションが保持する高忠実度履歴を返す。
             history,
             historyTruncated: existing.historyTruncated === true,
+            subagents: this._subagentSnapshots(existing, history),
           }
         }
         if (r.status === "superseded") {
@@ -850,8 +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, result?.thread)
-      if (resuming) this._scheduleSubagentReplay(session)
+      if (resuming) await this._restoreSubagentsFromHistory(session, history)
       // 案C: 権威的なターン状態を resume 応答から取り出してフロントへ渡す。
       // これによりフロントは会話末尾からの推測をやめ、Thread.status で turnActive を
       // 決められる (生成中スピナー固着バグの根治)。新規スレッドは常に idle 相当。
@@ -908,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,
@@ -1078,7 +1079,6 @@ 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 {
@@ -1623,11 +1623,14 @@ export class CodexStreamBridge extends EventEmitter {
       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)
@@ -1646,6 +1649,7 @@ export class CodexStreamBridge extends EventEmitter {
         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) {
@@ -1656,6 +1660,7 @@ export class CodexStreamBridge extends EventEmitter {
     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"
@@ -1668,7 +1673,11 @@ export class CodexStreamBridge extends EventEmitter {
       session,
       agentThreadId,
       phase,
-      { agentPath: item.agentPath, metadata, atMs },
+      {
+        agentPath: item.agentPath,
+        metadata,
+        atMs,
+      },
       { emit },
     )
   }
@@ -1690,49 +1699,65 @@ export class CodexStreamBridge extends EventEmitter {
               ? Math.round(turn.startedAt * 1000)
               : Date.now()
     if (msg.method === "turn/started") {
-      this._setSubagentPhase(session, threadId, "started", { agentPath: record.agentPath, atMs })
+      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 })
+        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 },
-        )
+  _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)
       }
-      this._emitSubagentState(session, record, { force: true })
     }
+    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
   }
 
-  _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 })
+  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()]
@@ -1745,6 +1770,8 @@ export class CodexStreamBridge extends EventEmitter {
             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)
@@ -1763,23 +1790,34 @@ export class CodexStreamBridge extends EventEmitter {
               { agentPath: record.agentPath, atMs: lastTurnAtMs },
               { emit: false },
             )
-          } else if (thread?.status?.type === "active" && lastTurn?.status === "inProgress") {
+          } else if (
+            thread?.status?.type === "active" &&
+            (!lastTurn || lastTurn.status === "inProgress")
+          ) {
             this._setSubagentPhase(
               session,
               record.agentThreadId,
               "started",
-              { agentPath: record.agentPath, atMs: lastTurnAtMs },
+              {
+                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",
+            "codex subagent thread/read failed during resume; excluded from ready snapshot",
           )
         }
       }
@@ -1841,6 +1879,19 @@ 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") {

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 が