@cocorograph/hub-agent 0.8.40 → 0.8.42

package/package.json

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

@@ -56,6 +56,11 @@ import { readPositiveIntEnv, sanitizePositiveInt } from "./positive-int-env.mjs"
 import { nextSessionSeq } from "./session-seq.mjs"
 import { codexRolloutPresence, listCodexThreadsFromDisk } from "./usage.mjs"
 
+function parseTurnMismatch(reason) {
+  const mismatch = /^expected active turn id (\S+) but found (\S+)$/.exec(reason)
+  return mismatch ? { expected: mismatch[1], found: mismatch[2] } : null
+}
+
 /**
  * sibling-inject (2026-07-04) 用: spawn する codex app-server プロセス自身の
  * 環境変数に、この cwd の capability トークンを乗せる。ディスクには書かず、
@@ -765,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 で補完する
@@ -1754,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 (
@@ -1818,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"
@@ -1831,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,
@@ -1848,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()
@@ -2058,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 =
@@ -2463,15 +2612,66 @@ export class CodexStreamBridge extends EventEmitter {
     if (!session.dead) this._emitQueueState(session)
   }
 
-  /** @returns {Promise<void>} */
+  /**
+   * @returns {Promise<
+   *   | { outcome: "interrupted", turnId: string, corrected: boolean }
+   *   | { outcome: "no_active_turn" }
+   *   | { outcome: "failed", reason: string }
+   * >}
+   */
   async interrupt({ stream_id }) {
     const session = this._require(stream_id)
     this._touch(session, stream_id)
-    if (!session.activeTurnId) return
-    await session.client.request("turn/interrupt", {
-      threadId: session.threadId,
-      turnId: session.activeTurnId,
-    })
+    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,
+      })
+      result = { outcome: "interrupted", turnId, corrected: false }
+    } catch (err) {
+      const reason = err?.message || String(err)
+      const mismatch = parseTurnMismatch(reason)
+      if (!mismatch) result = { outcome: "failed", reason }
+
+      if (mismatch) {
+      const correctedTurnId = mismatch.found
+      // 是正は再送前に行い、再送中の corrected turn の完了通知を正しく照合できるようにする。
+      // 初回リクエスト中に状態が進んでいた場合は、その新しい状態を上書きしない。
+      if (session.activeTurnId === turnId) {
+        session.activeTurnId = correctedTurnId
+      }
+      try {
+        attemptedRootTurnId = correctedTurnId
+        await session.client.request("turn/interrupt", {
+          threadId: session.threadId,
+          turnId: correctedTurnId,
+        })
+        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
+        }
+        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

@@ -3194,6 +3194,30 @@ export function handleCodexChatInput(msg, ctx) {
   return p
 }
 
+export async function handleCodexInterrupt(msg, ctx) {
+  let result
+  if (!ctx.codexBridge) {
+    result = { outcome: "failed", reason: "bridge_unavailable", children: [] }
+  } else {
+    try {
+      result = await ctx.codexBridge.interrupt({ stream_id: msg.stream_id })
+      if (result.outcome === "failed") {
+        ctx.logger?.warn?.({ err: result.reason }, "codex.interrupt failed")
+      }
+    } catch (err) {
+      const reason = err?.message || String(err)
+      ctx.logger?.warn?.({ err: reason }, "codex.interrupt failed")
+      result = { outcome: "failed", reason, children: [] }
+    }
+  }
+  ctx.client.send({
+    type: "codex.interrupt.response",
+    stream_id: msg.stream_id,
+    request_id: msg.request_id ?? null,
+    ...result,
+  })
+}
+
 /**
  * tmux.kill_session の処理 (症状3 根治)。要求された session を kill し、要求元へ
  * tmux.kill_session.result を返したうえで、kill できた各 session について
@@ -4333,9 +4357,10 @@ async function dispatch(msg, ctx) {
         })
         return
       case "codex.interrupt":
-        if (!ctx.codexBridge) return
-        ctx.codexBridge.interrupt({ stream_id: msg.stream_id }).catch((err) => {
-          ctx.logger?.warn?.({ err: err.message }, "codex.interrupt failed")
+        // fire-and-forget だが async なので、送信失敗を未処理 rejection にしない
+        // (handleBundleSyncRequest と同じ作法)。停止経路が例外で無言死しないための保険。
+        handleCodexInterrupt(msg, ctx).catch((err) => {
+          ctx.logger?.warn?.({ err: err?.message || String(err) }, "codex.interrupt handler failed")
         })
         return
       case "codex.detach":