@cocorograph/hub-agent 0.8.1 → 0.8.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocorograph/hub-agent",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "description": "Hub Hosted Cockpit のローカル常駐 agent。Hub と outbound WSS で接続し、ローカルの tmux/pty を中継する。",
   "type": "module",
   "license": "UNLICENSED",

package/src/codex-delivery-audit.mjs

@@ -0,0 +1,177 @@
+import { createHash } from "node:crypto"
+import { open, stat } from "node:fs/promises"
+
+import { findCodexRolloutFile } from "./usage.mjs"
+
+const MAX_AUDIT_BYTES = 4 * 1024 * 1024
+
+function sha256(text) {
+  return createHash("sha256").update(String(text ?? ""), "utf8").digest("hex")
+}
+
+function userMessageText(record) {
+  if (record?.type !== "response_item") return null
+  const payload = record.payload
+  if (payload?.type !== "message" || payload?.role !== "user") return null
+  if (typeof payload.content === "string") return payload.content
+  if (!Array.isArray(payload.content)) return null
+  return payload.content
+    .map((part) =>
+      part && typeof part === "object" && typeof part.text === "string" ? part.text : "",
+    )
+    .join("")
+}
+
+/**
+ * 注入前の rollout 位置を記録する。rollout がまだ無い fresh thread も offset=0 として扱い、
+ * verify 時に同じ threadId から再解決する。rollout は二次監査であり、失敗しても配送を止めない。
+ */
+export async function snapshotCodexDeliveryAudit(
+  threadId,
+  text,
+  { findRolloutFile = findCodexRolloutFile } = {},
+) {
+  const contentHash = sha256(text)
+  let filePath = null
+  let offset = 0
+  let snapshotReason = null
+  try {
+    filePath = await findRolloutFile(threadId)
+    if (filePath) offset = (await stat(filePath)).size
+    else snapshotReason = "rollout_not_found_before_dispatch"
+  } catch (err) {
+    snapshotReason = `snapshot_error:${err instanceof Error ? err.message : String(err)}`
+    filePath = null
+    offset = 0
+  }
+  return {
+    threadId,
+    contentHash,
+    filePath,
+    offset,
+    snapshotReason,
+    dispatchedAtMs: Date.now(),
+  }
+}
+
+async function scanAuditRange(audit) {
+  const filePath = audit.filePath
+  if (!filePath) return { durable: false, reason: "audit_file_path_missing" }
+  const info = await stat(filePath)
+  if (info.size <= audit.offset) {
+    return { durable: false, reason: "rollout_not_advanced", filePath }
+  }
+
+  // 注入前 offset からだけ読む。極端な flush 増加時は末尾 4MiB に制限し、先頭の半端行を捨てる。
+  const desiredStart = Math.min(audit.offset, info.size)
+  const start = Math.max(desiredStart, info.size - MAX_AUDIT_BYTES)
+  const length = info.size - start
+  const fh = await open(filePath, "r")
+  let text
+  try {
+    const buffer = Buffer.alloc(length)
+    const { bytesRead } = await fh.read(buffer, 0, length, start)
+    text = buffer.subarray(0, bytesRead).toString("utf8")
+  } finally {
+    await fh.close()
+  }
+
+  let lines = text.split("\n")
+  if (start > desiredStart) lines = lines.slice(1)
+  let matchingContentMissingTimestamp = 0
+  let matchingContentBeforeDispatch = 0
+  for (const line of lines) {
+    if (!line.trim()) continue
+    let record
+    try {
+      record = JSON.parse(line)
+    } catch {
+      continue
+    }
+    const message = userMessageText(record)
+    if (message === null || sha256(message) !== audit.contentHash) continue
+    const recordAtMs = Date.parse(record?.timestamp || "")
+    // rollout が注入前には未生成だった場合 offset=0 になるため、同一 thread の過去の同一本文を
+    // durable と誤認しない。timestamp を持たない record も安全側で監査対象外にする。
+    if (
+      audit.snapshotReason &&
+      !Number.isFinite(recordAtMs)
+    ) {
+      matchingContentMissingTimestamp += 1
+      continue
+    }
+    if (audit.snapshotReason && recordAtMs < audit.dispatchedAtMs) {
+      matchingContentBeforeDispatch += 1
+      continue
+    }
+    return {
+      durable: true,
+      reason: null,
+      filePath,
+      offset: audit.offset,
+      matchedTimestamp: record.timestamp || null,
+    }
+  }
+  if (matchingContentMissingTimestamp > 0) {
+    return {
+      durable: false,
+      reason: "matching_content_missing_timestamp",
+      matchingContentMissingTimestamp,
+      filePath,
+    }
+  }
+  if (matchingContentBeforeDispatch > 0) {
+    return {
+      durable: false,
+      reason: "matching_content_before_dispatch",
+      matchingContentBeforeDispatch,
+      filePath,
+    }
+  }
+  return {
+    durable: false,
+    reason: start > desiredStart ? "content_hash_not_found_in_capped_range" : "content_hash_not_found",
+    filePath,
+  }
+}
+
+/**
+ * rollout flush の遅延を許容して非同期再照合する。結果は監査ログ専用で、echo による delivered
+ * 判定を昇格・降格しない。
+ */
+export async function verifyCodexDeliveryAudit(
+  audit,
+  { findRolloutFile = findCodexRolloutFile, attempts = 8, intervalMs = 250 } = {},
+) {
+  if (!audit?.threadId || !audit?.contentHash) {
+    return { durable: false, reason: "invalid_audit_snapshot" }
+  }
+  let last = { durable: false, reason: "not_checked" }
+  let resolvedFilePath = audit.filePath || null
+  // snapshot 時に未発見なら毎 250ms の全セッション走査を避け、最終 attempt でだけ再解決する。
+  // 一度見つけた path は以後の flush 待ちで再利用する。
+  let resolutionAttempted = Boolean(resolvedFilePath)
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    try {
+      if (!resolvedFilePath && (!resolutionAttempted || attempt === attempts)) {
+        resolvedFilePath = await findRolloutFile(audit.threadId)
+        resolutionAttempted = true
+      }
+      if (!resolvedFilePath) {
+        last = { durable: false, reason: "rollout_not_found" }
+      } else {
+        last = await scanAuditRange({ ...audit, filePath: resolvedFilePath })
+      }
+    } catch (err) {
+      last = {
+        durable: false,
+        reason: `audit_error:${err instanceof Error ? err.message : String(err)}`,
+      }
+    }
+    if (last.durable) return { ...last, attempts: attempt }
+    if (attempt < attempts) {
+      await new Promise((resolve) => setTimeout(resolve, intervalMs))
+    }
+  }
+  return { ...last, attempts }
+}

package/src/codex-stream-bridge.mjs

@@ -41,8 +41,13 @@
  * 返す (browser 側での re-mount 白紙状態を解消する)。
  */
 import { EventEmitter } from "node:events"
+import { randomUUID } from "node:crypto"
 
 import { CodexAppServerClient } from "./codex-appserver-client.mjs"
+import {
+  snapshotCodexDeliveryAudit,
+  verifyCodexDeliveryAudit,
+} from "./codex-delivery-audit.mjs"
 import { getOrCreateSiblingToken } from "./sibling-token.mjs"
 import { codexRolloutPresence, listCodexThreadsFromDisk } from "./usage.mjs"
 
@@ -128,6 +133,12 @@ const DEAD_TERMINAL_TTL_MS =
 const TURN_START_TIMEOUT_MS =
   Number(process.env.HUB_AGENT_CODEX_TURN_START_TIMEOUT_MS) || 30 * 1000
 
+// sibling-inject の turn RPC が成功した後、app-server が同じ userMessage を
+// item/completed で echo するまで待つ上限。RPC accepted と userMessage delivered を
+// 分離し、旧 stream / 初期化競合で rollout に残らない入力を成功扱いしない。
+const DELIVERY_ECHO_TIMEOUT_MS =
+  Number(process.env.HUB_AGENT_CODEX_DELIVERY_ECHO_TIMEOUT_MS) || 8 * 1000
+
 const CLIENT_INFO = { name: "cockpit-hub-agent", title: "Cockpit", version: "1.0.0" }
 
 // T06499 (2026-07-18): 巨大スレッドの resume ガード。長期運用したスレッドの rollout は
@@ -305,6 +316,9 @@ export class CodexStreamBridge extends EventEmitter {
     stuckTurnTtlMs,
     deadTerminalTtlMs,
     turnStartTimeoutMs,
+    deliveryEchoTimeoutMs,
+    deliveryAuditSnapshot,
+    deliveryAuditVerify,
     rolloutPresence,
     listThreadsFromDisk,
     historyMaxItems,
@@ -325,6 +339,11 @@ export class CodexStreamBridge extends EventEmitter {
     this._deadTerminalTtlMs = deadTerminalTtlMs ?? DEAD_TERMINAL_TTL_MS
     // round3 major#2: turn/start 後に turn/started を待つ上限（既定 30s）。テストから短縮可能。
     this._turnStartTimeoutMs = turnStartTimeoutMs ?? TURN_START_TIMEOUT_MS
+    // sibling-inject の userMessage echo を待つ上限（既定 8s）。テストから短縮可能。
+    this._deliveryEchoTimeoutMs = deliveryEchoTimeoutMs ?? DELIVERY_ECHO_TIMEOUT_MS
+    // rollout は echo 後の二次監査専用。テストでは I/O を stub できる。
+    this._deliveryAuditSnapshot = deliveryAuditSnapshot || snapshotCodexDeliveryAudit
+    this._deliveryAuditVerify = deliveryAuditVerify || verifyCodexDeliveryAudit
     // #4 失敗分類の rollout 存在チェック (tri-state。テストから注入可能)。
     this._rolloutPresence = rolloutPresence || codexRolloutPresence
     // Phase 3 (Read-plane スライス2a): 一覧を rollout の disk 走査で作る (app-server 非 spawn)。
@@ -460,7 +479,8 @@ export class CodexStreamBridge extends EventEmitter {
       // 直列化し、二重 turn/start・queue 追い越し・並行 steer を構造的に排除する。旧 turnStarting/
       // pendingInputs の二重路 (queue 経路 + 直通経路) が overtaking と並行リトライ二重ターンの温床だった。
       /** @type {Array<{input: object[], model?: string, effort?: string, resolve: Function,
-       *  reject: Function, retriedAsStart?: boolean}>} round3 major#1: **session 単位の単一 FIFO**。
+       *  reject: Function, retriedAsStart?: boolean, deliveryId?: string,
+       *  sourceStreamId?: string}>} round3 major#1: **session 単位の単一 FIFO**。
        *  全 input() はここに積まれ、単一 pump (_pumpInputs) が **1 件ずつ直列**に処理する。直通経路を
        *  廃したので、drain 中の新規 input が queue を追い越したり、並行 turn/start・steer を発行して
        *  二重ターンになる事故が起きない。各 promise は **実 delivery (turn/start か turn/steer の RPC)**で
@@ -509,7 +529,9 @@ export class CodexStreamBridge extends EventEmitter {
       // 注入本文 (text) → source ('peer'|'orchestrator') を控える FIFO。sendToCwd/sendToStream が
       // 注入直前に積み、直後に app-server が返す userMessage の item/completed で本文一致により
       // _onNotification が消費して params.item.source を付ける (frontend が専用カードへ分岐)。
-      /** @type {Array<{text: string, source: 'peer'|'orchestrator'}>} */
+      /** @type {Array<{text: string, source?: 'peer'|'orchestrator',
+       *  deliveryId: string, sourceStreamId: string, deliveryPending: boolean,
+       *  deliveryPromise: Promise<object>, settleDelivery: Function}>} */
       pendingInjectSources: [],
     }
     session.ready = new Promise((resolve) => {
@@ -524,15 +546,46 @@ export class CodexStreamBridge extends EventEmitter {
     //     / MCP 起動の失敗 (thread op 未到達) は attach 失敗分類の対象外にする (pointer を消さない)。
     let reachedThreadOp = false
     try {
+      this.logger?.info?.(
+        { stream_id, cwd, resuming, lifecycle_stage: "initialize_started" },
+        "codex app-server session initialization",
+      )
       await client.request("initialize", { clientInfo: CLIENT_INFO })
+      // 公式 App Server handshake: initialize 応答後、同じ transport 上で initialized を
+      // 通知してから thread operation を開始する。現行 server の寛容動作に依存しない。
+      client.notify("initialized", {})
+      this.logger?.info?.(
+        { stream_id, cwd, resuming, lifecycle_stage: "initialized_sent" },
+        "codex app-server session initialization",
+      )
       reachedThreadOp = true
       const startParams = { cwd, model: model || undefined, sandbox: sandbox || undefined }
       if (effort) startParams.effort = effort
       if (approvalPolicy) startParams.approvalPolicy = approvalPolicy
+      this.logger?.info?.(
+        {
+          stream_id,
+          cwd,
+          resuming,
+          resume_thread_id: resumeThreadId || null,
+          lifecycle_stage: resuming ? "thread_resume_started" : "thread_start_started",
+        },
+        "codex app-server session initialization",
+      )
       const result = resuming
         ? await client.request("thread/resume", { ...startParams, threadId: resumeThreadId })
         : await client.request("thread/start", startParams)
       session.threadId = result?.thread?.id
+      this.logger?.info?.(
+        {
+          stream_id,
+          thread_id: session.threadId || null,
+          cwd,
+          resuming,
+          lifecycle_stage: resuming ? "thread_resume_completed" : "thread_start_completed",
+        },
+        "codex app-server session initialization",
+      )
       // 新規スレッド (thread/start) は履歴が無いので空配列。resume 時のみ平坦化する
       // (thread/start のレスポンスは turns を持たない仕様のため呼んでも常に空)。
       // T06499: 巨大スレッドは末尾 N ターンに絞る (truncated=true なら browser がバナー表示)。
@@ -808,6 +861,7 @@ export class CodexStreamBridge extends EventEmitter {
     client.start()
     try {
       await client.request("initialize", { clientInfo: CLIENT_INFO })
+      client.notify("initialized", {})
       const result = await client.request("account/rateLimits/read", {})
       this._accountRateLimitsByProfile.set(profileId, result)
       return result
@@ -860,22 +914,81 @@ export class CodexStreamBridge extends EventEmitter {
     return Array.from(new Set(this.sessions.values())).filter((s) => !s.dead)
   }
 
-  /** 連携カード種別 (Phase 2): 注入本文 → source を session の FIFO に控える。sendToCwd/
+  /** 連携カード種別 + 配達確認: 注入本文 → entry を session の FIFO に控える。sendToCwd/
    *  sendToStream が input() を呼ぶ直前に記録し、直後の userMessage echo を
-   *  _tagInjectSourceOnItem が拾う。
+   *  _tagInjectSourceOnItem が拾う。entry 自体が delivery promise の handle であり、
+   *  同一本文の並行注入でも splice した **その entry だけ**を settle する。
+   *
+   * App Server の userMessage item には client correlation metadata が無いため、同一本文の
+   * 複数注入は session FIFO と echo FIFO が同順であることに依存する。可視 CID を本文へ混ぜて
+   * モデル入力を汚さず、内部 deliveryId はログ・IPC 相関に使う。
    *  @param {object} session
    *  @param {string} text
-   *  @param {'peer'|'orchestrator'|undefined} source */
-  _recordInjectSource(session, text, source) {
-    if (!session || (source !== "peer" && source !== "orchestrator") || !text) return null
+   *  @param {'peer'|'orchestrator'|undefined} source
+   *  @param {string} deliveryId
+   *  @param {string} sourceStreamId */
+  _recordInjectSource(
+    session,
+    text,
+    source,
+    deliveryId = randomUUID(),
+    sourceStreamId = session?.stream_id || "",
+  ) {
+    if (!session || !text || !deliveryId) return null
     const list = session.pendingInjectSources || (session.pendingInjectSources = [])
-    const entry = { text, source }
+    let settleDelivery
+    const deliveryPromise = new Promise((resolve) => {
+      settleDelivery = resolve
+    })
+    const entry = {
+      text,
+      source: source === "peer" || source === "orchestrator" ? source : undefined,
+      deliveryId,
+      sourceStreamId,
+      deliveryPending: true,
+      deliveryPromise,
+      settleDelivery,
+    }
     list.push(entry)
     // echo が来ない稀ケースの無限成長を防ぐ (連携注入は低頻度、32 件で十分)。
-    if (list.length > 32) list.shift()
+    if (list.length > 32) {
+      const dropped = list.shift()
+      this._settleInjectDelivery(dropped, { delivered: false, reason: "tracking_overflow" })
+    }
     return entry
   }
 
+  /** delivery handle を一度だけ settle する。 */
+  _settleInjectDelivery(entry, result) {
+    if (!entry || !entry.deliveryPending) return
+    entry.deliveryPending = false
+    entry.settleDelivery?.(result)
+  }
+
+  /** session 終了時、echo 待機中の sibling injection を timeout より先に失敗確定する。 */
+  _settlePendingInjectDeliveries(session, reason = "session_dead") {
+    const pending = session?.pendingInjectSources
+    if (!Array.isArray(pending) || pending.length === 0) return
+    session.pendingInjectSources = []
+    for (const entry of pending) {
+      this._settleInjectDelivery(entry, { delivered: false, reason })
+    }
+  }
+
+  /** turn RPC accepted 後、対応する userMessage echo を timeout 付きで待つ。 */
+  async _waitInjectDelivery(entry) {
+    if (!entry) return { delivered: false, reason: "tracking_unavailable" }
+    if (!entry.deliveryPending) return entry.deliveryPromise
+    const timeout = new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        this._settleInjectDelivery(entry, { delivered: false, reason: "echo_timeout" })
+        resolve({ delivered: false, reason: "echo_timeout" })
+      }, this._deliveryEchoTimeoutMs)
+      entry.deliveryPromise.finally(() => clearTimeout(timer))
+    })
+    return Promise.race([entry.deliveryPromise, timeout])
+  }
+
   /** 連携カード種別 (Phase 2, cross-review round1 major#1 / round2 major): 注入 (input) が配送失敗
    *  したときに、record が返した **その entry だけ**を identity (indexOf) で取り消す。
    *  ⚠️ text で消してはいけない (round2 指摘): 同一本文を並行注入し後発だけ失敗すると、text 先頭
@@ -886,6 +999,7 @@ export class CodexStreamBridge extends EventEmitter {
     if (!list || !handle) return
     const idx = list.indexOf(handle)
     if (idx !== -1) list.splice(idx, 1)
+    this._settleInjectDelivery(handle, { delivered: false, reason: "input_failed" })
   }
 
   /** userMessage の echo (item/completed) が控えた注入本文と一致すれば、params を **クローン**して
@@ -911,9 +1025,25 @@ export class CodexStreamBridge extends EventEmitter {
     if (!text) return null
     const idx = list.findIndex((p) => p.text === text)
     if (idx === -1) return null
-    const { source } = list[idx]
-    list.splice(idx, 1)
-    return { ...msg.params, item: { ...item, source } }
+    const [entry] = list.splice(idx, 1)
+    this._settleInjectDelivery(entry, {
+      delivered: true,
+      itemId: item.id || null,
+      completedAtMs: msg.params?.completedAtMs || null,
+    })
+    this.logger?.info?.(
+      {
+        delivery_id: entry.deliveryId,
+        stream_id: entry.sourceStreamId,
+        current_stream_id: session.stream_id,
+        thread_id: session.threadId,
+        item_id: item.id || null,
+        delivery_state: "delivered",
+      },
+      "codex sibling injection userMessage echo observed",
+    )
+    const taggedItem = entry.source ? { ...item, source: entry.source } : { ...item }
+    return { ...msg.params, item: taggedItem }
   }
 
   /** 案B: この session を指す全購読 stream_id キーを sessions Map から外す（reap / exit 共通）。 */
@@ -950,6 +1080,15 @@ export class CodexStreamBridge extends EventEmitter {
         this._settleTurnActiveWaiter(session)
         // 会話ターン境界で「新しさ」を更新（閲覧 keepalive では更新しない）。
         session.lastTurnAtMs = Date.now()
+        this.logger?.info?.(
+          {
+            stream_id: session.stream_id,
+            thread_id: session.threadId,
+            turn_id: session.activeTurnId,
+            lifecycle_stage: "turn_started",
+          },
+          "codex app-server turn lifecycle",
+        )
         break
       case "turn/completed":
         session.activeTurnId = null
@@ -958,6 +1097,16 @@ export class CodexStreamBridge extends EventEmitter {
         this._settleTurnActiveWaiter(session)
         session.lastTurnAtMs = Date.now()
         this._autoResolveStalePendingApprovals(session, msg.params?.turn?.id)
+        this.logger?.info?.(
+          {
+            stream_id: session.stream_id,
+            thread_id: session.threadId,
+            turn_id: msg.params?.turn?.id || null,
+            turn_status: msg.params?.turn?.status || null,
+            lifecycle_stage: "turn_completed",
+          },
+          "codex app-server turn lifecycle",
+        )
         // Stage 5: turn 完了後の reap 予約は不要。以降 idle になれば周期 reconcile が
         // 長 idle TTL / LRU で扱う（detach 済みでも 7 日 warm 保持）。
         break
@@ -1036,6 +1185,7 @@ export class CodexStreamBridge extends EventEmitter {
     // round3: app-server が死んだら barrier を解除し queue を reject する（promise 宙吊り防止）。
     this._settleTurnActiveWaiter(session)
     this._drainRejectQueue(session, { reason: "queue_dead" })
+    this._settlePendingInjectDeliveries(session, "session_dead")
     // 案B: app-server が死んだら全購読 stream_id キーを Map から外す（1 端末分だけでは
     // 他の購読キーが dangling で残る）。
     this._dropAllStreamKeys(session)
@@ -1078,7 +1228,8 @@ export class CodexStreamBridge extends EventEmitter {
    *   ("Override the model for this turn and subsequent turns")。turn/start でのみ有効。
    * @param {string} [args.effort] - 公式スキーマ `TurnStartParams.effort`
    *   ("Override the reasoning effort for this turn and subsequent turns")。turn/start でのみ有効。
-   * @returns {Promise<void>}
+   * @param {string} [args.deliveryId] sibling-inject の内部相関 ID
+   * @returns {Promise<{method: "turn/start"|"turn/steer", deliveryId?: string}>}
    *
    * ⚠️ `turn/steer` (`TurnSteerParams`) には model/effort フィールドが存在しない
    * (公式スキーマで未対応と確認済み、2026-07-03)。そのためターン実行中 (busy) に
@@ -1086,7 +1237,7 @@ export class CodexStreamBridge extends EventEmitter {
    * (= turn/start) から有効になる。呼び出し側 (main.mjs) はこれを承知の上で常に
    * model/effort を渡してよい (steer 分岐では単に無視される)。
    */
-  async input({ stream_id, message, model, effort }) {
+  async input({ stream_id, message, model, effort, deliveryId }) {
     const session = this._require(stream_id)
     // Stage 5: _touch で lastActivityMs を更新 = LRU 先頭へ。ターン開始で activeTurnId が
     // 立ち、reconcile は healthy busy を protected 扱いにするので実行中に kill されない。
@@ -1096,7 +1247,16 @@ export class CodexStreamBridge extends EventEmitter {
     // round3 major#1: 全 input を **session 単位の単一 FIFO** に積み、単一 pump に処理させる。
     // promise は pump が実 delivery で settle する (即 resolve しない)。
     return new Promise((resolve, reject) => {
-      session.inputQueue.push({ input, model, effort, resolve, reject, retriedAsStart: false })
+      session.inputQueue.push({
+        input,
+        model,
+        effort,
+        deliveryId,
+        sourceStreamId: stream_id,
+        resolve,
+        reject,
+        retriedAsStart: false,
+      })
       void this._pumpInputs(session)
     })
   }
@@ -1133,7 +1293,19 @@ export class CodexStreamBridge extends EventEmitter {
               input: item.input,
             })
             session.inputQueue.shift()
-            item.resolve()
+            this.logger?.info?.(
+              {
+                delivery_id: item.deliveryId || null,
+                stream_id: item.sourceStreamId || session.stream_id,
+                current_stream_id: session.stream_id,
+                thread_id: session.threadId,
+                attempted_steer: true,
+                rpc_method: "turn/steer",
+                rpc_result: "accepted",
+              },
+              "codex input RPC settled",
+            )
+            item.resolve({ method: "turn/steer", deliveryId: item.deliveryId })
           } else {
             // round4 major#2: turn/start dispatch の **前に** 世代を控える。start 応答後に
             // turn/started(+completed) が pump 再開前に処理されても、世代前進で「ターンが始まった」を
@@ -1144,7 +1316,19 @@ export class CodexStreamBridge extends EventEmitter {
             if (item.effort) params.effort = item.effort
             await session.client.request("turn/start", params)
             session.inputQueue.shift()
-            item.resolve()
+            this.logger?.info?.(
+              {
+                delivery_id: item.deliveryId || null,
+                stream_id: item.sourceStreamId || session.stream_id,
+                current_stream_id: session.stream_id,
+                thread_id: session.threadId,
+                attempted_steer: false,
+                rpc_method: "turn/start",
+                rpc_result: "accepted",
+              },
+              "codex input RPC settled",
+            )
+            item.resolve({ method: "turn/start", deliveryId: item.deliveryId })
             // 次の item を steer にするため turn/started (= 世代前進) を待つ。timeout でハングを防ぐ。
             // timeout したら「ターンが正しく始まらなかった」とみなし残り queue を reject して打ち切る。
             const becameActive = await this._waitTurnActive(session, genBefore)
@@ -1155,6 +1339,19 @@ export class CodexStreamBridge extends EventEmitter {
           }
         } catch (err) {
           if (attemptedSteer && !item.retriedAsStart) {
+            this.logger?.warn?.(
+              {
+                delivery_id: item.deliveryId || null,
+                stream_id: item.sourceStreamId || session.stream_id,
+                current_stream_id: session.stream_id,
+                thread_id: session.threadId,
+                attempted_steer: true,
+                rpc_method: "turn/steer",
+                rpc_result: "retry_as_start",
+                err: err instanceof Error ? err.message : String(err),
+              },
+              "codex input RPC settled",
+            )
             // turn/steer 失敗 → 自己修復: activeTurnId を捨て、同 item を turn/start で 1 回だけリトライ
             // (shift しない = 同 item を次ループの start 経路で再処理)。並行はしない (単一 pump)。
             // 元の steer エラーを stash して、リトライも失敗したとき合成メッセージを作れるようにする。
@@ -1181,6 +1378,20 @@ export class CodexStreamBridge extends EventEmitter {
             e = err instanceof Error ? err : new Error(String(err))
             if (!e.reason) e.reason = "start_error"
           }
+          this.logger?.error?.(
+            {
+              delivery_id: item.deliveryId || null,
+              stream_id: item.sourceStreamId || session.stream_id,
+              current_stream_id: session.stream_id,
+              thread_id: session.threadId,
+              attempted_steer: attemptedSteer,
+              rpc_method: attemptedSteer ? "turn/steer" : "turn/start",
+              rpc_result: "failed",
+              err: e.message,
+              reason: e.reason || null,
+            },
+            "codex input RPC settled",
+          )
           item.reject(e)
         }
       }
@@ -1490,9 +1701,14 @@ export class CodexStreamBridge extends EventEmitter {
    *
    * @param {string} cwd
    * @param {string} text
-   * @returns {{status:"delivered", session:object} | {status:"not_found"}}
+   * @returns {Promise<
+   *   {status:"delivered", session:object, delivery_id:string, accepted_via:string}
+   *   | {status:"delivery_unconfirmed", session:object, delivery_id:string, accepted_via:string, reason:string}
+   *   | {status:"delivery_failed", session:object, delivery_id:string, reason:string}
+   *   | {status:"not_found"}
+   * >}
    */
-  sendToCwd(cwd, text, source) {
+  async sendToCwd(cwd, text, source) {
     if (!cwd || !text) return { status: "not_found" }
     // 案B: distinct session で走査（多対一 Map の重複を除く）。
     const cands = this._liveSessions().filter((s) => s.cwd === cwd)
@@ -1525,29 +1741,11 @@ export class CodexStreamBridge extends EventEmitter {
     // 明示しておく。ターン実行中は healthy busy = protected なので reconcile で kill されない。
     best.detachRequested = false
     this._touch(best)
-    // 連携カード種別 (Phase 2): 宛先確定後に記録 (not_found では記録しない)。handle を控え失敗時に除去。
-    const injectHandle = this._recordInjectSource(best, text, source)
-    this.logger?.info?.(
-      {
-        cwd,
-        stream_id: best.stream_id,
-        thread_id: best.threadId,
-        busy: !!best.activeTurnId,
-        candidates: this.describeLiveSessions(cwd).length,
-      },
-      "codex sendToCwd: injecting into most-recently-active session",
-    )
-    this.input({ stream_id: best.stream_id, message: { role: "user", content: text } }).catch(
-      (err) => {
-        // Phase 2: 配送失敗なら echo は来ないので stale な source entry を取り消す (誤タグ防止)。
-        this._removeInjectSource(best, injectHandle)
-        this.logger?.error(
-          { cwd, stream_id: best.stream_id, err: err?.message },
-          "sendToCwd: input threw unexpectedly",
-        )
-      },
-    )
-    return { status: "delivered", session: this._describe(best) }
+    return this._deliverInjection(best, text, source, {
+      cwd,
+      selection: "most-recently-active",
+      candidates: this.describeLiveSessions(cwd).length,
+    })
   }
 
   /**
@@ -1576,9 +1774,9 @@ export class CodexStreamBridge extends EventEmitter {
    * @param {string} cwd 呼び出し元がトークン検証した cwd (この cwd のセッションにのみ注入)
    * @param {string} id 宛先 stream_id (一意・推奨) または thread_id
    * @param {string} text
-   * @returns {{status: "delivered", session: object} | {status: "not_found"} | {status: "ambiguous", candidates: object[]}}
+   * @returns {Promise<object>}
    */
-  sendToStream(cwd, id, text, source) {
+  async sendToStream(cwd, id, text, source) {
     if (!cwd || !id || !text) return { status: "not_found" }
     let bySid = null
     const byThread = []
@@ -1604,19 +1802,166 @@ export class CodexStreamBridge extends EventEmitter {
     // (sendToCwd と同じ扱い)。
     target.detachRequested = false
     this._touch(target)
-    // 連携カード種別 (Phase 2): 宛先確定後に記録 (not_found/ambiguous では記録しない)。handle を控える。
-    const injectHandle = this._recordInjectSource(target, text, source)
-    this.input({ stream_id: target.stream_id, message: { role: "user", content: text } }).catch(
-      (err) => {
-        // Phase 2: 配送失敗なら echo は来ないので stale な source entry を取り消す (誤タグ防止)。
-        this._removeInjectSource(target, injectHandle)
-        this.logger?.error(
-          { id, stream_id: target.stream_id, err: err?.message },
-          "sendToStream: input threw unexpectedly",
-        )
+    return this._deliverInjection(target, text, source, {
+      cwd,
+      requested_id: id,
+      selection: bySid ? "stream_id" : "thread_id",
+    })
+  }
+
+  /**
+   * sibling-inject の4段階:
+   * dispatched (本関数開始) → accepted (turn RPC成功) →
+   * delivered (同一sessionの userMessage item/completed echo) → durable (rollout監査、別層)。
+   * ここでは delivered までを同期的に確認し、echo timeout は成功扱いしない。
+   */
+  async _deliverInjection(session, text, source, context = {}) {
+    const deliveryId = randomUUID()
+    const sourceStreamId = session.stream_id
+    const injectHandle = this._recordInjectSource(
+      session,
+      text,
+      source,
+      deliveryId,
+      sourceStreamId,
+    )
+    // 監査 offset の取得中も旧 stream を per-cwd reconcile から守るため、delivery handle を先に積む。
+    // rollout 監査は二次確認なので、snapshot 自体の失敗で配送を止めない。
+    let durableAudit
+    try {
+      durableAudit = await this._deliveryAuditSnapshot(session.threadId, text)
+    } catch (err) {
+      durableAudit = {
+        threadId: session.threadId,
+        contentHash: null,
+        filePath: null,
+        offset: 0,
+        snapshotReason: `snapshot_error:${err instanceof Error ? err.message : String(err)}`,
+      }
+    }
+    this.logger?.info?.(
+      {
+        ...context,
+        delivery_id: deliveryId,
+        stream_id: sourceStreamId,
+        thread_id: session.threadId,
+        busy: !!session.activeTurnId,
+        delivery_state: "dispatched",
+        durable_content_hash: durableAudit?.contentHash || null,
+        durable_offset: durableAudit?.offset ?? null,
+        durable_snapshot_reason: durableAudit?.snapshotReason || null,
       },
+      "codex sibling injection dispatched",
     )
-    return { status: "delivered", session: this._describe(target) }
+
+    let accepted
+    try {
+      accepted = await this.input({
+        stream_id: sourceStreamId,
+        message: { role: "user", content: text },
+        deliveryId,
+      })
+    } catch (err) {
+      this._removeInjectSource(session, injectHandle)
+      this.logger?.error?.(
+        {
+          ...context,
+          delivery_id: deliveryId,
+          stream_id: sourceStreamId,
+          current_stream_id: session.stream_id,
+          thread_id: session.threadId,
+          delivery_state: "failed",
+          err: err instanceof Error ? err.message : String(err),
+        },
+        "codex sibling injection failed before acceptance",
+      )
+      return {
+        status: "delivery_failed",
+        session: this._describe(session),
+        delivery_id: deliveryId,
+        reason: err?.reason || err?.message || "input_failed",
+      }
+    }
+
+    this.logger?.info?.(
+      {
+        ...context,
+        delivery_id: deliveryId,
+        stream_id: sourceStreamId,
+        current_stream_id: session.stream_id,
+        thread_id: session.threadId,
+        accepted_via: accepted?.method || null,
+        delivery_state: "accepted",
+      },
+      "codex sibling injection accepted",
+    )
+    const delivery = await this._waitInjectDelivery(injectHandle)
+    if (!delivery?.delivered) {
+      this.logger?.warn?.(
+        {
+          ...context,
+          delivery_id: deliveryId,
+          stream_id: sourceStreamId,
+          current_stream_id: session.stream_id,
+          thread_id: session.threadId,
+          accepted_via: accepted?.method || null,
+          delivery_state: "unconfirmed",
+          reason: delivery?.reason || "echo_timeout",
+          live: !session.dead,
+          busy: !!session.activeTurnId,
+        },
+        "codex sibling injection delivery unconfirmed",
+      )
+      return {
+        status: "delivery_unconfirmed",
+        session: this._describe(session),
+        delivery_id: deliveryId,
+        accepted_via: accepted?.method || null,
+        reason: delivery?.reason || "echo_timeout",
+      }
+    }
+    // rollout は内部形式・flush 遅延の影響を受けるため primary oracle にしない。echo delivered を
+    // 返した後、注入前 offset + threadId + 本文 hash で非同期監査し、結果だけを構造化ログへ残す。
+    void this._deliveryAuditVerify(durableAudit)
+      .then((auditResult) => {
+        this.logger?.[auditResult?.durable ? "info" : "warn"]?.(
+          {
+            ...context,
+            delivery_id: deliveryId,
+            stream_id: sourceStreamId,
+            current_stream_id: session.stream_id,
+            thread_id: session.threadId,
+            delivery_state: auditResult?.durable ? "durable" : "durable_unconfirmed",
+            durable_content_hash: durableAudit?.contentHash || null,
+            durable_offset: durableAudit?.offset ?? null,
+            durable_file: auditResult?.filePath || durableAudit?.filePath || null,
+            durable_reason: auditResult?.reason || null,
+            durable_attempts: auditResult?.attempts || null,
+          },
+          "codex sibling injection rollout durability audit",
+        )
+      })
+      .catch((err) => {
+        this.logger?.warn?.(
+          {
+            ...context,
+            delivery_id: deliveryId,
+            stream_id: sourceStreamId,
+            thread_id: session.threadId,
+            delivery_state: "durable_unconfirmed",
+            durable_reason: `audit_error:${err instanceof Error ? err.message : String(err)}`,
+          },
+          "codex sibling injection rollout durability audit",
+        )
+      })
+    return {
+      status: "delivered",
+      session: this._describe(session),
+      delivery_id: deliveryId,
+      accepted_via: accepted?.method || null,
+      item_id: delivery.itemId || null,
+      durable_state: "pending",
+    }
   }
 
   /** describeLiveSessions と同形の 1 セッション記述子 (sendToStream の結果整形に共用)。 */
@@ -1651,6 +1996,9 @@ export class CodexStreamBridge extends EventEmitter {
     if (session.pumping) return true
     if (Array.isArray(session.inputQueue) && session.inputQueue.length > 0) return true
     if (session._turnActiveWaiter) return true
+    // turn RPC accepted 後、対応 userMessage echo を待っている間も protected。
+    // ここを外すと別 attach の per-cwd reconcile が ACK 先を配達確認前に reap できる。
+    if (session.pendingInjectSources?.some((entry) => entry.deliveryPending)) return true
     if (!session.activeTurnId) return false
     return now - (session.lastActivityMs ?? now) <= this._stuckTurnTtlMs
   }
@@ -1662,6 +2010,7 @@ export class CodexStreamBridge extends EventEmitter {
     // round3: reap した session の barrier を解除し queue を reject する（promise 宙吊り防止）。
     this._settleTurnActiveWaiter(session)
     this._drainRejectQueue(session, { reason: "queue_dead" })
+    this._settlePendingInjectDeliveries(session, "session_dead")
     // 案B: 全購読 stream_id キーを Map から外す（primary 1 個だけ消すと dangling が残る）。
     this._dropAllStreamKeys(session)
     try {
@@ -1822,6 +2171,7 @@ export class CodexStreamBridge extends EventEmitter {
       // round3: shutdown で barrier を解除し queue 入力を reject（promise 宙吊り防止）。
       this._settleTurnActiveWaiter(session)
       this._drainRejectQueue(session, { reason: "queue_dead" })
+      this._settlePendingInjectDeliveries(session, "session_dead")
       // hub-agent 再起動時にターン実行中のセッションを落とすと thread が汚染されうる
       // (exec 中の kill → output 欠落)。因果を後から辿れるよう必ず記録する。
       this.logger?.[session.activeTurnId ? "warn" : "info"]?.(

package/src/sibling-inject.mjs

@@ -45,6 +45,16 @@ import { verifySiblingTokenAny, siblingTokenCwd } from "./sibling-token.mjs"
 export const SIBLING_REQUESTS_DIR =
   process.env.COCKPIT_SIBLING_REQUESTS_DIR || "/tmp/cockpit_sibling_requests"
 
+const DELIVERY_UNCONFIRMED_HINT =
+  "turn RPC は受理されましたが userMessage echo を確認できませんでした。既に届いている可能性があり、" +
+  "再送すると重複配送になります。再送前に対象セッションの受信状態または rollout 監査を確認してください。"
+const DELIVERY_FAILED_HINT =
+  "turn RPC の受付前または受付中に失敗しました。対象セッションを確認して再送してください。"
+
+function deliveredStateFor(kind) {
+  return kind === "codex" ? "delivered" : "dispatched"
+}
+
 export class SiblingInjectBridge {
   /**
    * @param {{dir?: string, claudeBridge?: object, codexBridge?: object, logger?: object}} [opts]
@@ -186,11 +196,34 @@ export class SiblingInjectBridge {
       } else if (isExplicit) {
         // 明示宛先: session_id (claude) / stream_id|thread_id (codex) で cwd 一致下に確定解決。
         // sendToStream は {status:"delivered"|"not_found"|"ambiguous"} を返す。
-        const r = bridge?.sendToStream?.(cwd, target_session_id, message, injectSource) ?? {
-          status: "not_found",
-        }
+        const r = bridge?.sendToStream
+          ? await bridge.sendToStream(cwd, target_session_id, message, injectSource)
+          : { status: "not_found" }
         if (r.status === "delivered") {
-          result = { ok: true, delivered_to: r.session }
+          result = {
+            ok: true,
+            delivered_to: r.session,
+            delivery_id: r.delivery_id,
+            delivery_state: deliveredStateFor(target_cli_kind),
+            durable_state: r.durable_state,
+            accepted_via: r.accepted_via,
+            item_id: r.item_id,
+          }
+        } else if (r.status === "delivery_unconfirmed" || r.status === "delivery_failed") {
+          result = {
+            ok: false,
+            error: r.status,
+            delivered_to: r.session,
+            delivery_id: r.delivery_id,
+            delivery_state:
+              r.status === "delivery_unconfirmed" ? "accepted_unconfirmed" : "failed",
+            accepted_via: r.accepted_via,
+            reason: r.reason,
+            hint:
+              r.status === "delivery_unconfirmed"
+                ? DELIVERY_UNCONFIRMED_HINT
+                : DELIVERY_FAILED_HINT,
+          }
         } else if (r.status === "ambiguous") {
           // 宛先 id が同一 cwd の複数 live セッションに一致し一意に定まらない。
           // ⚠️ 解消手段は CLI で異なる (T06271 レビュー4 minor):
@@ -235,9 +268,34 @@ export class SiblingInjectBridge {
         //    (サイレント誤配送 + delivered_to に実配送先でない sameCwd[0] を報告する成功偽装) が
         //    あった。sendToCwd を status 返却にして解決と配送を 1 呼び出しに統合し、delivered_to は
         //    **実配送先 (r.session)** を返す。
-        const r = bridge?.sendToCwd?.(cwd, text, injectSource) ?? { status: "not_found" }
+        const r = bridge?.sendToCwd
+          ? await bridge.sendToCwd(cwd, text, injectSource)
+          : { status: "not_found" }
         if (r.status === "delivered") {
-          result = { ok: true, delivered_to: r.session ?? null }
+          result = {
+            ok: true,
+            delivered_to: r.session ?? null,
+            delivery_id: r.delivery_id,
+            delivery_state: deliveredStateFor(target_cli_kind),
+            durable_state: r.durable_state,
+            accepted_via: r.accepted_via,
+            item_id: r.item_id,
+          }
+        } else if (r.status === "delivery_unconfirmed" || r.status === "delivery_failed") {
+          result = {
+            ok: false,
+            error: r.status,
+            delivered_to: r.session ?? null,
+            delivery_id: r.delivery_id,
+            delivery_state:
+              r.status === "delivery_unconfirmed" ? "accepted_unconfirmed" : "failed",
+            accepted_via: r.accepted_via,
+            reason: r.reason,
+            hint:
+              r.status === "delivery_unconfirmed"
+                ? DELIVERY_UNCONFIRMED_HINT
+                : DELIVERY_FAILED_HINT,
+          }
         } else if (r.status === "ambiguous") {
           result = {
             ok: false,
@@ -258,10 +316,24 @@ export class SiblingInjectBridge {
         target_cli_kind,
         op: op || "normal",
         ...(result.ok
-          ? { delivered_to: result.delivered_to }
-          : { error: result.error, live_sessions: result.live_sessions }),
+          ? {
+              delivered_to: result.delivered_to,
+              delivery_id: result.delivery_id,
+              delivery_state: result.delivery_state,
+              durable_state: result.durable_state,
+            }
+          : {
+              error: result.error,
+              delivery_id: result.delivery_id,
+              delivery_state: result.delivery_state,
+              live_sessions: result.live_sessions,
+            }),
       },
-      result.ok ? "sibling-inject delivered" : "sibling-inject failed",
+      result.ok
+        ? result.delivery_state === "delivered"
+          ? "sibling-inject delivered"
+          : "sibling-inject dispatched"
+        : "sibling-inject failed",
     )
     await this._writeResult(request_id, result)
     // 要求ファイルは処理後に必ず削除する (成否問わず、再処理させないため)。