agentworkshop 0.7.39 → 0.7.40

package/server/services/workshop/daq/drivers.ts

@@ -200,8 +200,17 @@ function mockImageSample(
 // Modbus TCP 真实驱动(modbus-serial;连接池按 host:port:unitId 复用)
 // ============================================================
 
+/**
+ * modbus-serial 客户端实例类型。
+ *
+ * 该包 index.d.ts 只写 `import { ModbusRTU } from "./ModbusRTU"` + `export default ModbusRTU`,
+ * **没有**具名 re-export(运行时 module.exports = 构造器,并自挂 module.exports.default = 自己),
+ * 因此 `import('modbus-serial').ModbusRTU` 在类型上并不存在 —— 从 default 导出取才与实际导出形态一致。
+ */
+type ModbusRtuClient = InstanceType<typeof import('modbus-serial').default>
+
 export interface ModbusConn {
-  client: import('modbus-serial').ModbusRTU
+  client: ModbusRtuClient
   lastUsed: number
   /** 连接级操作队列尾(采/控共用链路串行化:TCP 网关并发事务会协议错乱) */
   tail: Promise<unknown>
@@ -232,7 +241,7 @@ export function evictModbusConn(cfg: Record<string, unknown>, transport: ModbusT
  * 安全关闭:半开 socket(对端断电)时 modbus-serial close() 等待 FIN 永不返回,
  * 一律 500ms 超时保护(fire-and-forget 底层 close,调用方不阻塞)。
  */
-export async function closeModbusSafely(client: import('modbus-serial').ModbusRTU): Promise<void> {
+export async function closeModbusSafely(client: ModbusRtuClient): Promise<void> {
   await Promise.race([
     Promise.resolve()
       .then(() => client.close())
@@ -252,7 +261,7 @@ export function withModbusConn<R>(conn: ModbusConn, fn: () => Promise<R>): Promi
   const run = conn.tail.then(() => fn(), () => fn())
   let timer: NodeJS.Timeout | undefined
   let dead = false
-  const guarded = Promise.race([
+  const guarded: Promise<R> = Promise.race([
     run,
     new Promise<never>((_, rej) => {
       timer = setTimeout(() => {
@@ -264,7 +273,7 @@ export function withModbusConn<R>(conn: ModbusConn, fn: () => Promise<R>): Promi
         rej(new Error('Modbus 响应超时(3s)——连接可能半开,已作废重连'))
       }, 3000)
     }),
-  ] as Promise<R>)
+  ])
   void guarded.catch(() => { /* 超时分支先 reject,防 unhandled */ })
   conn.tail = guarded.then(
     () => {
@@ -298,7 +307,7 @@ export async function getModbusConn(cfg: Record<string, unknown>, transport: Mod
   }
   // CJS 互操作:require 形状可能是 { ModbusRTU } / default.ModbusRTU / 构造器本身
   const mod = reqNative('modbus-serial') as unknown as { ModbusRTU?: unknown, default?: { ModbusRTU?: unknown } | unknown }
-  const ModbusRTU = (mod.ModbusRTU ?? (mod.default as { ModbusRTU?: unknown } | undefined)?.ModbusRTU ?? mod) as new () => import('modbus-serial').ModbusRTU
+  const ModbusRTU = (mod.ModbusRTU ?? (mod.default as { ModbusRTU?: unknown } | undefined)?.ModbusRTU ?? mod) as new () => ModbusRtuClient
   const client = new ModbusRTU()
   client.setTimeout(3000)
   // tcp = Modbus TCP(MBAP 封装);rtu-tcp = RTU over TCP(串口网关透传,CRC16 帧,无 MBAP)
@@ -490,6 +499,17 @@ export interface OpcUaConn {
 
 const opcuaPool = new Map<string, OpcUaConn>()
 
+/**
+ * 在飞建连去重表（同池 key → 尚未 settle 的建连任务）。
+ *
+ * 修复动因(实测事故):同端点**并发首连**此前无去重——两条采样/写控请求同时进入时
+ * 各建一条 OPCUAClient,而后一条的 `opcuaPool.set` 会**覆盖**前一条:
+ * 被覆盖的 session 与 TCP 连接从此无人持有,空闲 sweep 也扫不到 → **永久泄漏**;
+ * 重连 churn(断链演练/反复建节点)下还会触发 node-opcua 内部
+ * `_internal_create_secure_channel failed, this._secureChannel is supposed to be null`。
+ */
+const opcuaInflight = new Map<string, Promise<OpcUaConn>>()
+
 // OPC UA 会话空闲回收(对照 modbus 池 sweep;节点删除/端点弃用后不再有读取
 // 路径触发 3 错误驱逐,无 sweep 会话与 TCP 连接会永久驻留)
 const OPCUA_IDLE_MS = 600_000
@@ -533,6 +553,20 @@ export async function getOpcUaConn(cfg: Record<string, unknown>): Promise<OpcUaC
     existing.lastUsed = Date.now()
     return existing
   }
+  // 在飞去重:同 key 并发首连复用同一条建连任务(否则后写覆盖 pool → 前一条 session/socket 永久泄漏)
+  const pending = opcuaInflight.get(key)
+  if (pending) return pending
+  const task = createOpcUaConn(cfg, key)
+  opcuaInflight.set(key, task)
+  try {
+    return await task
+  }
+  finally {
+    opcuaInflight.delete(key)
+  }
+}
+
+async function createOpcUaConn(cfg: Record<string, unknown>, key: string): Promise<OpcUaConn> {
   const opcua = reqNative('node-opcua') as typeof import('node-opcua')
   const securityMode = (['None', 'Sign', 'SignAndEncrypt'] as const).includes(cfg.securityMode as 'None')
     ? (cfg.securityMode as 'None')
@@ -574,15 +608,33 @@ export async function getOpcUaConn(cfg: Record<string, unknown>): Promise<OpcUaC
   }
   const client = opcua.OPCUAClient.create(clientOpts as Parameters<typeof opcua.OPCUAClient.create>[0])
   await client.connect(String(cfg.endpoint))
+  // type 是 node-opcua 的 UserIdentityInfo 判别式(node-opcua-client createUserIdentityToken →
+  // coerceUserIdentityInfo:userName 存在时正是补成 UserTokenType.UserName 走同一分支),
+  // 显式写出既满足协议类型,也免去"字段漏写、等库回填"的隐式依赖;两个分支都返回 Promise<ClientSession>。
   const session = cfg.username
-    ? await client.createSession({ userName: String(cfg.username), password: String(cfg.password ?? '') })
+    ? await client.createSession({ type: opcua.UserTokenType.UserName, userName: String(cfg.username), password: String(cfg.password ?? '') })
     : await client.createSession()
   const conn: OpcUaConn = { session, client, lastUsed: Date.now(), errors: 0 }
+  // 竞态二次校验:建连期间若已有连接入池(并发首连的另一方完成),关闭本次新建并复用既有,
+  // 避免 opcuaPool.set 覆盖导致 session/socket 永久泄漏。
+  const raced = opcuaPool.get(key)
+  if (raced) {
+    try {
+      await session.close()
+    }
+    catch { /* 清理失败不覆盖原始错误 */ }
+    try {
+      await client.disconnect()
+    }
+    catch { /* 清理失败不覆盖原始错误 */ }
+    return raced
+  }
   opcuaPool.set(key, conn)
   return conn
 }
 
-/** 驱逐 OPC UA 连接(采样/写控共享池;连续故障后触发,下次调用重建) */
+/** 驱逐 OPC UA 连接(采样/写控共享池;连续故障后触发,下次调用重建)。
+ *  只作用于**已入池**的连接:在飞建连本身就是新建的,交由竞态二次校验处理。 */
 export async function evictOpcUaConn(cfg: Record<string, unknown>): Promise<void> {
   const key = opcuaKey(cfg)
   const conn = opcuaPool.get(key)
@@ -961,7 +1013,10 @@ export const httpDaqDriver: DaqDriver = {
           return { ok: true, message: `接口可达,vector 帧 ${(j.points as unknown[]).length} 点`, latencyMs: Date.now() - t0 }
         }
         if (typeof j.png === 'string' || typeof j.blob === 'string') {
-          return { ok: true, message: `接口可达,image 帧(base64, ${(j.png ?? j.blob as string).length} chars)`, latencyMs: Date.now() - t0 }
+          // 与生产分支同构:png/blob 至少一个是 base64 字符串(见上一行守卫)。
+          // b64 的取值表达式与原来逐字一致(断言运行时擦除),只是把 unknown 标注成 string 以取 .length
+          const b64 = (j.png as string | undefined) ?? (j.blob as string)
+          return { ok: true, message: `接口可达,image 帧(base64, ${b64.length} chars)`, latencyMs: Date.now() - t0 }
         }
         const v = extractNumeric(text, driverConfig.jsonPath ? String(driverConfig.jsonPath) : undefined)
         return { ok: true, message: `接口可达,取值 = ${v}`, sampleValue: v, latencyMs: Date.now() - t0 }

package/server/services/workshop/daq/host-ports.ts

@@ -20,10 +20,11 @@ export interface ActiveRunSnapshot {
 /** 遥测上报端口:绑定设备的值回写 + 孪生场景推送 + 绑定校验(中心实现 = device-twin.repo) */
 export interface DaqTelemetryPort {
   /**
-   * 遥测回写:telemetry 键值写入绑定设备的孪生,state 为同设备多节点汇聚的最严重态。
+   * 遥测回写:telemetry 键值写入绑定设备的孪生,state 为同设备多节点汇聚的最严重态
+   * (alarm > warn > ok,与 device-twin.repo.applyTelemetry 的 nodeState 同一个域)。
    * 目标设备不存在 → { ok:false }(调用方解绑自身,链路自愈);成功 → { ok:true, twinId }。
    */
-  applyTelemetry(deviceId: string, telemetry: Record<string, number | string | boolean>, state: string): { ok: boolean, twinId: string | null }
+  applyTelemetry(deviceId: string, telemetry: Record<string, number | string | boolean>, state: 'alarm' | 'warn' | 'ok'): { ok: boolean, twinId: string | null }
   /** 孪生场景载荷(WS device.updated 帧;设备已删 → null) */
   scenePayload(twinId: string): unknown | null
   /** 绑定目标存在性校验 */

package/server/services/workshop/daq/storage/timescale.adapter.ts

@@ -239,7 +239,9 @@ export class TimescaleAdapter implements TsdbPort {
       at: tsToMs(r.ts),
       kind: String(r.kind) as 'vector' | 'image',
       points: String(r.kind) === 'vector' ? pointsFromMeta(r.meta) : undefined,
-      metrics: asObject(r.metrics),
+      // 与 sqlite.adapter 同法:metrics 列由本管线写入(下沉处理器产出 avg/max/brightness/zone_* 数值),
+      // asObject 只做 JSON 还原(Record<string, unknown>),按端口契约收窄到 Record<string, number>(断言运行时擦除)
+      metrics: asObject(r.metrics) as Record<string, number>,
       meta: asObject(r.meta),
       deviceBindingId: r.device_binding_id ?? null,
       lineId: r.line_id ?? null,

package/server/services/workshop/db/channel.repo.ts

@@ -54,6 +54,10 @@ export function createChannelRepo(db: DatabaseSync) {
         name: input.name,
         description: input.description ?? '',
         scenarioPrompt: input.scenarioPrompt ?? '',
+        // INSERT 不含该列 → 落库取列默认(llm_json TEXT NOT NULL DEFAULT '',见 database.ts v11);
+        // 返回的内存行按同一事实补该列,使 create() 的返回值与随后 findById() 读到的行形状一致。
+        // 注意:insert.run(...) 的参数列表保持不变(多传一个参数会与 SQL 占位符数量不符)。
+        llmJson: '',
         leadAgentId: null,
         workspace: input.workspace ?? '',
         enabled: 1,

package/server/services/workshop/db/ops.repo.ts

@@ -104,9 +104,12 @@ export function createAlarmEventRepo(db: DatabaseSync) {
 
   return {
     /** 按 id 取报警关联节点(产线权限判定用);不存在返回 undefined */
-    nodeIdById(id) {
+    nodeIdById(id: string): string | undefined {
       const r = db.prepare('SELECT node_id FROM alarm_events WHERE id = ?').get(id)
-      return r?.node_id
+      // node_id 列是 TEXT NOT NULL,写入侧恒为 string(见 database.ts 的 alarm_events 定义);
+      // 显式收窄后,调用方拿到的是 string|undefined,而不是 node:sqlite 的 SQLOutputValue 联合
+      const v = r?.node_id
+      return typeof v === 'string' ? v : undefined
     },
 
     /** 报警产生(同 node+metric 未确认报警幂等去重,防止高频越限刷表) */

package/server/services/workshop/db/retention.ts

@@ -9,11 +9,16 @@
  * 覆盖链:config.yml < runtime-settings < env(AW_<键> 或历史别名)。时间列均为 TEXT ISO。
  * channel_events 与 daq_samples 已有各自保留机制,此处不重复覆盖。
  */
+import type { DatabaseSync } from 'node:sqlite'
 import { retentionSettings } from '../settings'
 
-type DatabaseSyncLike = {
-  prepare: (sql: string) => { run: (...args: unknown[]) => { changes: number | bigint } }
-}
+/**
+ * 库句柄契约 = node:sqlite DatabaseSync 的只读子集。
+ * 早先手写的鸭子类型把 run 声明为 `(...args: unknown[])`,与 StatementSync 的
+ * `...anonymousParameters: SQLInputValue[]` 反向不兼容(unknown 形参不接受 SQLInputValue),
+ * 于是**真实的 DatabaseSync 反而传不进来**。直接从权威类型取子集即消除该漂移(纯类型,运行时零变化)。
+ */
+type DatabaseSyncLike = Pick<DatabaseSync, 'prepare'>
 
 const DAY_MS = 86_400_000
 const BATCH = 5000

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

@@ -11,7 +11,7 @@
 
 import { randomUUID } from 'node:crypto'
 import { applyTransform, inverseTransform, normalizeDataTransform, dcwKeyFromRef } from '../../../../shared/dcw-protocol'
-import type { AepDcwNodeChange, DcwDriverKind, DcwNodeView, DataTransform, LineInput, LineQueryOpts, LineQueryResult, LineRunState, LineView, ProductInput, ProductView, RecipeInput, RecipeRunView, RecipeView, DcwWriteMeta } from '../../../../shared/dcw-protocol'
+import type { AepDcwNodeChange, DcwDriverKind, DcwNodeView, 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 { findDcwTemplate } from './dcw-templates'
@@ -22,6 +22,9 @@ 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'
@@ -353,6 +356,9 @@ class DcwController {
       semantics: input.semantics,
     })
     this.repo.insert(node)
+    // 工艺参数映射面:节点创建即自动生成同名映射(用户/Agent 的参数语义面;
+    // PLC 寻址细节仍封装在节点驱动配置内)。失败不阻断节点创建(可事后手工补建)。
+    getDcwParamRepo().ensureForNode(node)
     this.syncRuntimes()
     this.emitNodeChanged('added', node)
     return node
@@ -431,6 +437,8 @@ class DcwController {
     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()
@@ -537,22 +545,21 @@ class DcwController {
     }
     // 调控闭环护栏(F1/F8):Agent 互斥(open 记录他人持有)+ 回退冷却方向性
     getRecipeRollBackManager().beforeWrite(node, eng, meta)
-    // 写联锁按产线:仅当**本节点所属产线**在跑时,叠加该批次配方的工艺窗口
-    const run = getActiveLineRun(node.lineId)
-    if (run && recipeRunId == null) {
-      const recipe = getDcwRecipeRepo().byId(run.recipeId)
-      const param = recipe?.params.find(p => p.nodeId === id)
-      if (param) {
-        if (param.min != null && eng < param.min) {
-          throw new AppError(400, ErrorCodes.VALIDATION_ERROR, `设定值 ${eng}${node.unit} 低于当前配方「${run.recipeName}」的工艺下限 ${param.min}${node.unit}(节点全局量程 ${node.min}~${node.max} 不适用于本批次)`)
-        }
-        if (param.max != null && eng > param.max) {
-          throw new AppError(400, ErrorCodes.VALIDATION_ERROR, `设定值 ${eng}${node.unit} 超出当前配方「${run.recipeName}」的工艺上限 ${param.max}${node.unit}(节点全局量程 ${node.min}~${node.max} 不适用于本批次)`)
-        }
-      }
-    }
+    // 写入限界分层联锁(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)
+    const outcome = await rt.write(eng, recipeRunId, benchToleranceOverride)
     // 调控闭环入册:仅成功写记锚/开记录(失败写不动账本 —— PLC 值未变更);
     // 窗口聚合异步回填(F2)
     if (outcome.ok !== false) {
@@ -618,6 +625,90 @@ class DcwController {
     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() {
@@ -950,6 +1041,7 @@ class DcwController {
   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 })
   }
 
@@ -959,6 +1051,8 @@ class DcwController {
       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) {
@@ -1032,6 +1126,39 @@ class DcwController {
 
 // ---------- 单例(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 {

package/server/services/workshop/dcw/dcw-product.repo.ts

@@ -19,13 +19,43 @@ const DB_PATH = join(ensureDataDir(), 'dcw-products.json')
 function load(): ProductView[] {
   try {
     const parsed = loadJsonFile(DB_PATH, null)
-    return Array.isArray(parsed) ? parsed as ProductView[] : []
+    return Array.isArray(parsed) ? parsed.map(normRow) as ProductView[] : []
   }
   catch {
     return []
   }
 }
 
+/** 行规范化:paramLimits 键值容错(非有限数字的侧丢弃;min>max 整条丢弃) */
+function normRow(p: ProductView): ProductView {
+  const raw = p.paramLimits
+  if (raw == null || typeof raw !== 'object' || Array.isArray(raw)) return p
+  const out: ProductView['paramLimits'] = {}
+  for (const [key, range] of Object.entries(raw)) {
+    if (!key || range == null || typeof range !== 'object') continue
+    const min = range.min == null ? undefined : Number(range.min)
+    const max = range.max == null ? undefined : Number(range.max)
+    const okMin = min == null || Number.isFinite(min)
+    const okMax = max == null || Number.isFinite(max)
+    if (!okMin || !okMax) continue
+    if (min != null && max != null && min > max) continue
+    const entry: { min?: number, max?: number } = {}
+    if (min != null) entry.min = min
+    if (max != null) entry.max = max
+    if (Object.keys(entry).length > 0) out[key] = entry
+  }
+  return { ...p, paramLimits: out }
+}
+
+/** 载荷规范化(创建/更新共用;键级有效性由控制器按产线工艺参数校验) */
+function normLimitsInput(v: unknown): Record<string, { min?: number, max?: number }> | undefined {
+  if (v == null) return undefined
+  if (typeof v !== 'object' || Array.isArray(v)) {
+    throw new AppError(400, ErrorCodes.VALIDATION_ERROR, 'paramLimits 需为对象(键=工艺参数 key)')
+  }
+  return normRow({ paramLimits: v as ProductView['paramLimits'] } as ProductView).paramLimits
+}
+
 class DcwProductRepo {
   private list: ProductView[] = load()
 
@@ -47,6 +77,8 @@ class DcwProductRepo {
       description: String(input.description ?? '').trim(),
       createdAt: new Date().toISOString(),
     }
+    const limits = normLimitsInput(input.paramLimits)
+    if (limits) p.paramLimits = limits
     this.list.push(p)
     this.flush()
     return p
@@ -62,6 +94,11 @@ class DcwProductRepo {
     }
     if (patch.description !== undefined) p.description = String(patch.description).trim()
     if (patch.lineId !== undefined) p.lineId = String(patch.lineId)
+    if (patch.paramLimits !== undefined) {
+      const limits = normLimitsInput(patch.paramLimits)
+      if (limits && Object.keys(limits).length > 0) p.paramLimits = limits
+      else delete p.paramLimits
+    }
     this.flush()
     return p
   }

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

@@ -64,7 +64,7 @@ export class DcwNodeRuntime {
    * 用户/Recipe 设定值(核心写命令入口)。
    * 工艺安全量程硬校验(越界拒绝)+ 在飞互斥(同一通道同时只允许一个写事务)。
    */
-  async write(eng: number, recipeRunId: string | null = null): Promise<DcwWriteOutcome> {
+  async write(eng: number, recipeRunId: string | null = null, toleranceOverride?: number): Promise<DcwWriteOutcome> {
     const node = this.node
     const invalid = node.validateEng(eng)
     if (invalid) throw new AppError(400, ErrorCodes.VALIDATION_ERROR, invalid)
@@ -75,7 +75,8 @@ export class DcwNodeRuntime {
     node.state = 'writing'
     node.lastWriteAt = new Date().toISOString()
     try {
-      return await this.host.executeWrite(node, eng, writeTolerance(node), recipeRunId)
+      // D8 基准消融:no-readback/ungated 臂由 write() 传入 MAX 容差 → 回读差异不再致败(假成功语义)
+      return await this.host.executeWrite(node, eng, toleranceOverride ?? writeTolerance(node), recipeRunId)
     }
     catch (err) {
       // 执行链抛错(异常不流向 outcome):状态机必须离开 writing,否则通道永久 409

package/server/services/workshop/dcw/drivers.ts

@@ -524,7 +524,10 @@ export const mqttDcwDriver: DcwWriteDriver = {
         // 失败/超时路径同样关闭连接(此前只在成功后 end,超时会泄漏 client +
         // broker session),已关闭的 client 重复 end 幂等安全
         await new Promise<void>((resolve) => {
-          client.end(false, {}, resolve)
+          // mqtt 的 DoneCallback 是 Node 风格 (error?: Error) => void;直接把 Promise 的 resolve
+          // 传进去会把 error 当成"完成值"兑现(错误被吞)。这里显式包一层,保持原语义:
+          // 回调一触发即完成,且与原来一样**不**因该 error 而 reject。
+          client.end(false, {}, () => resolve())
         })
       }
       return {
@@ -552,7 +555,7 @@ export const mqttDcwDriver: DcwWriteDriver = {
         })
         c.once('connect', () => resolve(c))
         c.once('error', err => reject(new Error(err.message)))
-      }).then(c => new Promise<void>(r => c.end(false, {}, r)))
+      }).then(c => new Promise<void>(r => c.end(false, {}, () => r())))
       return { ok: true, message: `Broker 连接成功(${String(driverConfig.host)}:${Number(driverConfig.port ?? 1883)});未执行发布,避免误触发真实设备动作` }
     }
     catch (err) {

package/server/services/workshop/dcw/param-conversion.ts

@@ -0,0 +1,78 @@
+/**
+ * ParamConversion —— 工艺参数 → PLC 标准转换模式展开器(配置期)。
+ *
+ * 用户在映射配置期选定「标准转换模式」(float32 直写 / int16·int32 线性标定)
+ * 与设备连接 + 寄存器,本模块将其一次性展开为执行节点驱动配置:
+ *   - float32       原始值 = 工程值,驱动直写 float32
+ *   - int16-scaled  eng∈[engMin,engMax] 线性映射 raw∈[rawMin,rawMax],int16 编码
+ *   - int32-scaled  同上,int32 编码
+ * 运行期双向换算(下发 encode / 回读 decode)由既有驱动链完成,本模块零参与 ——
+ * 展开产物即单一事实源(driverConfig),转换模式本身仅作展示/审计摘要留存。
+ */
+
+import type { ParamAccessSpec } from '../../../../shared/dcw-protocol'
+import { AppError, ErrorCodes } from '../../../utils/errors'
+
+/** 展开产物:执行节点创建所需的驱动字段(结构与 DCW 驱动 configFields 一致) */
+export interface DerivedAccess {
+  driver: 'modbus-tcp' | 'modbus-rtu'
+  driverConfig: Record<string, string | number | boolean>
+  /** 节点工艺安全量程(取标定工程量程;float32 模式由调用方回退模板量程) */
+  engMin?: number
+  engMax?: number
+}
+
+/** 校验 + 展开:接入规格 → 驱动配置(非法配置在配置期即拒,不带病运行) */
+export function deriveAccess(access: ParamAccessSpec): DerivedAccess {
+  const driver = access.driver ?? 'modbus-tcp'
+  const host = String(access.host ?? '').trim()
+  if (!host) throw new AppError(400, ErrorCodes.VALIDATION_ERROR, 'access.host 必填:设备连接地址(PLC/网关 IP)')
+  const register = Number(access.register)
+  if (!Number.isInteger(register) || register < 40001 || register > 49999) {
+    throw new AppError(400, ErrorCodes.VALIDATION_ERROR, `access.register 须为 4xxxx 保持寄存器地址(当前: ${String(access.register)})`)
+  }
+  const conv = access.conversion
+  if (!conv || !['float32', 'int16-scaled', 'int32-scaled'].includes(conv?.mode)) {
+    throw new AppError(400, ErrorCodes.VALIDATION_ERROR, `access.conversion.mode 须为标准转换模式之一: float32 / int16-scaled / int32-scaled(当前: ${String(conv?.mode)})`)
+  }
+  const byteOrder = conv.byteOrder ?? 'big'
+  const base = {
+    host,
+    port: access.port == null ? 502 : Number(access.port),
+    unitId: access.unitId == null ? 1 : Number(access.unitId),
+    register,
+  }
+
+  if (conv.mode === 'float32') {
+    // float32 直写:未配原始量程 → 驱动 raw=eng
+    return {
+      driver,
+      driverConfig: { ...base, dataType: 'float32', byteOrder },
+    }
+  }
+
+  // int16/int32 线性标定:标定量程必填且 eng 跨度/raw 跨度非零
+  const engMin = Number(conv.engMin)
+  const engMax = Number(conv.engMax)
+  const rawMin = Number(conv.rawMin)
+  const rawMax = Number(conv.rawMax)
+  for (const [k, v] of [['engMin', engMin], ['engMax', engMax], ['rawMin', rawMin], ['rawMax', rawMax]] as const) {
+    if (!Number.isFinite(v)) throw new AppError(400, ErrorCodes.VALIDATION_ERROR, `转换模式 ${conv.mode} 需要完整线性标定:${k} 缺失或非数字`)
+  }
+  if (engMax === engMin) throw new AppError(400, ErrorCodes.VALIDATION_ERROR, `线性标定非法:engMax(${engMax}) 不得等于 engMin`)
+  if (rawMax === rawMin) throw new AppError(400, ErrorCodes.VALIDATION_ERROR, `线性标定非法:rawMax(${rawMax}) 不得等于 rawMin`)
+  return {
+    driver,
+    driverConfig: {
+      ...base,
+      dataType: conv.mode === 'int16-scaled' ? 'int16' : 'int32',
+      byteOrder,
+      engMin,
+      engMax,
+      rawMin,
+      rawMax,
+    },
+    engMin,
+    engMax,
+  }
+}