agentworkshop 0.7.48 → 0.7.50

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

@@ -1,147 +1,137 @@
-/**
- * DcwControllerWrite —— 数控写入(联锁/量程/租约)与驱动探测
- * (拆分层,承 DcwControllerBindings;方法体与原文件逐行一致)
- */
-import { DcwControllerBindings } from './bindings'
-import type { DcwDriverKind, DcwWriteMeta } from '../../../../../shared/dcw-protocol'
-import { AppError, ErrorCodes } from '../../../../utils/errors'
-import { assertWithinLimits } from '../param-limits'
-import { emitDcwWrite } from '@/server/services/workshop/plugins/host.mjs'
-import { getActiveLineRun } from '../line-run'
-import { getRecipeRollBackManager } from '../recipe-rollback-manager'
-import { normalizeDcwDriverKind, resolveDcwDriver } from '../drivers'
-import { opsActorKindOf, opsWriteMemo } from './helpers'
-import { recordOps } from '../../ops/ops'
-
-export abstract class DcwControllerWrite extends DcwControllerBindings {
-  /** 手动设定:用户提交工程量,网关校验/换算/下发/回读校验。
-   *  配方联锁:产线运行中,写入值还须落在活动配方对该参数的工艺窗口内
-   *  (节点全局量程之外的第二道约束 —— 换配方即换工艺窗口)。
-   *  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 })
-    // 写入保持窗(防参数震荡):agent/manual 写成功一次即锁定节点 writeLockSeconds;
-    // 锁定期间的新写一律 429 快速拒绝(不排队 —— 排队写会在窗满后立刻落库,等同
-    // 为持续篡改保留通道)。rollback(安全恢复)/recipe(批量下发)不受保持窗约束;
-    // AW_BENCH_MODE=1 基准旁路(基准多轮连续写同节点,锁会破坏既有证据可复现性)。
-    // 顺序在限界联锁之后:越量程/越窗是确定性非法(400),不得被暂时性限频(429)
-    // 抢答,否则客户端会对非法值做 30s 的无谓重试。
-    const srcForLock = meta?.source ?? (recipeRunId ? 'recipe' : 'manual')
-    const benchBypass = process.env.AW_BENCH_MODE === '1'
-    const lockMs = Math.max(0, Math.round((node.writeLockSeconds ?? 30) * 1000))
-    const lockable = (srcForLock === 'agent' || srcForLock === 'manual') && lockMs > 0 && !benchBypass
-    if (lockable) {
-      const now = Date.now()
-      const until = this.writeLocks.get(id) ?? 0
-      // 过期条目顺手清掉,防注册表随节点删除/长时运行无限增长
-      if (this.writeLocks.size > 500) {
-        for (const [k, t] of this.writeLocks) {
-          if (t <= now) this.writeLocks.delete(k)
-        }
-      }
-      if (now < until) {
-        throw new AppError(
-          429,
-          ErrorCodes.WRITE_FREQUENT,
-          `当前写入频繁:「${node.name}」处于写入保持窗口(剩余 ${Math.ceil((until - now) / 1000)}s),请稍后再试`,
-        )
-      }
-    }
-    // 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) {
-      // 写成功 → 锁定写入保持窗(agent/manual 路径;recipe/rollback 豁免)
-      if (lockable) this.writeLocks.set(id, Date.now() + lockMs)
-      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 的唯一语义读写面)----------
-}
+/**
+ * DcwControllerWrite —— 数控写入(联锁/量程/租约)与驱动探测
+ * (拆分层,承 DcwControllerBindings;方法体与原文件逐行一致)
+ */
+import { DcwControllerBindings } from './bindings'
+import type { DcwDriverKind, DcwWriteMeta } from '../../../../../shared/dcw-protocol'
+import { AppError, ErrorCodes } from '../../../../utils/errors'
+import { assertWithinLimits, assertStepLimit } from '../param-limits'
+import { getRecipeRollBackManager } from '../recipe-rollback-manager'
+import { normalizeDcwDriverKind, resolveDcwDriver } from '../drivers'
+import { recordDcwWriteOps } from './write-audit'
+
+export abstract class DcwControllerWrite extends DcwControllerBindings {
+  /** 手动设定:用户提交工程量,网关校验/换算/下发/回读校验。
+   *  配方联锁:产线运行中,写入值还须落在活动配方对该参数的工艺窗口内
+   *  (节点全局量程之外的第二道约束 —— 换配方即换工艺窗口)。
+   *  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 })
+    const srcForLock = meta?.source ?? (recipeRunId ? 'recipe' : 'manual')
+    const benchBypass = process.env.AW_BENCH_MODE === '1'
+    // 在线 Agent/人工控制都走安全小步与 60s 最小间隔:这是探索阶段的硬卡控，
+    // 不依赖提示词也不依赖前端，驱动调用前完成拒绝。recipe/rollback 仍由其
+    // 专用路径管理，避免启动批次时把整套配方误判为在线探索步。
+    if ((srcForLock === 'agent' || srcForLock === 'manual') && !benchBypass) {
+      const previous = typeof node.value === 'number'
+        ? node.value
+        : (typeof node.readValue === 'number' ? node.readValue : null)
+      assertStepLimit(node, eng, { includeSoft: !benchNoInterlock, skipRecipe: false }, previous)
+      const previousAt = node.lastWriteAt ? Date.parse(node.lastWriteAt) : NaN
+      if (Number.isFinite(previousAt)) {
+        const elapsed = Date.now() - previousAt
+        if (elapsed < 60_000) {
+          throw new AppError(429, ErrorCodes.WRITE_INTERVAL_NOT_ELAPSED, `DCW 节点「${node.name}」两次在线写入间隔必须至少 60s，当前还需 ${Math.ceil((60_000 - elapsed) / 1000)}s`)
+        }
+      }
+    }
+    // 写入保持窗(防参数震荡):agent/manual 写成功一次即锁定节点 writeLockSeconds;
+    // 锁定期间的新写一律 429 快速拒绝(不排队 —— 排队写会在窗满后立刻落库,等同
+    // 为持续篡改保留通道)。rollback(安全恢复)/recipe(批量下发)不受保持窗约束;
+    // AW_BENCH_MODE=1 基准旁路(基准多轮连续写同节点,锁会破坏既有证据可复现性)。
+    // 顺序在限界联锁之后:越量程/越窗是确定性非法(400),不得被暂时性限频(429)
+    // 抢答,否则客户端会对非法值做 30s 的无谓重试。
+    const configuredLockMs = Math.max(0, Math.round((node.writeLockSeconds ?? 30) * 1000))
+    const lockMs = (srcForLock === 'agent' || srcForLock === 'manual') && !benchBypass ? Math.max(60_000, configuredLockMs) : configuredLockMs
+    const lockable = (srcForLock === 'agent' || srcForLock === 'manual') && lockMs > 0 && !benchBypass
+    if (lockable) {
+      const now = Date.now()
+      const until = this.writeLocks.get(id) ?? 0
+      // 过期条目顺手清掉,防注册表随节点删除/长时运行无限增长
+      if (this.writeLocks.size > 500) {
+        for (const [k, t] of this.writeLocks) {
+          if (t <= now) this.writeLocks.delete(k)
+        }
+      }
+      if (now < until) {
+        throw new AppError(
+          429,
+          ErrorCodes.WRITE_FREQUENT,
+          `当前写入频繁:「${node.name}」处于写入保持窗口(剩余 ${Math.ceil((until - now) / 1000)}s),请稍后再试`,
+        )
+      }
+    }
+    // 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) {
+      // 写成功 → 锁定写入保持窗(agent/manual 路径;recipe/rollback 豁免)
+      if (lockable) this.writeLocks.set(id, Date.now() + lockMs)
+      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)单点入册(write-audit)
+      try {
+        recordDcwWriteOps({ id, node, eng, prevValue, outcome, src: srcForLock as DcwWriteMeta['source'], meta, recipeRunId })
+      }
+      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 的唯一语义读写面)----------
+}

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

@@ -36,11 +36,20 @@ interface DcwNodeOptions {
   semantics?: string
   /** 周期读间隔 ms(null = 走网关默认;0 = 关闭周期读,仅手动读取) */
   readIntervalMs?: number | null
-  /** 写入保持窗秒数(写成功后节点锁定该时长,防参数震荡;0 = 不锁;默认 30) */
+  /** 写入保持窗秒数(写成功后节点锁定该时长,防参数震荡;0 = 不锁;默认 60) */
   writeLockSeconds?: number
+  /** 单次控制步长上限(工程量;undefined 采用量程 2% 默认值;null 显式关闭) */
+  stepLimit?: number | null
   createdAt?: string
 }
 
+function normalizeStepLimit(value: number | null): number | null {
+  if (value == null) return null
+  const n = Number(value)
+  if (!Number.isFinite(n) || n <= 0) return null
+  return n
+}
+
 export class DcwNode {
   readonly id: string
   templateRef: string
@@ -69,6 +78,8 @@ export class DcwNode {
   readIntervalMs: number | null = null
   /** 写入保持窗秒数(写成功后锁定;防参数频繁修改震荡;0 = 不锁) */
   writeLockSeconds = 30
+  /** 单次控制步长上限(工程量);探索阶段必须有有限值 */
+  stepLimit: number | null
   lastAckAt: string | null = null
   lastWriteAt: string | null = null
   state: DcwNodeState = 'idle'
@@ -101,7 +112,9 @@ export class DcwNode {
     this.lineId = o.lineId ?? ''
     this.semantics = o.semantics
     this.readIntervalMs = o.readIntervalMs ?? null
-    this.writeLockSeconds = Math.max(0, Math.min(3600, Math.round(o.writeLockSeconds ?? 30)))
+    this.writeLockSeconds = Math.max(0, Math.min(3600, Math.round(o.writeLockSeconds ?? 60)))
+    const fallbackStep = Math.max(10 ** -this.decimals, (this.max - this.min) * 0.02)
+    this.stepLimit = o.stepLimit === undefined ? Number(fallbackStep.toFixed(this.decimals)) : normalizeStepLimit(o.stepLimit)
     this.createdAt = o.createdAt ?? new Date().toISOString()
   }
 
@@ -155,6 +168,7 @@ export class DcwNode {
       holdIntervalMs: this.holdIntervalMs,
       readIntervalMs: this.readIntervalMs,
       writeLockSeconds: this.writeLockSeconds,
+      stepLimit: this.stepLimit,
       unit: this.unit,
       decimals: this.decimals,
       min: this.min,
@@ -200,6 +214,7 @@ export class DcwNode {
       semantics: row.semantics == null ? undefined : String(row.semantics),
       readIntervalMs: row.readIntervalMs == null ? null : Number(row.readIntervalMs),
       writeLockSeconds: row.writeLockSeconds == null ? undefined : Number(row.writeLockSeconds),
+      stepLimit: row.stepLimit === undefined ? undefined : (row.stepLimit == null ? null : Number(row.stepLimit)),
       posZ: row.posZ == null ? undefined : Number(row.posZ),
       createdAt: row.createdAt != null ? String(row.createdAt) : undefined,
     })
@@ -252,6 +267,7 @@ export class DcwNode {
       lastReadError: this.lastReadError,
       readIntervalMs: this.readIntervalMs,
       writeLockSeconds: this.writeLockSeconds,
+      stepLimit: this.stepLimit,
       lastAckAt: this.lastAckAt,
       lastWriteAt: this.lastWriteAt,
       state: this.state,

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

@@ -104,6 +104,11 @@ const normParams = (params: RecipeParam[] | undefined, lineId = ''): RecipeParam
       if (out.max != null && out.value > out.max) {
         throw new AppError(400, ErrorCodes.VALIDATION_ERROR, `参数 ${label} 设定值 ${out.value} 超出配方上限 ${out.max}`)
       }
+      if (p.stepLimit != null) {
+        const step = Number(p.stepLimit)
+        if (!Number.isFinite(step) || step <= 0) throw new AppError(400, ErrorCodes.VALIDATION_ERROR, `参数 ${label} 的 recipe stepLimit 必须为正数`)
+        out.stepLimit = step
+      }
       return out
     })
 

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

@@ -75,7 +75,7 @@ export class DcwNodeRuntime {
     node.state = 'writing'
     node.lastWriteAt = new Date().toISOString()
     try {
-      // D8 基准消融:no-readback/ungated 臂由 write() 传入 MAX 容差 → 回读差异不再致败(假成功语义)
+      // D8 基准消融:no-readback/ungated 臂由 write() 传入 MAX 容差 → 回读差异不再致败(假成功语义)
       return await this.host.executeWrite(node, eng, toleranceOverride ?? writeTolerance(node), recipeRunId)
     }
     catch (err) {
@@ -116,13 +116,19 @@ export class DcwNodeRuntime {
           })
       }
     }
-    // 周期读:被动观测,不依赖写过、不与写在飞互斥(仅同节点读串行)
+    // 周期读:被动观测,不依赖写过、不与写在飞互斥(仅同节点读串行)。
+    // reading 闸门全程持有:与 readNow() 双向互斥(周期读在飞时手动读 409,
+    // 手动读在飞时本拍跳过) —— 早先此处只查不置,闸门形同虚设。
     if (this.reading || !node.enabled) return
     const readInt = node.readIntervalMs ?? this.host.defaults().readIntervalMs
     if (!readInt || readInt <= 0) return
     if (now - this.lastReadTick < readInt) return
     this.lastReadTick = now
-    void this.host.executeRead(node).catch(() => {})
+    this.reading = true
+    void Promise.resolve()
+      .then(() => this.host.executeRead(node))
+      .catch(() => {})
+      .finally(() => { this.reading = false })
   }
 
   /** 手动读取(on-demand;REST/Agent 工具共用;与周期读同一在飞互斥) */

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

@@ -14,7 +14,8 @@
  *   http.ts                HTTP/REST 写驱动(POST JSON;2xx 视为受理)
  *   registry.ts            内置驱动注册表 + 插件写驱动注册 + 目录/归一解析
  */
-export { supportsDcwRead, engToRaw, rawToEng, encodeWords } from './shared'
+export { supportsDcwRead } from './registry'
+export { engToRaw, rawToEng, encodeWords } from './shared'
 export type { DcwWriteInput, DcwWriteResult, DcwWriteDriver, DcwReadInput, DcwReadResult } from './shared'
 export { mockDcwDriver } from './mock'
 export { modbusTcpDcwDriver } from './modbus'

package/server/services/workshop/dcw/drivers/modbus-rtu.ts

@@ -1,93 +1,85 @@
-/**
- * Modbus RTU over TCP 写驱动(串口网关透传)
- * (由 server/services/workshop/dcw/drivers.ts 按职责拆出;内容逐行原文搬运)
- */
-import type { DcwWriteDriver, DcwWriteInput, DcwWriteResult } from './shared'
-import { AppError } from '../../../../utils/errors'
-import { classifyCommError, decodeRegisters, evictModbusConn, getModbusConn, registerOffset, withModbusConn } from '../../daq/drivers'
-import { encodeWords, engToRaw, rawToEng, reqNative } from './shared'
-import { modbusRead } from './modbus'
-
-// ============================================================
-// Modbus RTU over TCP 写驱动(串口网关透传;写保持寄存器 + 同址回读)
-// ============================================================
-
-export async function modbusRtuWrite(input: DcwWriteInput): Promise<DcwWriteResult> {
-  const cfg = input.driverConfig
-  if (!cfg.host) throw new AppError(400, 'BAD_REQUEST', '缺少网关地址 host')
-  if (cfg.register == null) throw new AppError(400, 'BAD_REQUEST', '缺少写寄存器地址 register')
-  const dataType = String(cfg.dataType ?? 'float32')
-  const byteOrder = String(cfg.byteOrder ?? 'big')
-  const raw = engToRaw(input.eng, input)
-  const rounded = dataType === 'float32' ? raw : Math.round(raw)
-  const words = encodeWords(rounded, dataType, byteOrder)
-  const offset = registerOffset(Number(cfg.register ?? 0), 'holding')
-  const conn = await getModbusConn(cfg, 'rtu-tcp')
-  conn.lastUsed = Date.now()
-  return withModbusConn(conn, async (): Promise<DcwWriteResult> => {
-    try {
-      await conn.client.writeRegisters(offset, words)
-      const rb = await conn.client.readHoldingRegisters(offset, words.length)
-      const rawBack = decodeRegisters(rb.data as number[], dataType, byteOrder)
-      const engBack = rawToEng(rawBack, input)
-      const ok = Math.abs(engBack - input.eng) <= input.tolerance
-      conn.errors = 0
-      return {
-        ok,
-        message: ok
-          ? `写入并回读一致:${input.eng} → raw ${rounded},回读 ${Number(engBack.toFixed(4))}`
-          : `回读偏差超容差:写 ${input.eng},回读 ${Number(engBack.toFixed(4))}(容差 ${input.tolerance})`,
-        raw: rounded,
-        readback: engBack,
-      }
-    }
-    catch (err) {
-      conn.errors++
-      if (conn.errors >= 3) evictModbusConn(cfg, 'rtu-tcp')
-      throw err
-    }
-  })
-}
-
-export const modbusRtuDcwDriver: DcwWriteDriver = {
-  kind: 'modbus-rtu',
-  async available() {
-    try {
-      reqNative('modbus-serial')
-      return true
-    }
-    catch {
-      return false
-    }
-  },
-  async write(input) {
-    try {
-      return await modbusRtuWrite(input)
-    }
-    catch (err) {
-      if (err instanceof AppError) throw err
-      return { ok: false, message: `Modbus RTU 写入失败: ${classifyCommError(err)}`, raw: null, readback: null }
-    }
-  },
-  async read(input) {
-    try {
-      return await modbusRead(input, 'rtu-tcp')
-    }
-    catch (err) {
-      return { ok: false, message: `Modbus RTU 读取失败: ${classifyCommError(err)}`, eng: null, raw: null }
-    }
-  },
-  async test(driverConfig) {
-    const t0 = Date.now()
-    try {
-      if (!driverConfig.host) return { ok: false, message: '缺少网关地址 host' }
-      if (driverConfig.register == null) return { ok: false, message: '缺少写寄存器地址 register' }
-      const conn = await getModbusConn(driverConfig, 'rtu-tcp')
-      await withModbusConn(conn, () => conn.client.readHoldingRegisters(registerOffset(Number(driverConfig.register ?? 0), 'holding'), 1))
-      return { ok: true, message: `网关连接成功,写寄存器可访问(${Date.now() - t0}ms)` }
-    }
-    catch (err) {
-      return { ok: false, message: classifyCommError(err) }
-    }
-  },
-}
+/**
+ * Modbus RTU over TCP 写驱动(串口网关透传)
+ * (由 server/services/workshop/dcw/drivers.ts 按职责拆出;内容逐行原文搬运)
+ */
+import type { DcwWriteDriver, DcwWriteInput, DcwWriteResult } from './shared'
+import { AppError } from '../../../../utils/errors'
+import { classifyCommError, decodeRegisters, evictModbusConn, getModbusConn, registerOffset, withModbusConn } from '../../daq/drivers/modbus-tcp'
+import { encodeWords, engToRaw, rawToEng, readbackAck, reqNative } from './shared'
+import { modbusRead } from './modbus'
+
+// ============================================================
+// Modbus RTU over TCP 写驱动(串口网关透传;写保持寄存器 + 同址回读)
+// ============================================================
+
+export async function modbusRtuWrite(input: DcwWriteInput): Promise<DcwWriteResult> {
+  const cfg = input.driverConfig
+  if (!cfg.host) throw new AppError(400, 'BAD_REQUEST', '缺少网关地址 host')
+  if (cfg.register == null) throw new AppError(400, 'BAD_REQUEST', '缺少写寄存器地址 register')
+  const dataType = String(cfg.dataType ?? 'float32')
+  const byteOrder = String(cfg.byteOrder ?? 'big')
+  const raw = engToRaw(input.eng, input)
+  const rounded = dataType === 'float32' ? raw : Math.round(raw)
+  const words = encodeWords(rounded, dataType, byteOrder)
+  const offset = registerOffset(Number(cfg.register ?? 0), 'holding')
+  const conn = await getModbusConn(cfg, 'rtu-tcp')
+  conn.lastUsed = Date.now()
+  return withModbusConn(conn, async (): Promise<DcwWriteResult> => {
+    try {
+      await conn.client.writeRegisters(offset, words)
+      const rb = await conn.client.readHoldingRegisters(offset, words.length)
+      const rawBack = decodeRegisters(rb.data as number[], dataType, byteOrder)
+      const engBack = rawToEng(rawBack, input)
+      conn.errors = 0
+      return readbackAck(input, engBack, { raw: rounded, rawNote: String(rounded) })
+    }
+    catch (err) {
+      conn.errors++
+      if (conn.errors >= 3) evictModbusConn(cfg, 'rtu-tcp')
+      throw err
+    }
+  })
+}
+
+export const modbusRtuDcwDriver: DcwWriteDriver = {
+  kind: 'modbus-rtu',
+  async available() {
+    try {
+      reqNative('modbus-serial')
+      return true
+    }
+    catch {
+      return false
+    }
+  },
+  async write(input) {
+    try {
+      return await modbusRtuWrite(input)
+    }
+    catch (err) {
+      if (err instanceof AppError) throw err
+      return { ok: false, message: `Modbus RTU 写入失败: ${classifyCommError(err)}`, raw: null, readback: null }
+    }
+  },
+  async read(input) {
+    try {
+      return await modbusRead(input, 'rtu-tcp')
+    }
+    catch (err) {
+      return { ok: false, message: `Modbus RTU 读取失败: ${classifyCommError(err)}`, eng: null, raw: null }
+    }
+  },
+  async test(driverConfig) {
+    const t0 = Date.now()
+    try {
+      if (!driverConfig.host) return { ok: false, message: '缺少网关地址 host' }
+      if (driverConfig.register == null) return { ok: false, message: '缺少写寄存器地址 register' }
+      const conn = await getModbusConn(driverConfig, 'rtu-tcp')
+      await withModbusConn(conn, () => conn.client.readHoldingRegisters(registerOffset(Number(driverConfig.register ?? 0), 'holding'), 1))
+      return { ok: true, message: `网关连接成功,写寄存器可访问(${Date.now() - t0}ms)` }
+    }
+    catch (err) {
+      return { ok: false, message: classifyCommError(err) }
+    }
+  },
+}