agentworkshop 0.7.41 → 0.7.46

package/server/services/workshop/dcw/dcw-controller.ts

@@ -1,1176 +0,0 @@
-/**
- * DcwController —— 数据写控制网关(应用级单例,与 DaqController 对称)。
- *
- * 每个写控制节点一个独立 DcwNodeRuntime(边缘控制运行时),网关统一调度:
- *   - 手动写命令(REST/前端设定)→ 工程量校验 → 驱动写(换算/回读校验在驱动)
- *     → ACK 记账(节点状态/写历史/WS dcw.written 直推)
- *   - 保写心跳(runtime 元数据 holdIntervalMs,PLC 设定恢复语义)
- *   - Recipe 应用:批次(Run)隔离 + 逐参数写 + 结果快照
- * 用户语义 = 工程量;PLC 底层全部由系统封装。
- */
-
-import { randomUUID } from 'node:crypto'
-import { applyTransform, inverseTransform, normalizeDataTransform, dcwKeyFromRef } from '../../../../shared/dcw-protocol'
-import type { AepDcwNodeChange, DcwDriverKind, DcwNodeView, DcwParamInput, DcwParamView, DataTransform, LineInput, LineQueryOpts, LineQueryResult, LineRunState, LineView, ProductInput, ProductView, RecipeInput, RecipeRunView, RecipeView, DcwWriteMeta } from '../../../../shared/dcw-protocol'
-import { AppError, ErrorCodes } from '../../../utils/errors'
-import { normalizeDcwDriverKind, resolveDcwDriver } from './drivers'
-import { attachDcwPluginBridge } from './plugin-bridge'
-import { findDcwTemplate } from './dcw-templates'
-import { getDeviceTwinRepo } from '../assets/device-twin.repo'
-import { DcwNode } from './dcw-node'
-import { getDcwNodeRepo } from './dcw-node.repo'
-import { DcwNodeRuntime } from './dcw-runtime'
-import { getDcwRecipeRepo, type DcwWriteHistoryEntry } from './dcw-recipe.repo'
-import { getDcwProductRepo } from './dcw-product.repo'
-import { getDcwLineRepo } from './dcw-line.repo'
-import { getDcwParamRepo } from './param-map.repo'
-import { assertWithinLimits, limitsBreakdownOf } from './param-limits'
-import { deriveAccess } from './param-conversion'
-import { emitDcwWrite } from '@/server/services/workshop/plugins/host.mjs'
-import { clearActiveLineRun, getActiveLineRun, getAllActiveLineRuns, setActiveLineRun } from './line-run'
-import { getRecipeRollBackManager } from './recipe-rollback-manager'
-import { recordOps } from '../ops/ops'
-import { daqRuntimeSettings } from '../settings'
-
-/** 运维日志写下发防噪:同节点同值 10s 内的心跳重下发不重复入册 */
-const opsWriteMemo = new Map<string, { eng: number, at: number }>()
-
-// 写驱动插件桥(模块装载即挂;插件宿主先到则注册项排队、此处接管回放)
-attachDcwPluginBridge()
-
-/** 周期读网关默认间隔(节点 readIntervalMs=null 时生效;真实 PLC 建议按链路承载调整) */
-const DEFAULT_READ_INTERVAL_MS = 5000
-
-/** write() 来源 → 日志来源(user 人工下发 / agent 智能体 / system 配方·回退等系统路径) */
-function opsActorKindOf(source: string): 'user' | 'agent' | 'system' {
-  if (source === 'agent') return 'agent'
-  if (source === 'manual') return 'user'
-  return 'system'
-}
-
-type BroadcastFn = (type: string, payload: unknown) => void
-
-export interface DcwCreateInput {
-  templateRef?: string
-  name?: string
-  driver?: DcwDriverKind
-  driverConfig?: Record<string, string | number | boolean>
-  /** 数据语义标定钩子(encode:物理值 → PLC 设定值) */
-  transform?: DataTransform
-  holdIntervalMs?: number | null
-  /** 周期读间隔 ms(null = 网关默认;0 = 仅手动读取) */
-  readIntervalMs?: number | null
-  unit?: string
-  decimals?: number
-  min?: number
-  max?: number
-  enabled?: boolean
-  posX?: number
-  posZ?: number
-  deviceBindingId?: string | null
-  deviceIds?: string[]
-  /** 所属产线('' = 未分配) */
-  lineId?: string
-  /** 节点级工艺语义备注(覆盖模板) */
-  semantics?: string
-}
-
-export interface DcwPatchInput {
-  name?: string
-  driver?: DcwDriverKind
-  driverConfig?: Record<string, string | number | boolean>
-  /** 数据语义标定钩子(encode) */
-  transform?: DataTransform
-  holdIntervalMs?: number | null
-  /** 周期读间隔 ms(null = 网关默认;0 = 仅手动读取) */
-  readIntervalMs?: number | null
-  unit?: string
-  decimals?: number
-  min?: number
-  max?: number
-  enabled?: boolean
-  posX?: number
-  posZ?: number
-  lineId?: string
-  semantics?: string
-}
-
-/** 网关扫描周期(ms;保写心跳分辨率) */
-const SWEEP_MS = 500
-
-class DcwController {
-  private repo = getDcwNodeRepo()
-  private broadcast: BroadcastFn | null = null
-  private timer: NodeJS.Timeout | null = null
-  /** 边缘控制运行时注册表(节点 id → 独立运行时) */
-  private runtimes = new Map<string, DcwNodeRuntime>()
-
-  running = true
-  private writesTotal = 0
-  private writesFailed = 0
-
-  // ---------- 生命周期 ----------
-
-  private ensureLoop(): void {
-    this.syncRuntimes()
-    if (this.timer) return
-    this.timer = setInterval(() => this.sweep(), SWEEP_MS)
-    this.timer.unref?.()
-  }
-
-  /** 网关统一调度:保写心跳在各运行时内部自治(单节点写事务不波及邻居);
-   *  调控闭环:open 优化记录的系统兜底评估复用本节拍(F1,不建新定时器) */
-  private sweep(): void {
-    if (!this.running) return
-    const now = Date.now()
-    for (const rt of this.runtimes.values()) rt.tick(now)
-    getRecipeRollBackManager().evaluateOpenRecords(now)
-  }
-
-  private syncRuntimes(): void {
-    const live = new Set<string>()
-    for (const node of this.repo.all()) {
-      live.add(node.id)
-      if (!this.runtimes.has(node.id)) {
-        this.runtimes.set(node.id, new DcwNodeRuntime(node, this.host))
-      }
-    }
-    for (const id of [...this.runtimes.keys()]) {
-      if (!live.has(id)) this.runtimes.delete(id)
-    }
-  }
-
-  // ---------- 网关服务面(runtime host)----------
-
-  private host = {
-    running: () => this.running,
-    defaults: () => ({ holdIntervalMs: 0, readIntervalMs: DEFAULT_READ_INTERVAL_MS }),
-    executeWrite: async (node: DcwNode, eng: number, tolerance: number, recipeRunId: string | null) =>
-      this.executeWrite(node, eng, tolerance, recipeRunId),
-    executeRead: async (node: DcwNode) => this.executeRead(node),
-  }
-
-  /**
-   * 核心写执行:驱动写(工程量→原始值换算 + 回读校验在驱动内)
-   * → ACK 记账(节点状态/写历史)→ WS 直推。真实/模拟驱动同一路径。
-   */
-  private async executeWrite(node: DcwNode, eng: number, tolerance: number, recipeRunId: string | null): Promise<{ ok: boolean, message: string, raw: number | null, readback: number | null }> {
-    const at = new Date().toISOString()
-    // 数据语义标定钩子(encode):物理值 → PLC 设定值。
-    // 回读值再经 decoder 换算回物理量做死区校验(容差按标定比例同步缩放)。
-    const t = node.transform
-    const plcValue = inverseTransform(eng, t)
-    const plcTolerance = Math.max(tolerance, 1e-9) / (t?.kind === 'linear' && Math.abs(t.scale ?? 1) > 0 ? Math.abs(t.scale!) : 1)
-    let outcome: { ok: boolean, message: string, raw: number | null, readback: number | null }
-    try {
-      outcome = await resolveDcwDriver(node.driver).write({
-        eng: plcValue,
-        tolerance: plcTolerance,
-        domain: { min: node.min, max: node.max },
-        driverConfig: node.driverConfig,
-      })
-      // 回读换算回物理量(message 保留 PLC 域数值供排查)
-      if (outcome.readback != null) outcome.readback = applyTransform(outcome.readback, t)
-      if (outcome.ok) outcome.message = `${outcome.message}(标定后物理值 ${Number((outcome.readback ?? eng).toFixed(node.decimals))})`
-    }
-    catch (err) {
-      outcome = { ok: false, message: err instanceof Error ? err.message : String(err), raw: null, readback: null }
-    }
-    this.writesTotal++
-    if (!outcome.ok) this.writesFailed++
-    // set 后 hook:节点暴露值 = PLC 回读经 decoder 解码的**真实物理值**(而非指令值);
-    // 回读缺失(驱动不支持)才回退指令值。节点对外呈现的始终是处理后的工艺参数。
-    node.applyWriteResult(outcome.readback ?? eng, outcome.ok, outcome.message, at)
-    // 写值走防抖落盘:保写心跳按 holdIntervalMs 周期触发本方法,同步全量重写
-    // dcws.json 会随节点数放大成周期性 fs 抖动;防抖窗内崩溃丢失的设定值可从 PLC 回读恢复
-    this.repo.flushDebounced()
-    const repo = getDcwRecipeRepo()
-    const entry: DcwWriteHistoryEntry = {
-      id: `wh-${randomUUID().slice(0, 8)}`,
-      nodeId: node.id,
-      nodeName: node.name,
-      param: findDcwTemplate(node.templateKey)?.ch ?? node.templateKey,
-      eng: node.value ?? eng,
-      raw: outcome.raw,
-      ok: outcome.ok,
-      message: outcome.message,
-      recipeRunId,
-      at,
-    }
-    repo.appendHistory(entry)
-    this.broadcast?.('dcw.written', {
-      nodeId: node.id,
-      templateRef: node.templateRef,
-      lineId: node.lineId ?? null,
-      value: node.value ?? eng,
-      raw: outcome.raw,
-      ok: outcome.ok,
-      message: outcome.message,
-      recipeRunId,
-      at,
-    })
-    this.emitNodeChanged('updated', node)
-    return outcome
-  }
-
-  private emitNodeChanged(op: AepDcwNodeChange['op'], node: DcwNode | null): void {
-    const payload: AepDcwNodeChange = { op, node: node ? node.toView() : null }
-    this.broadcast?.('dcw.node.changed', payload)
-  }
-
-  /**
-   * 核心读执行:驱动读(寄存器解码 + 工程量映射在驱动内)→ 标定 decode(PLC 值 → 物理值)
-   * → 读状态记账(节点 readValue/lastReadAt,失败记 lastReadError 不动写状态机)→ WS dcw.read 直推。
-   * 不支持读的驱动(mock 外的 mqtt/http)不产生节点状态噪音,直接返回说明。
-   */
-  private async executeRead(node: DcwNode): Promise<{ ok: boolean, value: number | null, raw: number | null, message: string, at: string }> {
-    const at = new Date().toISOString()
-    const driver = resolveDcwDriver(node.driver)
-    if (!driver.read) {
-      return { ok: false, value: null, raw: null, message: `驱动 ${node.driver} 不支持读取(仅观测型通道)`, at }
-    }
-    let r: { ok: boolean, message: string, eng: number | null, raw: number | null }
-    try {
-      r = await driver.read({ domain: { min: node.min, max: node.max }, driverConfig: node.driverConfig })
-    }
-    catch (err) {
-      r = { ok: false, eng: null, raw: null, message: err instanceof Error ? err.message : String(err) }
-    }
-    // 读回的是 PLC 设定值域 → 经标定 decode 换算物理量(与写链路 inverse 互逆)
-    const value = r.ok && r.eng != null ? applyTransform(r.eng, node.transform) : null
-    node.applyReadResult(value, r.raw, r.ok, r.message, at)
-    this.repo.flushDebounced()
-    this.broadcast?.('dcw.read', {
-      nodeId: node.id,
-      templateRef: node.templateRef,
-      lineId: node.lineId ?? null,
-      value,
-      raw: r.raw,
-      ok: r.ok,
-      message: r.message,
-      at,
-    })
-    return { ok: r.ok, value, raw: r.raw, message: r.message, at }
-  }
-
-  /** 手动读取(REST/前端「读取」按钮/Agent 工具;走运行时在飞互斥) */
-  async readNow(id: string): Promise<{ ok: boolean, value: number | null, raw: number | null, message: string, at: string }> {
-    this.ensureLoop()
-    const rt = this.runtimes.get(id)
-    if (!rt) throw new AppError(404, ErrorCodes.NOT_FOUND, `控制节点不存在: ${id}`)
-    return rt.readNow()
-  }
-
-  setBroadcast(fn: BroadcastFn | null): void {
-    this.broadcast = fn
-    // 调控闭环 WS 帧(dcw.optimization.changed)与既有帧同一广播通道
-    getRecipeRollBackManager().setBroadcast(fn)
-  }
-
-  // ---------- 查询 ----------
-
-  listViews(): DcwNodeView[] {
-    this.ensureLoop()
-    return this.repo.all().map(n => n.toView())
-  }
-
-  byId(id: string): DcwNode | undefined {
-    return this.repo.byId(id)
-  }
-
-  controllerState() {
-    // 单次遍历(hardening PERF-1):status 高频路径不再对全表多次 all()
-    const nodes = this.repo.all()
-    return {
-      running: this.running,
-      nodesTotal: nodes.length,
-      nodesOnline: this.running ? nodes.filter(n => n.enabled).length : 0,
-      writesTotal: this.writesTotal,
-      writesFailed: this.writesFailed,
-    }
-  }
-
-  // ---------- 网关全局 ----------
-
-  startAll() {
-    this.running = true
-    // 恢复控制:因「暂停全部控制」转 offline 的启用节点回待机(暂停态与恢复态对称)
-    for (const n of this.repo.all()) {
-      if (n.enabled && n.state === 'offline') n.state = 'idle'
-    }
-    this.ensureLoop()
-    this.broadcast?.('dcw.controller', this.controllerState())
-    return this.controllerState()
-  }
-
-  stopAll() {
-    this.running = false
-    for (const n of this.repo.all()) {
-      if (n.enabled && n.value != null) n.state = 'offline'
-    }
-    this.broadcast?.('dcw.controller', this.controllerState())
-    return this.controllerState()
-  }
-
-  /**
-   * 暂停全部控制 → 网关停止;恢复全部控制 → 网关启动。
-   * 节点启停与网关暂停完全独立:enabled 标志是唯一下发资格,恢复后只有
-   * enabled=true(即暂停时刻在控制的那批)的节点恢复;暂停前/暂停期间
-   * 手动停用的节点保持停用,不会被自动拉起。
-   */
-  pauseAll() {
-    return this.stopAll()
-  }
-
-  resumeAll() {
-    return this.startAll()
-  }
-
-  // ---------- 节点 CRUD(单点控制入口)----------
-
-  create(input: DcwCreateInput): DcwNode {
-    this.ensureLoop()
-    if (!input.templateRef) {
-      throw new AppError(400, ErrorCodes.VALIDATION_ERROR, 'templateRef 必填:控制节点必须绑定工艺参数模板')
-    }
-    const tpl = findDcwTemplate(dcwKeyFromRef(input.templateRef))
-    if (!tpl) {
-      throw new AppError(404, ErrorCodes.NOT_FOUND, `未知控制模板: ${input.templateRef}`)
-    }
-    const seq = this.repo.all().filter(n => n.templateKey === dcwKeyFromRef(input.templateRef!)).length + 1
-    const node = new DcwNode({
-      id: `dw-${randomUUID().slice(0, 8)}`,
-      templateRef: input.templateRef,
-      name: input.name ?? `${tpl.name} ${String(seq).padStart(2, '0')}`,
-      driver: input.driver ? normalizeDcwDriverKind(input.driver) : undefined,
-      driverConfig: input.driverConfig ?? {},
-      transform: normalizeDataTransform(input.transform),
-      enabled: input.enabled,
-      holdIntervalMs: input.holdIntervalMs ?? null,
-      readIntervalMs: input.readIntervalMs ?? null,
-      unit: input.unit,
-      decimals: input.decimals,
-      min: input.min,
-      max: input.max,
-      deviceBindingId: input.deviceBindingId ?? null,
-      deviceIds: input.deviceIds ?? (input.deviceBindingId ? [input.deviceBindingId] : []),
-      posX: input.posX,
-      posZ: input.posZ,
-      lineId: input.lineId,
-      semantics: input.semantics,
-    })
-    this.repo.insert(node)
-    // 工艺参数映射面:节点创建即自动生成同名映射(用户/Agent 的参数语义面;
-    // PLC 寻址细节仍封装在节点驱动配置内)。失败不阻断节点创建(可事后手工补建)。
-    getDcwParamRepo().ensureForNode(node)
-    this.syncRuntimes()
-    this.emitNodeChanged('added', node)
-    return node
-  }
-
-  patch(id: string, patch: DcwPatchInput): DcwNode {
-    const node = this.repo.byId(id)
-    if (!node) throw new AppError(404, ErrorCodes.NOT_FOUND, `控制节点不存在: ${id}`)
-    let rearm = false
-    if (patch.name !== undefined) node.name = patch.name
-    if (patch.driver !== undefined) node.driver = normalizeDcwDriverKind(patch.driver)
-    if (patch.driverConfig !== undefined) node.driverConfig = { ...node.driverConfig, ...patch.driverConfig }
-    if (patch.transform !== undefined) {
-      if (patch.transform.kind === 'linear' && (!Number.isFinite(Number(patch.transform.scale)) || Number(patch.transform.scale) === 0)) {
-        throw new AppError(400, ErrorCodes.VALIDATION_ERROR, '标定系数 scale 必须为非零数字(物理值 = scale × PLC值 + offset)')
-      }
-      node.transform = normalizeDataTransform(patch.transform)
-    }
-    if (patch.unit !== undefined) node.unit = patch.unit
-    // decimals 必须 0..6 整数:它同时喂给 toFixed() —— 越界值会在**驱动已经写进 PLC 之后**
-    // 由 applyWriteResult/applyReadResult 抛 RangeError,造成「硬件已改、账本无记录、
-    // 调用方吃 500」(审计实测:decimals=101 → PLC 写入成功、无锚点、无写历史)。
-    // 在校验入口一次性拒掉,别让脏值走到写路径。
-    if (patch.decimals !== undefined) {
-      const d = Number(patch.decimals)
-      if (!Number.isInteger(d) || d < 0 || d > 6) {
-        throw new AppError(400, ErrorCodes.VALIDATION_ERROR, `decimals 必须为 0..6 的整数(当前: ${String(patch.decimals)})`)
-      }
-      node.decimals = d
-    }
-    if (patch.min !== undefined) {
-      const v = Number(patch.min)
-      if (!Number.isFinite(v)) throw new AppError(400, ErrorCodes.VALIDATION_ERROR, `min 必须为有限数字(当前: ${String(patch.min)})`)
-      node.min = v
-    }
-    if (patch.max !== undefined) {
-      const v = Number(patch.max)
-      if (!Number.isFinite(v)) throw new AppError(400, ErrorCodes.VALIDATION_ERROR, `max 必须为有限数字(当前: ${String(patch.max)})`)
-      node.max = v
-    }
-    // 量程交叉校验放在两者都应用之后:min>max 会让 writeTolerance 变负、越界判定恒真
-    if (node.max < node.min) {
-      throw new AppError(400, ErrorCodes.VALIDATION_ERROR, `量程无效:max(${node.max}) 不得小于 min(${node.min})`)
-    }
-    if (patch.holdIntervalMs !== undefined) {
-      node.holdIntervalMs = patch.holdIntervalMs == null ? null : Math.max(0, Math.min(3_600_000, Math.round(patch.holdIntervalMs)))
-      rearm = true
-    }
-    if (patch.readIntervalMs !== undefined) {
-      node.readIntervalMs = patch.readIntervalMs == null ? null : Math.max(0, Math.min(3_600_000, Math.round(patch.readIntervalMs)))
-      rearm = true
-    }
-    if (patch.enabled !== undefined) {
-      node.enabled = patch.enabled
-      // 暂停/恢复的状态同步:暂停 → offline(暂停控制);恢复 → 回到待机(等下次写 ACK 转 ok)
-      if (!patch.enabled) node.state = 'offline'
-      else if (node.state === 'offline') node.state = 'idle'
-      rearm = true
-    }
-    if (patch.posX !== undefined) node.posX = patch.posX
-    if (patch.posZ !== undefined) node.posZ = patch.posZ
-    if (patch.lineId !== undefined) {
-      const lid = String(patch.lineId)
-      if (lid && !getDcwLineRepo().byId(lid)) throw new AppError(404, ErrorCodes.NOT_FOUND, `产线不存在: ${lid}`)
-      node.lineId = lid
-    }
-    if (patch.semantics !== undefined) node.semantics = String(patch.semantics)
-    if (rearm) this.runtimes.get(id)?.rearm()
-    this.repo.flushNow()
-    this.emitNodeChanged('updated', node)
-    return node
-  }
-
-  remove(id: string): void {
-    const node = this.repo.byId(id)
-    if (!node) throw new AppError(404, ErrorCodes.NOT_FOUND, `控制节点不存在: ${id}`)
-    this.repo.remove(id)
-    this.runtimes.delete(id)
-    // 级联清理:工艺参数映射面随执行节点删除(参数不存在悬空引用)
-    getDcwParamRepo().removeForNode(id)
-    // 级联清理:该节点的 Agent 绑定移除,挂起中的手动审批按失效收敛
-    void import('../agents/node-bindings.repo').then(({ getAgentNodeBindingRepo }) => {
-      const repo = getAgentNodeBindingRepo()
-      for (const b of repo.byNode(id)) {
-        void import('../agents/tool-approvals').then(({ getToolApprovals }) => {
-          getToolApprovals().cancelPendingFor(b.agentId, id)
-        }).catch(() => {})
-        repo.removeAgentNode(b.agentId, id, 'dcw')
-      }
-    }).catch(() => {})
-    this.emitNodeChanged('removed', node)
-  }
-
-  bind(id: string, deviceId: string | null): DcwNode {
-    const node = this.repo.byId(id)
-    if (!node) throw new AppError(404, ErrorCodes.NOT_FOUND, `控制节点不存在: ${id}`)
-    if (deviceId) {
-      const twin = getDeviceTwinRepo().findById(deviceId)
-      if (!twin) throw new AppError(404, ErrorCodes.NOT_FOUND, `目标设备不存在: ${deviceId}`)
-    }
-    // 排他语义保留;多对多增删用 bindDevice/unbindDeviceNode/setDeviceBindings
-    node.deviceIds = deviceId ? [deviceId] : []
-    node.deviceBindingId = deviceId
-    this.repo.flushNow()
-    this.emitNodeChanged('updated', node)
-    return node
-  }
-
-  /** 追加一台绑定设备((节点,设备)对唯一;幂等) */
-  bindDevice(id: string, deviceId: string): DcwNode {
-    const node = this.repo.byId(id)
-    if (!node) throw new AppError(404, ErrorCodes.NOT_FOUND, `控制节点不存在: ${id}`)
-    const twin = getDeviceTwinRepo().findById(deviceId)
-    if (!twin) throw new AppError(404, ErrorCodes.NOT_FOUND, `目标设备不存在: ${deviceId}`)
-    if (node.deviceIds.includes(deviceId)) return node
-    node.deviceIds = [...node.deviceIds, deviceId]
-    node.deviceBindingId = node.deviceIds[0] ?? null
-    this.repo.flushNow()
-    this.emitNodeChanged('updated', node)
-    return node
-  }
-
-  /** 解绑一台设备(其余绑定保留) */
-  unbindDeviceNode(id: string, deviceId: string): DcwNode {
-    const node = this.repo.byId(id)
-    if (!node) throw new AppError(404, ErrorCodes.NOT_FOUND, `控制节点不存在: ${id}`)
-    if (!node.deviceIds.includes(deviceId)) return node
-    node.deviceIds = node.deviceIds.filter(d => d !== deviceId)
-    node.deviceBindingId = node.deviceIds[0] ?? null
-    this.repo.flushNow()
-    this.emitNodeChanged('updated', node)
-    return node
-  }
-
-  /** 整体设定绑定设备列表(去重、校验存在性;全量替换) */
-  setDeviceBindings(id: string, deviceIds: string[]): DcwNode {
-    const node = this.repo.byId(id)
-    if (!node) throw new AppError(404, ErrorCodes.NOT_FOUND, `控制节点不存在: ${id}`)
-    const unique = [...new Set(deviceIds.map(String).filter(Boolean))]
-    for (const d of unique) {
-      if (!getDeviceTwinRepo().findById(d)) {
-        throw new AppError(404, ErrorCodes.NOT_FOUND, `目标设备不存在: ${d}`)
-      }
-    }
-    node.deviceIds = unique
-    node.deviceBindingId = unique[0] ?? null
-    this.repo.flushNow()
-    this.emitNodeChanged('updated', node)
-    return node
-  }
-
-  /** 设备删除级联解绑(device-twins 删除路由调用)。flushNow 移出循环(同 daq 侧) */
-  unbindDevice(deviceId: string): void {
-    let touched = false
-    for (const node of this.repo.all()) {
-      if (!node.deviceIds.includes(deviceId)) continue
-      node.deviceIds = node.deviceIds.filter(d => d !== deviceId)
-      node.deviceBindingId = node.deviceIds[0] ?? null
-      touched = true
-      this.emitNodeChanged('updated', node)
-    }
-    if (touched) this.repo.flushNow()
-  }
-
-  // ---------- 写命令(上位机核心操作)----------
-
-  /** 手动设定:用户提交工程量,网关校验/换算/下发/回读校验。
-   *  配方联锁:产线运行中,写入值还须落在活动配方对该参数的工艺窗口内
-   *  (节点全局量程之外的第二道约束 —— 换配方即换工艺窗口)。
-   *  meta(F7):账本与优化记录的身份信息 —— 手动/配方/Agent/回退四路共用本入口,
-   *  缺省按 manual/user 记账;调控闭环护栏(Agent 互斥/回退冷却)在 beforeWrite。 */
-  async write(id: string, eng: number, recipeRunId: string | null = null, meta?: DcwWriteMeta) {
-    this.ensureLoop()
-    const rt = this.runtimes.get(id)
-    if (!rt) throw new AppError(404, ErrorCodes.NOT_FOUND, `控制节点不存在: ${id}`)
-    const node = rt.node
-    // 控制暂停双重门控:网关全局暂停(暂停全部控制)或节点级暂停 → 一律拒绝下发。
-    // 手动 REST / 配方下发 / 产线开跑 / Agent 工具共用本入口,拒绝语义单点收敛。
-    if (!this.running) {
-      throw new AppError(409, ErrorCodes.CONFLICT, '控制网关已暂停(暂停全部控制):设定下发被拒绝,请先「恢复全部控制」')
-    }
-    if (!node.enabled) {
-      throw new AppError(409, ErrorCodes.CONFLICT, `当前节点暂停:「${node.name}」控制已暂停,仅开启控制的节点可被设定`)
-    }
-    // 调控闭环护栏(F1/F8):Agent 互斥(open 记录他人持有)+ 回退冷却方向性
-    getRecipeRollBackManager().beforeWrite(node, eng, meta)
-    // 写入限界分层联锁(param-limits):节点安全量程(结构层,驱动内 validateEng 结构性兜底)
-    // ∩ 工艺参数基准限界 ∩ 活动产品限界 ∩ 活动配方工艺窗口 —— 逐层收窄取交集,
-    // 手动 REST / Agent 工具 / 配方下发 / 回退四路共用本咽喉点,越界一律拒绝。
-    // D8 基准消融:仅 AW_BENCH_MODE=1 且 meta.benchArm='no-interlock'/'ungated' 时
-    // 旁路软联锁层(参数/产品/配方);结构层与硬量程校验结构性不可旁路;
-    // 生产模式(env 缺省)恒为 full 臂。
-    const benchNoInterlock = process.env.AW_BENCH_MODE === '1' && (meta?.benchArm === 'no-interlock' || meta?.benchArm === 'ungated')
-    // 配方下发路径(recipeRunId != null)跳过配方窗口层:下发值已在配方保存时对自身窗口校验,
-    // 且中途应用新配方不应被旧批次配方窗口误伤;产品/参数基准层对配方下发照常约束。
-    assertWithinLimits(node, eng, { includeSoft: !benchNoInterlock, skipRecipe: recipeRunId != null })
-    // D8: no-readback / ungated 臂 → 容差置 MAX,回读差异不致败(假成功语义,供 I2 消融)
-    const benchNoReadback = process.env.AW_BENCH_MODE === '1' && (meta?.benchArm === 'no-readback' || meta?.benchArm === 'ungated')
-    const benchToleranceOverride = benchNoReadback ? Number.MAX_VALUE : undefined
-    const prevValue = typeof node.value === 'number' ? node.value : null
-    const outcome = await rt.write(eng, recipeRunId, benchToleranceOverride)
-    // 调控闭环入册:仅成功写记锚/开记录(失败写不动账本 —— PLC 值未变更);
-    // 窗口聚合异步回填(F2)
-    if (outcome.ok !== false) {
-      try {
-        const rbInfo = getRecipeRollBackManager().afterWrite(
-          node,
-          eng,
-          prevValue,
-          meta ?? { source: recipeRunId ? 'recipe' : 'manual', actor: 'user' },
-          recipeRunId,
-        )
-        if (rbInfo) {
-          outcome.recordId = rbInfo.recordId
-          outcome.anchorId = rbInfo.anchorId
-        }
-      }
-      catch (err) {
-        console.error('[dcw] 调控闭环入册失败(不影响写结果):', err)
-      }
-      // 运维日志:所有下发路径(manual/recipe/agent/rollback)单点入册 + 实时事件
-      try {
-        const src = meta?.source ?? (recipeRunId ? 'recipe' : 'manual')
-        const memo = opsWriteMemo.get(id)
-        const now = Date.now()
-        if (!memo || memo.eng !== eng || now - memo.at > 10_000) {
-          opsWriteMemo.set(id, { eng, at: now })
-          if (opsWriteMemo.size > 500)
-            opsWriteMemo.clear()
-          const runNow = getActiveLineRun(node.lineId)
-          recordOps({
-            actor: meta?.actor ?? 'user',
-            actorName: meta?.actorName ?? meta?.actor ?? 'user',
-            actorKind: opsActorKindOf(src),
-            action: `dcw.write.${src}`,
-            kind: 'write',
-            targetKind: 'dcw-node',
-            targetId: id,
-            summary: `下发设定「${node.name}」→ ${eng}${node.unit ?? ''}(${src === 'manual' ? '手动' : src === 'agent' ? 'Agent' : src === 'rollback' ? '回退恢复' : '配方'})`,
-            lineId: node.lineId ?? '',
-            productId: runNow?.productId ?? '',
-            recipeId: runNow?.recipeId ?? recipeRunId ?? '',
-            detail: { eng, prevValue, ok: outcome.ok, message: outcome.message, taskId: meta?.taskId ?? null },
-          })
-          // 插件钩子:写控 ACK 观察(与运维入册同点同去重节流)
-          emitDcwWrite({ nodeId: id, name: node.name, eng, prevValue, ok: outcome.ok, source: src, lineId: node.lineId ?? '', at: new Date().toISOString() })
-        }
-      }
-      catch {
-        // 日志失败不影响写结果
-      }
-    }
-    return outcome
-  }
-
-  /** 连接测试 */
-  async testDriver(kind: DcwDriverKind, driverConfig: Record<string, unknown>) {
-    return resolveDcwDriver(normalizeDcwDriverKind(kind)).test(driverConfig)
-  }
-
-  async testNode(id: string) {
-    const node = this.repo.byId(id)
-    if (!node) throw new AppError(404, ErrorCodes.NOT_FOUND, `控制节点不存在: ${id}`)
-    return this.testDriver(node.driver, node.driverConfig)
-  }
-
-  // ---------- 工艺参数映射面(用户/Agent 的唯一语义读写面)----------
-
-  /**
-   * 创建工艺参数映射。两条路径:
-   *  - nodeId 绑定路径:映射指向既有执行节点;
-   *  - access 接入路径:设备连接 + 寄存器 + **标准转换模式**一键建映射 —— 系统
-   *    按转换模式展开驱动配置并自动创建执行节点(float32 直写 / int16·int32 线性
-   *    标定),配置期一次性选定,运行期双向换算全自动。
-   */
-  createParamMapping(input: DcwParamInput): DcwParamView {
-    const access = input.access
-    if (!access) {
-      const row = getDcwParamRepo().create(input)
-      return this.paramById(row.id)
-    }
-    if (input.nodeId) {
-      throw new AppError(400, ErrorCodes.VALIDATION_ERROR, 'access 与 nodeId 互斥:access 路径由系统自动创建执行节点')
-    }
-    if (!input.templateRef) {
-      throw new AppError(400, ErrorCodes.VALIDATION_ERROR, 'templateRef 必填:工艺参数需绑定语义模板(单位/量程/语义)')
-    }
-    const lineId = String(input.lineId ?? '')
-    if (lineId && !getDcwLineRepo().byId(lineId)) throw new AppError(404, ErrorCodes.NOT_FOUND, `产线不存在: ${lineId}`)
-    const derived = deriveAccess(access)
-    // 执行节点:驱动配置由转换模式展开(单一事实源);标定工程量程即节点安全量程
-    const node = this.create({
-      templateRef: input.templateRef,
-      name: input.name,
-      driver: derived.driver,
-      driverConfig: derived.driverConfig,
-      min: derived.engMin,
-      max: derived.engMax,
-      lineId,
-    })
-    // this.create() 已自动生成参数面;覆盖语义面(key/名称/基准限界)并留存转换模式
-    const auto = getDcwParamRepo().byNode(node.id)
-    const row = getDcwParamRepo().update(auto!.id, {
-      key: input.key,
-      name: input.name,
-      min: input.min ?? null,
-      max: input.max ?? null,
-      conversion: access.conversion,
-    })
-    return this.paramById(row.id)
-  }
-
-  listParamViews(): DcwParamView[] {
-    return getDcwParamRepo().listViews()
-  }
-
-  paramById(id: string): DcwParamView {
-    const row = getDcwParamRepo().byId(id)
-    if (!row) throw new AppError(404, ErrorCodes.NOT_FOUND, `工艺参数不存在: ${id}`)
-    const view = getDcwParamRepo().viewOf(row)
-    if (!view) throw new AppError(404, ErrorCodes.NOT_FOUND, `工艺参数 ${id} 的执行节点已不存在(映射悬空)`)
-    return view
-  }
-
-  /** 参数寻址写命令:工程量直写,限界联锁在 write() 咽喉点统一生效 */
-  async writeParam(id: string, value: number, meta?: DcwWriteMeta, recipeRunId: string | null = null) {
-    const row = getDcwParamRepo().byId(id)
-    const node = row ? this.repo.byId(row.nodeId) : undefined
-    if (!row || !node) throw new AppError(404, ErrorCodes.NOT_FOUND, `工艺参数不存在(或执行节点已删除): ${id}`)
-    const outcome = await this.write(node.id, value, recipeRunId, meta)
-    return { ...outcome, param: getDcwParamRepo().viewOf(row) }
-  }
-
-  /** 参数寻址读命令(读执行节点 PLC 值,标定解码为物理量) */
-  async readParam(id: string) {
-    const row = getDcwParamRepo().byId(id)
-    const node = row ? this.repo.byId(row.nodeId) : undefined
-    if (!row || !node) throw new AppError(404, ErrorCodes.NOT_FOUND, `工艺参数不存在(或执行节点已删除): ${id}`)
-    const read = await this.readNow(node.id)
-    return { ...read, param: getDcwParamRepo().viewOf(row) }
-  }
-
-  /** 参数当前有效写入限界剖面(分层 + 交集;展示/工具回包共用) */
-  paramLimitsOf(id: string) {
-    const row = getDcwParamRepo().byId(id)
-    const node = row ? this.repo.byId(row.nodeId) : undefined
-    if (!row || !node) throw new AppError(404, ErrorCodes.NOT_FOUND, `工艺参数不存在(或执行节点已删除): ${id}`)
-    return limitsBreakdownOf(node)
-  }
-
-  // ---------- Recipe 配方 ----------
-
-  listRecipes() {
-    return getDcwRecipeRepo().list()
-  }
-
-  createRecipe(input: RecipeInput) {
-    return getDcwRecipeRepo().create(input)
-  }
-
-  updateRecipe(id: string, patch: Partial<RecipeInput>, meta?: { by: 'user' | 'agent' | 'system', actorName: string, actor: string, description: string }) {
-    const recipe = getDcwRecipeRepo().update(id, patch, meta)
-    // 配方参数版本变更 → 运维日志(版本号 + 归因;与版本历史同点入册)
-    if (patch.params !== undefined) {
-      try {
-        recordOps({
-          actor: meta?.actor ?? 'user',
-          actorName: meta?.actorName ?? meta?.actor ?? 'user',
-          actorKind: meta?.by ?? 'user',
-          action: meta?.by === 'agent' ? 'recipe.update.agent' : 'recipe.update',
-          kind: 'recipe',
-          targetKind: 'recipe',
-          targetId: id,
-          summary: `更新配方「${recipe.name}」→ v${recipe.version ?? 1}${meta?.description ? `:${meta.description.slice(0, 80)}` : ''}`,
-          lineId: recipe.lineId ?? '',
-          productId: recipe.productId ?? '',
-          recipeId: id,
-          detail: { version: recipe.version ?? 1, description: meta?.description ?? '' },
-        })
-      }
-      catch { /* 日志失败不影响更新 */ }
-    }
-    return recipe
-  }
-
-  /** 回退配方参数到历史版本/lastGood(生成新版本;非破坏) */
-  revertRecipe(id: string, target: { version?: number, toLastGood?: boolean }, meta: { by: 'user' | 'agent' | 'system', actorName: string, actor: string, description: string }) {
-    const recipe = getDcwRecipeRepo().revertToVersion(id, target, meta)
-    try {
-      recordOps({
-        actor: meta.actor,
-        actorName: meta.actorName,
-        actorKind: meta.by,
-        action: 'recipe.revert',
-        kind: 'recipe',
-        targetKind: 'recipe',
-        targetId: id,
-        summary: `回退配方「${recipe.name}」→ v${recipe.version ?? 1}${meta.description ? `:${meta.description.slice(0, 80)}` : ''}`,
-        lineId: recipe.lineId ?? '',
-        productId: recipe.productId ?? '',
-        recipeId: id,
-        detail: { version: recipe.version ?? 1, description: meta.description },
-      })
-    }
-    catch { /* 日志失败不影响回退 */ }
-    return recipe
-  }
-
-  recipeVersions(id: string) {
-    return getDcwRecipeRepo().versions(id)
-  }
-
-  removeRecipe(id: string): void {
-    if (!getDcwRecipeRepo().remove(id)) throw new AppError(404, ErrorCodes.NOT_FOUND, `Recipe 不存在: ${id}`)
-  }
-
-  listRuns() {
-    return getDcwRecipeRepo().listRuns()
-  }
-
-  listHistory(limit = 100): DcwWriteHistoryEntry[] {
-    return getDcwRecipeRepo().historyList(limit)
-  }
-
-  /**
-   * 逐参数写核心(apply 与产线开跑共用):**节点级寻址** —— 每个参数显式指向
-   * 控制节点(节点才是真实控制 PLC 工艺参数的执行体)→ 逐参数写命令
-   * (runId 入写历史)→ 结果快照。节点不存在 → 该参数记失败不阻塞其余。
-   */
-  private async writeRecipeParams(recipe: RecipeView, run: RecipeRunView): Promise<void> {
-    const results: RecipeRunView['results'] = []
-    for (const param of recipe.params) {
-      const node = param.nodeId ? this.repo.byId(param.nodeId) : undefined
-      if (!node) {
-        results.push({ templateRef: param.templateRef ?? param.nodeId, nodeId: null, ok: false, message: `已跳过:节点 ${param.nodeId} 已删除,参数未下发`, value: param.value })
-        continue
-      }
-      // 停用/解绑守卫:节点已停用或已不在配方所属产线(被解绑/改挂)→ 不下发,
-      // 明确记因(run.results 可见),其余参数照常
-      if (!node.enabled) {
-        results.push({ templateRef: node.templateRef, nodeId: node.id, ok: false, message: `已跳过:节点「${node.name}」已停用,参数未下发`, value: param.value })
-        continue
-      }
-      if (node.lineId !== recipe.lineId) {
-        results.push({ templateRef: node.templateRef, nodeId: node.id, ok: false, message: `已跳过:节点「${node.name}」已取消绑定(${node.lineId ? '已改挂其他产线' : '已从产线移除'}),参数未下发`, value: param.value })
-        continue
-      }
-      try {
-        const outcome = await this.write(node.id, param.value, run.id, { source: 'recipe', actor: 'recipe' })
-        results.push({ templateRef: node.templateRef, nodeId: node.id, ok: outcome.ok, message: outcome.message, value: param.value })
-      }
-      catch (err) {
-        results.push({ templateRef: node.templateRef, nodeId: node.id, ok: false, message: err instanceof Error ? err.message : String(err), value: param.value })
-      }
-    }
-    run.results = results
-    getDcwRecipeRepo().updateRun(run)
-  }
-
-  /** Recipe 手动应用(一键下发工艺参数集;不激活产线窗口) */
-  async applyRecipe(recipeId: string) {
-    this.ensureLoop()
-    const repo = getDcwRecipeRepo()
-    const recipe = repo.byId(recipeId)
-    if (!recipe) throw new AppError(404, ErrorCodes.NOT_FOUND, `Recipe 不存在: ${recipeId}`)
-    if (recipe.params.length === 0) throw new AppError(400, ErrorCodes.VALIDATION_ERROR, 'Recipe 无工艺参数,无可下发内容')
-    const run = repo.createRun(recipe)
-    await this.writeRecipeParams(recipe, run)
-    return run
-  }
-
-  closeRun(id: string) {
-    return getDcwRecipeRepo().closeRun(id)
-  }
-
-  // ---------- 产线(实体 CRUD;节点/产品/配方挂载其下实现隔离) ----------
-
-  listLines(): LineView[] {
-    return getDcwLineRepo().all()
-  }
-
-  createLine(input: LineInput): LineView {
-    return getDcwLineRepo().create(input)
-  }
-
-  updateLine(id: string, patch: Partial<LineInput>): LineView {
-    return getDcwLineRepo().update(id, patch)
-  }
-
-  /** 删除产线:自动停止运行窗口。purge=true 连同旗下节点(含 Agent 绑定级联)/产品/配方一并删除;
-   *  否则仅解除挂载(lineId='' 未分配),节点与历史数据保留 */
-  async removeLine(id: string, opts?: { purge?: boolean }): Promise<void> {
-    const line = getDcwLineRepo().byId(id)
-    if (!line) throw new AppError(404, ErrorCodes.NOT_FOUND, `产线不存在: ${id}`)
-    if (getActiveLineRun(id)) this.lineStop(id)
-    // 快照迭代:purge 分支的 this.remove 会边遍历边删节点
-    for (const n of [...this.repo.all()]) {
-      if (n.lineId !== id) continue
-      if (opts?.purge) this.remove(n.id)
-      else {
-        n.lineId = ''
-        this.emitNodeChanged('updated', n)
-      }
-    }
-    if (opts?.purge) {
-      this.repo.flushNow()
-      const productRepo = getDcwProductRepo()
-      for (const p of productRepo.all()) {
-        if (p.lineId === id) productRepo.remove(p.id)
-      }
-      const recipeRepo = getDcwRecipeRepo()
-      for (const r of recipeRepo.list()) {
-        if (r.lineId === id) recipeRepo.remove(r.id)
-      }
-    }
-    else {
-      const productRepo = getDcwProductRepo()
-      for (const p of productRepo.all()) {
-        if (p.lineId === id) productRepo.update(p.id, { lineId: '' })
-      }
-      const recipeRepo = getDcwRecipeRepo()
-      for (const r of recipeRepo.list()) {
-        if (r.lineId === id) recipeRepo.detachLine(r.id)
-      }
-    }
-    getDcwLineRepo().remove(id)
-    this.broadcast?.('dcw.controller', this.controllerState())
-  }
-
-  // ---------- 产线运营(逐产线开跑;开跑必设配方;窗口内数采逐样本打标) ----------
-
-  /**
-   * 产线开跑:选定产品+配方 → 下发配方参数 → 创建批次并激活**该产线**窗口。
-   * 门控:配方必归属本产线的产品且含工艺参数 —— 未设定配方不可开跑数据采集。
-   */
-  async lineStart(lineId: string, recipeId: string) {
-    this.ensureLoop()
-    if (!this.running) {
-      throw new AppError(409, ErrorCodes.CONFLICT, '控制网关已暂停(暂停全部控制):开跑需下发配方参数,请先「恢复全部控制」')
-    }
-    const line = getDcwLineRepo().byId(lineId)
-    if (!line) throw new AppError(404, ErrorCodes.NOT_FOUND, `产线不存在: ${lineId}`)
-    if (getActiveLineRun(lineId)) {
-      throw new AppError(409, ErrorCodes.CONFLICT, `产线「${line.name}」已在运行(批次 ${getActiveLineRun(lineId)!.runId}),请先停止当前数据采集`)
-    }
-    const repo = getDcwRecipeRepo()
-    const recipe = repo.byId(recipeId)
-    if (!recipe) throw new AppError(404, ErrorCodes.NOT_FOUND, `Recipe 不存在: ${recipeId}`)
-    if (recipe.lineId !== lineId) {
-      throw new AppError(400, ErrorCodes.VALIDATION_ERROR, `配方「${recipe.name}」不属于产线「${line.name}」,请先将其产品挂载到本产线`)
-    }
-    if (recipe.params.length === 0) {
-      throw new AppError(400, ErrorCodes.VALIDATION_ERROR, '开跑前必须先设定配方:当前 Recipe 无工艺参数')
-    }
-    const product = getDcwProductRepo().byId(recipe.productId)
-    if (!product) {
-      throw new AppError(400, ErrorCodes.VALIDATION_ERROR, '开跑前必须先设定配方:Recipe 未归属有效产品,请先补全产品信息')
-    }
-    const run = repo.createRun(recipe)
-    setActiveLineRun({
-      lineId,
-      runId: run.id,
-      recipeId: recipe.id,
-      recipeName: recipe.name,
-      productId: product.id,
-      productName: product.name,
-      startedAt: run.startedAt,
-      taggedSamples: 0,
-    })
-    await this.writeRecipeParams(recipe, run)
-    this.broadcast?.('dcw.controller', this.controllerState())
-    return run
-  }
-
-  /** 产线停止:关闭该产线批次窗口(此后样本不再打标;数据保留可查)+ 该产线数采停摆 */
-  lineStop(lineId: string) {
-    const line = getDcwLineRepo().byId(lineId)
-    if (!line) throw new AppError(404, ErrorCodes.NOT_FOUND, `产线不存在: ${lineId}`)
-    const prev = clearActiveLineRun(lineId)
-    if (!prev) throw new AppError(400, ErrorCodes.VALIDATION_ERROR, `产线「${line.name}」未在运行`)
-    const run = getDcwRecipeRepo().closeRun(prev.runId)
-    // 调控闭环封窗:该线 open 优化记录随批次窗口关闭(防跨批次污染)
-    getRecipeRollBackManager().closeForLine(lineId)
-    this.broadcast?.('dcw.controller', this.controllerState())
-    // 数采门控联动:该产线无活动配方即停止其节点采集,置 offline 并广播收敛
-    void import('../daq/daq-controller').then(({ getDaqController }) => {
-      getDaqController().markLineOffline(lineId)
-    }).catch(() => {})
-    return run
-  }
-
-  /** 单条产线运行状态(活动窗口 + 打标计数) */
-  lineState(lineId: string): LineRunState {
-    const base: LineRunState = { lineId, active: false, runId: null, recipeId: null, recipeName: null, productId: null, productName: null, startedAt: null, taggedSamples: 0 }
-    const r = getActiveLineRun(lineId)
-    if (!r) return base
-    return {
-      ...base,
-      active: true,
-      runId: r.runId,
-      recipeId: r.recipeId,
-      recipeName: r.recipeName,
-      productId: r.productId,
-      productName: r.productName,
-      startedAt: r.startedAt,
-      taggedSamples: r.taggedSamples,
-    }
-  }
-
-  /** 全部产线运行状态(产线总览/状态条聚合) */
-  allLineStates(): LineRunState[] {
-    const lines = getDcwLineRepo().all()
-    const seen = new Set(lines.map(l => l.id))
-    const states = lines.map(l => this.lineState(l.id))
-    // 已删除产线的残留窗口兜底展示(避免批次计数幽灵丢失)
-    for (const r of getAllActiveLineRuns()) {
-      if (!seen.has(r.lineId)) states.push(this.lineState(r.lineId))
-    }
-    return states
-  }
-
-  /** 是否存在任意活动产线窗口(数采全局快速门) */
-  hasAnyActiveLineRun(): boolean {
-    return getAllActiveLineRuns().length > 0
-  }
-
-  /**
-   * 产线数据查询(产品/配方/工艺参数/时间/间隔 五维):
-   * 打标样本跨通道聚合;paramKey 限定工艺参数(DAQ 模板),bucketMs 降采样。
-   */
-  async lineQuery(opts: LineQueryOpts): Promise<LineQueryResult> {
-    const { getTsdb, tsdbReady } = await import('../daq/storage')
-    await tsdbReady
-    const { getDaqNodeRepo } = await import('../daq/daq-node.repo')
-    const { findDaqTemplate } = await import('../daq/daq-templates')
-    // 时间间隔参数(bucketMs):缺省与下限来自 daq.query.*(live 配置,热重载)
-    const { defaultBucketMs, minBucketMs } = daqRuntimeSettings().query
-    const bucketMs = opts.bucketMs == null ? defaultBucketMs : Math.max(minBucketMs, Math.min(3_600_000, Math.round(opts.bucketMs)))
-    const nodeFilter = opts.nodeId ? opts.nodeId.split(',').map(x => x.trim()).filter(Boolean) : []
-    const nodes = getDaqNodeRepo().all().filter((n) => {
-      if (opts.paramKey && n.templateKey !== opts.paramKey) return false
-      if (opts.lineId && (n.lineId ?? '') !== opts.lineId) return false
-      // 节点维过滤(多节点绑定同模板时精确定位;支持多节点逗号分隔)
-      if (nodeFilter.length > 0 && !nodeFilter.includes(n.id)) return false
-      return true
-    })
-    const series = await getTsdb().queryTagged({
-      productId: opts.productId,
-      recipeId: opts.recipeId,
-      lineId: opts.lineId,
-      nodeIds: nodes.map(n => n.id),
-      fromMs: opts.fromMs,
-      toMs: opts.toMs,
-      bucketMs,
-      limit: opts.limit,
-    })
-    const channels: LineQueryResult['channels'] = []
-    for (const n of nodes) {
-      const points = series.get(n.id)
-      if (!points || points.length === 0) continue
-      const tpl = findDaqTemplate(n.templateKey)
-      channels.push({
-        nodeId: n.id,
-        nodeName: n.name,
-        templateRef: n.templateRef,
-        ch: tpl?.ch ?? n.templateKey,
-        unit: n.unit,
-        points,
-      })
-    }
-    return { productId: opts.productId ?? null, recipeId: opts.recipeId ?? null, channels }
-  }
-
-  // ---------- 产品 ----------
-
-  listProducts(): ProductView[] {
-    return getDcwProductRepo().all()
-  }
-
-  createProduct(input: ProductInput): ProductView {
-    const lineId = String(input.lineId ?? '')
-    if (lineId && !getDcwLineRepo().byId(lineId)) throw new AppError(404, ErrorCodes.NOT_FOUND, `产线不存在: ${lineId}`)
-    assertProductParamLimits(lineId, input.paramLimits)
-    return getDcwProductRepo().create({ ...input, lineId })
-  }
-
-  updateProduct(id: string, patch: Partial<ProductInput>): ProductView {
-    if (patch.lineId) {
-      const lid = String(patch.lineId)
-      if (!getDcwLineRepo().byId(lid)) throw new AppError(404, ErrorCodes.NOT_FOUND, `产线不存在: ${lid}`)
-    }
-    const prev = getDcwProductRepo().byId(id)
-    const targetLine = String(patch.lineId ?? prev?.lineId ?? '')
-    assertProductParamLimits(targetLine, patch.paramLimits)
-    const updated = getDcwProductRepo().update(id, patch)
-    // 产品换线 → 旗下配方产线归属级联(开跑校验按 recipe.lineId)
-    if (prev && prev.lineId !== updated.lineId) {
-      const recipeRepo = getDcwRecipeRepo()
-      for (const r of recipeRepo.list()) {
-        if (r.productId === id) recipeRepo.setRecipeLine(r.id, updated.lineId)
-      }
-    }
-    return updated
-  }
-
-  removeProduct(id: string): void {
-    const product = getDcwProductRepo().byId(id)
-    if (!product) throw new AppError(404, ErrorCodes.NOT_FOUND, `产品不存在: ${id}`)
-    if (product.lineId && getActiveLineRun(product.lineId)?.productId === id) {
-      throw new AppError(409, ErrorCodes.CONFLICT, '产品正在产线运行中,不可删除(请先停止数据采集)')
-    }
-    getDcwProductRepo().remove(id)
-  }
-
-  /**
-   * 批次数据视图(产品隔离):批次窗口内的写历史 + 全部数采节点的窗口内汇总
-   * (latest/avg/min/max/cnt,窗口 > 60s 时按窗口/100 自动降采样)。
-   */
-  async runData(id: string) {
-    const repo = getDcwRecipeRepo()
-    const run = repo.runById(id)
-    if (!run) throw new AppError(404, ErrorCodes.NOT_FOUND, `批次不存在: ${id}`)
-    const endMs = run.endedAt ? Date.parse(run.endedAt) : Date.now()
-    const startMs = Date.parse(run.startedAt)
-    const writes = repo.historyInWindow(run.startedAt, run.endedAt, id)
-    const { getDaqNodeRepo } = await import('../daq/daq-node.repo')
-    const { getTsdb, tsdbReady } = await import('../daq/storage')
-    const { findDaqTemplate } = await import('../daq/daq-templates')
-    await tsdbReady
-    const bucketMs = endMs - startMs > 60_000 ? Math.max(1000, Math.round((endMs - startMs) / 200)) : undefined
-    const daq = [] as Array<{ templateRef: string, nodeId: string, nodeName: string, ch: string, unit: string, latest: number | null, avg: number | null, min: number | null, max: number | null, cnt: number }>
-    // 并行查询(tsdb 往返一次/节点,互不依赖):N+1 串行会让 50 节点产线的批次视图放大 50 倍时延。
-    // 只查本批次产线的节点:批次归属单线,跨线节点的 tsdb 往返是纯浪费(节点数增长线性放大)
-    const lineNodes = getDaqNodeRepo().all().filter(n => !run.lineId || n.lineId === run.lineId)
-    const results = await Promise.all(lineNodes.map(async (node) => {
-      try {
-        const points = await getTsdb().query(node.id, { fromMs: startMs, toMs: endMs, bucketMs, limit: 500 })
-        return { node, points }
-      }
-      catch { return { node, points: [] } } // 单节点查询失败不阻塞整体
-    }))
-    for (const { node, points } of results) {
-      {
-        if (points.length === 0) continue
-        const values = points.map(p => p.value ?? p.avg ?? 0).filter(v => Number.isFinite(v))
-        if (values.length === 0) continue
-        const tpl = findDaqTemplate(node.templateKey)
-        daq.push({
-          templateRef: node.templateRef,
-          nodeId: node.id,
-          nodeName: node.name,
-          ch: tpl?.ch ?? node.templateKey,
-          unit: node.unit,
-          latest: values[values.length - 1]!,
-          avg: Number((values.reduce((a, b) => a + b, 0) / values.length).toFixed(node.decimals)),
-          min: Number(Math.min(...values).toFixed(node.decimals)),
-          max: Number(Math.max(...values).toFixed(node.decimals)),
-          cnt: values.length,
-        })
-      }
-    }
-    return { run, daq, writes }
-  }
-}
-
-// ---------- 单例(HMR 存活) ----------
-
-/**
- * 产品级工艺参数限界校验:键必须命中该产品所属产线上的工艺参数映射
- * (防静默失效的拼错键);区间须 min<=max 且为有限数字。产品未挂产线时限界无
- * 寻址语境,拒绝非空限界。
- */
-function assertProductParamLimits(lineId: string, paramLimits: ProductInput['paramLimits'] | undefined): void {
-  if (paramLimits == null) return
-  if (typeof paramLimits !== 'object' || Array.isArray(paramLimits)) {
-    throw new AppError(400, ErrorCodes.VALIDATION_ERROR, 'paramLimits 需为对象(键=工艺参数 key,值={min?,max?})')
-  }
-  const entries = Object.entries(paramLimits)
-  if (entries.length === 0) return
-  if (!lineId) {
-    throw new AppError(400, ErrorCodes.VALIDATION_ERROR, '产品未挂载产线,不可设定工艺参数限界(限界按产线内的工艺参数寻址)')
-  }
-  const lineKeys = new Set(
-    getDcwParamRepo().listViews().filter(p => p.lineId === lineId).map(p => p.key),
-  )
-  for (const [key, range] of entries) {
-    if (!lineKeys.has(key)) {
-      throw new AppError(400, ErrorCodes.VALIDATION_ERROR, `产品限界的工艺参数键「${key}」在产线上不存在(可用的工艺参数:${[...lineKeys].join(', ') || '无 —— 先创建写控节点生成参数面'})`)
-    }
-    const min = range?.min == null ? null : Number(range.min)
-    const max = range?.max == null ? null : Number(range.max)
-    if ((range?.min != null && !Number.isFinite(min)) || (range?.max != null && !Number.isFinite(max))) {
-      throw new AppError(400, ErrorCodes.VALIDATION_ERROR, `产品限界「${key}」的上下限需为数字`)
-    }
-    if (min != null && max != null && min > max) {
-      throw new AppError(400, ErrorCodes.VALIDATION_ERROR, `产品限界「${key}」非法:min ${min} > max ${max}`)
-    }
-  }
-}
-
-const g = globalThis as typeof globalThis & { __dcwController?: DcwController }
-
-export function getDcwController(): DcwController {
-  g.__dcwController ??= new DcwController()
-  return g.__dcwController
-}
-
-/** 广播装配(dcw 路由模块加载时调用一次;首访即上电) */
-export function bindDcwBroadcast(fn: BroadcastFn | null): void {
-  getDcwController().setBroadcast(fn)
-}