@cocorograph/hub-agent 0.8.33 → 0.8.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocorograph/hub-agent",
-  "version": "0.8.33",
+  "version": "0.8.35",
   "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") {
@@ -747,8 +748,8 @@ export class CodexStreamBridge extends EventEmitter {
        *  deliveryId: string, sourceStreamId: string, deliveryPending: boolean,
        *  deliveryPromise: Promise<object>, settleDelivery: Function}>} */
       pendingInjectSources: [],
-      /** 組み込み collaboration subagent の表示用台帳。ライフサイクルの安定キーは
-       * agentThreadId（item.id は dynamicToolCall とのメタデータ結合にだけ使う）。 */
+      /** 組み込み collaboration subagent の表示用台帳。検索キーは agentThreadId、
+       * 外部へ出す安定した委譲 ID は spawn dynamicToolCall の item.id を保持する。 */
       subagents: new Map(),
       /** dynamicToolCall(spawn_agent) の item.id -> 表示メタデータ。 */
       subagentSpawnMetadata: new Map(),
@@ -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 {
@@ -1460,6 +1460,12 @@ export class CodexStreamBridge extends EventEmitter {
     const list = session?.pendingInjectSources
     if (!list || !list.length) return null
     if (msg?.method !== "item/completed") return null
+    const sourceThreadId = msg.params?.threadId
+    if (
+      typeof sourceThreadId === "string" &&
+      sourceThreadId &&
+      sourceThreadId !== session?.threadId
+    ) return null
     const item = msg.params?.item
     if (!item || item.type !== "userMessage") return null
     const content = item.content
@@ -1582,13 +1588,14 @@ export class CodexStreamBridge extends EventEmitter {
       notification: {
         method: "cockpit/subagent_state",
         params: {
-          delegationId: record.agentThreadId,
+          delegationId: record.delegationId,
           agentThreadId: record.agentThreadId,
           agentPath: record.agentPath,
           phase: record.phase,
           agent: record.agent,
           description: record.description,
           prompt: record.prompt,
+          background: record.background === true,
           atMs: record.atMs,
         },
       },
@@ -1609,6 +1616,14 @@ export class CodexStreamBridge extends EventEmitter {
         ? details.agentPath
         : previous?.agentPath || ""
     const metadata = details.metadata || null
+    const delegationId =
+      previous?.delegationId ||
+      (typeof details.delegationId === "string" && details.delegationId
+        ? details.delegationId
+        : null)
+    // raw child thread ID を委譲 ID に代用しない。spawn lifecycle 由来の安定 ID が無い
+    // 通知は台帳へ登録せず、後続 item も unknown として未タグのまま扱う。
+    if (typeof delegationId !== "string" || !delegationId) return null
     const transitionAtMs =
       previous?.phase === phase
         ? previous.atMs
@@ -1616,6 +1631,7 @@ export class CodexStreamBridge extends EventEmitter {
           ? details.atMs
           : Date.now()
     const record = {
+      delegationId,
       agentThreadId,
       agentPath,
       phase,
@@ -1623,11 +1639,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)
@@ -1635,8 +1654,20 @@ export class CodexStreamBridge extends EventEmitter {
     return record
   }
 
-  _observeSubagentItem(session, item, atMs = Date.now(), { emit = true } = {}) {
+  _observeSubagentItem(
+    session,
+    item,
+    atMs = Date.now(),
+    { emit = true, sourceThreadId = session?.threadId } = {},
+  ) {
     if (!item || typeof item !== "object") return
+    // root thread の collaboration item だけが root subagent 台帳の正本。子 thread 内の
+    // spawn/subAgentActivity（孫）を root の lifecycle/snapshot へ昇格しない。
+    if (
+      typeof sourceThreadId === "string" &&
+      sourceThreadId &&
+      sourceThreadId !== session?.threadId
+    ) return
     if (item.type === "dynamicToolCall") {
       const namespace = item.namespace
       if (namespace !== "collaboration" || item.tool !== "spawn_agent" || !item.id) return
@@ -1646,6 +1677,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 +1688,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 +1701,12 @@ export class CodexStreamBridge extends EventEmitter {
       session,
       agentThreadId,
       phase,
-      { agentPath: item.agentPath, metadata, atMs },
+      {
+        delegationId: item.id,
+        agentPath: item.agentPath,
+        metadata,
+        atMs,
+      },
       { emit },
     )
   }
@@ -1690,49 +1728,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.delegationId,
+        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 +1799,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 +1819,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,13 +1908,47 @@ 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 taggedParams = this._tagInjectSourceOnItem(session, msg)
-    const effectiveParams = taggedParams || msg.params
+    let effectiveParams = taggedParams || msg.params
+    const childRecord =
+      typeof eventThreadId === "string" ? session.subagents.get(eventThreadId) : null
+    const childTextDelta =
+      msg.method === "item/agentMessage/delta" ||
+      msg.method === "item/reasoning/summaryTextDelta" ||
+      msg.method === "item/reasoning/textDelta"
+    if (childRecord && childTextDelta) {
+      // 子の message/reasoning 途中 delta を root liveText へ混ぜない。前景・背景とも
+      // attribution 付き item/completed が表示の正本で、root/unknown delta は従来どおり
+      // fail-open で通す。
+      return
+    }
+    if (
+      childRecord &&
+      (msg.method === "item/started" || msg.method === "item/completed") &&
+      effectiveParams?.item &&
+      typeof effectiveParams.item === "object"
+    ) {
+      // app-server 所有の item は変更せず、既知の子 thread だけを attribution 付きで複製する。
+      // unknown/root を推測で子扱いしない。delegationId は child thread ID ではなく、spawn
+      // lifecycle が保持する安定 ID を使う。
+      const attributedItem = {
+        ...effectiveParams.item,
+        _hubSubagent: {
+          delegationId: childRecord.delegationId,
+          threadId: eventThreadId,
+          runtime: "codex",
+          background: childRecord.background === true,
+        },
+      }
+      effectiveParams = { ...effectiveParams, item: attributedItem }
+    }
     if (msg.method === "item/started" || msg.method === "item/completed") {
       this._observeSubagentItem(
         session,
         effectiveParams?.item,
         effectiveParams?.completedAtMs || Date.now(),
+        { sourceThreadId: eventThreadId },
       )
     }
     const childTurnNotification =
@@ -1917,8 +2018,8 @@ export class CodexStreamBridge extends EventEmitter {
         void this._pumpInputs(session)
         break
       case "item/completed":
-        // T06541 案1: 完了した ThreadItem を高忠実度履歴に追記する（cwd reattach で返す用）。
-        // Phase 2: タグ済み item (effectiveParams.item) を積む = reattach でも source が残る。
+        // 完了した ThreadItem を高忠実度履歴に追記する（cwd reattach で返す用）。
+        // attribution/source 済み item (effectiveParams.item) を積み、emit と同じ clone を使う。
         this._appendHistoryItem(session, effectiveParams?.item, effectiveParams?.completedAtMs)
         break
       default:

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 が