@cocorograph/hub-agent 0.8.41 → 0.8.43

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocorograph/hub-agent",
-  "version": "0.8.41",
+  "version": "0.8.43",
   "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({
@@ -3791,11 +3791,11 @@ async function dispatch(msg, ctx) {
           })
           if (resumeSessionId) {
             void ctx.siblingInjectBridge
-              ?.replayActiveDelegations(cwdArg || process.env.HOME || process.cwd(), resumeSessionId)
+              ?.replayDelegations(cwdArg || process.env.HOME || process.cwd(), resumeSessionId)
               .catch((err) => {
                 ctx.logger?.warn?.(
                   { err: err?.message || String(err), stream_id, session_id: resumeSessionId },
-                  "failed to replay active delegations after Claude attach",
+                  "failed to replay delegations after Claude attach",
                 )
               })
           }

package/src/sibling-inject.mjs

@@ -75,20 +75,68 @@ export const ACTIVE_DELEGATIONS_PER_SESSION_LIMIT = 100
 export const DELEGATION_LEDGER_RETENTION_MS = 24 * 60 * 60 * 1000
 const SIBLING_REQUEST_MAX_BYTES = 1024 * 1024
 const DELEGATE_PROMPT_MAX_LENGTH = 64_000
+const TERMINAL_DELEGATE_PROMPT_MAX_LENGTH = 2_000
+const TERMINAL_DELEGATE_AGENT_MAX_LENGTH = 200
+const TERMINAL_DELEGATE_DESCRIPTION_MAX_LENGTH = 2_000
+const DELEGATION_ID_MAX_LENGTH = 200
 
 const execFile = promisify(execFileCallback)
 
-function truncateDelegatePrompt(prompt) {
-  if (prompt.length <= DELEGATE_PROMPT_MAX_LENGTH) return prompt
-  let end = DELEGATE_PROMPT_MAX_LENGTH
-  const lastCodeUnit = prompt.charCodeAt(end - 1)
+function truncateString(value, maxLength, truncationNote) {
+  if (value.length <= maxLength) return value
+  let end = maxLength
+  const lastCodeUnit = value.charCodeAt(end - 1)
   if (lastCodeUnit >= 0xd800 && lastCodeUnit <= 0xdbff) end -= 1
-  return (
-    prompt.slice(0, end) +
-    `\n\n[依頼本文はここで打ち切られています（全 ${prompt.length} 文字）]`
+  return value.slice(0, end) + truncationNote(value.length)
+}
+
+function truncateDelegatePrompt(prompt) {
+  return truncateString(
+    prompt,
+    DELEGATE_PROMPT_MAX_LENGTH,
+    (length) => `\n\n[依頼本文はここで打ち切られています（全 ${length} 文字）]`,
   )
 }
 
+function compactTerminalEvent(event, includePrompt = false) {
+  const storedEvent = {}
+  for (const field of [
+    "type",
+    "subtype",
+    "delegation_id",
+    "phase",
+    "background",
+    "timestamp",
+  ]) {
+    if (event[field] !== undefined) storedEvent[field] = event[field]
+  }
+
+  if (typeof event.agent === "string") {
+    storedEvent.agent = truncateString(
+      event.agent,
+      TERMINAL_DELEGATE_AGENT_MAX_LENGTH,
+      (length) => `\n\n[エージェント名はここで打ち切られています（全 ${length} 文字）]`,
+    )
+  }
+  if (typeof event.description === "string") {
+    storedEvent.description = truncateString(
+      event.description,
+      TERMINAL_DELEGATE_DESCRIPTION_MAX_LENGTH,
+      (length) => `\n\n[説明はここで打ち切られています（全 ${length} 文字）]`,
+    )
+  }
+  if (includePrompt && typeof event.prompt === "string") {
+    storedEvent.prompt = truncateString(
+      event.prompt,
+      TERMINAL_DELEGATE_PROMPT_MAX_LENGTH,
+      (length) =>
+        `\n\n[終了済み委譲の依頼本文はここで打ち切られています（全 ${length} 文字）]`,
+    )
+  }
+
+  return storedEvent
+}
+
 /**
  * `ps` の起動時刻を送受信双方で比較する契約形へ正規化する。
  * 先頭・末尾の Unicode 空白だけを除去し、日時本体の内部空白は変更しない。
@@ -312,7 +360,7 @@ export class SiblingInjectBridge {
     this._pidStartedAt = pidStartedAt
     /** @type {Map<string, Map<string, {event: object, recordedAt: number}>>} cwd+session ごとの進行中委譲。 */
     this._activeDelegations = new Map()
-    /** @type {Map<string, Map<string, number>>} 終端→開始の逆転で遅着 started を復活させない墓標。 */
+    /** @type {Map<string, Map<string, {startedEvent?: object, terminalEvent: object, startedAt?: number, recordedAt: number}>>} 終了済み委譲の再送情報を兼ねた墓標。 */
     this._terminalDelegations = new Map()
   }
 
@@ -329,8 +377,8 @@ export class SiblingInjectBridge {
       if (entries.size === 0) this._activeDelegations.delete(sessionKey)
     }
     for (const [sessionKey, entries] of this._terminalDelegations) {
-      for (const [delegationId, recordedAt] of entries) {
-        if (recordedAt < cutoff) entries.delete(delegationId)
+      for (const [delegationId, entry] of entries) {
+        if (entry.recordedAt < cutoff) entries.delete(delegationId)
       }
       if (entries.size === 0) this._terminalDelegations.delete(sessionKey)
     }
@@ -340,6 +388,10 @@ export class SiblingInjectBridge {
     this._pruneDelegations()
     const sessionKey = this._delegationSessionKey(cwd, sessionId)
     if (event.phase !== "started") {
+      const activeEntry = this._activeDelegations.get(sessionKey)?.get(event.delegation_id)
+      const existingTerminalEntry = this._terminalDelegations
+        .get(sessionKey)
+        ?.get(event.delegation_id)
       this._activeDelegations.get(sessionKey)?.delete(event.delegation_id)
       if (this._activeDelegations.get(sessionKey)?.size === 0) {
         this._activeDelegations.delete(sessionKey)
@@ -350,7 +402,21 @@ export class SiblingInjectBridge {
         this._terminalDelegations.set(sessionKey, terminalEntries)
       }
       terminalEntries.delete(event.delegation_id)
-      terminalEntries.set(event.delegation_id, this._now())
+      terminalEntries.set(event.delegation_id, {
+        ...(activeEntry
+          ? {
+              startedEvent: compactTerminalEvent(activeEntry.event, true),
+              startedAt: activeEntry.recordedAt,
+            }
+          : existingTerminalEntry?.startedEvent && existingTerminalEntry.startedAt !== undefined
+            ? {
+                startedEvent: existingTerminalEntry.startedEvent,
+                startedAt: existingTerminalEntry.startedAt,
+              }
+            : {}),
+        terminalEvent: compactTerminalEvent(event),
+        recordedAt: this._now(),
+      })
       while (terminalEntries.size > ACTIVE_DELEGATIONS_PER_SESSION_LIMIT) {
         terminalEntries.delete(terminalEntries.keys().next().value)
       }
@@ -394,14 +460,35 @@ export class SiblingInjectBridge {
     }
   }
 
-  /** attach/再接続時に同じ cwd+session の進行中委譲だけを再送する。 */
-  async replayActiveDelegations(cwd, sessionId) {
+  /** attach/再接続時に同じ cwd+session の進行中・終了済み委譲を開始順で再送する。 */
+  async replayDelegations(cwd, sessionId) {
     if (!cwd || !sessionId) return
     this._pruneDelegations()
     const sessionKey = this._delegationSessionKey(cwd, sessionId)
-    const entries = this._activeDelegations.get(sessionKey)
-    if (!entries) return
-    for (const [delegationId, entry] of [...entries]) {
+    const replayEntries = [
+      ...[...(this._activeDelegations.get(sessionKey) || [])].map(([delegationId, entry]) => ({
+        delegationId,
+        entry,
+        kind: "active",
+        startedAt: entry.recordedAt,
+      })),
+      ...[...(this._terminalDelegations.get(sessionKey) || [])]
+        .filter(([, entry]) => entry.startedEvent && entry.startedAt !== undefined)
+        .map(([delegationId, entry]) => ({
+          delegationId,
+          entry,
+          kind: "terminal",
+          startedAt: entry.startedAt,
+        })),
+    ].sort((a, b) => a.startedAt - b.startedAt)
+
+    for (const { delegationId, entry, kind } of replayEntries) {
+      if (kind === "terminal") {
+        if (this._terminalDelegations.get(sessionKey)?.get(delegationId) !== entry) continue
+        this.claudeBridge?.emitToStream?.(cwd, sessionId, entry.startedEvent)
+        this.claudeBridge?.emitToStream?.(cwd, sessionId, entry.terminalEvent)
+        continue
+      }
       const alive = await this._delegateProcessAlive(entry.event)
       // 生存確認中に終端が届いた場合、古い snapshot の started/stopped を後から流さない。
       if (this._activeDelegations.get(sessionKey)?.get(delegationId) !== entry) continue
@@ -571,6 +658,7 @@ export class SiblingInjectBridge {
       phase,
       agent,
       description,
+      background,
       prompt,
       timestamp,
       pid,
@@ -590,10 +678,12 @@ export class SiblingInjectBridge {
     const badDelegateBody =
       typeof delegation_id !== "string" ||
       !delegation_id ||
+      delegation_id.length > DELEGATION_ID_MAX_LENGTH ||
       !delegatePhases.has(phase) ||
       (phase === "started" && (typeof agent !== "string" || !agent)) ||
       (agent !== undefined && typeof agent !== "string") ||
       (description !== undefined && typeof description !== "string") ||
+      (background !== undefined && typeof background !== "boolean") ||
       (prompt !== undefined && typeof prompt !== "string") ||
       (pid !== undefined && (!Number.isInteger(pid) || pid <= 0)) ||
       (pid_started_at !== undefined && typeof pid_started_at !== "string") ||
@@ -656,6 +746,7 @@ export class SiblingInjectBridge {
             phase,
             ...(agent !== undefined ? { agent } : {}),
             ...(description !== undefined ? { description } : {}),
+            ...(background !== undefined ? { background } : {}),
             ...(phase === "started" && prompt ? { prompt: truncateDelegatePrompt(prompt) } : {}),
             ...(pid !== undefined ? { pid } : {}),
             ...(pid_started_at !== undefined ? { pid_started_at } : {}),