agentworkshop 0.8.5 → 0.8.7

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

@@ -1,103 +1,103 @@
-/**
- * DcwControllerProducts —— 产品 CRUD 与运行数据
- * (拆分层,承 DcwControllerLines;方法体与原文件逐行一致)
- */
-import { DcwControllerLines } from './lines'
-import type { ProductInput, ProductView } from '../../../../../shared/dcw-protocol'
-import { AppError, ErrorCodes } from '../../../../utils/errors'
-import { assertProductParamLimits } from './helpers'
-import { getActiveLineRun } from '../line-run'
-import { getDcwLineRepo } from '../dcw-line.repo'
-import { getDcwProductRepo } from '../dcw-product.repo'
-import { getDcwRecipeRepo } from '../dcw-recipe.repo'
-
-export abstract class DcwControllerProducts extends DcwControllerLines {
-  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 }
-  }
-}
+/**
+ * DcwControllerProducts —— 产品 CRUD 与运行数据
+ * (拆分层,承 DcwControllerLines;方法体与原文件逐行一致)
+ */
+import { DcwControllerLines } from './lines'
+import type { ProductInput, ProductView } from '../../../../../shared/dcw-protocol'
+import { AppError, ErrorCodes } from '../../../../utils/errors'
+import { assertProductParamLimits } from './helpers'
+import { getActiveLineRun } from '../line-run'
+import { getDcwLineRepo } from '../dcw-line.repo'
+import { getDcwProductRepo } from '../dcw-product.repo'
+import { getDcwRecipeRepo } from '../dcw-recipe.repo'
+
+export abstract class DcwControllerProducts extends DcwControllerLines {
+  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 }
+  }
+}

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

@@ -7,12 +7,13 @@ import type { DcwWriteHistoryEntry } from '../dcw-recipe.repo'
 import type { RecipeInput, RecipeRunView, RecipeView, WriteVerifyOutcome } from '../../../../../shared/dcw-protocol'
 import { AppError, ErrorCodes } from '../../../../utils/errors'
 import { getDcwRecipeRepo } from '../dcw-recipe.repo'
-import { assertRecipeOpIntervalForExecution, recordRecipeOpAnchor } from '../recipe-op-anchor'
+import { assertRecipeOpIntervalForExecution, beginRecipeOp, endRecipeOp, recordRecipeOpAnchor } from '../recipe-op-anchor'
 import { hydrateTrialLastAt, setTrialLastAt } from './gate-persist'
 import { recordOps } from '../../ops/ops'
 import { summarizeAck, verifyRecipeWrite } from './write-verify'
 import { writeTolerance } from '../dcw-runtime'
 import { notifyLineOperators } from '../../runtime/line-notify'
+import { assertWithinLimits } from '../param-limits'
 
 /**
  * 试验节拍 env 解析(显式 0 = 关闭;空/非法 = 默认 5 分钟)。
@@ -111,7 +112,7 @@ export abstract class DcwControllerRecipes extends DcwControllerParams {
    * 2026-10-08 ACK 鉴定:每参数写后经 verifyRecipeWrite 补验(链路受理→独立回读
    * 证实),结果行携带 ack/verify —— 「ok」不再被当成「设备已生效」。
    */
-  protected async writeRecipeParams(recipe: RecipeView, run: RecipeRunView): Promise<void> {
+  protected async writeRecipeParams(recipe: RecipeView, run: RecipeRunView, opts: { enforceRecipeWindow?: boolean } = {}): Promise<void> {
     const results: RecipeRunView['results'] = []
     for (const param of recipe.params) {
       const node = param.nodeId ? this.repo.byId(param.nodeId) : undefined
@@ -129,6 +130,24 @@ export abstract class DcwControllerRecipes extends DcwControllerParams {
         results.push({ templateRef: node.templateRef, nodeId: node.id, ok: false, message: `已跳过:节点「${node.name}」已取消绑定(${node.lineId ? '已改挂其他产线' : '已从产线移除'}),参数未下发`, value: param.value })
         continue
       }
+      // 2026-10-28:trial/候选覆盖值必须再过一次配方工艺窗口。
+      // 配方路径在 write() 里 skipRecipe:true(保存值已在保存时校验),但 trial 的
+      // overrides 是新值 —— 曾在 40~48 的配方窗下把 80/120 写进 PLC。
+      if (opts.enforceRecipeWindow) {
+        try {
+          assertWithinLimits(node, param.value, { includeSoft: true, skipRecipe: false })
+        }
+        catch (err) {
+          results.push({
+            templateRef: node.templateRef,
+            nodeId: node.id,
+            ok: false,
+            message: `候选值未下发(越界):${err instanceof Error ? err.message : String(err)}`,
+            value: param.value,
+          })
+          continue
+        }
+      }
       try {
         const outcome = await this.write(node.id, param.value, run.id, { source: 'recipe', actor: 'recipe' })
         // ACK 鉴定:命令 ok 但仅链路受理(mqtt/http-no-echo/mock)→ 独立回读补验
@@ -169,6 +188,13 @@ export abstract class DcwControllerRecipes extends DcwControllerParams {
     }
   }
 
+  /** 占位试验节拍(与 assertTrialCadence 同步调用,中间不得有 await;B-P1-2)。 */
+  private claimTrialCadence(lineId: string): void {
+    const at = Date.now()
+    this.trialLastAt.set(lineId, at)
+    setTrialLastAt(lineId, at) // P1-5 落盘
+  }
+
   /**
    * Recipe 手动应用 / Agent 试验(一键下发工艺参数集;不激活产线窗口)。
    * v19 trial 语义:**声明式覆盖集** —— 提供 overrides 时只写 overrides 列出的节点
@@ -197,9 +223,41 @@ export abstract class DcwControllerRecipes extends DcwControllerParams {
     if (unknown.length) {
       throw new AppError(400, ErrorCodes.VALIDATION_ERROR, `覆盖参数不在配方内: ${unknown.map(o => o.nodeId).join(', ')}(试验只能修改配方已有参数的值;新增参数请先 recipe_update)`)
     }
-    if (opts.trial) this.assertTrialCadence(recipe.lineId)
+    if (opts.trial) {
+      // B-P1-2(2026-10-28 审查):判定与占位必须同一次同步执行(中间无 await),
+      // 否则并发 trial 双双过检;写入完成前第二次会被节拍拦下。
+      this.assertTrialCadence(recipe.lineId)
+      this.claimTrialCadence(recipe.lineId)
+    }
     // Recipe 级下发间隔卡控(执行时兜底):仅 Agent 路径;approvalId 自豁免防审批竞态
-    if (opts.agentDispatch) assertRecipeOpIntervalForExecution(recipe, { approvalId: opts.agentApprovalId, emergency: opts.emergency })
+    if (opts.agentDispatch) {
+      assertRecipeOpIntervalForExecution(recipe, { approvalId: opts.agentApprovalId, emergency: opts.emergency })
+      // 在飞占位:频控是"查-做-记"三段,首尾之间隔着整批写入(秒级)。两个并发下发
+      // 都会在"查"时看到旧锚。占位与判定同步完成,follow 到 finally 释放。
+      beginRecipeOp(recipeId, recipe.name)
+    }
+    try {
+      return await this.applyRecipeLocked(recipe, opts, overrides)
+    }
+    finally {
+      if (opts.agentDispatch) endRecipeOp(recipeId)
+    }
+  }
+
+  /** applyRecipe 的持锁段(调用方已通过节拍/频控判定并在飞占位;不得在此重复占位)。 */
+  private async applyRecipeLocked(
+    recipe: RecipeView,
+    opts: {
+      overrides?: Array<{ nodeId: string, value: number }>
+      trial?: boolean
+      agentDispatch?: boolean
+      agentApprovalId?: string
+      emergency?: boolean
+    },
+    overrides: Array<{ nodeId: string, value: number }>,
+  ): Promise<RecipeRunView> {
+    const repo = getDcwRecipeRepo()
+    const recipeId = recipe.id
     // 声明式覆盖集:有 overrides 只写声明的节点(未声明参数保持现状,绝不顺带整批);
     // 无 overrides(手动应用/统一回退重下发)= 整批语义
     const effective = overrides.length > 0
@@ -209,7 +267,7 @@ export abstract class DcwControllerRecipes extends DcwControllerParams {
         })
       : recipe.params
     const run = repo.createRun(recipe, effective)
-    await this.writeRecipeParams({ ...recipe, params: effective }, run)
+    await this.writeRecipeParams({ ...recipe, params: effective }, run, { enforceRecipeWindow: overrides.length > 0 })
     // 运行中应用新配方版本 → 谱系拆段(A13):旧段在 now 闭合,新段记录新版本/内容 hash。
     try {
       const { getActiveLineRun, setActiveLineRun } = await import('../line-run')

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

@@ -123,6 +123,18 @@ export abstract class DcwControllerWrite extends DcwControllerBindings {
       catch (err) {
         reject(err instanceof AppError ? err : new AppError(409, ErrorCodes.STEP_LIMIT_EXCEEDED, String(err instanceof Error ? err.message : err)))
       }
+      // 失败冷却(5s):失败写不占 60s 成功间隔(断链恢复可立即重试),
+      // 但也不允许失败后无间隔轰炸设备 —— 只认最近一次**尝试**且节点仍处 error。
+      if (node.state === 'error' && node.lastAttemptAt) {
+        const failedAt = Date.parse(node.lastAttemptAt)
+        if (Number.isFinite(failedAt)) {
+          const sinceFail = Date.now() - failedAt
+          if (sinceFail < 5_000) {
+            reject(new AppError(429, ErrorCodes.WRITE_INTERVAL_NOT_ELAPSED, `DCW 节点「${node.name}」上次写入失败,${Math.ceil((5_000 - sinceFail) / 1000)}s 后可重试`))
+          }
+        }
+      }
+      // 60s 成功间隔:只认最近一次**成功**下发(失败尝试不占用窗口)
       const previousAt = node.lastWriteAt ? Date.parse(node.lastWriteAt) : NaN
       if (Number.isFinite(previousAt)) {
         const elapsed = Date.now() - previousAt

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

@@ -82,7 +82,10 @@ export class DcwNode {
   /** 单次控制步长上限(工程量);探索阶段必须有有限值 */
   stepLimit: number | null
   lastAckAt: string | null = null
+  /** 最近一次**成功**下发(设备已证实/受理)的时刻;失败写不更新 */
   lastWriteAt: string | null = null
+  /** 最近一次写**尝试**的时刻(含失败);仅用于诊断/失败冷却,不参与 60s 成功间隔 */
+  lastAttemptAt: string | null = null
   state: DcwNodeState = 'idle'
   /** 所属产线('' = 未分配;采集门控/写联锁/场景光晕按产线隔离) */
   lineId = ''
@@ -137,8 +140,12 @@ export class DcwNode {
    *  此前失败写把从未被 PLC 接受的指令值占进 value —— 保写心跳按 value 周期重下发,
    *  会把幻影指令值反复写向设备(10-07 事故放大器);同时污染步长基准与回退账本 prevValue。 */
   applyWriteResult(eng: number, ok: boolean, message: string, at: string): void {
-    this.lastWriteAt = at
+    // 尝试时间恒更新;成功时间只在设备证实/受理时更新 ——
+    // 失败写不再占用 60s 成功间隔(现场瞬断恢复后可立即重试),失败冷却另由
+    // write.ts 用 lastAttemptAt 做 5s 防轰炸。
+    this.lastAttemptAt = at
     if (ok) {
+      this.lastWriteAt = at
       this.value = Number(eng.toFixed(this.decimals))
       this.lastAckAt = at
       this.state = 'ok'
@@ -191,6 +198,7 @@ export class DcwNode {
       lastReadError: this.lastReadError,
       lastAckAt: this.lastAckAt,
       lastWriteAt: this.lastWriteAt,
+      lastAttemptAt: this.lastAttemptAt,
       state: this.state,
       lastError: this.lastError,
       createdAt: this.createdAt,
@@ -228,6 +236,9 @@ export class DcwNode {
     if (row.lastReadError != null) node.lastReadError = String(row.lastReadError)
     if (row.lastAckAt != null) node.lastAckAt = String(row.lastAckAt)
     if (row.lastWriteAt != null) node.lastWriteAt = String(row.lastWriteAt)
+    if (row.lastAttemptAt != null) node.lastAttemptAt = String(row.lastAttemptAt)
+    // 旧快照兼容:历史 lastWriteAt 是「尝试时间」语义,补一份到 lastAttemptAt
+    else if (row.lastWriteAt != null) node.lastAttemptAt = String(row.lastWriteAt)
     if (row.state != null) {
       const restored = String(row.state)
       // 持久化恢复消毒:'writing' 是进程内瞬态(写事务在飞)。若被快照带出后进程
@@ -275,6 +286,7 @@ export class DcwNode {
       stepLimit: this.stepLimit,
       lastAckAt: this.lastAckAt,
       lastWriteAt: this.lastWriteAt,
+      lastAttemptAt: this.lastAttemptAt,
       state: this.state,
       lastError: this.lastError,
       createdAt: this.createdAt,

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

@@ -357,7 +357,16 @@ class DcwRecipeRepo {
   markGood(recipeId: string, runId: string): RecipeView {
     const r = this.byId(recipeId)
     if (!r) throw new AppError(404, ErrorCodes.NOT_FOUND, `Recipe 不存在: ${recipeId}`)
-    if (!this.runById(runId)) throw new AppError(404, ErrorCodes.NOT_FOUND, `批次不存在: ${runId}`)
+    const run = this.runById(runId)
+    if (!run) throw new AppError(404, ErrorCodes.NOT_FOUND, `批次不存在: ${runId}`)
+    // 2026-10-28:此前只校验 run 存在 —— 可把同线另一个配方/别的产品的批次标为"已知良好",
+    // 之后 to_last_good 会把那个批次的 setpoints 整批写进当前配方。
+    if (run.recipeId !== recipeId) {
+      throw new AppError(400, ErrorCodes.VALIDATION_ERROR, `批次 ${runId} 属于配方 ${run.recipeId},不能标记为配方 ${recipeId} 的良好批次`)
+    }
+    if (run.lineId !== r.lineId) {
+      throw new AppError(400, ErrorCodes.VALIDATION_ERROR, `批次 ${runId} 属于产线 ${run.lineId},与配方产线 ${r.lineId} 不一致`)
+    }
     r.lastGoodRunId = runId
     this.flushRecipes()
     return r

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

@@ -8,6 +8,7 @@
 
 import { AppError, ErrorCodes } from '../../../utils/errors'
 import type { DcwNode } from './dcw-node'
+import { assertWithinLimits } from './param-limits'
 
 /** 回读死区容差:max(0.5×10^-小数位, 量程 0.5%) */
 export function writeTolerance(node: DcwNode): number {
@@ -49,6 +50,8 @@ export interface DcwReadOutcome {
 export class DcwNodeRuntime {
   private writing = false
   private lastHoldAt = 0
+  /** 保写被限界拒绝的最近告警时刻(节流,避免每拍刷日志) */
+  private holdBlockedAt = 0
   /** 周期读节拍 + 在飞互斥(读事务不与写事务互斥,但同节点读不重入) */
   private lastReadTick = 0
   private reading = false
@@ -77,7 +80,8 @@ export class DcwNodeRuntime {
     }
     this.writing = true
     node.state = 'writing'
-    node.lastWriteAt = new Date().toISOString()
+    // 只记「尝试」;成功时间由 applyWriteResult 在设备证实后写入
+    node.lastAttemptAt = new Date().toISOString()
     try {
       // D8 基准消融:no-readback/ungated 臂由 write() 传入 MAX 容差 → 回读差异不再致败(假成功语义)
       return await this.host.executeWrite(node, eng, toleranceOverride ?? writeTolerance(node), recipeRunId)
@@ -107,20 +111,40 @@ export class DcwNodeRuntime {
       const hold = node.holdIntervalMs ?? this.host.defaults().holdIntervalMs
       // P0-1 保写产线门:绑定产线的节点仅在产线活动(有运行批次窗口)时保写,停线即挂起,
       // 开线后下一拍自然恢复(10-07 事故根因④:停线不挂起心跳,残留节点持续直写)。
-      // lineId=''(未分配产线的独立通道)不受门控,保持独立节点用法。
-      if (hold && hold > 0 && now - this.lastHoldAt >= hold && (!node.lineId || this.host.lineActive(node.lineId))) {
-        this.lastHoldAt = now
-        this.writing = true
-        node.state = 'writing'
-        // tick 是同步节拍(由 sweep 同步调用),这里 fire-and-forget 但**全程持锁**,
-        // 保证与 write() 互斥;finally 里收敛状态并释放闸门。
-        void Promise.resolve()
-          .then(() => this.host.executeWrite(node, node.value!, writeTolerance(node), null))
-          .catch(() => { /* 保写失败不抛出:下一拍重试 */ })
-          .finally(() => {
-            this.writing = false
-            if (node.state === 'writing') node.state = 'error'
-          })
+      // 2026-10-28:未分配产线的节点不再默认豁免 —— 删线(purge=false)会把 lineId 置空,
+      // 旧逻辑因此让已下线产线的设定值被永久重写。现在必须显式 AW_HOLD_UNASSIGNED=1 才保写。
+      const lineGate = node.lineId ? this.host.lineActive(node.lineId) : process.env.AW_HOLD_UNASSIGNED === '1'
+      if (hold && hold > 0 && now - this.lastHoldAt >= hold && lineGate) {
+        // 2026-10-28:保写心跳也过四层限界(含配方窗)。此前只查在飞闸门,操作员收窄量程/
+        // 换配方后可写被拒、心跳却按旧值持续重写 PLC。
+        let withinLimits = true
+        try {
+          assertWithinLimits(node, node.value!, { includeSoft: true, skipRecipe: false })
+        }
+        catch (err) {
+          withinLimits = false
+          if (now - this.holdBlockedAt > 60_000) {
+            this.holdBlockedAt = now
+            console.warn(`[dcw] 保写心跳被限界拒绝(跳过本拍):${node.name}(${node.id}) ${err instanceof Error ? err.message : String(err)}`)
+          }
+        }
+        if (!withinLimits) {
+          // 不写,但周期读继续(下方读路径与本块独立)
+        }
+        else {
+          this.lastHoldAt = now
+          this.writing = true
+          node.state = 'writing'
+          // tick 是同步节拍(由 sweep 同步调用),这里 fire-and-forget 但**全程持锁**,
+          // 保证与 write() 互斥;finally 里收敛状态并释放闸门。
+          void Promise.resolve()
+            .then(() => this.host.executeWrite(node, node.value!, writeTolerance(node), null))
+            .catch(() => { /* 保写失败不抛出:下一拍重试 */ })
+            .finally(() => {
+              this.writing = false
+              if (node.state === 'writing') node.state = 'error'
+            })
+        }
       }
     }
     // 周期读:被动观测,不依赖写过、不与写在飞互斥(仅同节点读串行)。