agentworkshop 0.8.4 → 0.8.6

package/server/services/workshop/agents/industrial/ops-tools.ts

@@ -16,7 +16,7 @@ import { getDcwParamRepo } from '../../dcw/param-map.repo'
 import { getOps } from '../../ops/ops'
 import { settingOf } from '../../settings'
 import { fanoutQuery, windowOf } from './audit-query'
-import { assertRecipeCreate, assertRecipeOperation, recipeApprovalPayload } from './recipe-gate'
+import { assertRecipeCreate, assertRecipeOperation, recipeApprovalPayload, type ActiveRecipeContext } from './recipe-gate'
 
 // ================================================================
 // 运维日志 / Recipe 变更史查询(Agent 自查面:负责产线 scoped)
@@ -750,8 +750,8 @@ export async function toolRecipeUpdate(agentId: string, args: {
   if (!target.ok) return { text: target.text, isError: true }
   const recipe = target.recipe
   const recipeId = recipe.id
-  // 权限模型 v2:绑定 → 二级认证 → 运行门(未在执行的配方不可操作)
-  const gate = assertRecipeOperation(agentId, recipe, 'update')
+  // 权限模型 v2 + 2026-10-28 双轨:版本操作只认 recipe 绑定(节点绑定不授予版本权)
+  const gate = assertRecipeOperation(agentId, recipe, 'update', list.map(p => String(p.node_id).trim()))
   if (!gate.ok) return { text: gate.text, isError: true }
   for (const p of list) {
     const nodeId = String(p.node_id).trim()
@@ -761,6 +761,13 @@ export async function toolRecipeUpdate(agentId: string, args: {
     if (!node.enabled) return { text: `节点「${node.name}」已停用,参数保存被拒。请先让用户恢复节点控制,或保存到其他节点。`, isError: true }
   }
   // HITL:manual 绑定(或全局下发审批开关)→ 保存前挂人工审批,理由随审批卡展示
+  // B-P1-4(2026-10-28 审查):审批卡展示的是"此刻的"配方定义;审批窗口内若有人并发
+  // 编辑同一配方,旧实现会把批准结果静默并进**已变的**定义(本次只改列出的参数,其余
+  // 取最新值),人工批准的语义被偷换。进入审批前记录定义指纹,批准后逐字比对。
+  const approvedDefinitionSnapshot = JSON.stringify({
+    version: recipe.version ?? 1,
+    params: recipe.params.map(p => ({ nodeId: p.nodeId, value: p.value, min: p.min ?? null, max: p.max ?? null })),
+  })
   let hitlNote = ''
   if (gate.hitlRequired) {
     const gateDecision = await hitlDispatchGate(
@@ -779,7 +786,7 @@ export async function toolRecipeUpdate(agentId: string, args: {
           const old = recipe.params.find(x => x.nodeId === String(p.node_id).trim())?.value
           return { nodeId: String(p.node_id).trim(), name: node?.name ?? String(p.node_id), from: old ?? null, to: Number(p.value), unit: node?.unit }
         }),
-        runId: gate.activeRunId,
+        context: gate.activeContext,
       }) },
     )
     if (!gateDecision.approved) {
@@ -788,8 +795,24 @@ export async function toolRecipeUpdate(agentId: string, args: {
       }
     }
     if (gateDecision.comment) hitlNote = `\n人工附言:${gateDecision.comment}`
-    const stale = await revalidateApprovedAction(agentId, recipe, 'update', 'recipe_update', { recipe_id: recipeId })
+    const stale = await revalidateApprovedAction(agentId, recipe, 'update', 'recipe_update', { recipe_id: recipeId, params: list.map(p => ({ node_id: p.node_id })) }, gate.activeContext)
     if (stale) return stale
+    // B-P1-4:批准后复核配方定义 —— 审批窗口内的并发编辑不得被静默并入已批版本。
+    const latestRecipe = getDcwRecipeRepo().byId(recipeId)
+    const latestSnapshot = latestRecipe
+      ? JSON.stringify({
+          version: latestRecipe.version ?? 1,
+          params: latestRecipe.params.map(p => ({ nodeId: p.nodeId, value: p.value, min: p.min ?? null, max: p.max ?? null })),
+        })
+      : ''
+    if (!latestRecipe || latestSnapshot !== approvedDefinitionSnapshot) {
+      return {
+        text: `人工已批准,但审批期间配方「${recipe.name}」的定义已被其他操作修改(v${recipe.version ?? 1} → v${latestRecipe?.version ?? '已删除'});`
+          + `为避免把本次批准静默并入已变更的定义,本次未执行、配方未改动。`
+          + `请调用 recipe_catalog/recipe_versions 重新读取最新参数与理由后,基于最新定义重新提交 recipe_update。`,
+        isError: true,
+      }
+    }
   }
   // 旧值快照(repo.update 原地改写 recipe.params,事后再取会把 before 读成新值)
   const beforeOf = new Map(recipe.params.map(p => [p.nodeId, p.value]))
@@ -887,7 +910,7 @@ export async function toolRecipeRollback(agentId: string, args: {
       recipe.id,
       `${emergency ? '【应急豁免频控】' : ''}配方回退:「${recipe.name}」→ ${toLastGood ? '已知良好批次冻结' : `v${version}`}${dispatch ? '(统一回退:定义回退+整批重下发)' : '(仅定义回退)'} | 理由:${reason} | 批准=执行回退;拒绝可附指导`,
       `${emergency ? '【应急】' : ''}配方回退审批`,
-      { payload: { ...recipeApprovalPayload('rollback', recipe.id, recipe.name, { reason, runId: gate.activeRunId }), ...(emergency ? { emergency: true } : {}) } },
+      { payload: { ...recipeApprovalPayload('rollback', recipe.id, recipe.name, { reason, context: gate.activeContext }), ...(emergency ? { emergency: true } : {}) } },
     )
     gateApprovalId = gateDecision.id
     if (!gateDecision.approved) {
@@ -896,11 +919,15 @@ export async function toolRecipeRollback(agentId: string, args: {
       }
     }
     if (gateDecision.comment) hitlNote = `\n人工附言:${gateDecision.comment}`
-    const stale = await revalidateApprovedAction(agentId, recipe, 'rollback', 'recipe_rollback', { recipe_id: recipeId })
+    const stale = await revalidateApprovedAction(agentId, recipe, 'rollback', 'recipe_rollback', { recipe_id: recipeId }, gate.activeContext)
     if (stale) return stale
   }
   try {
     if (dispatch) {
+      if (gate.hitlRequired) {
+        const staleAtDispatch = approvedContextError(agentId, recipe, 'rollback', gate.activeContext)
+        if (staleAtDispatch) return staleAtDispatch
+      }
       const { recipe: updated, run, definitionNoop } = await getDcwController().rollbackRecipeAndDispatch(recipeId, {
         version: toLastGood ? undefined : version,
         toLastGood,
@@ -979,23 +1006,58 @@ async function hitlDispatchGate(agentId: string, recipeId: string, detail: strin
 }
 
 /**
- * 审批返回「批准」后的二次授权复核(2026-10-18):审批可能挂起数分钟,
- * 期间绑定/产线授权/运行批次都可能被撤销。批准不等于授权仍然有效:
+ * 审批返回「批准」后的二次状态复核:审批可能挂起数分钟,
+ * 期间绑定/产线授权/活动产线上下文都可能变化。批准不等于授权与上下文仍然有效:
  *  - 重新跑 assertRecipeOperation(绑定/二级认证/运行门);
+ *  - 将当前 line/product/recipe/run 元组与审批时快照比较,变化即拒绝;
  *  - 重新跑 grant-guard(频道属主的产线 grant,收权即失活)。
- * 任一失败 → 本次不执行,回包说明原因(Agent 可据此重新申请)。
+ * 任一失败 → 本次不执行,回包说明原因(Agent 可据此核实上下文并重新申请)。
  */
+function approvedContextError(
+  agentId: string,
+  recipe: { id: string, name: string, lineId?: string, params?: Array<{ nodeId: string }>, access?: { requireAuth?: boolean, authorizedAgentIds?: string[] } },
+  op: 'update' | 'dispatch' | 'trial' | 'rollback',
+  expectedContext: ActiveRecipeContext,
+  targetNodeIds?: string[],
+): { text: string, isError: true } | null {
+  const currentGate = assertRecipeOperation(agentId, recipe, op, targetNodeIds)
+  if (!currentGate.ok) {
+    return { text: `人工已批准,但审批期间授权已失效,本次未执行:${currentGate.text}`, isError: true }
+  }
+  const current = currentGate.activeContext
+  if (current.lineId !== expectedContext.lineId
+    || current.runId !== expectedContext.runId
+    || current.recipeId !== expectedContext.recipeId
+    || current.productId !== expectedContext.productId) {
+    return {
+      text: '人工已批准,但审批期间产线/产品/配方/批次上下文已变化,本次未执行。请核查当前运行上下文后重新提交。',
+      isError: true,
+    }
+  }
+  return null
+}
+
+/** 从审批时的工具参数还原「本次覆盖的节点集」(trial/update 只写声明节点;其余=整批)。 */
+function targetNodesFromArgs(op: 'update' | 'dispatch' | 'trial' | 'rollback', args: Record<string, unknown>): string[] | undefined {
+  if (op !== 'trial' && op !== 'update') return undefined
+  const params = Array.isArray(args.params) ? args.params : []
+  const ids = params
+    .map(p => String((p as { node_id?: unknown } | null)?.node_id ?? '').trim())
+    .filter(Boolean)
+  return ids.length > 0 ? ids : undefined
+}
+
 export async function revalidateApprovedAction(
   agentId: string,
-  recipe: { id: string, name: string, lineId?: string, access?: { requireAuth?: boolean, authorizedAgentIds?: string[] } },
+  recipe: { id: string, name: string, lineId?: string, params?: Array<{ nodeId: string }>, access?: { requireAuth?: boolean, authorizedAgentIds?: string[] } },
   op: 'update' | 'dispatch' | 'trial' | 'rollback',
   toolName: string,
   args: Record<string, unknown>,
+  expectedContext: ActiveRecipeContext,
 ): Promise<{ text: string, isError: true } | null> {
-  const again = assertRecipeOperation(agentId, recipe, op)
-  if (!again.ok) {
-    return { text: `人工已批准,但审批期间授权已失效,本次未执行:${again.text}`, isError: true }
-  }
+  const targetNodeIds = targetNodesFromArgs(op, args)
+  const initialContextError = approvedContextError(agentId, recipe, op, expectedContext, targetNodeIds)
+  if (initialContextError) return initialContextError
   try {
     // manager 未装配(单测/嵌入)→ 只做绑定与运行门复核;装配后叠加产线 grant 复核
     const g = globalThis as typeof globalThis & {
@@ -1011,6 +1073,11 @@ export async function revalidateApprovedAction(
   catch (err) {
     return { text: `人工已批准,但审批后权限复核不可用,本次未执行:${err instanceof Error ? err.message : String(err)}。请稍后重试。`, isError: true }
   }
+  // Grant lookup is asynchronous. Re-read the active tuple after that await so
+  // queued line/run changes cannot pass between the initial comparison and the
+  // caller's dispatch continuation.
+  const changedAfterGrantCheck = approvedContextError(agentId, recipe, op, expectedContext, targetNodeIds)
+  if (changedAfterGrantCheck) return changedAfterGrantCheck
   return null
 }
 
@@ -1050,8 +1117,8 @@ export async function toolRecipeTrial(agentId: string, args: {
   if (!target.ok) return { text: target.text, isError: true }
   const recipe = target.recipe
   const recipeId = recipe.id
-  // 权限模型 v2:绑定 → 二级认证 → 运行门(未在执行的配方不可试验)
-  const gate = assertRecipeOperation(agentId, recipe, 'trial')
+  // 权限模型 v2 + 2026-10-28 双轨:recipe 绑定 ∨ 本次候选覆盖集 ⊆ dcw 节点绑定面
+  const gate = assertRecipeOperation(agentId, recipe, 'trial', list.map(p => p.nodeId))
   if (!gate.ok) return { text: gate.text, isError: true }
   for (const p of list) {
     const node = getDcwController().byId(p.nodeId)
@@ -1086,7 +1153,7 @@ export async function toolRecipeTrial(agentId: string, args: {
             const old = recipe.params.find(x => x.nodeId === p.nodeId)?.value
             return { nodeId: p.nodeId, name: node?.name ?? p.nodeId, from: old ?? null, to: p.value, unit: node?.unit }
           }),
-          runId: gate.activeRunId,
+          context: gate.activeContext,
         }), ...(emergency ? { emergency: true } : {}) } },
       )
       gateApprovalId = gateDecision.id
@@ -1097,9 +1164,15 @@ export async function toolRecipeTrial(agentId: string, args: {
       }
       // 人工附言随批准回执回流(Agent 与审计都能看到放行时人的原话)
       if (gateDecision.comment) hitlNote = `\n人工附言:${gateDecision.comment}`
-      const stale = await revalidateApprovedAction(agentId, recipe, 'trial', 'recipe_trial', { recipe_id: recipeId })
+      const stale = await revalidateApprovedAction(agentId, recipe, 'trial', 'recipe_trial', { recipe_id: recipeId, params: list.map(p => ({ node_id: p.nodeId })) }, gate.activeContext)
       if (stale) return stale
+      const staleAtDispatch = approvedContextError(agentId, recipe, 'trial', gate.activeContext, list.map(p => p.nodeId))
+      if (staleAtDispatch) return staleAtDispatch
     }
+    // 2026-10-28 执行点复核(双轨授权,D13 同款):审批/节拍等待期间绑定可能被撤销,
+    // 下发前最后一次同步重算覆盖集 —— 收回即失活,不把授权变更带进写入。
+    const execGate = assertRecipeOperation(agentId, recipe, 'trial', list.map(p => p.nodeId))
+    if (!execGate.ok) return { text: `下发前授权复核未通过,本次未执行:${execGate.text}`, isError: true }
     const run = await getDcwController().applyRecipe(recipeId, { overrides: list, trial: true, agentDispatch: true, agentApprovalId: gateApprovalId, emergency })
     // ACK 鉴定三段口径(2026-10-08):ok 只是命令受理,未证实/失败必须如实回给 Agent
     const acks = run.ackSummary ?? { verified: run.results.filter(r => r.ok).length, unverified: 0, failed: run.results.filter(r => !r.ok).length, total: run.results.length }
@@ -1187,7 +1260,7 @@ export async function toolRecipeApply(agentId: string, args: {
             const node = getDcwController().byId(p.nodeId)
             return { nodeId: p.nodeId, name: node?.name ?? p.nodeId, from: null, to: p.value, unit: node?.unit }
           }),
-          runId: gate.activeRunId,
+          context: gate.activeContext,
         }), recipeVersion: dispatch.version, ...(emergency ? { emergency: true } : {}) } },
       )
       gateApprovalId = gateDecision.id
@@ -1198,7 +1271,7 @@ export async function toolRecipeApply(agentId: string, args: {
       }
       // 人工附言随批准回执回流(与 recipe_trial 同口径)
       if (gateDecision.comment) hitlNote = `\n人工附言:${gateDecision.comment}`
-      const stale = await revalidateApprovedAction(agentId, recipe, 'dispatch', 'recipe_apply', { recipe_id: recipeId })
+      const stale = await revalidateApprovedAction(agentId, recipe, 'dispatch', 'recipe_apply', { recipe_id: recipeId }, gate.activeContext)
       if (stale) return stale
     }
     // 放在最后一次 await 之后,与 applyRecipe 的同步取值/建批之间不再让出执行权。
@@ -1206,6 +1279,13 @@ export async function toolRecipeApply(agentId: string, args: {
     if (!currentRecipe || JSON.stringify(currentRecipe) !== approvedDefinition) {
       return { text: '配方在审批期间已变更,与本次审批展示的快照不一致,本次未执行。请核查最新配方后重新提交 recipe_apply。', isError: true }
     }
+    if (gate.hitlRequired) {
+      const staleAtDispatch = approvedContextError(agentId, recipe, 'dispatch', gate.activeContext)
+      if (staleAtDispatch) return staleAtDispatch
+    }
+    // 2026-10-28 执行点复核(双轨授权):recipe 绑定或节点覆盖集在下发前再算一次
+    const execGate = assertRecipeOperation(agentId, recipe, 'dispatch')
+    if (!execGate.ok) return { text: `下发前授权复核未通过,本次未执行:${execGate.text}`, isError: true }
     // 完整覆盖集让控制器复制每个已批准值,逐参数异步写期间也不再共享可变配方参数。
     const run = await getDcwController().applyRecipe(recipeId, { overrides: dispatch.params, agentDispatch: true, agentApprovalId: gateApprovalId, emergency })
     // ACK 鉴定三段口径(2026-10-08):ok 只是命令受理,未证实/失败必须如实回给 Agent

package/server/services/workshop/agents/industrial/param-tools.ts

@@ -1,69 +1,69 @@
-/**
- * 工艺参数语义面辅助(参数引用解析/量程文本/写容差)与 param_control 的 v2 禁用桩
- * (由 server/services/workshop/agents/industrial-tools.ts 按职责拆出;内容逐行原文搬运)
- */
-import type { DcwParamView } from '../../../../../shared/dcw-protocol'
-import { getDcwController } from '../../dcw/dcw-controller'
-import { getDcwParamRepo } from '../../dcw/param-map.repo'
-import { limitsBreakdownOf } from '../../dcw/param-limits'
-
-/** 读/设定偏差对照容差(与服务端回读死区同口径) */
-export function writeToleranceOf(node: { decimals: number, min: number, max: number }): number {
-  return Math.max(0.5 * 10 ** -node.decimals, (node.max - node.min) * 0.005)
-}
-
-/** 工艺参数解析(param_control/param_read 共用):pp-id 优先,其次按 key;跨产线同名需 line_id 消歧 */
-export function resolveParamRef(ref: string, lineId?: string): { ok: true, param: DcwParamView } | { ok: false, text: string, isError: true } {
-  const repo = getDcwParamRepo()
-  const trimmed = String(ref ?? '').trim()
-  if (!trimmed) {
-    return { ok: false, text: 'param 必填:工艺参数 id(pp-*)或参数 key(见 my_industrial_nodes)。', isError: true }
-  }
-  const row = trimmed.startsWith('pp-') ? repo.byId(trimmed) : undefined
-  if (row) {
-    const view = repo.viewOf(row)
-    if (!view) return { ok: false, text: `工艺参数 ${trimmed} 的执行节点已不存在(映射悬空)。`, isError: true }
-    if (lineId && view.lineId !== lineId) {
-      return { ok: false, text: `工艺参数 ${view.key} 不属于产线 ${lineId}(实际归属:${view.lineId || '未分配'})。`, isError: true }
-    }
-    return { ok: true, param: view }
-  }
-  const hits = repo.byKey(trimmed)
-    .map(r => repo.viewOf(r))
-    .filter((v): v is DcwParamView => v != null)
-  const scoped = lineId ? hits.filter(v => v.lineId === lineId) : hits
-  if (scoped.length === 1) return { ok: true, param: scoped[0]! }
-  if (scoped.length === 0) {
-    const catalog = repo.listViews().slice(0, 12).map(v => `${v.key}(${v.name})`).join('、')
-    return { ok: false, text: `未找到工艺参数「${trimmed}」${lineId ? `(产线 ${lineId})` : ''}。可用参数:${catalog || '无 —— 请先让用户创建写控节点生成参数面'}。`, isError: true }
-  }
-  return { ok: false, text: `工艺参数「${trimmed}」命中 ${scoped.length} 条同名映射,请附加 line_id 消歧或改用参数 id(${scoped.map(v => v.id).join(' / ')})。`, isError: true }
-}
-
-/** 参数面权限摘要(工具回包统一口径;不透出寄存器等 PLC 寻址细节) */
-export function paramLimitsText(param: DcwParamView): string {
-  const node = getDcwController().byId(param.nodeId)
-  if (!node) return '执行节点已删除'
-  const bd = limitsBreakdownOf(node)
-  const layers = bd.layers.filter(l => l.min != null || l.max != null).map(l => l.label).join(' ∩ ')
-  return `有效写入区间 ${bd.effective.min}~${bd.effective.max}${param.unit}(约束层:${layers || '无'});单步上限=${bd.stepLimit == null ? '未配置' : `${bd.stepLimit}${param.unit}`}(${bd.stepLimitSource});Agent写入间隔≥60s`
-}
-
-/** 工具:param_control —— 按工艺参数下发设定值(推荐的参数语义寻址面)。
- *  权限沿用节点绑定(参数 → 执行节点);限界联锁(参数基准 ∩ 产品 ∩ 配方 ∩ 节点安全量程)
- *  在网关咽喉点统一生效。args.hypothesis 声明本次假设(入册),args.task_id 关联任务。 */
-export async function toolParamControl(agentId: string, args: {
-  param?: string
-  value?: number | string
-  hypothesis?: string
-  task_id?: string
-  line_id?: string
-}, channelId?: string): Promise<{ text: string, isError?: boolean }> {
-  void agentId
-  void args
-  void channelId
-  return {
-    text: '参数直写已禁用(权限模型 v2):Agent 不再直接改写运行中的工艺参数。请改用绑定的配方 —— recipe_update(写入新版本)/ recipe_apply(整批下发)/ recipe_trial(候选试验);治理联锁与 HITL 在配方面照常生效。',
-    isError: true,
-  }
-}
+/**
+ * 工艺参数语义面辅助(参数引用解析/量程文本/写容差)与 param_control 的 v2 禁用桩
+ * (由 server/services/workshop/agents/industrial-tools.ts 按职责拆出;内容逐行原文搬运)
+ */
+import type { DcwParamView } from '../../../../../shared/dcw-protocol'
+import { getDcwController } from '../../dcw/dcw-controller'
+import { getDcwParamRepo } from '../../dcw/param-map.repo'
+import { limitsBreakdownOf } from '../../dcw/param-limits'
+
+/** 读/设定偏差对照容差(与服务端回读死区同口径) */
+export function writeToleranceOf(node: { decimals: number, min: number, max: number }): number {
+  return Math.max(0.5 * 10 ** -node.decimals, (node.max - node.min) * 0.005)
+}
+
+/** 工艺参数解析(param_control/param_read 共用):pp-id 优先,其次按 key;跨产线同名需 line_id 消歧 */
+export function resolveParamRef(ref: string, lineId?: string): { ok: true, param: DcwParamView } | { ok: false, text: string, isError: true } {
+  const repo = getDcwParamRepo()
+  const trimmed = String(ref ?? '').trim()
+  if (!trimmed) {
+    return { ok: false, text: 'param 必填:工艺参数 id(pp-*)或参数 key(见 my_industrial_nodes)。', isError: true }
+  }
+  const row = trimmed.startsWith('pp-') ? repo.byId(trimmed) : undefined
+  if (row) {
+    const view = repo.viewOf(row)
+    if (!view) return { ok: false, text: `工艺参数 ${trimmed} 的执行节点已不存在(映射悬空)。`, isError: true }
+    if (lineId && view.lineId !== lineId) {
+      return { ok: false, text: `工艺参数 ${view.key} 不属于产线 ${lineId}(实际归属:${view.lineId || '未分配'})。`, isError: true }
+    }
+    return { ok: true, param: view }
+  }
+  const hits = repo.byKey(trimmed)
+    .map(r => repo.viewOf(r))
+    .filter((v): v is DcwParamView => v != null)
+  const scoped = lineId ? hits.filter(v => v.lineId === lineId) : hits
+  if (scoped.length === 1) return { ok: true, param: scoped[0]! }
+  if (scoped.length === 0) {
+    const catalog = repo.listViews().slice(0, 12).map(v => `${v.key}(${v.name})`).join('、')
+    return { ok: false, text: `未找到工艺参数「${trimmed}」${lineId ? `(产线 ${lineId})` : ''}。可用参数:${catalog || '无 —— 请先让用户创建写控节点生成参数面'}。`, isError: true }
+  }
+  return { ok: false, text: `工艺参数「${trimmed}」命中 ${scoped.length} 条同名映射,请附加 line_id 消歧或改用参数 id(${scoped.map(v => v.id).join(' / ')})。`, isError: true }
+}
+
+/** 参数面权限摘要(工具回包统一口径;不透出寄存器等 PLC 寻址细节) */
+export function paramLimitsText(param: DcwParamView): string {
+  const node = getDcwController().byId(param.nodeId)
+  if (!node) return '执行节点已删除'
+  const bd = limitsBreakdownOf(node)
+  const layers = bd.layers.filter(l => l.min != null || l.max != null).map(l => l.label).join(' ∩ ')
+  return `有效写入区间 ${bd.effective.min}~${bd.effective.max}${param.unit}(约束层:${layers || '无'});单步上限=${bd.stepLimit == null ? '未配置' : `${bd.stepLimit}${param.unit}`}(${bd.stepLimitSource});Agent写入间隔≥60s`
+}
+
+/** 工具:param_control —— 按工艺参数下发设定值(推荐的参数语义寻址面)。
+ *  权限沿用节点绑定(参数 → 执行节点);限界联锁(参数基准 ∩ 产品 ∩ 配方 ∩ 节点安全量程)
+ *  在网关咽喉点统一生效。args.hypothesis 声明本次假设(入册),args.task_id 关联任务。 */
+export async function toolParamControl(agentId: string, args: {
+  param?: string
+  value?: number | string
+  hypothesis?: string
+  task_id?: string
+  line_id?: string
+}, channelId?: string): Promise<{ text: string, isError?: boolean }> {
+  void agentId
+  void args
+  void channelId
+  return {
+    text: '参数直写已禁用(权限模型 v2):Agent 不再直接改写运行中的工艺参数。请改用绑定的配方 —— recipe_update(写入新版本)/ recipe_apply(整批下发)/ recipe_trial(候选试验);治理联锁与 HITL 在配方面照常生效。',
+    isError: true,
+  }
+}

package/server/services/workshop/agents/industrial/recipe-gate.ts

@@ -1,15 +1,24 @@
 /**
- * Recipe 操作统一鉴权门(权限模型 v2)。
+ * Recipe 操作统一鉴权门(权限模型 v2 + 2026-10-28 节点级写授权双轨)。
  *
- * Agent 不再直碰数控节点 —— 对产线的全部写动作收敛到「绑定的 recipe」上:
- *   ① 绑定门:必须持有该 recipe 的绑定(kind='recipe';可绑定多个配方);
+ * 对产线的全部写动作仍收敛在配方管道上;授权面有两条轨(取并集):
+ *   ① 绑定门:
+ *      - recipe 绑定(kind='recipe',nodeId 字段=配方 id)= **配方操作权**
+ *        (update/apply/trial/rollback 全部放行,维持权限模型 v2 语义);
+ *      - dcw 节点绑定(kind='dcw')= **点位写授权**(2026-10-28 恢复,非直写入口):
+ *        对「当前活动配方」的 trial/apply,只要本次覆盖的节点 ⊆ 自己的 dcw 绑定面
+ *        即放行 —— 授权跟设备节点走(稳定),管控跟活动配方走(动态),换配方不停摆。
+ *        版本操作(update/rollback)不授予:配方级操作权仍须 recipe 绑定。
+ *      - 目标节点集缺省 = 配方全部参数(apply / 无 overrides 的 trial);
+ *        trial 传本次 overrides 的节点集(只写声明节点,部分覆盖即拒)。
  *   ② 认证门:recipe.access.requireAuth=true 时,只有 authorizedAgentIds 清单内的
  *      Agent 可操作(fail-closed:开认证但清单为空 = 无人可操作);
  *   ③ 运行门:配方必须**正在执行**(该产线存在本配方的活动批次)—— 未运行的配方
  *      一律不可操作(参数写入/下发/试验/回退同样受限);
  *   ④ HITL 判定:绑定 mode='manual' → 每次动作挂起等人工批准(必带 Agent 理由);
  *      mode='auto'(显式确认切换)→ 免批直执行。全局开关 security.recipeDispatchApproval
- *      保持兼容:开启时即便 auto 绑定也挂审批。
+ *      保持兼容:开启时即便 auto 绑定也挂审批。节点级轨的 manual 语义跟随覆盖该批
+ *      节点的 dcw 绑定(任一 manual 即挂审批)。
  *      线级总闸(2026-10-08):line.controlMode='manual'(缺省,fail-safe)时 auto 绑定
  *      也强制人工审批 —— 手动模式下人类必须过目每一次写动作。
  */
@@ -17,15 +26,23 @@ import { getAgentNodeBindingRepo, type AgentNodeBinding } from '../node-bindings
 import { getDcwController } from '../../dcw/dcw-controller'
 import { getDcwLineRepo } from '../../dcw/dcw-line.repo'
 import { getActiveLineRun } from '../../dcw/line-run'
+import { executionModeOfAgent } from '../execution-mode'
 
 export type RecipeOp = 'update' | 'dispatch' | 'trial' | 'rollback' | 'create'
 
+export type ActiveRecipeContext = {
+  lineId: string
+  runId: string
+  recipeId: string
+  productId: string
+}
+
 export type RecipeGateResult
-  = | { ok: true, binding: AgentNodeBinding, hitlRequired: boolean, activeRunId: string }
+  = | { ok: true, binding: AgentNodeBinding, hitlRequired: boolean, activeContext: ActiveRecipeContext }
     | { ok: false, text: string }
 
 /** 运行门:该配方当前是否有活动批次(未结束的 run) */
-export function activeRunOfRecipe(recipeId: string): { id: string } | null {
+export function activeRunOfRecipe(recipeId: string): ActiveRecipeContext | null {
   const run = getDcwController().listRuns().find(r => r.recipeId === recipeId && !r.endedAt)
   if (!run) return null
   // 反僵尸交叉校验(鲁棒性):DB 行未结束 ≠ 产线在运行 —— 多次 apply/崩溃/重启会泄漏
@@ -33,26 +50,68 @@ export function activeRunOfRecipe(recipeId: string): { id: string } | null {
   // 权威运行态是 line-run 注册表(内存+line-runs.json 落盘,崩溃可恢复):
   // run 所属产线必须在注册表中运行,且注册表的活跃批次就是本批次。
   const active = getActiveLineRun(run.lineId)
-  if (!active || active.runId !== run.id) return null
-  return { id: run.id }
+  if (!active || active.runId !== run.id || active.recipeId !== recipeId) return null
+  return {
+    lineId: active.lineId,
+    runId: active.runId,
+    recipeId: active.recipeId,
+    productId: active.productId,
+  }
+}
+
+/** 节点展示名(拒绝文案用;节点已删除时退回 id) */
+function nodeLabel(nodeId: string): string {
+  const n = getDcwController().byId(nodeId)
+  return n ? `${n.name}(${nodeId})` : nodeId
+}
+
+function listNodes(ids: string[]): string {
+  return ids.length > 0 ? ids.map(nodeLabel).join('、') : '(无)'
 }
 
-/** 统一鉴权门:绑定 → 二级认证 → 运行门;返回绑定与 HITL 判定(不做挂起,挂起由调用方执行) */
+/** 统一鉴权门:绑定(配方级 ∪ 节点级)→ 二级认证 → 运行门;返回绑定与 HITL 判定(不做挂起,挂起由调用方执行)
+ *  targetNodeIds:本次动作实际覆盖的节点集;缺省 = 配方全部参数(整批 apply)。 */
 export function assertRecipeOperation(
   agentId: string,
-  recipe: { id: string, name: string, lineId?: string, access?: { requireAuth?: boolean, authorizedAgentIds?: string[] } },
+  recipe: { id: string, name: string, lineId?: string, params?: Array<{ nodeId: string }>, access?: { requireAuth?: boolean, authorizedAgentIds?: string[] } },
   op: RecipeOp,
+  targetNodeIds?: string[],
 ): RecipeGateResult {
   const opLabel = op === 'update' ? '参数写入' : op === 'dispatch' ? '下发' : op === 'trial' ? '试验下发' : '回退'
-  // ① 绑定门(kind='recipe';nodeId 字段 = recipeId)
-  const binding = getAgentNodeBindingRepo().find(agentId, recipe.id, 'recipe')
-  if (!binding) {
-    return {
-      ok: false,
-      text: `无权${opLabel}配方「${recipe.name}」(${recipe.id}):你未绑定该配方。权限模型 v2 下 Agent 不直接操作数控节点 —— 通过绑定 recipe 获得参数写入与下发能力(可绑定多个配方);请让用户或 lead 为你绑定(recipe 绑定首绑默认 manual,每次动作需人工批准)。`,
+  // ① 绑定门(双轨):recipe 绑定 = 配方操作权;dcw 绑定 = 点位写授权(仅 trial/apply)
+  const bindings = getAgentNodeBindingRepo().byAgent(agentId)
+  const recipeBinding = bindings.find(b => b.kind === 'recipe' && b.nodeId === recipe.id)
+  const dcwBindings = bindings.filter(b => b.kind === 'dcw')
+  const dcwBound = new Set(dcwBindings.map(b => b.nodeId))
+  const recipeNodes = (recipe.params ?? []).map(p => p.nodeId).filter(Boolean)
+  const targets = (targetNodeIds && targetNodeIds.length > 0 ? targetNodeIds : recipeNodes)
+    .map(id => String(id ?? '').trim())
+    .filter(Boolean)
+  const versionOp = op === 'update' || op === 'rollback'
+  let coveringBindings: AgentNodeBinding[] = []
+  if (!recipeBinding) {
+    if (versionOp) {
+      return {
+        ok: false,
+        text: `无权${opLabel}配方「${recipe.name}」(${recipe.id}):节点绑定(dcw)只授予参数下发/试验权(点位授权),配方版本操作(参数保存/回退)需要绑定该配方(kind='recipe',配方级操作权)。请让用户或 lead 为你绑定该配方(recipe 绑定首绑默认 manual,每次动作需人工批准)。`,
+      }
+    }
+    if (targets.length === 0) {
+      return {
+        ok: false,
+        text: `无权${opLabel}配方「${recipe.name}」:配方没有参数节点,无法确认授权覆盖集。请先为配方配置参数节点,或让用户/lead 绑定该配方(kind='recipe')。`,
+      }
     }
+    const missing = targets.filter(id => !dcwBound.has(id))
+    if (missing.length > 0) {
+      return {
+        ok: false,
+        text: `无权${opLabel}配方「${recipe.name}」:本次覆盖的节点中有 ${missing.length} 个不在你的数控节点绑定面内 —— ${listNodes(missing)}。你已绑定的可写节点:${listNodes([...dcwBound])}。请让用户或 lead 为你补绑这些节点(节点绑定 = 点位写授权),或改用已授权节点重试;若要对整批配方操作,也可改为绑定配方(kind='recipe')。`,
+      }
+    }
+    coveringBindings = dcwBindings.filter(b => targets.includes(b.nodeId))
   }
-  // ② 二级认证(用户在配方编辑里开启并勾选授权 Agent)
+  // ② 二级认证(用户在配方编辑里开启并勾选授权 Agent;双轨共用)
   if (recipe.access?.requireAuth && !(recipe.access.authorizedAgentIds ?? []).includes(agentId)) {
     return {
       ok: false,
@@ -69,12 +128,22 @@ export function assertRecipeOperation(
   }
   // ④ HITL 判定:manual 绑定 → 逐动作人工批准;auto → 免批。
   //    线级总闸(2026-10-08 生产化):line.controlMode='manual'(缺省)时,即便绑定为
-  //    auto 也强制人工审批 —— 手动模式下人类必须过目每一次写动作(fail-safe)。
+  //    auto 也强制人工审批 —— 手动模式下人类必须过目每一次写动作。
+  //    频道层钳位(2026-10-28 三模式):Agent 所属频道 executionMode='manual' 时同理强制;
+  //    'auto'(中性缺省)/'observe'(分发层已拒写,不可达)不改变本判定。
   const lineManual = recipe.lineId ? getDcwLineRepo().controlModeOf(recipe.lineId) === 'manual' : false
+  const channelManual = executionModeOfAgent(agentId) === 'manual'
   // ⑤ 全局开关兼容位:security.recipeDispatchApproval 开启时即便 auto 也挂审批(保留语义)
   const globalGate = false // 由调用方按 settingOf('security.recipeDispatchApproval') 叠加(本模块不依赖设置服务)
   void globalGate
-  return { ok: true, binding, hitlRequired: binding.mode === 'manual' || lineManual, activeRunId: run.id }
+  // 节点级轨的 manual 语义:覆盖本次批次的 dcw 绑定任一 manual 即挂审批(fail-safe)
+  const nodeManual = coveringBindings.some(b => b.mode === 'manual')
+  const binding = recipeBinding ?? coveringBindings[0]
+  if (!binding) {
+    // 理论上不可达(targets 非空且全部已覆盖);fail-closed 防实现漂移
+    return { ok: false, text: `无权${opLabel}配方「${recipe.name}」:未找到有效授权绑定。` }
+  }
+  return { ok: true, binding, hitlRequired: binding.mode === 'manual' || nodeManual || lineManual || channelManual, activeContext: run }
 }
 
 /** 新建配方的授权门(尚无 recipe 可绑定):要求 Agent 在该线至少有一个写向绑定
@@ -109,13 +178,15 @@ export function assertRecipeCreate(agentId: string, lineId: string): { ok: true,
     }
   }
   const lineManual = getDcwLineRepo().controlModeOf(lineId) === 'manual'
-  return { ok: true, hitlRequired: manualBound || lineManual }
+  const channelManual = executionModeOfAgent(agentId) === 'manual'
+  return { ok: true, hitlRequired: manualBound || lineManual || channelManual }
 }
 
 /** 审批单载荷(结构化;前端审批卡渲染理由/参数/批次) */
 export function recipeApprovalPayload(op: RecipeOp, recipeId: string, recipeName: string, extra: {
   reason: string
   params?: Array<{ nodeId: string, name: string, from: number | null, to: number, unit?: string }>
+  context?: ActiveRecipeContext
   runId?: string
 }): Record<string, unknown> {
   return {
@@ -126,6 +197,6 @@ export function recipeApprovalPayload(op: RecipeOp, recipeId: string, recipeName
     recipeName,
     reason: extra.reason,
     ...(extra.params ? { params: extra.params } : {}),
-    ...(extra.runId ? { runId: extra.runId } : {}),
+    ...(extra.context ? { context: { ...extra.context }, runId: extra.context.runId } : extra.runId ? { runId: extra.runId } : {}),
   }
 }

package/server/services/workshop/agents/industrial/recipe-propose-tools.ts

@@ -278,7 +278,7 @@ export async function toolRecipePropose(agentId: string, args: {
   }
 
   // 批准不等于授权仍有效:复核绑定/认证/运行门/产线 grant(审批期间可能被撤销)
-  const stale = await revalidateApprovedAction(agentId, recipe, 'dispatch', 'recipe_propose', { recipe_id: recipeId })
+  const stale = await revalidateApprovedAction(agentId, recipe, 'dispatch', 'recipe_propose', { recipe_id: recipeId }, gate.activeContext)
   if (stale) return stale
 
   // ---------- ⑦b 批准(choice 已由 decide 链 fail-closed 归一):选定包整批下发 ----------

package/server/services/workshop/agents/industrial/tool-verify-legacy-specs.ts

@@ -34,9 +34,9 @@ export const LEGACY_VERIFY_SPECS: Record<string, ToolVerifySpec> = {
   line_status: { refs: [{ param: 'line_id', kind: 'line', mode: 'read' }] },
   line_start: { refs: [{ param: 'recipe_id', kind: 'recipe', mode: 'write' }] },
   recipe_versions: { refs: [{ param: 'recipe_id', kind: 'recipe', mode: 'read' }] },
-  recipe_update: { atLeastOne: [{ params: ['recipe_id', 'line_id'], hint: 'recipe_id 或 line_id 至少提供一个:只给 line_id 时按该线当前活动批次解析配方。' }], refs: [{ param: 'recipe_id', kind: 'recipe', mode: 'write' }, { param: 'line_id', kind: 'line', mode: 'read' }], deepNodeRefs: ['params[].node_id'] },
+  recipe_update: { atLeastOne: [{ params: ['recipe_id', 'line_id'], hint: 'recipe_id 或 line_id 至少提供一个:只给 line_id 时按该线当前活动批次解析配方。' }], refs: [{ param: 'recipe_id', kind: 'recipe', mode: 'write' }, { param: 'line_id', kind: 'line', mode: 'read' }], deepNodeRefs: ['params[].node_id'], writeNodeRefs: ['params[].node_id'] },
   recipe_rollback: { refs: [{ param: 'recipe_id', kind: 'recipe', mode: 'write' }] },
-  recipe_trial: { atLeastOne: [{ params: ['recipe_id', 'line_id'], hint: 'recipe_id 或 line_id 至少提供一个:只给 line_id 时按该线当前活动批次解析配方。' }], refs: [{ param: 'recipe_id', kind: 'recipe', mode: 'write' }, { param: 'line_id', kind: 'line', mode: 'read' }], deepNodeRefs: ['params[].node_id'] },
+  recipe_trial: { atLeastOne: [{ params: ['recipe_id', 'line_id'], hint: 'recipe_id 或 line_id 至少提供一个:只给 line_id 时按该线当前活动批次解析配方。' }], refs: [{ param: 'recipe_id', kind: 'recipe', mode: 'write' }, { param: 'line_id', kind: 'line', mode: 'read' }], deepNodeRefs: ['params[].node_id'], writeNodeRefs: ['params[].node_id'] },
   recipe_apply: { atLeastOne: [{ params: ['recipe_id', 'line_id'], hint: 'recipe_id 或 line_id 至少提供一个:只给 line_id 时按该线当前活动批次解析配方。' }], refs: [{ param: 'recipe_id', kind: 'recipe', mode: 'write' }, { param: 'line_id', kind: 'line', mode: 'read' }] },
   recipe_propose: { refs: [{ param: 'recipe_id', kind: 'recipe', mode: 'read' }], deepNodeRefs: ['packages[].params[].node_id'] },
   // 分析与经验面