agentworkshop 0.8.5 → 0.8.7

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

@@ -553,9 +553,15 @@ export async function toolRecipeCreate(agentId: string, args: {
   }
   if (!lineId) return { text: '无法确定产线:请提供 line_id 或 source_recipe_id(from_run_id 也可推断)。', isError: true }
   if (!readable.includes(lineId)) return { text: `无权在产线 ${lineId} 新建配方(你的可读产线:${readable.join(', ') || '(无)'})。`, isError: true }
-  const productId = String(args.product_id ?? '').trim() || source?.productId || (run?.productId ?? '')
+  let productId = String(args.product_id ?? '').trim() || source?.productId || (run?.productId ?? '')
+  if (!productId && lineId) {
+    // 只给 line_id 时:该线仅挂一个产品则自动归属(与"只传 line_id 即可操作"的工具哲学一致;
+    // 多产品歧义仍要求显式 product_id,fail-closed)
+    const lineProducts = getDcwProductRepo().all().filter(p => p.lineId === lineId)
+    if (lineProducts.length === 1) productId = lineProducts[0]!.id
+  }
   const product = productId ? getDcwProductRepo().byId(productId) : undefined
-  if (!productId || !product) return { text: `产品 ${productId || '(未提供)'} 不存在;新配方必须归属产品(product_id 或源配方可推断)。`, isError: true }
+  if (!productId || !product) return { text: `产品 ${productId || '(未提供)'} 不存在;新配方必须归属产品(product_id、源配方推断,或该产线恰好只挂一个产品时自动归属)。`, isError: true }
   if (product.lineId !== lineId) return { text: `产品「${product.name}」归属产线 ${product.lineId},与目标产线 ${lineId} 不一致。`, isError: true }
   if (source && source.lineId !== lineId) return { text: `源配方「${source.name}」归属产线 ${source.lineId},与目标产线 ${lineId} 不一致。`, isError: true }
 
@@ -750,8 +756,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 +767,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(
@@ -788,8 +801,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 }, gate.activeContext)
+    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]))
@@ -992,11 +1021,12 @@ async function hitlDispatchGate(agentId: string, recipeId: string, detail: strin
  */
 function approvedContextError(
   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',
   expectedContext: ActiveRecipeContext,
+  targetNodeIds?: string[],
 ): { text: string, isError: true } | null {
-  const currentGate = assertRecipeOperation(agentId, recipe, op)
+  const currentGate = assertRecipeOperation(agentId, recipe, op, targetNodeIds)
   if (!currentGate.ok) {
     return { text: `人工已批准,但审批期间授权已失效,本次未执行:${currentGate.text}`, isError: true }
   }
@@ -1013,15 +1043,26 @@ function approvedContextError(
   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 initialContextError = approvedContextError(agentId, recipe, op, expectedContext)
+  const targetNodeIds = targetNodesFromArgs(op, args)
+  const initialContextError = approvedContextError(agentId, recipe, op, expectedContext, targetNodeIds)
   if (initialContextError) return initialContextError
   try {
     // manager 未装配(单测/嵌入)→ 只做绑定与运行门复核;装配后叠加产线 grant 复核
@@ -1041,7 +1082,7 @@ export async function revalidateApprovedAction(
   // 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)
+  const changedAfterGrantCheck = approvedContextError(agentId, recipe, op, expectedContext, targetNodeIds)
   if (changedAfterGrantCheck) return changedAfterGrantCheck
   return null
 }
@@ -1082,8 +1123,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)
@@ -1129,11 +1170,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 }, gate.activeContext)
+      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)
+      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 }
@@ -1244,6 +1289,9 @@ export async function toolRecipeApply(agentId: string, args: {
       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,17 +1,27 @@
 /**
- * Recipe 操作统一鉴权门(权限模型 v2)。
+ * Recipe 操作统一鉴权门(权限模型 v2 + 2026-10-28 节点级写授权双轨 + 产线配方管理权)。
  *
- * Agent 不再直碰数控节点 —— 对产线的全部写动作收敛到「绑定的 recipe」上:
- *   ① 绑定门:必须持有该 recipe 的绑定(kind='recipe';可绑定多个配方);
+ * 对产线的全部写动作仍收敛在配方管道上;授权面有三条轨(取并集):
+ *   ① 绑定门:
+ *      - recipe 绑定(kind='recipe',nodeId 字段=配方 id)= **单配方操作权**
+ *        (update/apply/trial/rollback 全部放行,维持权限模型 v2 语义);
+ *      - line-recipe 绑定(kind='line-recipe',nodeId 字段=产线 id)= **产线配方管理权**
+ *        (2026-10-28 新增):对该产线**全部配方**(含未来新建)可 查看/新建/修改/回退;
+ *      - dcw 节点绑定(kind='dcw')= **点位写授权**(非直写入口):同时是下发范围的收窄器 ——
+ *        ▸ 下发授权规则(trial/apply):
+ *          - Agent 持有 recipe 级授权(单配方绑定 ∨ 产线管理权)且**未绑任何 dcw**:
+ *            默认可对该(线)配方全部参数下发(向下兼容,存量行为不变);
+ *          - Agent 绑了 dcw:下发覆盖集必须 ⊆ dcw 绑定面(部分覆盖即拒,列出缺失节点);
+ *          - Agent 无任何 recipe 级授权:覆盖集 ⊆ dcw 绑定面才放行(纯点位轨)。
+ *        ▸ 版本操作(update/rollback)只认 recipe 级授权:dcw 绑定不授予版本权。
  *   ② 认证门:recipe.access.requireAuth=true 时,只有 authorizedAgentIds 清单内的
  *      Agent 可操作(fail-closed:开认证但清单为空 = 无人可操作);
  *   ③ 运行门:配方必须**正在执行**(该产线存在本配方的活动批次)—— 未运行的配方
  *      一律不可操作(参数写入/下发/试验/回退同样受限);
- *   ④ HITL 判定:绑定 mode='manual' → 每次动作挂起等人工批准(必带 Agent 理由);
- *      mode='auto'(显式确认切换)→ 免批直执行。全局开关 security.recipeDispatchApproval
- *      保持兼容:开启时即便 auto 绑定也挂审批。
+ *   ④ HITL 判定:授权绑定的 mode='manual' → 每次动作挂起等人工批准(必带 Agent 理由);
+ *      mode='auto'(显式确认切换)→ 免批。dcw 点位轨覆盖该批次任一 manual 同样强制。
  *      线级总闸(2026-10-08):line.controlMode='manual'(缺省,fail-safe)时 auto 绑定
- *      也强制人工审批 —— 手动模式下人类必须过目每一次写动作。
+ *      也强制人工审批;频道层钳位(三模式)同理。
  */
 import { getAgentNodeBindingRepo, type AgentNodeBinding } from '../node-bindings.repo'
 import { getDcwController } from '../../dcw/dcw-controller'
@@ -50,22 +60,77 @@ export function activeRunOfRecipe(recipeId: string): ActiveRecipeContext | null
   }
 }
 
-/** 统一鉴权门:绑定 → 二级认证 → 运行门;返回绑定与 HITL 判定(不做挂起,挂起由调用方执行) */
+/** 节点展示名(拒绝文案用;节点已删除时退回 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 判定(不做挂起,挂起由调用方执行)
+ *  targetNodeIds:本次动作实际覆盖的节点集;缺省 = 配方全部参数(整批 apply)。
+ *  下发规则:持 recipe 级授权(单配方 ∨ 产线管理)且未绑任何 dcw → 全参数放行(向下兼容);
+ *  绑了 dcw → 覆盖集 ⊆ dcw 绑定面;两者都无 → 纯点位轨(覆盖集 ⊆ dcw 面)。 */
 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=单配方操作权;line-recipe=产线配方管理权;dcw=点位写授权(兼下发收窄器)
+  const bindings = getAgentNodeBindingRepo().byAgent(agentId)
+  const recipeBinding = bindings.find(b => b.kind === 'recipe' && b.nodeId === recipe.id)
+  const lineBinding = recipe.lineId
+    ? bindings.find(b => b.kind === 'line-recipe' && b.nodeId === recipe.lineId)
+    : undefined
+  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'
+  // 配方级授权锚:单配方绑定 或 产线管理权(版本操作 + 「无 dcw 即全参数下发」的载体)
+  const recipeLevelGrant = recipeBinding ?? lineBinding
+  let coveringBindings: AgentNodeBinding[] = []
+  if (!recipeLevelGrant) {
+    if (versionOp) {
+      return {
+        ok: false,
+        text: `无权${opLabel}配方「${recipe.name}」(${recipe.id}):节点绑定(dcw)只授予参数下发/试验权(点位授权),配方版本操作(参数保存/回退)需要配方级授权 —— 绑定该配方(kind='recipe')或持有其产线的配方管理权(kind='line-recipe')。请让用户或 lead 为你授权(recipe 绑定首绑默认 manual,每次动作需人工批准)。`,
+      }
     }
+    if (targets.length === 0) {
+      return {
+        ok: false,
+        text: `无权${opLabel}配方「${recipe.name}」:配方没有参数节点,无法确认授权覆盖集。请先为配方配置参数节点,或让用户/lead 授予你配方级授权。`,
+      }
+    }
+    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')或产线配方管理权(kind='line-recipe')。`,
+      }
+    }
+    coveringBindings = dcwBindings.filter(b => targets.includes(b.nodeId))
+  }
+  else if (dcwBindings.length > 0 && !versionOp) {
+    // 绑了 dcw = 下发范围收窄到这些点位(部分覆盖即拒);版本操作不受 dcw 收窄影响
+    const missing = targets.filter(id => !dcwBound.has(id))
+    if (missing.length > 0) {
+      return {
+        ok: false,
+        text: `下发被收窄:你已绑定数控节点,${opLabel}只能覆盖这些点位。本次覆盖的节点中有 ${missing.length} 个未绑定 —— ${listNodes(missing)}。你已绑定的可写节点:${listNodes([...dcwBound])}。请只对已绑定节点下发,或让用户/lead 补绑后再试(未绑定任何数控节点时才默认对配方全部参数放行)。`,
+      }
+    }
+    coveringBindings = dcwBindings.filter(b => targets.includes(b.nodeId))
   }
-  // ② 二级认证(用户在配方编辑里开启并勾选授权 Agent)
+  // ② 二级认证(用户在配方编辑里开启并勾选授权 Agent;三轨共用)
   if (recipe.access?.requireAuth && !(recipe.access.authorizedAgentIds ?? []).includes(agentId)) {
     return {
       ok: false,
@@ -80,9 +145,9 @@ export function assertRecipeOperation(
       text: `配方「${recipe.name}」当前未在执行(产线上没有本配方的活动批次),按运行门约束${opLabel}被拒。请先由用户在产线开跑本配方,再进行参数写入/下发。`,
     }
   }
-  // ④ HITL 判定:manual 绑定 → 逐动作人工批准;auto → 免批。
+  // ④ 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
@@ -90,11 +155,19 @@ export function assertRecipeOperation(
   // ⑤ 全局开关兼容位:security.recipeDispatchApproval 开启时即便 auto 也挂审批(保留语义)
   const globalGate = false // 由调用方按 settingOf('security.recipeDispatchApproval') 叠加(本模块不依赖设置服务)
   void globalGate
-  return { ok: true, binding, hitlRequired: binding.mode === 'manual' || lineManual || channelManual, activeContext: run }
+  // dcw 点位轨的 manual 语义:覆盖本次批点的 dcw 绑定任一 manual 即挂审批(fail-safe)
+  const nodeManual = coveringBindings.some(b => b.mode === 'manual')
+  const binding = recipeLevelGrant ?? coveringBindings[0]
+  if (!binding) {
+    // 理论上不可达(配方级授权或全部覆盖必有其一);fail-closed 防实现漂移
+    return { ok: false, text: `无权${opLabel}配方「${recipe.name}」:未找到有效授权绑定。` }
+  }
+  return { ok: true, binding, hitlRequired: binding.mode === 'manual' || nodeManual || lineManual || channelManual, activeContext: run }
 }
 
-/** 新建配方的授权门(尚无 recipe 可绑定):要求 Agent 在该线至少有一个写向绑定
- *  (dcw 节点或已有配方),并且 line 存在;manual 线/绑定 → 人工批准。
+/** 新建配方的授权门(尚无 recipe 可绑定):要求 Agent 在该线至少有一个授权锚
+ *  (dcw 节点、已有配方,或 2026-10-28 起的产线配方管理权 kind='line-recipe'),
+ *  并且 line 存在;manual 线/绑定 → 人工批准。
  *  频道绑线是只读扩权,不能单独作为新建配方的依据(否则只读频道可凭空造配方)。 */
 export function assertRecipeCreate(agentId: string, lineId: string): { ok: true, hitlRequired: boolean } | { ok: false, text: string } {
   if (!lineId) return { ok: false, text: '新建配方需要明确产线(line_id 或 source_recipe_id 可推断)。' }
@@ -102,6 +175,14 @@ export function assertRecipeCreate(agentId: string, lineId: string): { ok: true,
   let lineBound = false
   let manualBound = false
   for (const b of bindings) {
+    if (b.kind === 'line-recipe') {
+      // 产线配方管理权:对该线全部配方(含新建)的管理授权锚
+      if (b.nodeId === lineId) {
+        lineBound = true
+        if (b.mode === 'manual') manualBound = true
+      }
+      continue
+    }
     if (b.kind === 'recipe') {
       const r = getDcwController().listRecipes().find(x => x.id === b.nodeId)
       if (r?.lineId === lineId) {
@@ -121,7 +202,7 @@ export function assertRecipeCreate(agentId: string, lineId: string): { ok: true,
   if (!lineBound) {
     return {
       ok: false,
-      text: `无权在产线 ${lineId} 新建配方:你尚未绑定该产线的任何数控节点或配方。新建配方会创建可下发的参数基线,必须由用户/lead 先给你绑定该产线的节点或配方(绑定首绑默认 manual,人工批准)。`,
+      text: `无权在产线 ${lineId} 新建配方:你尚未持有该产线的任何授权锚(数控节点绑定、配方绑定或产线配方管理权)。新建配方会创建可下发的参数基线,必须由用户/lead 先授予 —— 绑定该线节点/配方,或授予产线配方管理权(kind='line-recipe';绑定首绑默认 manual,人工批准)。`,
     }
   }
   const lineManual = getDcwLineRepo().controlModeOf(lineId) === 'manual'

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

@@ -145,9 +145,10 @@ export async function toolRecipePropose(agentId: string, args: {
   // 权限模型 v2:持有该配方绑定(kind=recipe)即算"配方内授权";兼容历史 dcw 节点绑定
   const bindings = getAgentNodeBindingRepo().byAgent(agentId)
   const boundInRecipe = bindings.some(b => b.kind === 'recipe' && b.nodeId === recipeId)
+    || bindings.some(b => b.kind === 'line-recipe' && b.nodeId === recipe.lineId)
     || bindings.some(b => b.kind === 'dcw' && recipe.params.some(p => p.nodeId === b.nodeId))
   if (!boundInRecipe) {
-    return { text: `无权提交配方 ${recipeId} 的整包方案(需持有该配方的绑定;找 lead 授予配方操作权)。`, isError: true }
+    return { text: `无权提交配方 ${recipeId} 的整包方案(需持有该配方的绑定或其产线的配方管理权;找 lead 授予)。`, isError: true }
   }
   const line = getDcwLineRepo().byId(recipe.lineId)
 

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'] },
   // 分析与经验面

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

@@ -42,6 +42,9 @@ export interface ToolRefFaces {
   agentId: string
   /** 绑定面节点:dcw+daq 绑定节点 ∪ 绑定配方参数节点 */
   boundNodes: Set<string>
+  /** 写授权面 W(a):dcw 绑定节点 ∪ 绑定配方参数节点(节点级写授权,与 recipe-gate 同口径;
+   *  daq 只读绑定与频道绑线只读扩权不进写面) */
+  writeFace: Set<string>
   /** 仅数采绑定(dcw 工具只认 dcw 绑定,读取面只认 daq 绑定——分面保留) */
   daqBoundNodes: Set<string>
   /** 绑定的配方(kind='recipe' 的绑定,nodeId 字段存 recipeId) */
@@ -54,12 +57,15 @@ export interface ToolRefFaces {
   channelLineId: string
   /** 频道绑线下的数采节点(v28 只读扩权面) */
   channelLineNodes: Set<string>
+  /** 产线配方管理权(kind='line-recipe'):lineId → 授权(2026-10-28) */
+  managedLines: Map<string, { mode: 'auto' | 'manual' }>
 }
 
 /** 解析调用者的合法引用面(只读,不缓存——绑定可在调用间隙被用户改写) */
 export function resolveRefFaces(agentId: string): ToolRefFaces {
   const bindings = getAgentNodeBindingRepo().byAgent(agentId)
   const boundNodes = new Set<string>()
+  const writeFace = new Set<string>()
   const daqBoundNodes = new Set<string>()
   const boundRecipes = new Set<string>()
   const recipeLines = new Set<string>()
@@ -72,11 +78,15 @@ export function resolveRefFaces(agentId: string): ToolRefFaces {
         recipeLines.add(r.lineId)
         readableLines.add(r.lineId)
       }
-      for (const p of (r?.params ?? [])) boundNodes.add(p.nodeId)
+      for (const p of (r?.params ?? [])) {
+        boundNodes.add(p.nodeId)
+        writeFace.add(p.nodeId)
+      }
       continue
     }
     boundNodes.add(b.nodeId)
     if (b.kind === 'daq') daqBoundNodes.add(b.nodeId)
+    else writeFace.add(b.nodeId)
     const n = b.kind === 'dcw' ? getDcwController().byId(b.nodeId) : getDaqNodeRepo().byId(b.nodeId)
     if (n?.lineId) readableLines.add(n.lineId)
   }
@@ -86,7 +96,22 @@ export function resolveRefFaces(agentId: string): ToolRefFaces {
   if (channelLineId) {
     for (const n of getDaqNodeRepo().all()) if (n.lineId === channelLineId) channelLineNodes.add(n.id)
   }
-  return { agentId, boundNodes, daqBoundNodes, boundRecipes, recipeLines, readableLines, channelLineId, channelLineNodes }
+  // 产线配方管理权:该线全部配方的参数进入写面(下发仍受「绑 dcw 即收窄」规则约束,
+  // 精确判定在 recipe-gate;预检面放宽到线配方参数,避免管理操作在预检被误拦)
+  const managedLines = new Map<string, { mode: 'auto' | 'manual' }>()
+  for (const b of bindings) {
+    if (b.kind !== 'line-recipe') continue
+    if (managedLines.has(b.nodeId)) continue
+    managedLines.set(b.nodeId, { mode: b.mode })
+    for (const r of getDcwController().listRecipes()) {
+      if (r.lineId !== b.nodeId) continue
+      for (const p of (r.params ?? [])) {
+        boundNodes.add(p.nodeId)
+        writeFace.add(p.nodeId)
+      }
+    }
+  }
+  return { agentId, boundNodes, writeFace, daqBoundNodes, boundRecipes, recipeLines, readableLines, channelLineId, channelLineNodes, managedLines }
 }
 
 // ===== 归属判定 =====
@@ -143,6 +168,20 @@ function denyNode(faces: ToolRefFaces, toolName: string, args: Record<string, un
   ], faces, hint, { param, value: id, lineId: row?.lineId })
 }
 
+/** 写面拒绝(2026-10-28):参数要写到的节点必须落在 W(a)=dcw 绑定 ∪ 绑定配方参数节点 ∪ 管理线配方参数。
+ *  比 denyNode 更明确:读得到 ≠ 写得到(频道绑线只读扩权/他配方节点都不构成写授权)。 */
+function denyWriteNode(faces: ToolRefFaces, toolName: string, args: Record<string, unknown>, param: string, id: string, exists: boolean): HostToolResult {
+  const row = exists ? nodeRow(id) : null
+  const where = row ? `(节点「${row.name}」${row.lineId ? `,归属产线 ${row.lineId}` : ''})` : '(节点不存在或已删除)'
+  const managedNote = faces.managedLines.size > 0
+    ? `你持有产线配方管理权的线:[${[...faces.managedLines.keys()].join(', ')}](仅覆盖这些线上的配方参数)。`
+    : ''
+  const hint = `该节点不在你的写授权面(节点绑定=点位写授权;配方绑定=配方操作权;产线管理权=该线配方参数)。你的可写节点:${listOf(faces.writeFace)}。${managedNote} 如需写入,请让用户或 lead 为你绑定该数控节点(dcw),或授予配方绑定/产线配方管理权。`
+  return deny(toolName, args, [
+    `工具调用被拒(写授权校验,${toolName}):参数节点「${id}」不在你的写授权面内${where}。`,
+  ], faces, hint, { param, value: id, lineId: row?.lineId })
+}
+
 function denyLine(faces: ToolRefFaces, toolName: string, args: Record<string, unknown>, param: string, id: string): HostToolResult {
   const exists = getDcwController().listLines().some(l => l.id === id)
   const hint = `你的可读产线:${listOf(faces.readableLines)}${faces.channelLineId ? `(其中「${faces.channelLineId}」来自频道绑线,只读)` : ''}。如需访问该产线,请让用户授予对应产线权限(权限管理),或把当前频道绑定到该产线;也可以改用上述可读产线重试。`
@@ -370,6 +409,16 @@ export function verifyToolReferences(agentId: string, toolName: string, args: Re
         if (!exists || !nodeAllowed(faces, id)) return denyNode(faces, toolName, args, key, id, exists)
       }
     }
+    // 写入型参数节点:必须落在写授权面 W(a)(只读面/频道绑线/他配方节点不构成写授权)。
+    // 先于 deepNodeRefs 检查:nodeAllowed 允许"绑定配方所在产线的任意节点",对写入过宽,
+    // 写面判定才是本工具真正的授权边界(拒绝文案也更能行动)。
+    for (const path of spec.writeNodeRefs ?? []) {
+      const leaf = path.split('.').pop() ?? path
+      for (const id of collectDeep(args, path)) {
+        const exists = nodeRow(id) !== null
+        if (!exists || !faces.writeFace.has(id)) return denyWriteNode(faces, toolName, args, leaf, id, exists)
+      }
+    }
     for (const path of spec.deepNodeRefs ?? []) {
       // 深路径的 param 名用于文案:取最后一段
       const leaf = path.split('.').pop() ?? path