agentworkshop 0.8.4 → 0.8.6

package/server/services/workshop/daq/daq-controller/ingest.ts

@@ -1,8 +1,8 @@
 /**
  * DaqControllerIngest —— 样本与帧的入库、发布、告警评估
- * (拆分层,承 DaqControllerState;方法体与原文件逐行一致)
+ * (拆分层,承 DaqControllerPush;publishSample 供轮询与被动订阅两条生产路径共用)
  */
-import { DaqControllerState } from './state'
+import { DaqControllerPush } from './push'
 import type { AepDaqFrame, AepDaqReading } from '../../../../../shared/daq-protocol'
 import type { DaqSampleEnvelope } from '../bus/queue-port'
 import type { DaqNode } from '../daq-node'
@@ -11,14 +11,38 @@ import { emitDaqFrame, emitDaqSample } from '@/server/services/workshop/plugins/
 import { findDaqTemplate } from '../daq-templates'
 import { getDaqHostPorts } from '../host-ports'
 import { getDaqQueue } from '../bus'
+import { tsdbRowOf } from './tsdb-row'
+import type { DaqFrameSample } from '../drivers'
 
-export abstract class DaqControllerIngest extends DaqControllerState {
+export abstract class DaqControllerIngest extends DaqControllerPush {
   /** 生产面:样本帧入队 */
   protected publishSample(env: DaqSampleEnvelope): void {
     void getDaqQueue().then(q => q.publish(env)).catch(() => {})
     this.producedCount++
   }
 
+  /**
+   * 外部推送帧的统一后处理入口(2026-10-28 审查 A-P1-3)。
+   *
+   * 轮询采样 / 被动订阅 / 外部 ingest 三条生产路径必须共用同一 sink 管线:
+   * 模板 processor(thumbnail/deriveMetric/qualityGate)→ 图像落对象存储 → 服务端
+   * 计算 sha256/size。外部调用方只提供原始 blob 或点列,绝不信任其自报指标与指纹;
+   * 否则"完全相同链路"的承诺不成立(缩略图缺失、质量门被绕过、派生指标为空)。
+   */
+  async processExternalFrame(
+    node: DaqNode,
+    raw:
+      | { kind: 'vector', points: number[], metrics?: Record<string, number> }
+      | { kind: 'image', blob: Buffer, mime: string, width?: number, height?: number, metrics?: Record<string, number> },
+    atMs: number,
+  ): Promise<{ frame: NonNullable<DaqSampleEnvelope['frame']> } | null> {
+    // 外部推送未必携带像素尺寸;缺省记 0(未知),不阻断落库与缩略图生成
+    const frame: DaqFrameSample['frame'] = raw.kind === 'image'
+      ? { ...raw, width: raw.width ?? 0, height: raw.height ?? 0 }
+      : raw
+    return this.processFrameSample(node, frame, atMs)
+  }
+
   /** 消费面:样本入网关管线(状态派生已在 runtime 完成)。
    *  allowPublish = 通过该节点 WS 下发节拍门控;入库/遥测回写不受门控(每帧必达)。 */
   /**
@@ -62,16 +86,14 @@ export abstract class DaqControllerIngest extends DaqControllerState {
     const tsMs = Date.parse(env.at)
     const lineRun = getDaqHostPorts()?.lineRun.activeRun(node.lineId) ?? null
     if (lineRun) getDaqHostPorts()?.lineRun.bumpTaggedSamples(node.lineId)
-    this.tsdbBuffer.push({
+    this.tsdbBuffer.push(tsdbRowOf({
       nodeId: node.id,
       tsMs,
       value: env.value,
       state: node.state,
-      lineId: lineRun?.lineId ?? null,
-      productId: lineRun?.productId ?? null,
-      recipeId: lineRun?.recipeId ?? null,
-      runId: lineRun?.runId ?? null,
-    })
+      nodeLineId: node.lineId,
+      run: lineRun,
+    }))
     if (this.tsdbBuffer.length > TSDB_BUFFER_CAP) {
       this.tsdbBuffer.splice(0, this.tsdbBuffer.length - TSDB_BUFFER_CAP)
       this.tsdbDropped += 1
@@ -111,7 +133,7 @@ export abstract class DaqControllerIngest extends DaqControllerState {
       kind: f.kind,
       templateKey: node.templateKey,
       deviceBindingId: node.deviceBindingId,
-      lineId: lineRun?.lineId ?? null,
+      lineId: node.lineId || null,
       productId: lineRun?.productId ?? null,
       recipeId: lineRun?.recipeId ?? null,
       runId: lineRun?.runId ?? null,

package/server/services/workshop/daq/daq-controller/push.ts

@@ -0,0 +1,357 @@
+/**
+ * DaqControllerPush —— 推送式协议(MQTT 等被动订阅)的订阅绑定 / 回收 / 看门狗
+ *
+ * 与轮询路径的分工:
+ *  - 轮询(modbus/opcua/http/mock):sweep 按 intervalMs 调用 runtime.tick → sample()
+ *  - 推送(mqtt):本层建立常驻订阅;每条报文经 publishSample → 队列 → runtime.onSample
+ *    → 状态派生/告警/打标/入库。**不进入 sweep 轮询**,因此不会把同一条报文
+ *    按采样 tick 重复入库,也不会在设备停发后伪造冻值。
+ *  - 产线门控与轮询同源:节点所属产线无活动批次时不入库(开线后订阅照常在线,
+ *    恢复开跑即刻继续入库,无需重连)。
+ */
+import { DaqControllerState } from './state'
+import type { DaqNode } from '../daq-node'
+import type { DaqSampleEnvelope } from '../bus/queue-port'
+import type { DaqDriver, DaqPushSample } from '../drivers'
+import { resolveDaqDriver } from '../drivers'
+import { getDaqHostPorts } from '../host-ports'
+import { MQTT_STALE_DEFAULT_MS } from '../drivers/mqtt'
+import { applyTransform, normalizeSignalKind } from '../../../../../shared/daq-protocol'
+import { findDaqTemplate } from '../daq-templates'
+import { log } from './helpers'
+
+/** 订阅失败后的重试退避(避免 sweep 每 250ms 打一次 broker) */
+const PUSH_RETRY_BACKOFF_MS = 5_000
+
+/** 停线缓存值的最大补种年龄(超过视为无关,等设备新报文) */
+export const RETAINED_SEED_MAX_AGE_MS = 600_000
+
+/**
+ * 停线补种计划(纯函数,便于单测;A-P1-2)。
+ *
+ * retained-only 设备在停线期间只发过一条状态,开跑后需把缓存值补种一次。补种的
+ * **时间戳必须是补种时刻**(now):用缓存到达时刻会被运行时乱序游标判 late 丢弃
+ * (上一批样本已推进游标),而 runSeeded 又已置真 → 整批零数据。
+ */
+export function retainedSeedPlan(
+  bind: { runSeeded: boolean, lastValue: number | null, lastAt: number },
+  now: number,
+): { value: number, atMs: number } | null {
+  if (bind.runSeeded || bind.lastValue == null) return null
+  if (now - bind.lastAt > RETAINED_SEED_MAX_AGE_MS) return null
+  return { value: bind.lastValue, atMs: now }
+}
+
+interface PushBinding {
+  stop: () => void | Promise<void>
+  /** 订阅参数指纹(节点 topic/host/jsonPath 变更 → 重建订阅) */
+  fingerprint: string
+  startedAt: number
+  /** 最近一条报文到达时刻(0 = 尚未收到) */
+  lastAt: number
+  lastValue: number | null
+  /** 当前活动批次 runId(用于识别新一批次开跑) */
+  runId: string | null
+  /** 本批次是否已把缓存/首条值作为种子入库(未开跑时收到的值在开跑后补种一次) */
+  runSeeded: boolean
+  /** 帧处理在飞(异步落对象存储期间丢弃后续帧,防高码率图像无界并发) */
+  frameBusy: boolean
+  /** 帧背压丢弃计数(诊断) */
+  frameDropped: number
+  /** 故障广播节流 */
+  lastWarnAt: number
+}
+
+export abstract class DaqControllerPush extends DaqControllerState {
+  protected pushBindings = new Map<string, PushBinding>()
+  protected pushPending = new Set<string>()
+  /** 订阅失败重试时刻(nodeId → epoch ms) */
+  protected pushRetryAt = new Map<string, number>()
+
+  /** 样本入队(由 ingest 层实现;push 只负责生产) */
+  protected abstract publishSample(env: DaqSampleEnvelope): void
+  /** 驱动故障广播(由 ingest 层实现;按节点/运行时节流) */
+  protected abstract broadcastDriverError(node: DaqNode, message: string): void
+
+  /** 单节点驱动输入(与 sampleNode 的模板域解析同源) */
+  protected pushInputOf(node: DaqNode, now: number) {
+    const tpl = findDaqTemplate(node.templateKey)
+    return {
+      ctx: { nodeId: node.id, now, ageMs: now - Date.parse(node.createdAt || new Date(now).toISOString()) },
+      config: {
+        base: tpl?.base ?? (node.min + node.max) / 2,
+        amp: tpl?.amp ?? Math.max((node.max - node.min) * 0.04, 0.001),
+        min: node.min,
+        max: node.max,
+      },
+      driverConfig: node.driverConfig,
+      signalKind: normalizeSignalKind(tpl?.signalKind),
+      vector: tpl?.vector,
+    }
+  }
+
+  /** 订阅参数指纹:驱动优先自报(凭据/TLS/主题/QoS),否则按常见字段保守拼接。
+   *  指纹计算绝不能抛错 —— 它在 250ms sweep 定时器里执行,异常会被稳定性守卫判 fatal。 */
+  private pushFingerprint(node: DaqNode, drv: DaqDriver): string {
+    try {
+      if (typeof drv.fingerprint === 'function') return drv.fingerprint(node.driverConfig)
+    }
+    catch (err) {
+      return `fingerprint-error:${err instanceof Error ? err.message : String(err)}`
+    }
+    const c = node.driverConfig ?? {}
+    return [node.driver, c.host, c.port, c.topic, c.jsonPath, c.username, c.secure, c.tls].map(v => String(v ?? '')).join('|')
+  }
+
+  /** 订阅对账:enabled + 有产线 + 驱动支持 subscribe → 保持一条绑定;否则回收。 */
+  syncPushBindings(): void {
+    for (const node of this.repo.all()) {
+      const drv = resolveDaqDriver(node.driver)
+      const want = typeof drv.subscribe === 'function' && node.enabled && Boolean(node.lineId)
+      if (!want) {
+        if (this.pushBindings.has(node.id)) void this.stopPushBinding(node.id)
+        continue
+      }
+      const existing = this.pushBindings.get(node.id)
+      if (existing) {
+        // topic/host/凭据/QoS 等订阅参数变更:回收后下一拍按新参数重建
+        if (existing.fingerprint !== this.pushFingerprint(node, drv)) void this.stopPushBinding(node.id)
+        continue
+      }
+      if (this.pushPending.has(node.id)) continue
+      const retryAt = this.pushRetryAt.get(node.id) ?? 0
+      if (retryAt > Date.now()) continue
+      this.pushPending.add(node.id)
+      void this.startPushBinding(node, drv)
+    }
+    // 已删除节点的绑定回收
+    for (const id of [...this.pushBindings.keys()]) {
+      if (!this.repo.byId(id)) void this.stopPushBinding(id)
+    }
+    for (const id of [...this.pushRetryAt.keys()]) {
+      if (!this.repo.byId(id)) this.pushRetryAt.delete(id)
+    }
+  }
+
+  private async startPushBinding(node: DaqNode, drv: DaqDriver): Promise<void> {
+    const nodeId = node.id
+    const fingerprint = this.pushFingerprint(node, drv)
+    // 先放一个占位绑定再订阅:retained 种子报文可能在 subscribe() 的 SUBACK 之后、
+    // Promise 续体之前到达(onPushSample 需要 binding 才入库);占位 stop 在成功后替换。
+    const provisional: PushBinding = { stop: () => { /* 订阅尚未建立 */ }, fingerprint, startedAt: Date.now(), lastAt: 0, lastValue: null, runId: null, runSeeded: false, frameBusy: false, frameDropped: 0, lastWarnAt: 0 }
+    this.pushBindings.set(nodeId, provisional)
+    try {
+      const stop = await drv.subscribe!({
+        ...this.pushInputOf(node, Date.now()),
+        onSample: sample => this.onPushSample(nodeId, sample),
+        onError: err => this.onPushError(nodeId, err),
+      })
+      provisional.stop = stop
+      const live = this.repo.byId(nodeId)
+      // 建连期间节点可能被停用/删除/换线/换 topic,或网关被停止:立刻回收,不留孤儿订阅。
+      // 也必须确认 map 里仍是本次占位(期间可能已被 stop 并被新一轮 sweep 替换)。
+      if (this.pushBindings.get(nodeId) !== provisional
+        || !live || !live.enabled || !live.lineId || !this.running
+        || this.pushFingerprint(live, resolveDaqDriver(live.driver)) !== fingerprint) {
+        if (this.pushBindings.get(nodeId) === provisional) this.pushBindings.delete(nodeId)
+        try {
+          await stop()
+        }
+        catch { /* 已停 */ }
+        return
+      }
+      this.pushRetryAt.delete(nodeId)
+      live.lastError = null
+      log.info(`[daq-push] ${live.name}(${nodeId}) ${live.driver} 被动订阅已建立`)
+    }
+    catch (err) {
+      this.pushBindings.delete(nodeId)
+      const msg = err instanceof Error ? err.message : String(err)
+      const live = this.repo.byId(nodeId)
+      if (live && this.running) {
+        live.lastError = `被动订阅建立失败:${msg}`
+        if (live.state !== 'alarm') live.state = 'offline'
+        const now = Date.now()
+        if (now - (this.pushRetryAt.get(nodeId) ?? 0) > 30_000) {
+          this.broadcastDriverError(live, `被动订阅建立失败:${msg}`)
+        }
+      }
+      if (this.running) this.pushRetryAt.set(nodeId, Date.now() + PUSH_RETRY_BACKOFF_MS)
+      log.warn(`[daq-push] ${node.name}(${nodeId}) 订阅失败(5s 后重试): ${msg}`)
+    }
+    finally {
+      this.pushPending.delete(nodeId)
+    }
+  }
+
+  private async stopPushBinding(nodeId: string): Promise<void> {
+    const b = this.pushBindings.get(nodeId)
+    this.pushBindings.delete(nodeId)
+    this.pushPending.delete(nodeId)
+    this.pushRetryAt.delete(nodeId)
+    if (!b) return
+    try {
+      await b.stop()
+    }
+    catch { /* 已停 */ }
+  }
+
+  /** 停止全部订阅(网关停止/进程退出) */
+  async stopAllPushBindings(): Promise<void> {
+    const ids = [...this.pushBindings.keys()]
+    await Promise.all(ids.map(id => this.stopPushBinding(id)))
+  }
+
+  /** 报文回调:解析成功 + 网关运行 + 产线在跑 → 入队(时间戳=到达时刻,单调递增)。
+   *  - 标量:未开跑时缓存最近值(retained-only 设备停线期间只收到一条状态,开跑后补种一次);
+   *  - 帧(向量/图像):走与轮询相同的 sink 管线 + 图像落对象存储,帧信封入队。 */
+  private onPushSample(nodeId: string, sample: DaqPushSample): void {
+    if (!this.running) return
+    const bind = this.pushBindings.get(nodeId)
+    if (!bind) return
+    const atMs = sample.atMs
+    bind.lastAt = Math.max(bind.lastAt + 1, atMs)
+    const node = this.repo.byId(nodeId)
+    if (!node || !node.enabled) return
+    const host = getDaqHostPorts()
+    const run = host?.lineRun.activeRun(node.lineId) ?? null
+    if (sample.frame) {
+      // 帧不做停线缓存(图像可能很大):未开跑直接丢弃,开跑后由设备下一帧继续
+      if (!run) {
+        bind.runId = null
+        bind.runSeeded = false
+        return
+      }
+      if (bind.runId !== run.runId) {
+        bind.runId = run.runId
+        bind.runSeeded = false
+      }
+      if (bind.frameBusy) {
+        bind.frameDropped++
+        if (Date.now() - bind.lastWarnAt > 30_000) {
+          bind.lastWarnAt = Date.now()
+          log.warn(`[daq-push] ${node.name}(${nodeId}) 帧处理拥塞,丢弃累计 ${bind.frameDropped} 帧`)
+        }
+        return
+      }
+      bind.frameBusy = true
+      void this.publishPushFrame(node, sample.frame, bind.lastAt, bind, run.runId).catch((err) => {
+        this.onPushError(nodeId, err instanceof Error ? err : new Error(String(err)))
+      }).finally(() => {
+        bind.frameBusy = false
+      })
+      return
+    }
+    bind.lastValue = sample.value
+    // 产线门控:未开跑期间订阅保持在线但不入库;记录当前批次,开跑瞬间补种缓存值
+    if (!run) {
+      bind.runId = null
+      bind.runSeeded = false
+      return
+    }
+    if (bind.runId !== run.runId) {
+      bind.runId = run.runId
+      bind.runSeeded = false
+    }
+    // 报文恢复即自愈:清掉停发期写入的 lastError(状态由 runtime.onSample 重新派生)
+    if (node.lastError) node.lastError = null
+    this.publishPushValue(node, sample.value, bind.lastAt)
+    bind.runSeeded = true
+  }
+
+  /** 推送帧经统一后处理(模板 sink + 对象存储)后入队;完成时复核绑定/批次/最新性 */
+  private async publishPushFrame(node: DaqNode, frame: NonNullable<DaqPushSample['frame']>, atMs: number, bind: PushBinding, runId: string): Promise<void> {
+    if (!this.running) return
+    const processed = await this.processFrameSample(node, frame, atMs)
+    if (!processed) return
+    if (!this.running || this.pushBindings.get(node.id) !== bind) return
+    const host = getDaqHostPorts()
+    const liveRun = host?.lineRun.activeRun(node.lineId)
+    // 异步处理期间批次已切换:该帧不能打上新区批次的标签(宁丢不错标)
+    if (!liveRun || liveRun.runId !== runId) return
+    // 只有最新一帧完成才清错误;慢帧晚到不能抹掉新帧的错误
+    if (bind.lastAt === atMs && node.lastError) node.lastError = null
+    const metrics = processed.frame.metrics ?? {}
+    // 与轮询帧口径一致(runtime 帧分支 = metrics.avg ?? 0),避免推送/轮询展示值分叉
+    const value = Number(metrics.avg ?? 0)
+    this.publishSample({
+      nodeId: node.id,
+      templateRef: node.templateRef,
+      value: Number(value.toFixed(node.decimals)),
+      state: 'ok',
+      at: new Date(atMs).toISOString(),
+      frame: processed.frame,
+    })
+    bind.runSeeded = true
+  }
+
+  /** 推送值经队列进入统一管线(物理量标定 + 节点精度) */
+  private publishPushValue(node: DaqNode, value: number, atMs: number): void {
+    const phys = applyTransform(value, node.transform)
+    this.publishSample({
+      nodeId: node.id,
+      templateRef: node.templateRef,
+      value: Number(phys.toFixed(node.decimals)),
+      state: 'ok',
+      at: new Date(atMs).toISOString(),
+    })
+  }
+
+  /** 订阅期错误:落 lastError(是否 offline 交由陈值看门狗判定,避免瞬时解析错误误判链路)。
+   *  报文确实到达但解析失败也算"链路有消息"—— 更新 lastAt,避免 watchdog 误报"未收到报文"。 */
+  private onPushError(nodeId: string, err: Error): void {
+    if (!this.running) return
+    const bind = this.pushBindings.get(nodeId)
+    if (bind) bind.lastAt = Math.max(bind.lastAt + 1, Date.now())
+    const node = this.repo.byId(nodeId)
+    if (!node) return
+    node.lastError = `被动订阅报文错误:${err.message}`
+    if (bind && Date.now() - bind.lastWarnAt > 30_000) {
+      bind.lastWarnAt = Date.now()
+      this.broadcastDriverError(node, `被动订阅报文错误:${err.message}`)
+    }
+  }
+
+  /** 陈值看门狗(sweep 调用):产线在跑但订阅长时间无报文 → offline + 可读 lastError。
+   *  不写入任何样本 —— 停发期间库里不该出现"冻值新样本"。 */
+  checkPushLiveness(now: number): void {
+    const host = getDaqHostPorts()
+    if (!host) return
+    for (const [nodeId, bind] of this.pushBindings) {
+      const node = this.repo.byId(nodeId)
+      if (!node || !node.enabled) continue
+      const run = host.lineRun.activeRun(node.lineId)
+      if (!run) {
+        bind.runId = null
+        bind.runSeeded = false
+        continue
+      }
+      // 新批次开跑:把停线期间缓存的最近值补种一次(retained-only 设备整批只有这一条状态;
+      // 超过 10 分钟的旧缓存不补,等新报文)
+      if (bind.runId !== run.runId) {
+        bind.runId = run.runId
+        bind.runSeeded = false
+      }
+      if (!bind.runSeeded && bind.lastValue != null && (now - bind.lastAt) <= RETAINED_SEED_MAX_AGE_MS) {
+        // 2026-10-28 审查 A-P1-2:补种时间戳 = 补种时刻(见 retainedSeedPlan 注释)。
+        const seed = retainedSeedPlan(bind, now)
+        if (seed) this.publishPushValue(node, seed.value, seed.atMs)
+        bind.runSeeded = true
+        if (node.lastError) node.lastError = null
+      }
+      const staleMs = Number(node.driverConfig?.staleMs ?? MQTT_STALE_DEFAULT_MS)
+      if (!(staleMs > 0)) continue
+      const since = bind.lastAt || bind.startedAt
+      if (now - since <= staleMs) continue
+      const msg = bind.lastAt
+        ? `MQTT 被动订阅:${Math.round((now - bind.lastAt) / 1000)}s 未收到报文(设备停发/主题无发布/网络分区),节点置 offline(停发期间不写样本)`
+        : `MQTT 被动订阅:订阅后 ${Math.round((now - bind.startedAt) / 1000)}s 未收到首条报文(检查 broker/主题/设备发布)`
+      node.state = 'offline'
+      node.lastError = msg
+      if (now - bind.lastWarnAt > 30_000) {
+        bind.lastWarnAt = now
+        this.broadcastDriverError(node, msg)
+      }
+    }
+  }
+}

package/server/services/workshop/daq/daq-controller/runtime-control.ts

@@ -10,6 +10,7 @@ import { getObjectStore } from '../objectstore'
 import { getTsdb } from '../storage'
 import { listPluginDrivers } from '../drivers'
 import { startAlarmEscalator } from '../alarm-notify'
+import { AppError } from '../../../../utils/errors'
 
 export abstract class DaqControllerRuntimeControl extends DaqControllerFrames {
   /** 后端能力自描述(meta 用) */
@@ -20,6 +21,11 @@ export abstract class DaqControllerRuntimeControl extends DaqControllerFrames {
   // ---------- 控制器全局 ----------
 
   startAll(): AepDaqControllerState {
+    // S10:后端明确降级时禁止开采(手动 resume 也不能绕过启动屏障)
+    const infra = (globalThis as unknown as { __daqInfraStatus?: () => { degraded: boolean, warning?: string } }).__daqInfraStatus?.()
+    if (infra?.degraded) {
+      throw new AppError(409, 'DAQ_INFRA_DEGRADED', `数采基础设施降级,禁止启动采集:${infra.warning ?? '后端不可用'}。请先修复后端或调用 /api/workshop/daq/infra/reconnect。`)
+    }
     this.running = true
     this.ensureLoop()
     startAlarmEscalator() // S5:升级通知扫描器(懒启动,进程内单例)
@@ -29,6 +35,8 @@ export abstract class DaqControllerRuntimeControl extends DaqControllerFrames {
 
   stopAll(): AepDaqControllerState {
     this.running = false
+    // 网关停止 = 采集停止:被动订阅一并回收(否则 MQTT 节点在"暂停"期间仍会收报文入库)
+    void this.stopAllPushBindings()
     for (const n of this.repo.all()) {
       if (n.enabled) n.state = 'offline'
     }

package/server/services/workshop/daq/daq-controller/state.ts

@@ -162,8 +162,15 @@ export abstract class DaqControllerState extends DaqControllerContracts {
       vector: tpl?.vector,
     })
     if (res == null || typeof res !== 'object' || !('frame' in res) || res.frame == null) return res
-    // 下沉管线(生产侧;单步失败保留原帧,永不抛出 —— 见 frames.ts runSinkPipeline)
-    const raw = res.frame
+    return this.processFrameSample(node, res.frame, now)
+  }
+
+  /**
+   * 帧后处理(轮询采样与推送订阅共用):模板 sink 下沉管线 → 图像落对象存储。
+   * 返回队列信封帧(vector 点列 / image 引用 + 完整性指纹);非法帧返回 null。
+   */
+  protected async processFrameSample(node: DaqNode, raw: DaqFrameSample['frame'], now: number): Promise<{ frame: NonNullable<DaqSampleEnvelope['frame']> } | null> {
+    const tpl = findDaqTemplate(node.templateKey)
     // 契约守卫:帧联合只有 vector/image;驱动返回未知 kind(如误包 scalar)直接丢帧,
     // 绝不蒙成 image 走 blob 管线(会在 sink 派生处炸出 undefined.length)
     if (raw.kind !== 'vector' && raw.kind !== 'image') return null
@@ -176,7 +183,8 @@ export abstract class DaqControllerState extends DaqControllerContracts {
     }
     // 图像:主图 + 缩略图落对象存储(失败抛出 → tick 按驱动故障节流,采集不中断)
     const os = getObjectStore()
-    const objectKey = daqObjectKey(node.id, now, '.png')
+    const ext = wf.mime === 'image/jpeg' ? '.jpg' : wf.mime === 'image/webp' ? '.webp' : wf.mime === 'image/gif' ? '.gif' : wf.mime === 'image/bmp' ? '.bmp' : wf.mime === 'image/tiff' ? '.tiff' : '.png'
+    const objectKey = daqObjectKey(node.id, now, ext)
     await os.put(objectKey, wf.blob!, wf.mime ?? 'image/png')
     // P0-2 像素完整性:sha256+size 随帧入 daq_frames.meta(blob 就手计算,1Hz 下开销可忽略;
     // 存量文件不回填 —— 保留期内自然出清)

package/server/services/workshop/daq/daq-controller/sweep-alarms.ts

@@ -12,18 +12,24 @@ import { getDaqHostPorts } from '../host-ports'
 import { getOps, recordOps } from '../../ops/ops'
 import { getActiveLineRun } from '../../dcw/line-run'
 import { newAlarmId, notifyAlarm } from '../alarm-notify'
+import { resolveDaqDriver } from '../drivers'
 
 export abstract class DaqControllerSweepAlarms extends DaqControllerIngest {
   /** 网关统一调度:250ms 扫描,到期判定与互斥由各运行时私有节拍自治(单节点慢/停不波及邻居)。
-   *  产线门控:未选定配方(无活动 LineRun)不执行采集 —— 采样与实时下发均由配方驱动。 */
+   *  产线门控:未选定配方(无活动 LineRun)不执行采集 —— 采样与实时下发均由配方驱动。
+   *  推送式协议(MQTT)不走本循环采样:订阅在 syncPushBindings 建立,报文到达即入库;
+   *  该循环只负责订阅对账与陈值看门狗。 */
   protected sweep(): void {
     if (!this.pipelineReady || !this.running) return
+    // 订阅对账与看门狗不依赖"是否有活动批次"(未开跑也保持 broker 在线,开跑即恢复入库)
+    this.syncPushBindings()
+    const now = Date.now()
+    this.checkPushLiveness(now)
     const host = getDaqHostPorts()
     if (!host || !host.lineRun.hasAnyActiveRun()) return
     // 在飞闸门:上一拍未消化的并发额度不叠加(避免积压 tick 雪崩)
     const budget = SWEEP_MAX_CONCURRENCY - this.samplingInFlight
     if (budget <= 0) return
-    const now = Date.now()
     const defs = this.runtimeDefaults()
     const rts = [...this.runtimes.values()]
     const total = rts.length
@@ -36,6 +42,8 @@ export abstract class DaqControllerSweepAlarms extends DaqControllerIngest {
     for (let i = 0; i < total && started < budget; i++) {
       const rt = rts[(this.sweepCursor + i) % total]!
       examined = i + 1
+      // 推送式驱动(存在 subscribe)不轮询:否则同一条报文会被采样 tick 重复入库
+      if (typeof resolveDaqDriver(rt.node.driver).subscribe === 'function') continue
       // 逐产线门控:节点只在其所属产线的活动批次窗口内采集(lineId 空 = 未分配,不采集)
       if (!host.lineRun.activeRun(rt.node.lineId)) continue
       if (!rt.isDue(now, defs)) continue
@@ -110,6 +118,8 @@ export abstract class DaqControllerSweepAlarms extends DaqControllerIngest {
     const payload = {
       id, nodeId: node.id, nodeName: node.name, metric,
       value, rule, threshold, escalation: 0, createdAt,
+      // S14:告警帧必须带产线归属,否则 scene-events 会当作"线无关"广播给所有 peer
+      lineId: node.lineId || null,
     }
     this.broadcast?.('daq.alarm', payload)
     notifyAlarm(payload)
@@ -135,7 +145,7 @@ export abstract class DaqControllerSweepAlarms extends DaqControllerIngest {
 
   /** alarm 恢复沿:广播恢复(报警保持 open 待人工 ack) */
   protected handleAlarmRecover(node: DaqNode, value: number): void {
-    this.broadcast?.('daq.alarm.changed', { nodeId: node.id, nodeName: node.name, recovered: true, value, at: new Date().toISOString() })
+    this.broadcast?.('daq.alarm.changed', { nodeId: node.id, nodeName: node.name, recovered: true, value, at: new Date().toISOString(), lineId: node.lineId || null })
   }
 
   /** 报警确认(HITL 闭环的人为一步;幂等:已确认返回 false) */

package/server/services/workshop/daq/daq-controller/tsdb-row.ts

@@ -0,0 +1,48 @@
+/**
+ * TSDB 行装配(纯函数,便于单测)。
+ *
+ * 语义(F7a):
+ *  - lineId = 节点所属产线(配置事实),未开线也写入 —— 未开线时段样本可按线检索;
+ *  - product/recipe/run 只在活动 LineRun 窗口内才有值(批次语义不被伪造);
+ *  - 未分配产线的节点 lineId 保持 null(不冒充任何产线)。
+ */
+export interface TsdbRunTags {
+  lineId: string
+  productId?: string | null
+  recipeId?: string | null
+  runId?: string | null
+}
+
+export interface TsdbSampleInput {
+  nodeId: string
+  tsMs: number
+  value: number
+  state: string
+  nodeLineId?: string | null
+  run: TsdbRunTags | null
+}
+
+export interface TsdbSampleRow {
+  nodeId: string
+  tsMs: number
+  value: number
+  state: string
+  lineId: string | null
+  productId: string | null
+  recipeId: string | null
+  runId: string | null
+}
+
+export function tsdbRowOf(input: TsdbSampleInput): TsdbSampleRow {
+  const nodeLine = input.nodeLineId ? String(input.nodeLineId) : ''
+  return {
+    nodeId: input.nodeId,
+    tsMs: input.tsMs,
+    value: input.value,
+    state: input.state,
+    lineId: nodeLine || null,
+    productId: input.run?.productId ?? null,
+    recipeId: input.run?.recipeId ?? null,
+    runId: input.run?.runId ?? null,
+  }
+}

package/server/services/workshop/daq/daq-controller/tsdb-twin.ts

@@ -11,11 +11,15 @@ import { TSDB_WRITE_RETRIES, log } from './helpers'
 import { findDaqTemplate } from '../daq-templates'
 import { getDaqHostPorts } from '../host-ports'
 import { getTsdb } from '../storage'
+import { getDcwNodeRepo } from '../../dcw/dcw-node.repo'
 
 export abstract class DaqControllerTsdbTwin extends DaqControllerSweepAlarms {
-  /** 网关消费泵:队列帧按节点分发回其运行时(乱序防御/状态派生/下发门控在 runtime) */
+  /** 网关消费泵:队列帧按节点分发回其运行时(乱序防御/状态派生/下发门控在 runtime)。
+   *  只校验网关运行态:外部 /ingest 是文档化的入库入口,产线门控由来源侧/路由自身判定,
+   *  不能在这里静默丢弃(否则 /ingest 返回 accepted 却没有行)。 */
   protected onSampleFromQueue(env: DaqSampleEnvelope): void {
     this.consumedCount++
+    if (!this.running) return
     const rt = this.runtimes.get(env.nodeId)
     if (!rt) return
     if (rt.onSample(env) === 'late') this.lateDropped++
@@ -128,11 +132,30 @@ export abstract class DaqControllerTsdbTwin extends DaqControllerSweepAlarms {
   /** 遥测 WS 推送(1s/设备节流):孪生状态/遥测事件化直推,前端全量轮询降级为断线兜底 */
   protected twinPushAt = new Map<string, number>()
 
+  /** 孪生绑定节点所属产线(唯一时返回;多线/未绑定 → null,保持全局语义) */
+  private twinLineId(twinId: string): string | null {
+    try {
+      const lines = new Set<string>()
+      for (const n of this.repo.all()) {
+        if (n.lineId && (n.deviceIds ?? []).includes(twinId)) lines.add(n.lineId)
+      }
+      for (const n of getDcwNodeRepo().all()) {
+        if (n.lineId && (n.deviceIds ?? []).includes(twinId)) lines.add(n.lineId)
+      }
+      return lines.size === 1 ? [...lines][0]! : null
+    }
+    catch { return null }
+  }
+
   protected pushTwinTelemetry(twinId: string): void {
     const now = Date.now()
     if (now - (this.twinPushAt.get(twinId) ?? 0) < 1000) return
     this.twinPushAt.set(twinId, now)
     const payload = getDaqHostPorts()?.telemetry.scenePayload(twinId)
-    if (payload) this.broadcast?.('device.updated', payload)
+    if (payload) {
+      // S14:补产线归属,让 scene-events 按 peer 可见集过滤;唯一产线才补,多线保持全局
+      const lineId = this.twinLineId(twinId)
+      this.broadcast?.('device.updated', lineId ? { ...(payload as object), lineId } : payload)
+    }
   }
 }

package/server/services/workshop/daq/daq-controller/views.ts

@@ -10,6 +10,7 @@ import type { DaqNode } from '../daq-node'
 import { g_queueLost } from './helpers'
 import { getDaqQueue } from '../bus'
 import { getTsdb, tsdbReady } from '../storage'
+import { queryLatest } from '../storage/latest-window'
 
 export abstract class DaqControllerViews extends DaqControllerTsdbTwin {
   protected emitNodeChanged(op: AepDaqNodeChange['op'], node: DaqNode | null): void {
@@ -74,12 +75,14 @@ export abstract class DaqControllerViews extends DaqControllerTsdbTwin {
     return this.repo.byId(id)
   }
 
-  /** 节点历史(时序库查询透传;raw 或 bucket 聚合形态) */
+  /** 节点历史(时序库查询透传;raw 或 bucket 聚合形态)。
+   *  实时面固定取**窗口末尾** limit 段(tail):样本/趋势/Agent 都按「末元素=最新」消费,
+   *  窗口超 limit 时不能拿最旧段冒充最新(2026-10-27 MQTT 审计实测的静默说谎)。 */
   async samples(id: string, opts: { fromMs?: number, toMs?: number, bucketMs?: number, limit?: number }) {
     this.ensureLoop()
     await tsdbReady
     const node = this.repo.byId(id)
     if (!node) throw new AppError(404, 'NOT_FOUND', `数采节点不存在: ${id}`)
-    return getTsdb().query(id, opts)
+    return queryLatest(getTsdb(), id, opts)
   }
 }