@cocorograph/hub-agent 0.8.52 → 0.8.54

package/package.json

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

package/src/claude-stream-bridge.mjs

@@ -40,13 +40,19 @@ import { nextSessionSeq } from "./session-seq.mjs"
  * この cwd の capability トークンを乗せる。ディスクには書かず、プロセス環境変数
  * としてのみ渡す (src/sibling-token.mjs のコメント参照)。
  * @param {string} cwd
- * @returns {{COCKPIT_SIBLING_TOKEN: string, COCKPIT_SIBLING_CWD: string}}
+ * @returns {NodeJS.ProcessEnv & {COCKPIT_SIBLING_TOKEN: string, COCKPIT_SIBLING_CWD: string,
+ *   COCKPIT_DELEGATE_EVENT_ACK: string}}
  */
 function siblingEnvFor(cwd) {
   return {
     ...process.env,
     COCKPIT_SIBLING_TOKEN: getOrCreateSiblingToken(cwd),
     COCKPIT_SIBLING_CWD: cwd,
+    // hub-agent が spawn した Claude 配下 producer だけが delegate-event の受理 ACK を
+    // 要求するための capability。能力は spawn 時点で固定されるため、hub-agent を旧版へ
+    // ロールバックしても既存 producer は ACK を要求し続け、timeout し得る。
+    // 旧 bundle はこの値を無視し、従来どおり fire-and-forget のまま動く。
+    COCKPIT_DELEGATE_EVENT_ACK: "1",
     // ask-sibling スキル (cockpit_orch.py) が「自分は claude/codex どちらか」を
     // 環境変数から確実に判定できるようにする (ヒューリスティック不要)。
     COCKPIT_SIBLING_SELF_KIND: "claude",

package/src/codex-stream-bridge.mjs

@@ -1003,6 +1003,10 @@ export class CodexStreamBridge extends EventEmitter {
       historyTruncated: false,
       historyStart: 0,
       historyTotal: 0,
+      // cold resume が確定した parent cursor の基準件数と、それ以降の root live 追記数。
+      // thread/read の短縮が「先頭 compaction」か「末尾反映待ち」かを区別する。
+      historyColdBaseTotal: 0,
+      historyLiveCursorAdditions: 0,
       // reattach 表示履歴には child item も含むが cursor は parent item だけを数える。
       // historyItems/historyCursorWeights は常に同長。weight は 1=parent / 0=child で、trim 時の
       // start 前進量を決める。ready の start/total はこの cursor 専用で配列 index ではない。
@@ -1010,6 +1014,9 @@ export class CodexStreamBridge extends EventEmitter {
       historyCursorWeights: [],
       historySnapshotCache: new AsyncTtlCache({ ttlMs: this._historySnapshotCacheTtlMs }),
       historySnapshotReleaseTimer: null,
+      historySnapshotBuildSeq: 0,
+      historySnapshotReturnedBuildSeq: 0,
+      historySnapshotFreshOperations: new Set(),
       historySnapshotComparable: false,
       historyAttachInProgress: true,
       historyItemArrivedDuringAttach: false,
@@ -1178,6 +1185,8 @@ export class CodexStreamBridge extends EventEmitter {
       session.historyTruncated = historyTruncated
       session.historyStart = flat.start
       session.historyTotal = flat.total
+      session.historyColdBaseTotal = flat.total
+      session.historyLiveCursorAdditions = 0
       session.historyCursorWeights = history.map(() => 1)
       session.historyAttachInProgress = false
       session.historySnapshotComparable = session.historyItemArrivedDuringAttach !== true
@@ -1248,7 +1257,7 @@ export class CodexStreamBridge extends EventEmitter {
     } catch (err) {
       this.sessions.delete(stream_id)
       this._settleAllPendingApprovals(session, { respond: false })
-      this._disposeHistorySnapshot(session)
+      this._disposeSessionHistory(session)
       client.stop()
       settleReady(null) // reattach 待ちへ「失敗」を通知 (reject しない)
       // 失敗も 1 行に落とす。**_classifyAttachFailure より前**に出す (分類は rollout の disk 走査を
@@ -1375,6 +1384,12 @@ export class CodexStreamBridge extends EventEmitter {
     const cursorWeight = countsForCursor ? 1 : 0
     session.historyCursorWeights.push(cursorWeight)
     session.historyTotal = (Number.isInteger(session.historyTotal) ? session.historyTotal : 0) + cursorWeight
+    if (cursorWeight === 1 && session.historyAttachInProgress !== true) {
+      session.historyLiveCursorAdditions =
+        (Number.isInteger(session.historyLiveCursorAdditions)
+          ? session.historyLiveCursorAdditions
+          : 0) + 1
+    }
     // 古い page は同じ snapshot 座標内なら順序が壊れないため cache は clear しない。
     // child 更新は parent thread/read snapshot にも無関係。TTL 後の再取得で自然に追随する。
     session.historyBytes += estimateItemBytes(entry)
@@ -1432,14 +1447,170 @@ export class CodexStreamBridge extends EventEmitter {
     session.historySnapshotCache?.clear?.()
   }
 
+  _abortFreshHistorySnapshot(session) {
+    if (!session) return
+    // clear() は進行中AsyncTtlCache buildを切り離して新世代buildを許すため、fresh operationも
+    // 一時的に複数並走し得る。finally deleteとの競合を避け、snapshot配列を全件abort→stopする。
+    const operations = [...(session.historySnapshotFreshOperations || [])]
+    for (const operation of operations) {
+      operation.abort?.()
+      try {
+        operation.stop?.()
+      } catch (error) {
+        this.logger?.warn?.(
+          {
+            error_code: codexHostCapabilityErrorCode(
+              error,
+              "CODEX_HISTORY_SNAPSHOT_STOP_FAILED",
+            ),
+          },
+          "codex history snapshot client stop failed",
+        )
+      }
+    }
+  }
+
+  _disposeSessionHistory(session) {
+    this._abortFreshHistorySnapshot(session)
+    this._disposeHistorySnapshot(session)
+  }
+
+  async _resumeFullHistorySnapshot(
+    session,
+    advertisedTotal,
+    requiredTotal,
+    liveItems,
+    coldBaseTotal,
+    additionsAtRequest,
+  ) {
+    const client = this._clientFactory({
+      cwd: session.cwd,
+      codexCmd: this.codexCmd,
+      logger: this.logger,
+      env: siblingEnvFor(session.cwd),
+    })
+    client.on("error", (error) => {
+      this.logger?.warn?.(
+        {
+          error_code: codexHostCapabilityErrorCode(
+            error,
+            "CODEX_HISTORY_SNAPSHOT_CLIENT_ERROR",
+          ),
+        },
+        "codex history snapshot client error",
+      )
+    })
+    const startedAt = Date.now()
+    let stopped = false
+    const stopClient = () => {
+      if (stopped) return
+      stopped = true
+      client.stop()
+    }
+    let rejectAbort
+    const aborted = new Promise((_, reject) => {
+      rejectAbort = reject
+    })
+    const abort = () => {
+      const error = new Error("stream_id is not attached")
+      error.code = "CODEX_HISTORY_SNAPSHOT_FALLBACK_ABORTED"
+      rejectAbort(error)
+    }
+    const operation = { client, abort, stop: stopClient }
+    session.historySnapshotFreshOperations.add(operation)
+    this.logger?.info?.(
+      {
+        thread_id: session.threadId,
+        advertised_total: advertisedTotal,
+        required_total: requiredTotal,
+        live_items: liveItems,
+        cold_base_total: coldBaseTotal,
+        additions_at_request: additionsAtRequest,
+      },
+      "codex history snapshot fallback started",
+    )
+    try {
+      const items = await Promise.race([
+        (async () => {
+          client.start()
+          await client.request("initialize", {
+            clientInfo: CLIENT_INFO,
+            capabilities: {
+              experimentalApi: true,
+              mcpServerOpenaiFormElicitation: true,
+            },
+          })
+          client.notify("initialized", {})
+          const result = await client.request("thread/resume", {
+            cwd: session.cwd,
+            threadId: session.threadId,
+          })
+          if (result?.thread?.id !== session.threadId) {
+            throw new Error("fresh thread/resume returned a different thread")
+          }
+          const resumedItems = flattenAllThreadItems(result.thread)
+          if (resumedItems.length < requiredTotal) {
+            throw new Error("fresh history snapshot is shorter than required prefix total")
+          }
+          return resumedItems
+        })(),
+        aborted,
+      ])
+      this.logger?.info?.(
+        {
+          thread_id: session.threadId,
+          advertised_total: advertisedTotal,
+          required_total: requiredTotal,
+          live_items: liveItems,
+          cold_base_total: coldBaseTotal,
+          additions_at_request: additionsAtRequest,
+          elapsed_ms: Date.now() - startedAt,
+        },
+        "codex history snapshot fallback completed",
+      )
+      return items
+    } catch (error) {
+      const isAborted = error?.code === "CODEX_HISTORY_SNAPSHOT_FALLBACK_ABORTED"
+      this.logger?.[isAborted ? "info" : "warn"]?.(
+        {
+          thread_id: session.threadId,
+          advertised_total: advertisedTotal,
+          required_total: requiredTotal,
+          live_items: liveItems,
+          cold_base_total: coldBaseTotal,
+          additions_at_request: additionsAtRequest,
+          elapsed_ms: Date.now() - startedAt,
+          error_code: codexHostCapabilityErrorCode(
+            error,
+            "CODEX_HISTORY_SNAPSHOT_FALLBACK_FAILED",
+          ),
+        },
+        isAborted
+          ? "codex history snapshot fallback aborted"
+          : "codex history snapshot fallback failed",
+      )
+      throw error
+    } finally {
+      stopClient()
+      session.historySnapshotFreshOperations.delete(operation)
+    }
+  }
+
   async _historySnapshot(session) {
     // この reader は既存の別責務の thread/read と統合しない。要求した root thread と応答の
     // thread id が一致することを、この履歴取得経路自身で必ず検証する。
     const cache = session.historySnapshotCache
-    const items = await cache.get(async () => {
+    const snapshot = await cache.get(async () => {
+      const buildSeq = (Number.isInteger(session.historySnapshotBuildSeq)
+        ? session.historySnapshotBuildSeq
+        : 0) + 1
+      session.historySnapshotBuildSeq = buildSeq
       // session破棄時の cache.clear() で進行中callerが新世代buildへ合流し直しても、停止済み
       // clientへ2本目のthread/readを送らない。
       if (session.dead) throw new Error("stream_id is not attached")
+      const additionsAtRequest = Number.isInteger(session.historyLiveCursorAdditions)
+        ? session.historyLiveCursorAdditions
+        : 0
       const result = await session.client.request("thread/read", {
         threadId: session.threadId,
         includeTurns: true,
@@ -1447,11 +1618,22 @@ export class CodexStreamBridge extends EventEmitter {
       if (result?.thread?.id !== session.threadId) {
         throw new Error("thread/read returned a different thread")
       }
-      const items = flattenAllThreadItems(result.thread)
+      if (session.dead) throw new Error("stream_id is not attached")
+      let items = flattenAllThreadItems(result.thread)
+      const coldBaseTotal = Number.isInteger(session.historyColdBaseTotal)
+        ? session.historyColdBaseTotal
+        : 0
+      const liveCursorAdditions = Number.isInteger(session.historyLiveCursorAdditions)
+        ? session.historyLiveCursorAdditions
+        : 0
+      const advertisedTotal = Math.max(
+        Number.isInteger(session.historyTotal) ? session.historyTotal : 0,
+        coldBaseTotal + liveCursorAdditions,
+      )
+      const knownPrefixAtRequest = coldBaseTotal + additionsAtRequest
       if (
         session.historySnapshotComparable === true &&
-        Number.isInteger(session.historyTotal) &&
-        items.length !== session.historyTotal
+        items.length !== advertisedTotal
       ) {
         this.logger?.warn?.(
           {
@@ -1462,14 +1644,50 @@ export class CodexStreamBridge extends EventEmitter {
           "codex history snapshot item count differs from live parent cursor",
         )
       }
+      let usedFresh = false
+      // read開始時点で既知だったroot cursor prefixより短い場合だけcompactionと判定する。
+      // read発行前に観測した加算はread応答に含まれる前提。await中のlive追加はknownPrefixへ
+      // 含めず末尾lagとして許容し、この前提が破れた可能性はfallbackログで観測する。
+      if (items.length < knownPrefixAtRequest) {
+        const requiredTotal = coldBaseTotal > 0 ? coldBaseTotal : knownPrefixAtRequest
+        items = await this._resumeFullHistorySnapshot(
+          session,
+          advertisedTotal,
+          requiredTotal,
+          items.length,
+          coldBaseTotal,
+          additionsAtRequest,
+        )
+        usedFresh = true
+        // このbridgeはthread/rollback・thread/forkを呼ばず単調threadだけを扱うため、fresh
+        // thread/resumeのitemsは先頭からのdurable prefix。fresh成功時だけbaseを単調に引上げ、
+        // 並行live追加は差分として残す。
+        session.historyColdBaseTotal = Math.max(
+          Number.isInteger(session.historyColdBaseTotal) ? session.historyColdBaseTotal : 0,
+          items.length,
+        )
+        const newBase = session.historyColdBaseTotal
+        session.historyLiveCursorAdditions = Math.max(
+          0,
+          (Number.isInteger(session.historyTotal) ? session.historyTotal : 0) - newBase,
+        )
+      }
+      if (session.dead) throw new Error("stream_id is not attached")
       session.historyTotal = Math.max(
         items.length,
         Number.isInteger(session.historyTotal) ? session.historyTotal : 0,
       )
-      return items
+      return { items, usedFresh, buildSeq }
     })
+    if (session.dead) throw new Error("stream_id is not attached")
+    session.historySnapshotReturnedBuildSeq = Math.max(
+      Number.isInteger(session.historySnapshotReturnedBuildSeq)
+        ? session.historySnapshotReturnedBuildSeq
+        : 0,
+      snapshot.buildSeq,
+    )
     this._scheduleHistorySnapshotRelease(session)
-    return items
+    return snapshot
   }
 
   /**
@@ -1493,19 +1711,23 @@ export class CodexStreamBridge extends EventEmitter {
     if (before > (Number.isInteger(session.historyTotal) ? session.historyTotal : 0)) {
       throw new Error("before exceeds live history total")
     }
-    let all = await this._historySnapshot(session)
-    // readyが広告した正当cursorへTTL snapshotが追いついていない場合だけ、このrequest内で最大1回
-    // 強制再buildする。再帰/loopは使わず、なお短ければerrorへ固定する。
-    if (before > all.length) {
+    const maxItems = this._historyLimits.maxItems
+    const pageLimit = limit == null ? maxItems : Math.min(maxItems, limit)
+    const seqAtCall = Number.isInteger(session.historySnapshotReturnedBuildSeq)
+      ? session.historySnapshotReturnedBuildSeq
+      : 0
+    let snapshot = await this._historySnapshot(session)
+    // readyが広告した正当cursorへlive-only snapshotが追いついていない場合だけ、このrequest内で
+    // 最大1回再buildする。fresh済みsnapshotは同一requestで2本目を起動せず即errorへ固定する。
+    const usedFreshDuringCall = snapshot.usedFresh === true && snapshot.buildSeq > seqAtCall
+    if (before > snapshot.items.length && !usedFreshDuringCall) {
       this._disposeHistorySnapshot(session)
-      all = await this._historySnapshot(session)
+      snapshot = await this._historySnapshot(session)
     }
-    if (before > all.length) {
+    if (before > snapshot.items.length) {
       throw new Error("before exceeds history snapshot total")
     }
-    const maxItems = this._historyLimits.maxItems
-    const pageLimit = limit == null ? maxItems : Math.min(maxItems, limit)
-    const page = pageThreadItems(all, {
+    const page = pageThreadItems(snapshot.items, {
       before,
       maxItems: pageLimit,
       maxBytes: this._historyLimits.maxBytes,
@@ -3174,7 +3396,7 @@ export class CodexStreamBridge extends EventEmitter {
     if (session.dead) return
     this._markRunningSubagentsKilled(session)
     session.dead = true
-    this._disposeHistorySnapshot(session)
+    this._disposeSessionHistory(session)
     // round3: app-server が死んだら barrier を解除し queue を reject する（promise 宙吊り防止）。
     this._settleTurnActiveWaiter(session)
     this._drainRejectQueue(session, { reason: "queue_dead" })
@@ -4209,7 +4431,7 @@ export class CodexStreamBridge extends EventEmitter {
     if (session.dead) return
     this._markRunningSubagentsKilled(session, now)
     session.dead = true
-    this._disposeHistorySnapshot(session)
+    this._disposeSessionHistory(session)
     // round3: reap した session の barrier を解除し queue を reject する（promise 宙吊り防止）。
     this._settleTurnActiveWaiter(session)
     this._drainRejectQueue(session, { reason: "queue_dead" })
@@ -4399,7 +4621,7 @@ export class CodexStreamBridge extends EventEmitter {
     for (const session of this._liveSessions()) {
       this._markRunningSubagentsKilled(session)
       session.dead = true
-      this._disposeHistorySnapshot(session)
+      this._disposeSessionHistory(session)
       // round3: shutdown で barrier を解除し queue 入力を reject（promise 宙吊り防止）。
       this._settleTurnActiveWaiter(session)
       this._drainRejectQueue(session, { reason: "queue_dead" })

package/src/sibling-inject.mjs

@@ -37,10 +37,13 @@
  *   - 安全な再起動: `{op:"restart"}` → `{ok:true, restart_pending:true}`。本文と token を持たず、
  *       所有者限定の IPC directory/request file (0700/0600) だけを境界として扱う。
  * 処理後は必ず削除し (成否問わず)、通常 IPC は呼び出し側が待ち受けられるよう
- * `<request_id>.result.json` = `{ok, error?, delivered_to?, candidates?, live_sessions?, hint?,
+ * `<request_id>.result.json` = `{ok, error?, duplicate?, delivered_to?, candidates?, live_sessions?, hint?,
  * candidates_nameable?}` を書く (`candidates_nameable` は曖昧系エラーのときのみ。CLI が
  * 「候補を実行可能な `--to` として並べてよいか」を hint の文言に依存せず判定するための boolean)。
- * `delegate-event` だけは fire-and-forget のため応答ファイルを書かない。
+ * 同一 request_id の再投入は二重処理防止で無視するため、意味上の再送は新しい transport ID を使う。
+ * `delegate-event` の `request_ack` は省略または literal true だけが正規入力。true のとき受理結果を
+ * 書き、不正値でも property があれば明示エラーを書く。未指定の旧 producer は fire-and-forget の
+ * ままなので、新旧 bundle / hub-agent のローリング互換を保つ。
  *
  * ⚠️ codex の `delivery_state` は 4 値ある (2026-08-05 に `queued` を追加):
  *   - `delivered`            … userMessage echo まで確認済み (ok:true)
@@ -82,6 +85,7 @@ const SIBLING_SWEEP_DEBOUNCE_MS = 25
 
 export const ACTIVE_DELEGATIONS_PER_SESSION_LIMIT = 100
 export const DELEGATION_LEDGER_RETENTION_MS = 24 * 60 * 60 * 1000
+export const SIBLING_RESULT_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
@@ -491,8 +495,8 @@ export class SiblingInjectBridge {
     }
   }
 
-  _recordDelegateEvent(cwd, sessionId, event) {
-    this._pruneDelegations()
+  _recordDelegateEvent(cwd, sessionId, event, { prune = true } = {}) {
+    if (prune) this._pruneDelegations()
     const sessionKey = this._delegationSessionKey(cwd, sessionId)
     if (event.phase !== "started") {
       const activeEntry = this._activeDelegations.get(sessionKey)?.get(event.delegation_id)
@@ -542,11 +546,40 @@ export class SiblingInjectBridge {
     }
   }
 
-  _acceptsDelegateEvent(cwd, sessionId, event) {
+  _delegateEventAcceptance(cwd, sessionId, event) {
     this._pruneDelegations()
-    if (event.phase !== "started") return true
     const sessionKey = this._delegationSessionKey(cwd, sessionId)
-    return !this._terminalDelegations.get(sessionKey)?.has(event.delegation_id)
+    const terminal = this._terminalDelegations.get(sessionKey)?.get(event.delegation_id)
+    if (event.phase === "started") {
+      if (terminal) return "stale"
+      return this._activeDelegations.get(sessionKey)?.has(event.delegation_id)
+        ? "duplicate"
+        : "accept"
+    }
+    if (!terminal) return "accept"
+    // terminal 同士は後から届いた実イベントを最新終端として上書きできる。
+    // 例: replay が PID 消失から stopped を合成した後に producer の completed が届く。
+    return terminal.terminalEvent?.phase === event.phase ? "duplicate" : "accept"
+  }
+
+  _liveClaudeSession(cwd, sessionId) {
+    const matches = describeLiveSessionsUnion(this._bridges(), {
+      cwd,
+      cliKind: "claude",
+    }).filter((session) => session.session_id === sessionId)
+    if (matches.length === 1) return { status: "delivered", session: matches[0] }
+    return {
+      status: matches.length > 1 ? "ambiguous" : "not_found",
+      ...(matches.length ? { candidates: matches } : {}),
+    }
+  }
+
+  _delegateTargetFailure(targetResult) {
+    return {
+      ok: false,
+      error: AMBIGUOUS_TARGET_ERROR,
+      ...(targetResult?.candidates ? { candidates: targetResult.candidates } : {}),
+    }
   }
 
   async _delegateProcessAlive(event) {
@@ -699,7 +732,26 @@ export class SiblingInjectBridge {
       return
     }
     for (const n of names) {
-      if (n.endsWith(".json") && !n.endsWith(".result.json")) {
+      if (n.endsWith(".result.json")) {
+        const fp = path.join(this.dir, n)
+        try {
+          const info = await lstat(fp)
+          const uid = process.getuid?.()
+          if (
+            !info.isSymbolicLink() &&
+            info.isFile() &&
+            uid != null &&
+            info.uid === uid &&
+            // 壁時計が前へ step すると保持期間が短くなるが、result は再配送の正本ではなく
+            // 呼び出し側が回収する一時 ACK なので、24時間経過扱いでの掃除を許容する。
+            info.mtimeMs < this._now() - SIBLING_RESULT_RETENTION_MS
+          ) {
+            await unlink(fp)
+          }
+        } catch {
+          /* 同時に呼び出し側が回収済みなら no-op */
+        }
+      } else if (n.endsWith(".json")) {
         await this._ingest(n, { startup }).catch((err) => {
           this.logger?.warn({ err: err?.message, filename: n }, "sibling-inject sweep failed")
         })
@@ -709,7 +761,8 @@ export class SiblingInjectBridge {
 
   /**
    * 要求ファイル 1 件を読み、トークン検証後に対象 cwd のセッションへ注入する。
-   * 成否によらず要求ファイルは削除する。delegate-event 以外は結果ファイルも書く。
+   * 成否によらず要求ファイルは削除する。delegate-event は request_ack:true または
+   * malformed な request_ack property がある場合だけ結果ファイルも書く。
    * @param {string} filename `<request_id>.json`
    */
   async _ingest(filename, { startup = false } = {}) {
@@ -729,8 +782,8 @@ export class SiblingInjectBridge {
         // ⚠️ **結果ファイルを必ず書く**。ここで書かずに戻ると、結果をポーリングしている
         // 呼び出し側 (cockpit_orch.py) には「タイムアウト」としか見えない。タイムアウトは
         // 「不達とは限らない」と扱う契約なので、拒否した事実が呼び出し側で不達に化ける
-        // (＝黙って捨てたのと同じになる)。delegate-event の送り手は結果を読まないため、
-        // op を判別できないまま無条件に書いて構わない (余分な結果ファイルは stale 掃除の対象)。
+        // (＝黙って捨てたのと同じになる)。ここでは本文を parse できず op / request_ack を
+        // 判別できないため無条件に書く。旧 producer 向けの余分な結果は stale 掃除の対象。
         await this._writeResult(request_id, {
           ok: false,
           error: "request_too_large",
@@ -778,6 +831,7 @@ export class SiblingInjectBridge {
       timestamp,
       pid,
       pid_started_at,
+      request_ack,
     } = body || {}
     // 連携カード種別 (Phase 2, 2026-07-23): 注入を受け手画面で専用カード表示させるためのタグ。
     // 既知値 ('peer'|'orchestrator') のみ通し、未知値/未指定は undefined に落とす (未知の source を
@@ -787,6 +841,7 @@ export class SiblingInjectBridge {
     const isList = op === "list"
     const isExplicit = op === "inject"
     const isDelegateEvent = op === "delegate-event"
+    const hasRequestAck = Object.prototype.hasOwnProperty.call(body || {}, "request_ack")
     const isRestart = op === "restart"
     let result
     const badKind = target_cli_kind !== "claude" && target_cli_kind !== "codex"
@@ -803,6 +858,7 @@ export class SiblingInjectBridge {
       (prompt !== undefined && typeof prompt !== "string") ||
       (pid !== undefined && (!Number.isInteger(pid) || pid <= 0)) ||
       (pid_started_at !== undefined && typeof pid_started_at !== "string") ||
+      (request_ack !== undefined && request_ack !== true) ||
       (timestamp !== undefined &&
         (typeof timestamp !== "string" || Number.isNaN(Date.parse(timestamp))))
     const badBody = isDelegateEvent
@@ -892,21 +948,26 @@ export class SiblingInjectBridge {
           }
           // 墓標確認から配送成功時の台帳反映まで await を挟まない同期区間に閉じる。
           // 配送失敗した started は台帳へ残さず、終端後に遅着した started は配送前に拒否する。
-          if (!this._acceptsDelegateEvent(cwd, target_session_id, event)) {
+          const acceptance = this._delegateEventAcceptance(cwd, target_session_id, event)
+          if (acceptance === "duplicate") {
+            // ACK は「過去に受理した」だけでなく、対象 stream が現在も live であることも示す。
+            // 台帳だけで成功を返すと、宛先消失後の retry を受理済みと誤認させる。
+            const live = this._liveClaudeSession(cwd, target_session_id)
+            result = live.status === "delivered"
+              ? { ok: true, duplicate: true }
+              : this._delegateTargetFailure(live)
+          } else if (acceptance === "stale") {
             result = { ok: false, error: "stale_delegate_event" }
           } else {
             const r = this.claudeBridge?.emitToStream
               ? this.claudeBridge.emitToStream(cwd, target_session_id, event)
               : { status: "not_found" }
             if (r.status === "delivered") {
-              this._recordDelegateEvent(cwd, target_session_id, event)
+              // acceptance 直前に prune 済み。同じ同期区間で二重 prune しない。
+              this._recordDelegateEvent(cwd, target_session_id, event, { prune: false })
               result = { ok: true, delivered_to: r.session }
             } else {
-              result = {
-                ok: false,
-                error: AMBIGUOUS_TARGET_ERROR,
-                ...(r.candidates ? { candidates: r.candidates } : {}),
-              }
+              result = this._delegateTargetFailure(r)
             }
           }
         }
@@ -1068,6 +1129,7 @@ export class SiblingInjectBridge {
               delivery_state: result.delivery_state,
               durable_state: result.durable_state,
               reason: result.reason,
+              duplicate: result.duplicate,
             }
           : {
               error: result.error,
@@ -1077,7 +1139,9 @@ export class SiblingInjectBridge {
             }),
       },
       result.ok
-        ? result.delivery_state === "delivered"
+        ? result.duplicate
+          ? "sibling-inject duplicate acknowledged"
+          : result.delivery_state === "delivered"
           ? "sibling-inject delivered"
           : result.delivery_state === "queued"
             ? "sibling-inject queued"
@@ -1085,7 +1149,11 @@ export class SiblingInjectBridge {
         : "sibling-inject failed",
     )
     // startup sweep 由来の restart には待受者がいない。孤児 result を残さない。
-    if (!isDelegateEvent && !(isRestart && startup)) await this._writeResult(request_id, result)
+    if ((!isDelegateEvent || hasRequestAck) && !(isRestart && startup)) {
+      // delegate ACK は「対象 Claude stream の内部 event 経路へ受理」までの保証。
+      // ブラウザ側がイベントを登録・描画したことまでは保証しない。
+      await this._writeResult(request_id, result)
+    }
     // 要求ファイルは処理後に必ず削除する (成否問わず、再処理させないため)。
     try {
       await unlink(fp)