fix(pipeline): 修复取报-处理-回填链路的超时、吞吐、回填与 FIFO 问题

外部调用（ACM2-33）
- 共享 MySQL 与自有 PG 全部补有界超时：驱动 connect/socket 超时 + Hikari 池超时
  （注意 Micronaut 的 Hikari 项是毫秒数，不是 Duration 字面量）
- 删除主泵/毒丸路径的 inline 回填：跨库写不再占用 FIFO 关键路径，回填统一由扫描驱动
- 游标自愈：save() 改为「先 UPDATE、缺行 INSERT」，缺行只记一次 ERROR
- Pump/Dispatcher 外层 catch 补 error 日志与失败计数

投递吞吐（ACM2-34）
- Dispatcher 改批量领取；队头退避未到期或首条发送失败即停止本轮（保持目标内保序）
- 有活不再 sleep；删除不可达的 state==SENT 死条件；markSent 移入分支；
  superseded 清理加轮数上限与空 eventId 保护

回填闭环（ACM2-36，V4）
- MISSING（运行时确认行不存在）立即放弃自动重试并告警；暂时性故障达上限后停止自动重试
- 新增 reopen 人工恢复入口；放弃 ≠ 标记已确认（BACKFILL_AT 仍为空，清除前提不成立）
- 扫描改 (BACKFILL_ATTEMPTS, MSG_ID) 公平轮转并排除放弃行，消除全局回填饥饿
- V4 只加字段与必要索引，不按年龄做任何存量推断

切流播种（ACM2-35，V5）
- cutover-watermark 四模式（min/zero/max/显式 ID），默认不播种、代码不做默认选择
- 升级实例拒绝重新播种（SEEDED_AT 为 NULL ≠ 从未消费）；播种与水位同语句落库
- 非法取值由启动自检挡下

错误分类与入口契约（ACM2-37）
- 未知 SCHD 子类型改为 UNSUPPORTED，不再静默当全量日计划合并
- ADFT 运营日冲突改走 ProtocolViolation → DEAD(PROTOCOL)
- 兼容入口 receivedAt 缺失回退到注入 Clock；MessageLifecycleGate 强制注入 + 装配断言
- FIFO：主泵只领取 msgId ≤ W，兼容入口登记的行在水位追平前不被领取

时间源与可观测（ACM2-38 / ACM2-41 阶段 0）
- 仓储/处理器/作业全部经注入 Clock；移除 markTerminal/markBackfilled 的 Instant.now() 默认值
- 退避表档位与 max-attempts 对齐并加启动自检
- Micrometer 7 个 gauge（@Context 急切注册）+ /health 与 /metrics 共用积压快照缓存
- 只读迟到检测：监视被放行的空洞 ID 是否后来真的出现，只计数告警、不补入队

Plane: ACM2-33 ACM2-34 ACM2-35 ACM2-36 ACM2-37 ACM2-38 ACM2-41
Tests: 88 → 120（1 skipped 需真实 PG）

src/main/kotlin/com/gzzn/omms/msgexchange/processing/Pump.kt

@@ -11,12 +11,14 @@ import com.gzzn.omms.msgexchange.domain.ProcState
 import com.gzzn.omms.msgexchange.domain.ProcStatus
 import com.gzzn.omms.msgexchange.infra.log.TraceLog
 import com.gzzn.omms.msgexchange.infra.persistence.CminmsgInboxRepository
+import com.gzzn.omms.msgexchange.infra.persistence.InboxCursorRepository
 import com.gzzn.omms.msgexchange.infra.persistence.ProcStateRepository
 import com.gzzn.omms.msgexchange.infra.retry.ProcFailure
 import jakarta.inject.Singleton
 import java.time.Clock
 import java.time.Duration
 import java.time.Instant
+import java.util.concurrent.atomic.AtomicLong
 
 /**
  * 处理主泵：一个线程按消息 ID 从小到大一条条处理，保证先来的先处理。
@@ -33,13 +35,16 @@ import java.time.Instant
 @Singleton
 class Pump(
     private val procState: ProcStateRepository,
+    private val cursor: InboxCursorRepository,
     private val processor: MessageProcessor,
-    private val backfill: BackfillService,
     private val props: PipelineProps,
     private val clock: Clock,
 ) {
     private val log = org.slf4j.LoggerFactory.getLogger(Pump::class.java)
 
+    /** 连续失败计数：仅用于日志/排障，不代表业务状态。 */
+    private val tickFailures = AtomicLong(0)
+
     @Volatile
     private var running = true
 
@@ -52,11 +57,15 @@ class Pump(
         while (running) {
             try {
                 tick()
+                tickFailures.set(0)
             } catch (e: InterruptedException) {
                 Thread.currentThread().interrupt()
                 return
             } catch (e: Exception) {
-                // 兜底：单条消息的失败状态已在 processOne 内记录，这里只避免线程退出
+                // 兜底：单条消息的失败状态已在 processOne 内记录；但 tick 整体失败（DB 断连、
+                // 锁超时）在别处没有痕迹，必须留日志，否则排障无据可查。
+                val failures = tickFailures.incrementAndGet()
+                log.error("pump tick failed (failure #{})", failures, e)
                 sleepQuietly(props.pipeline.pollInterval)
             }
         }
@@ -64,10 +73,25 @@ class Pump(
 
     internal fun tick() {
         val head = procState.headUnfinished()
+        if (head == null) {
+            sleepQuietly(props.pipeline.pollInterval)
+            return
+        }
+        // 只领取"已被水位覆盖"的队头（`msgId <= W`）。
+        //
+        // 水位以内的行都是收报按 ID 顺序发现并登记的；水位之外的行只可能来自兼容入口
+        // 直接写 PROC_STATE（它不参与水位）。若允许领取，它就会越过那些尚未入队的较小 ID，
+        // 破坏 FIFO（缺口 G2）。这种行在空洞补齐、`W` 追平之后自然可领取。
+        val watermark = cursor.load().committedUpTo
+        if (head.msgId > watermark) {
+            warnBeyondWatermark(head.msgId, watermark)
+            sleepQuietly(props.pipeline.pollInterval)
+            return
+        }
         when {
-            head == null -> sleepQuietly(props.pipeline.pollInterval)
             head.state == ProcStatus.FAILED && poisoned(head) -> {
                 log.error("poison -> DEAD msgId={} attempts={} lastError={}", head.msgId, head.attempts, head.lastError)
+                // markTerminal 在同一条 UPDATE 里登记回填意图；回填由扫描补写，不在这里做跨库写。
                 procState.markTerminal(
                     head.msgId, ProcStatus.DEAD,
                     errorClass = ErrorClass.EXHAUSTED,
@@ -75,7 +99,6 @@ class Pump(
                     attempts = head.attempts,
                     now = clock.instant(),
                 )
-                backfill.attempt(head.msgId)
             }
             head.state == ProcStatus.FAILED && (head.nextAttemptAt ?: Instant.EPOCH) > clock.instant() ->
                 sleepQuietly(Duration.between(clock.instant(), head.nextAttemptAt))
@@ -90,6 +113,19 @@ class Pump(
     private fun poisoned(head: ProcState): Boolean =
         isHeadPoisoned(head, clock.instant(), props)
 
+    /** 上一次"队头在水位之外"告警时的水位值：只在它变化时告警，避免每秒刷屏。 */
+    private val warnedWatermark = AtomicLong(Long.MIN_VALUE)
+
+    private fun warnBeyondWatermark(msgId: Long, watermark: Long) {
+        if (warnedWatermark.getAndSet(watermark) != watermark) {
+            log.warn(
+                "head msgId={} is beyond watermark W={}; waiting for discovery " +
+                    "(row injected by the compat entry point?)",
+                msgId, watermark,
+            )
+        }
+    }
+
     private fun sleepQuietly(d: Duration) {
         if (!d.isNegative && !d.isZero) Thread.sleep(d.toMillis().coerceAtLeast(1))
     }
@@ -100,10 +136,11 @@ internal fun isHeadPoisoned(head: ProcState, now: Instant, props: PipelineProps)
         Duration.between(head.processingStartedAt ?: head.updatedAt, now) >= props.pipeline.headDeadline
 
 /**
- * 处理一条消息：读原文 → 解码 → 绑定业务身份 → 分派给对应处理器 → 提交后回填标记。
+ * 处理一条消息：读原文 → 解码 → 绑定业务身份 → 分派给对应处理器。
  *
- * 业务数据和终态由各处理器在自己的事务里写入。终态一旦落下（成功、跳过或死信），
- * 这里马上试一次把处理标记写回信箱；写不进去也没关系，回填扫描会按退避继续重试。
+ * 业务数据、终态与回填意图都由各处理器在自己的事务里写入（终态与回填意图是同一条 UPDATE）。
+ * **这里不做信箱回填**：主泵是 FIFO 关键路径，跨库写会把它绑在共享 MySQL 的可用性上。
+ * 回填由 `JobRunner` 定时的 `BackfillService.sweep` 驱动（调度周期不等于完成时限）。
  *
  * 任何意外异常都算在当前这条消息头上（记 FAILED(INFRA) 后重试），不会把主泵线程带崩。
  * 报文非法和整包协议拒绝不重试，直接进死信等人工处置。
@@ -118,14 +155,14 @@ class MessageProcessor(
     private val fdelProcessor: FdelProcessor,
     private val adftProcessor: AdftProcessor,
     private val procFailure: ProcFailure,
-    private val backfill: BackfillService,
     private val props: PipelineProps,
+    private val clock: Clock,
 ) {
     private val log = org.slf4j.LoggerFactory.getLogger(MessageProcessor::class.java)
 
     fun processOne(head: ProcState) {
         TraceLog.withTrace(head.msgId) {
-            val terminal = try {
+            try {
                 processInternal(head)
             } catch (e: InterruptedException) {
                 Thread.currentThread().interrupt()
@@ -135,13 +172,10 @@ class MessageProcessor(
                 log.warn("processOne unexpected failure msgId={} ec=INFRA msg={}", head.msgId, e.message ?: e.javaClass.simpleName)
                 procFailure.fail(head, ErrorClass.INFRA, e.message ?: e.javaClass.simpleName)
             }
-            // 终态已经写好了，马上试一次回填；写不进去也没关系，回填扫描会按退避继续重试
-            // （待办在写终态时就一起登记了）。还没处理完的消息不打标记。
-            if (terminal) backfill.attempt(head.msgId)
         }
     }
 
-    /** @return 这条消息是否已经落到终态（只有终态才允许回填信箱标记） */
+    /** @return 这条消息是否落到终态；回填由扫描驱动，调用方不再据此立即回填。 */
     private fun processInternal(head: ProcState): Boolean {
         // 守卫：手工/遗留 FAILED 行若 attempts 已达上限，直接终态（防止退避到期后无限重试）
         if (head.state == ProcStatus.FAILED && procFailure.scheduler.exhausted(head.attempts)) {
@@ -151,6 +185,7 @@ class MessageProcessor(
                 errorClass = ErrorClass.EXHAUSTED,
                 lastError = head.lastError ?: "max-attempts",
                 attempts = head.attempts,
+                now = clock.instant(),
             )
             return true
         }
@@ -179,7 +214,7 @@ class MessageProcessor(
             if (!procState.tryBindIdentity(head.msgId, identity)) {
                 val owner = procState.ownerOfIdentity(identity) ?: -1L
                 log.info("duplicate-of:{} -> SKIPPED msgId={}", owner, head.msgId)
-                procState.markTerminal(head.msgId, ProcStatus.SKIPPED, lastError = "duplicate-of:$owner")
+                procState.markTerminal(head.msgId, ProcStatus.SKIPPED, lastError = "duplicate-of:$owner", now = clock.instant())
                 return true
             }
         }
@@ -223,6 +258,7 @@ class MessageProcessor(
                 head.msgId, ProcStatus.DEAD,
                 errorClass = ErrorClass.PROTOCOL,
                 lastError = result.reason.take(1000),
+                now = clock.instant(),
             )
             return true
         }
@@ -233,7 +269,7 @@ class MessageProcessor(
     }
 
     private fun deadMalformed(head: ProcState, detail: String): Boolean {
-        procState.markTerminal(head.msgId, ProcStatus.DEAD, errorClass = ErrorClass.MALFORMED, lastError = detail)
+        procState.markTerminal(head.msgId, ProcStatus.DEAD, errorClass = ErrorClass.MALFORMED, lastError = detail, now = clock.instant())
         return true
     }
 }