@cocorograph/hub-agent 0.8.41 → 0.8.42

package/package.json

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

package/src/codex-stream-bridge.mjs

@@ -770,6 +770,8 @@ export class CodexStreamBridge extends EventEmitter {
       /** 組み込み collaboration subagent の表示用台帳。検索キーは agentThreadId、
        * 外部へ出す安定した委譲 ID は subAgentActivity の lifecycle ID を保持する。 */
       subagents: new Map(),
+      /** 停止対象の因果関係と実行中 turn を保持する、表示台帳とは独立した台帳。 */
+      subagentInterruptRegistry: new Map(),
       /** dynamicToolCall(spawn_agent) の item.id -> 表示メタデータ。 */
       subagentSpawnMetadata: new Map(),
       /** live subAgentActivity の spawn metadata miss を child thread/read で補完する
@@ -1759,9 +1761,22 @@ export class CodexStreamBridge extends EventEmitter {
     session,
     item,
     atMs = Date.now(),
-    { emit = true, sourceThreadId = session?.threadId } = {},
+    { emit = true, sourceThreadId = session?.threadId, sourceTurnId = null } = {},
   ) {
     if (!item || typeof item !== "object") return
+    if (item.type === "subAgentActivity") {
+      const childThreadId = item.agentThreadId
+      if (typeof childThreadId === "string" && childThreadId && childThreadId !== session?.threadId) {
+        const interruptFields = {}
+        if (typeof sourceThreadId === "string" && sourceThreadId) {
+          interruptFields.parentThreadId = sourceThreadId
+        }
+        if (typeof sourceTurnId === "string" && sourceTurnId) {
+          interruptFields.ownerTurnId = sourceTurnId
+        }
+        this._touchSubagentInterruptRecord(session, childThreadId, interruptFields)
+      }
+    }
     // root thread の collaboration item だけが root subagent 台帳の正本。子 thread 内の
     // spawn/subAgentActivity（孫）を root の lifecycle/snapshot へ昇格しない。
     if (
@@ -1823,8 +1838,6 @@ export class CodexStreamBridge extends EventEmitter {
   _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"
@@ -1836,6 +1849,16 @@ export class CodexStreamBridge extends EventEmitter {
             : typeof turn?.startedAt === "number"
               ? Math.round(turn.startedAt * 1000)
               : Date.now()
+    const interruptRecord = this._touchSubagentInterruptRecord(session, threadId)
+    const observedTurnId = typeof turn?.id === "string" ? turn.id : null
+    if (msg.method === "turn/started" && observedTurnId) {
+      interruptRecord.turnId = observedTurnId
+      interruptRecord.startedAtMs = atMs
+    } else if (msg.method === "turn/completed" && interruptRecord.turnId === observedTurnId) {
+      interruptRecord.turnId = null
+    }
+    const record = session.subagents.get(threadId)
+    if (!record) return true
     if (msg.method === "turn/started") {
       this._setSubagentPhase(session, threadId, "started", {
         agentPath: record.agentPath,
@@ -1853,6 +1876,127 @@ export class CodexStreamBridge extends EventEmitter {
     return true
   }
 
+  _touchSubagentInterruptRecord(session, threadId, fields = {}) {
+    const now = Date.now()
+    let record = session.subagentInterruptRegistry.get(threadId)
+    if (!record) {
+      record = {
+        threadId,
+        turnId: null,
+        parentThreadId: null,
+        ownerTurnId: null,
+        startedAtMs: null,
+        lastSeenAtMs: now,
+      }
+      session.subagentInterruptRegistry.set(threadId, record)
+    }
+    const { parentThreadId, ownerTurnId, ...mutableFields } = fields
+    Object.assign(record, mutableFields, { lastSeenAtMs: now })
+    if (!record.parentThreadId && typeof parentThreadId === "string" && parentThreadId) {
+      record.parentThreadId = parentThreadId
+    }
+    if (!record.ownerTurnId && typeof ownerTurnId === "string" && ownerTurnId) {
+      record.ownerTurnId = ownerTurnId
+    }
+    const expiredBefore = now - 4 * 60 * 60 * 1000
+    for (const [id, candidate] of session.subagentInterruptRegistry) {
+      if (candidate.turnId === null && candidate.lastSeenAtMs < expiredBefore) {
+        this._evictSubagentInterruptRecord(session, id, candidate)
+      }
+    }
+    while (session.subagentInterruptRegistry.size > 256) {
+      const oldest = [...session.subagentInterruptRegistry.entries()]
+        .filter(([, candidate]) => candidate.turnId === null)
+        .sort((a, b) => a[1].lastSeenAtMs - b[1].lastSeenAtMs)[0]
+      if (!oldest) {
+        this.logger?.warn?.(
+          { size: session.subagentInterruptRegistry.size, limit: 256 },
+          "codex subagent interrupt registry exceeds limit with all records active",
+        )
+        break
+      }
+      this._evictSubagentInterruptRecord(session, oldest[0], oldest[1])
+    }
+    return record
+  }
+
+  _evictSubagentInterruptRecord(session, threadId, record) {
+    if (record.turnId) {
+      this.logger?.warn?.({ thread_id: threadId, turn_id: record.turnId }, "evicting active codex subagent interrupt record")
+    }
+    session.subagentInterruptRegistry.delete(threadId)
+  }
+
+  _subagentOwnership(session, record) {
+    const visited = new Set()
+    let current = record
+    let hasBackgroundAncestor = false
+    while (current) {
+      if (visited.has(current.threadId)) return { ownerRootTurnId: null, hasBackgroundAncestor }
+      visited.add(current.threadId)
+      if (session.subagents.get(current.threadId)?.background === true) {
+        hasBackgroundAncestor = true
+      }
+      if (current.parentThreadId === session.threadId) {
+        return { ownerRootTurnId: current.ownerTurnId || null, hasBackgroundAncestor }
+      }
+      current = session.subagentInterruptRegistry.get(current.parentThreadId)
+    }
+    return { ownerRootTurnId: null, hasBackgroundAncestor }
+  }
+
+  async _interruptSubagent(session, record, targetRootTurnId) {
+    const displayed = session.subagents.get(record.threadId)
+    const backgroundKnown = displayed ? typeof displayed.background === "boolean" : false
+    const background = backgroundKnown ? displayed.background : null
+    try {
+      await session.client.request("turn/interrupt", { threadId: record.threadId, turnId: record.turnId })
+      return { threadId: record.threadId, turnId: record.turnId, outcome: "interrupted", background, backgroundKnown }
+    } catch (err) {
+      const reason = err?.message || String(err)
+      const mismatch = parseTurnMismatch(reason)
+      const latestRecord = session.subagentInterruptRegistry.get(record.threadId)
+      const latestOwnership = latestRecord ? this._subagentOwnership(session, latestRecord) : null
+      if (
+        mismatch &&
+        latestRecord?.turnId === mismatch.found &&
+        latestOwnership?.ownerRootTurnId === targetRootTurnId &&
+        !latestOwnership.hasBackgroundAncestor
+      ) {
+        try {
+          await session.client.request("turn/interrupt", {
+            threadId: latestRecord.threadId,
+            turnId: latestRecord.turnId,
+          })
+          return {
+            threadId: latestRecord.threadId,
+            turnId: latestRecord.turnId,
+            outcome: "interrupted",
+            background,
+            backgroundKnown,
+          }
+        } catch (retryErr) {
+          return {
+            threadId: latestRecord.threadId,
+            turnId: latestRecord.turnId,
+            outcome: "failed",
+            reason: retryErr?.message || String(retryErr),
+            background,
+            backgroundKnown,
+          }
+        }
+      }
+      return {
+        threadId: record.threadId,
+        turnId: record.turnId,
+        outcome: "failed",
+        reason,
+        background,
+        backgroundKnown,
+      }
+    }
+  }
+
   _subagentSnapshots(session, history = session?.historyItems) {
     const items = Array.isArray(history) ? history : []
     const startedIndexByThread = new Map()
@@ -2063,7 +2207,7 @@ export class CodexStreamBridge extends EventEmitter {
         session,
         effectiveParams?.item,
         effectiveParams?.completedAtMs || Date.now(),
-        { sourceThreadId: eventThreadId },
+        { sourceThreadId: eventThreadId, sourceTurnId: msg.params?.turnId },
       )
     }
     const childTurnNotification =
@@ -2478,20 +2622,23 @@ export class CodexStreamBridge extends EventEmitter {
   async interrupt({ stream_id }) {
     const session = this._require(stream_id)
     this._touch(session, stream_id)
-    if (!session.activeTurnId) return { outcome: "no_active_turn" }
+    if (!session.activeTurnId) return { outcome: "no_active_turn", children: [] }
 
     const turnId = session.activeTurnId
+    let attemptedRootTurnId = turnId
+    let result
     try {
       await session.client.request("turn/interrupt", {
         threadId: session.threadId,
         turnId,
       })
-      return { outcome: "interrupted", turnId, corrected: false }
+      result = { outcome: "interrupted", turnId, corrected: false }
     } catch (err) {
       const reason = err?.message || String(err)
       const mismatch = parseTurnMismatch(reason)
-      if (!mismatch) return { outcome: "failed", reason }
+      if (!mismatch) result = { outcome: "failed", reason }
 
+      if (mismatch) {
       const correctedTurnId = mismatch.found
       // 是正は再送前に行い、再送中の corrected turn の完了通知を正しく照合できるようにする。
       // 初回リクエスト中に状態が進んでいた場合は、その新しい状態を上書きしない。
@@ -2499,20 +2646,32 @@ export class CodexStreamBridge extends EventEmitter {
         session.activeTurnId = correctedTurnId
       }
       try {
+        attemptedRootTurnId = correctedTurnId
         await session.client.request("turn/interrupt", {
           threadId: session.threadId,
           turnId: correctedTurnId,
         })
-        return { outcome: "interrupted", turnId: correctedTurnId, corrected: true }
+        result = { outcome: "interrupted", turnId: correctedTurnId, corrected: true }
       } catch (retryErr) {
         const retryReason = retryErr?.message || String(retryErr)
         const retryMismatch = parseTurnMismatch(retryReason)
         if (retryMismatch && session.activeTurnId === correctedTurnId) {
           session.activeTurnId = retryMismatch.found
         }
-        return { outcome: "failed", reason: retryReason }
+        result = { outcome: "failed", reason: retryReason }
+      }
       }
     }
+    const children = []
+    const targetRootTurnId = attemptedRootTurnId
+    const interruptSnapshot = [...session.subagentInterruptRegistry.values()].map((record) => ({ ...record }))
+    for (const record of interruptSnapshot) {
+      if (!record.turnId) continue
+      const ownership = this._subagentOwnership(session, record)
+      if (ownership.ownerRootTurnId !== targetRootTurnId || ownership.hasBackgroundAncestor) continue
+      children.push(await this._interruptSubagent(session, { ...record }, targetRootTurnId))
+    }
+    return { ...result, children }
   }
 
   /** サーバー発の承認/入力要求への応答。result の shape は method ごとに呼び出し側が組み立てる。 */

package/src/main.mjs

@@ -3197,7 +3197,7 @@ export function handleCodexChatInput(msg, ctx) {
 export async function handleCodexInterrupt(msg, ctx) {
   let result
   if (!ctx.codexBridge) {
-    result = { outcome: "failed", reason: "bridge_unavailable" }
+    result = { outcome: "failed", reason: "bridge_unavailable", children: [] }
   } else {
     try {
       result = await ctx.codexBridge.interrupt({ stream_id: msg.stream_id })
@@ -3207,7 +3207,7 @@ export async function handleCodexInterrupt(msg, ctx) {
     } catch (err) {
       const reason = err?.message || String(err)
       ctx.logger?.warn?.({ err: reason }, "codex.interrupt failed")
-      result = { outcome: "failed", reason }
+      result = { outcome: "failed", reason, children: [] }
     }
   }
   ctx.client.send({