agentworkshop 0.7.39 → 0.7.41

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,9 +11,10 @@
 
 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, 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'
@@ -22,6 +23,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'
@@ -31,6 +35,9 @@ import { daqRuntimeSettings } from '../settings'
 /** 运维日志写下发防噪:同节点同值 10s 内的心跳重下发不重复入册 */
 const opsWriteMemo = new Map<string, { eng: number, at: number }>()
 
+// 写驱动插件桥(模块装载即挂;插件宿主先到则注册项排队、此处接管回放)
+attachDcwPluginBridge()
+
 /** 周期读网关默认间隔(节点 readIntervalMs=null 时生效;真实 PLC 建议按链路承载调整) */
 const DEFAULT_READ_INTERVAL_MS = 5000
 
@@ -353,6 +360,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 +441,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 +549,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 +629,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 +1045,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 +1055,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 +1130,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

@@ -9,6 +9,7 @@
  */
 import { createRequire } from 'node:module'
 import type { DcwDriverKind } from '../../../../shared/dcw-protocol'
+import { DCW_DRIVERS } from '../../../../shared/dcw-protocol'
 import { AppError } from '../../../utils/errors'
 import { classifyCommError, closeModbusSafely, decodeRegisters, evictModbusConn, evictOpcUaConn, getModbusConn, getOpcUaConn, modbusKey, registerOffset, withModbusConn } from '../daq/drivers'
 
@@ -524,7 +525,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 +556,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) {
@@ -634,12 +638,94 @@ const REGISTRY: Record<DcwDriverKind, DcwWriteDriver> = {
   'http': httpDcwDriver,
 }
 
+/**
+ * 插件写驱动注册表(经 ctx.dcw.registerWriteDriver;与数采侧 registerPluginDriver 对称)。
+ * globalThis 防 HMR 双实例;resolveDcwDriver 插件优先,热重载同名幂等覆盖。
+ * 驱动可携带可选 meta(label/configFields)进写控驱动目录(dcwDriverCatalog)。
+ */
+export interface PluginWriteDriverMeta {
+  kind: string
+  label: string
+  status: 'builtin' | 'real' | 'planned'
+  configFields?: import('../../../../shared/daq-protocol').DriverConfigField[]
+  plugin: true
+}
+
+const g_plugins = globalThis as typeof globalThis & { __dcwPluginDrivers?: Map<string, DcwWriteDriver> }
+function pluginRegistry(): Map<string, DcwWriteDriver> {
+  return g_plugins.__dcwPluginDrivers ??= new Map()
+}
+
+const g_metas = globalThis as typeof globalThis & { __dcwPluginDriverMetas?: Map<string, PluginWriteDriverMeta> }
+function pluginMetaRegistry(): Map<string, PluginWriteDriverMeta> {
+  return g_metas.__dcwPluginDriverMetas ??= new Map()
+}
+
+export function registerPluginWriteDriver(driver: DcwWriteDriver): void {
+  if (driver.kind in REGISTRY) console.warn(`[dcw-drivers] 插件写驱动覆盖内置:「${driver.kind}」`)
+  pluginRegistry().set(driver.kind, driver)
+  const meta = (driver as DcwWriteDriver & { meta?: Omit<PluginWriteDriverMeta, 'kind' | 'plugin'> }).meta
+  if (meta && typeof meta.label === 'string') {
+    pluginMetaRegistry().set(driver.kind, {
+      kind: driver.kind,
+      label: meta.label,
+      status: meta.status === 'builtin' || meta.status === 'planned' ? meta.status : 'real',
+      configFields: Array.isArray(meta.configFields) ? meta.configFields : [],
+      plugin: true,
+    })
+  }
+  else {
+    pluginMetaRegistry().delete(driver.kind)
+  }
+}
+
+export function listPluginWriteDrivers(): string[] {
+  return [...pluginRegistry().keys()]
+}
+
+/** 插件写驱动自描述目录(写控驱动目录合并端点用) */
+export function listPluginWriteDriverMetas(): PluginWriteDriverMeta[] {
+  return [...pluginMetaRegistry().values()]
+}
+
+/** 清空插件写驱动与其自描述目录(插件宿主热重载前调用;与数采侧 clearPluginDrivers 对称) */
+export function clearPluginWriteDrivers(): void {
+  pluginRegistry().clear()
+  pluginMetaRegistry().clear()
+}
+
+/**
+ * 写控驱动目录(内置 DCW_DRIVERS + 插件自描述合并;同名插件条目覆盖内置)。
+ * dcw index.get 以 `drivers` 下发,前端写控节点向导据此渲染。
+ */
+export async function dcwDriverCatalog(): Promise<Array<{
+  kind: string
+  label: string
+  status: 'builtin' | 'real' | 'planned'
+  configFields: import('../../../../shared/daq-protocol').DriverConfigField[]
+  plugin?: boolean
+}>> {
+  const out: Array<{ kind: string, label: string, status: 'builtin' | 'real' | 'planned', configFields: import('../../../../shared/daq-protocol').DriverConfigField[], plugin?: boolean }> = DCW_DRIVERS.map(d => ({
+    kind: d.kind,
+    label: d.label,
+    status: d.status,
+    configFields: d.configFields,
+  }))
+  for (const m of listPluginWriteDriverMetas()) {
+    const i = out.findIndex(d => d.kind === m.kind)
+    const entry = { kind: m.kind, label: m.label, status: m.status, configFields: m.configFields ?? [], plugin: true }
+    if (i >= 0) out[i] = entry
+    else out.push(entry)
+  }
+  return out
+}
+
 export function normalizeDcwDriverKind(kind: string): DcwDriverKind {
   if (kind === 'modbus') return 'modbus-tcp'
   if (kind === 'rtu' || kind === 'modbus-rtu-tcp') return 'modbus-rtu'
-  return (kind in REGISTRY ? kind : 'mock') as DcwDriverKind
+  return ((kind in REGISTRY || pluginRegistry().has(kind) ? kind : 'mock')) as DcwDriverKind
 }
 
 export function resolveDcwDriver(kind: DcwDriverKind): DcwWriteDriver {
-  return REGISTRY[kind] ?? mockDcwDriver
+  return pluginRegistry().get(kind) ?? REGISTRY[kind] ?? mockDcwDriver
 }

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,
+  }
+}