agentworkshop 0.7.54 → 0.7.58

package/server/services/workshop/agents/industrial/dcw-judge-tools.ts

@@ -1,149 +1,160 @@
-/**
- * 判定与回滚(dcw_judge / dcw_rollback / dcw_journal)与绑定鉴权
- * (由 server/services/workshop/agents/industrial-tools.ts 按职责拆出;内容逐行原文搬运)
- */
-import type { AgentNodeBinding } from '../node-bindings.repo'
-import { agentBadgeLabel } from '../agent-badge'
-import { getAgentNodeBindingRepo } from '../node-bindings.repo'
-import { getDcwController } from '../../dcw/dcw-controller'
-import { getRecipeRollBackManager } from '../../dcw/recipe-rollback-manager'
-import { requestManualApproval } from './manual-approval'
-
-/**
- * 写向工具的统一鉴权闸门(绑定必查)。
- *
- * 背景:dcw_control / dcw_read 各自抄了一份 `repo.find(agentId, nodeId, 'dcw')` 判定,
- * 而 dcw_rollback / dcw_judge 的「接管孤儿记录」分支忘了这一步 —— 任何 agent(哪怕
- * 零绑定)都能借 record_id 或超时接管,驱动真实 PLC 执行回退。这是权限模型里的
- * **默认放行**,与 node-bindings.repo 自述的「未绑定节点一律拒绝」直接冲突。
- * 收敛为单一入口后,新增写向工具不会再漏。
- *
- * @returns 命中返回绑定对象;未命中返回可直接回给模型的拒绝文本(isError)
- */
-export function requireDcwBinding(agentId: string, nodeId: string, action: string): { binding: AgentNodeBinding } | { error: { text: string, isError: true } } {
-  const repo = getAgentNodeBindingRepo()
-  const binding = nodeId ? repo.find(agentId, nodeId, 'dcw') : undefined
-  if (binding) return { binding }
-  const mine = repo.byAgent(agentId).filter(b => b.kind === 'dcw')
-  return {
-    error: {
-      text: mine.length
-        ? `无权${action}节点 ${nodeId || '(空)'}。你有权控制的数控节点:${mine.map(b => b.nodeId).join(', ')}(可用 my_industrial_nodes 查看物理含义)。`
-        : `你尚未绑定任何数控节点,无权${action}。请在数字孪生界面绑定数控节点。`,
-      isError: true,
-    },
-  }
-}
-
-/** 工具:dcw_judge —— 对自己的优化记录落判定(keep/rollback/uncertain)。
- *  判定与执行分离:rollback 判定只入册,执行必须再调 dcw_rollback。
- *  鉴权:记录所属节点必须仍在你的 dcw 绑定内 —— 接管孤儿记录同样受此约束。 */
-export async function toolDcwJudge(agentId: string, args: { record_id?: string, verdict?: string, reason?: string }): Promise<{ text: string, isError?: boolean }> {
-  const recordId = String(args.record_id ?? '').trim()
-  const verdict = String(args.verdict ?? '').trim() as 'keep' | 'rollback' | 'uncertain'
-  const reason = String(args.reason ?? '').trim()
-  if (!recordId)
-    return { text: 'record_id 必填(优化记录 id,dcw_control 下发成功后会返回)。', isError: true }
-  if (!['keep', 'rollback', 'uncertain'].includes(verdict))
-    return { text: 'verdict 必须为 keep / rollback / uncertain。', isError: true }
-  if (!reason)
-    return { text: 'reason 必填:判定必须引用数采证据(建议先 daq_query 取窗口数据再判定)。', isError: true }
-  const rb = getRecipeRollBackManager()
-  const record = rb.recordById(recordId)
-  if (!record)
-    return { text: `优化记录 ${recordId} 不存在。`, isError: true }
-  const takeover = record.agentId !== agentId && rb.isStale(record)
-  if (record.agentId !== agentId && !takeover)
-    return { text: `记录 ${recordId} 不是你发起的优化(发起者:${record.agentId ?? '用户'}),Agent 仅可判定自己的记录;他人记录请请用户在界面判定。`, isError: true }
-  // 接管是「时间」判定,不是「权限」判定 —— 权限必须单独查绑定(早先漏了这一步)
-  const auth = requireDcwBinding(agentId, record.nodeId, '判定该记录')
-  if ('error' in auth) return auth.error
-  try {
-    const finalReason = takeover ? `[接管孤儿记录,原属主 ${record.agentId ?? '?'} 超时未判定] ${reason}` : reason
-    const updated = rb.judge(recordId, verdict, finalReason, 'agent', agentId, { takeover, actorName: agentBadgeLabel(agentId) })
-    const next = verdict === 'rollback'
-      ? '判定已入册;请立即用 dcw_rollback(record_id) 执行回退(判定不自动改 PLC)。'
-      : verdict === 'keep'
-        ? `已定档为已验证经验${updated.recipeId ? '(配方已标记 lastGood)' : ''}。`
-        : '记录保持 open,继续观察或等下次设定关闭。'
-    return { text: `判定已入册:记录 ${recordId} → ${verdict}(${reason})。${next}` }
-  }
-  catch (err) {
-    return { text: `判定失败:${err instanceof Error ? err.message : String(err)}`, isError: true }
-  }
-}
-
-/** 工具:dcw_rollback —— 执行回退(自己的记录直接执行;他人记录需用户在界面执行)。
- *  鉴权:节点必须绑定给该 agent(record_id 路径先解析出 record.nodeId);
- *  manual 模式绑定与 dcw_control 同源 —— 回退也会改 PLC,必须推请用户确认。
- *  args: record_id(回退该记录到其 from 值)或 node_id(单步撤销到最近稳定锚);to = 指定目标锚。 */
-export async function toolDcwRollback(agentId: string, args: { record_id?: string, node_id?: string, to?: string }): Promise<{ text: string, isError?: boolean }> {
-  const rb = getRecipeRollBackManager()
-  const recordId = String(args.record_id ?? '').trim()
-  const nodeId = String(args.node_id ?? '').trim()
-  const to = String(args.to ?? '').trim() || undefined
-  if (!recordId && !nodeId)
-    return { text: 'record_id 或 node_id 至少提供一个。', isError: true }
-  try {
-    // 归属解析:record_id 路径的节点来自记录本身,node_id 路径直接用入参
-    const record = recordId ? rb.recordById(recordId) : undefined
-    if (recordId && !record)
-      return { text: `优化记录 ${recordId} 不存在。`, isError: true }
-    const targetNodeId = record?.nodeId ?? nodeId
-    if (record) {
-      const takeover = record.agentId !== agentId && rb.isStale(record)
-      if (record.agentId !== agentId && !takeover)
-        return { text: `记录 ${recordId} 不是你发起的优化(发起者:${record.agentId ?? '用户'}),回退他人记录请请用户在数采中心/产线详情执行;若原属主已消失(超时未判定),可先 dcw_judge 接管后再回退。`, isError: true }
-    }
-    // 授权闸门(早先整段缺失 → 任意 agent 可回退任意节点)
-    const auth = requireDcwBinding(agentId, targetNodeId, '回退')
-    if ('error' in auth) return auth.error
-    // manual 模式:回退是真实 PLC 写入,与 dcw_control/param_control 同源推请用户批准(manual-approval)
-    if (auth.binding.mode === 'manual') {
-      const node = getDcwController().byId(targetNodeId)
-      const ap = await requestManualApproval({
-        agentId,
-        nodeId: targetNodeId,
-        action: '回退',
-        detail: `${node?.name ?? targetNodeId} 回退到${record ? `记录 ${recordId} 的 from 值` : '最近稳定锚'}${to ? `(${to})` : ''}`,
-      })
-      if (!ap.ok) return { text: ap.text, isError: ap.isError }
-    }
-    if (record) {
-      const fresh = await rb.rollbackRecord(recordId, agentId, 'agent', undefined, { actorName: agentBadgeLabel(agentId) })
-      return { text: `回退已执行:记录 ${recordId} 标记 rolled-back;下发恢复值 ${fresh?.params[0]?.to}${'(以回读为准)'};新回退记录 ${fresh?.id} 已入册。请 daq_query 复测确认恢复。` }
-    }
-    const fresh = await rb.rollbackNode(targetNodeId, agentId, 'agent', to, { actorName: agentBadgeLabel(agentId) })
-    return { text: `节点单步回退已执行:恢复到最近稳定锚值;新回退记录 ${fresh?.id} 已入册。请 daq_query 复测确认恢复。` }
-  }
-  catch (err) {
-    const msg = err instanceof Error ? err.message : String(err)
-    return { text: `回退被拒绝:${msg}(回退经与下发相同的安全门控;冷却期内禁止重复回退)`, isError: true }
-  }
-}
-
-/** 工具:dcw_journal —— 参数变更史/优化记录查询(在册审计;谁/何时/从多少到多少/判定) */
-export async function toolDcwJournal(agentId: string, args: { node_id?: string, recipe_id?: string, limit?: number | string }): Promise<{ text: string, isError?: boolean }> {
-  const rb = getRecipeRollBackManager()
-  const nodeId = String(args.node_id ?? '').trim()
-  const recipeId = String(args.recipe_id ?? '').trim()
-  const limit = Math.min(Number(args.limit) || 20, 100)
-  const repo = getAgentNodeBindingRepo()
-  const bound = new Set(repo.byAgent(agentId).map(b => b.nodeId))
-  if (nodeId && !bound.has(nodeId))
-    return { text: `无权查询节点 ${nodeId} 的账本(仅可查自己绑定的节点)。`, isError: true }
-  const records = rb.records({ nodeId: nodeId || undefined, recipeId: recipeId || undefined, limit })
-  if (records.length === 0)
-    return { text: '窗口内无优化记录(该节点/配方尚无 Agent 调控历史)。' }
-  const lines = records.map((r) => {
-    const p = r.params[0]
-    const judge = r.judge ? `${r.judge.verdict}(${r.judge.by}:${r.judge.reason.slice(0, 50)})` : '未判定'
-    const closed = r.closedAt ? `,关闭于 ${r.closedAt.slice(11, 19)}(${r.closedBy})` : ',进行中'
-    return `- ${r.id} [${r.status}] ${r.nodeName}: ${p?.from ?? '?'} → ${p?.to},设定 ${r.setAt.slice(11, 19)},判定 ${judge}${closed}${r.hypothesis ? `\n  假设: ${r.hypothesis.slice(0, 80)}` : ''}`
-  })
-  const anchors = nodeId ? rb.journal({ nodeId, limit }) : []
-  const anchorLines = anchors.slice(0, 10).map(a => `- ${a.at.slice(11, 19)} [${a.source}/${a.actor}] ${a.prevValue ?? '?'} → ${a.newValue}`)
-  return {
-    text: `优化记录(${records.length} 条,含参数/判定/窗口):\n${lines.join('\n')}${nodeId ? `\n\n参数变更锚(最近 ${anchorLines.length} 条):\n${anchorLines.join('\n')}` : ''}\n\n判定与执行分离:rollback 判定后需 dcw_rollback 执行;回退同样入册可审计。`,
-  }
-}
+/**
+ * 判定与回滚(dcw_judge / dcw_rollback / dcw_journal)与绑定鉴权
+ * (由 server/services/workshop/agents/industrial-tools.ts 按职责拆出;内容逐行原文搬运)
+ */
+import type { AgentNodeBinding } from '../node-bindings.repo'
+import { agentBadgeLabel } from '../agent-badge'
+import { getAgentNodeBindingRepo } from '../node-bindings.repo'
+import { getDcwController } from '../../dcw/dcw-controller'
+import { getRecipeRollBackManager } from '../../dcw/recipe-rollback-manager'
+import { requestManualApproval } from './manual-approval'
+
+/**
+ * 写向工具的统一鉴权闸门(绑定必查)。
+ *
+ * 背景:dcw_control / dcw_read 各自抄了一份 `repo.find(agentId, nodeId, 'dcw')` 判定,
+ * 而 dcw_rollback / dcw_judge 的「接管孤儿记录」分支忘了这一步 —— 任何 agent(哪怕
+ * 零绑定)都能借 record_id 或超时接管,驱动真实 PLC 执行回退。这是权限模型里的
+ * **默认放行**,与 node-bindings.repo 自述的「未绑定节点一律拒绝」直接冲突。
+ * 收敛为单一入口后,新增写向工具不会再漏。
+ *
+ * @returns 命中返回绑定对象;未命中返回可直接回给模型的拒绝文本(isError)
+ */
+export function requireDcwBinding(agentId: string, nodeId: string, action: string): { binding: AgentNodeBinding } | { error: { text: string, isError: true } } {
+  const repo = getAgentNodeBindingRepo()
+  const binding = nodeId ? repo.find(agentId, nodeId, 'dcw') : undefined
+  if (binding) return { binding }
+  const mine = repo.byAgent(agentId).filter(b => b.kind === 'dcw')
+  return {
+    error: {
+      text: mine.length
+        ? `无权${action}节点 ${nodeId || '(空)'}。你有权控制的数控节点:${mine.map(b => b.nodeId).join(', ')}(可用 my_industrial_nodes 查看物理含义)。`
+        : `你尚未绑定任何数控节点,无权${action}。请在数字孪生界面绑定数控节点。`,
+      isError: true,
+    },
+  }
+}
+
+/** 工具:dcw_judge —— 对自己的优化记录落判定(keep/rollback/uncertain)。
+ *  判定与执行分离:rollback 判定只入册,执行必须再调 dcw_rollback。
+ *  鉴权:记录所属节点必须仍在你的 dcw 绑定内 —— 接管孤儿记录同样受此约束。 */
+export async function toolDcwJudge(agentId: string, args: { record_id?: string, verdict?: string, reason?: string }): Promise<{ text: string, isError?: boolean }> {
+  const recordId = String(args.record_id ?? '').trim()
+  const verdict = String(args.verdict ?? '').trim() as 'keep' | 'rollback' | 'uncertain'
+  const reason = String(args.reason ?? '').trim()
+  if (!recordId)
+    return { text: 'record_id 必填(优化记录 id,opt-*,仅限既有 open 优化记录)。注意:配方面链路(recipe_trial/recipe_apply/recipe_propose,批次 rr-*)不产生优化记录 —— 那条链路的判定直接用复测数据对照假设陈述:达标用 recipe_update 固化,劣化用 recipe_rollback,不要走 dcw_judge。', isError: true }
+  if (!['keep', 'rollback', 'uncertain'].includes(verdict))
+    return { text: 'verdict 必须为 keep / rollback / uncertain。', isError: true }
+  if (!reason)
+    return { text: 'reason 必填:判定必须引用数采证据(建议先 daq_query 取窗口数据再判定)。', isError: true }
+  const rb = getRecipeRollBackManager()
+  const record = rb.recordById(recordId)
+  if (!record)
+    return { text: `优化记录 ${recordId} 不存在。若你拿到的是批次号(rr-*)或审批单号(ap-*):配方面链路不产生优化记录,判定直接用复测数据陈述(达标 recipe_update 固化 / 劣化 recipe_rollback),不走 dcw_judge。`, isError: true }
+  const takeover = record.agentId !== agentId && rb.isStale(record)
+  if (record.agentId !== agentId && !takeover)
+    return { text: `记录 ${recordId} 不是你发起的优化(发起者:${record.agentId ?? '用户'}),Agent 仅可判定自己的记录;他人记录请请用户在界面判定。`, isError: true }
+  // 接管是「时间」判定,不是「权限」判定 —— 权限必须单独查绑定(早先漏了这一步)
+  const auth = requireDcwBinding(agentId, record.nodeId, '判定该记录')
+  if ('error' in auth) return auth.error
+  try {
+    const finalReason = takeover ? `[接管孤儿记录,原属主 ${record.agentId ?? '?'} 超时未判定] ${reason}` : reason
+    const updated = rb.judge(recordId, verdict, finalReason, 'agent', agentId, { takeover, actorName: agentBadgeLabel(agentId) })
+    const next = verdict === 'rollback'
+      ? '判定已入册;请立即用 dcw_rollback(record_id) 执行回退(判定不自动改 PLC)。'
+      : verdict === 'keep'
+        ? `已定档为已验证经验${updated.recipeId ? '(配方已标记 lastGood)' : ''}。`
+        : '记录保持 open,继续观察或等下次设定关闭。'
+    return { text: `判定已入册:记录 ${recordId} → ${verdict}(${reason})。${next}` }
+  }
+  catch (err) {
+    return { text: `判定失败:${err instanceof Error ? err.message : String(err)}`, isError: true }
+  }
+}
+
+/** 工具:dcw_rollback —— 执行回退(自己的记录直接执行;他人记录需用户在界面执行)。
+ *  鉴权:节点必须绑定给该 agent(record_id 路径先解析出 record.nodeId);
+ *  manual 模式绑定与 dcw_control 同源 —— 回退也会改 PLC,必须推请用户确认。
+ *  args: record_id(回退该记录到其 from 值)或 node_id(单步撤销到最近稳定锚);to = 指定目标锚。 */
+export async function toolDcwRollback(agentId: string, args: { record_id?: string, node_id?: string, to?: string }): Promise<{ text: string, isError?: boolean }> {
+  // 权限模型 v2:节点级单点回退收敛到 recipe 面(统一回退 = recipe_rollback dispatch=true,含 PLC 整批恢复)
+  void agentId
+  void args
+  return {
+    text: '节点级回退已禁用(权限模型 v2):Agent 不直接操作数控节点。请改用 recipe_rollback(recipe_id, to_last_good=true 或 version=N, dispatch=true, reason=…)—— 统一回退会恢复配方定义并把该版本参数整批重下发(PLC/MES 恢复一体)。',
+    isError: true,
+  }
+}
+
+/** v2 前的节点级回退实现(已停用;保留供回溯,不再被任何入口调用) */
+async function _toolDcwRollbackDisabled(agentId: string, args: { record_id?: string, node_id?: string, to?: string }): Promise<{ text: string, isError?: boolean }> {
+  const rb = getRecipeRollBackManager()
+  const recordId = String(args.record_id ?? '').trim()
+  const nodeId = String(args.node_id ?? '').trim()
+  const to = String(args.to ?? '').trim() || undefined
+  if (!recordId && !nodeId)
+    return { text: 'record_id 或 node_id 至少提供一个。', isError: true }
+  try {
+    // 归属解析:record_id 路径的节点来自记录本身,node_id 路径直接用入参
+    const record = recordId ? rb.recordById(recordId) : undefined
+    if (recordId && !record)
+      return { text: `优化记录 ${recordId} 不存在。`, isError: true }
+    const targetNodeId = record?.nodeId ?? nodeId
+    if (record) {
+      const takeover = record.agentId !== agentId && rb.isStale(record)
+      if (record.agentId !== agentId && !takeover)
+        return { text: `记录 ${recordId} 不是你发起的优化(发起者:${record.agentId ?? '用户'}),回退他人记录请请用户在数采中心/产线详情执行;若原属主已消失(超时未判定),可先 dcw_judge 接管后再回退。`, isError: true }
+    }
+    // 授权闸门(早先整段缺失 → 任意 agent 可回退任意节点)
+    const auth = requireDcwBinding(agentId, targetNodeId, '回退')
+    if ('error' in auth) return auth.error
+    // manual 模式:回退是真实 PLC 写入,与 dcw_control/param_control 同源推请用户批准(manual-approval)
+    if (auth.binding.mode === 'manual') {
+      const node = getDcwController().byId(targetNodeId)
+      const ap = await requestManualApproval({
+        agentId,
+        nodeId: targetNodeId,
+        action: '回退',
+        detail: `${node?.name ?? targetNodeId} 回退到${record ? `记录 ${recordId} 的 from 值` : '最近稳定锚'}${to ? `(${to})` : ''}`,
+      })
+      if (!ap.ok) return { text: ap.text, isError: ap.isError }
+    }
+    if (record) {
+      const fresh = await rb.rollbackRecord(recordId, agentId, 'agent', undefined, { actorName: agentBadgeLabel(agentId) })
+      return { text: `回退已执行:记录 ${recordId} 标记 rolled-back;下发恢复值 ${fresh?.params[0]?.to}${'(以回读为准)'};新回退记录 ${fresh?.id} 已入册。请 daq_query 复测确认恢复。` }
+    }
+    const fresh = await rb.rollbackNode(targetNodeId, agentId, 'agent', to, { actorName: agentBadgeLabel(agentId) })
+    return { text: `节点单步回退已执行:恢复到最近稳定锚值;新回退记录 ${fresh?.id} 已入册。请 daq_query 复测确认恢复。` }
+  }
+  catch (err) {
+    const msg = err instanceof Error ? err.message : String(err)
+    return { text: `回退被拒绝:${msg}(回退经与下发相同的安全门控;冷却期内禁止重复回退)`, isError: true }
+  }
+}
+
+/** 工具:dcw_journal —— 参数变更史/优化记录查询(在册审计;谁/何时/从多少到多少/判定) */
+export async function toolDcwJournal(agentId: string, args: { node_id?: string, recipe_id?: string, limit?: number | string }): Promise<{ text: string, isError?: boolean }> {
+  const rb = getRecipeRollBackManager()
+  const nodeId = String(args.node_id ?? '').trim()
+  const recipeId = String(args.recipe_id ?? '').trim()
+  const limit = Math.min(Number(args.limit) || 20, 100)
+  const repo = getAgentNodeBindingRepo()
+  const bound = new Set(repo.byAgent(agentId).map(b => b.nodeId))
+  if (nodeId && !bound.has(nodeId))
+    return { text: `无权查询节点 ${nodeId} 的账本(仅可查自己绑定的节点)。`, isError: true }
+  const records = rb.records({ nodeId: nodeId || undefined, recipeId: recipeId || undefined, limit })
+  if (records.length === 0)
+    return { text: '窗口内无优化记录(该节点/配方尚无 Agent 调控历史)。' }
+  const lines = records.map((r) => {
+    const p = r.params[0]
+    const judge = r.judge ? `${r.judge.verdict}(${r.judge.by}:${r.judge.reason.slice(0, 50)})` : '未判定'
+    const closed = r.closedAt ? `,关闭于 ${r.closedAt.slice(11, 19)}(${r.closedBy})` : ',进行中'
+    return `- ${r.id} [${r.status}] ${r.nodeName}: ${p?.from ?? '?'} → ${p?.to},设定 ${r.setAt.slice(11, 19)},判定 ${judge}${closed}${r.hypothesis ? `\n  假设: ${r.hypothesis.slice(0, 80)}` : ''}`
+  })
+  const anchors = nodeId ? rb.journal({ nodeId, limit }) : []
+  const anchorLines = anchors.slice(0, 10).map(a => `- ${a.at.slice(11, 19)} [${a.source}/${a.actor}] ${a.prevValue ?? '?'} → ${a.newValue}`)
+  return {
+    text: `优化记录(${records.length} 条,含参数/判定/窗口):\n${lines.join('\n')}${nodeId ? `\n\n参数变更锚(最近 ${anchorLines.length} 条):\n${anchorLines.join('\n')}` : ''}\n\n判定与执行分离:rollback 判定后需 dcw_rollback 执行;回退同样入册可审计。`,
+  }
+}

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

@@ -11,7 +11,7 @@ import { getDaqNodeRepo } from '../../daq/daq-node.repo'
 import { getDcwController } from '../../dcw/dcw-controller'
 import { getRecipeRollBackManager } from '../../dcw/recipe-rollback-manager'
 import { limitsBreakdownOf } from '../../dcw/param-limits'
-import { nodeSemanticCards } from '../industrial-context'
+import { nodeSemanticCards, recipeOperationFace } from '../industrial-context'
 import { writeToleranceOf } from './param-tools'
 import { requestManualApproval } from './manual-approval'
 import { guardTwinWrite } from '../../aml/twin/write-guard'
@@ -20,14 +20,16 @@ export async function toolMyIndustrialNodes(agentId: string): Promise<{ text: st
   const repo = getAgentNodeBindingRepo()
   const bindings = repo.byAgent(agentId)
   if (bindings.length === 0) {
-    return { text: '你尚未绑定任何工业节点。请在数字孪生界面的 Agent 详情面板中绑定数控/数采节点后再调用工业工具。' }
+    return { text: '你尚未绑定任何工业对象。请让用户或 lead 为你绑定:数控/数采节点(kind=daq 观察)或配方(kind=recipe,参数写入与下发)。' }
   }
   const cards = nodeSemanticCards(agentId)
   if (cards.stale > 0) repo.removeAgentNodeStale(agentId, bindings.filter((b) => {
-    const has = b.kind === 'dcw' ? !!getDcwController().byId(b.nodeId) : !!getDaqNodeRepo().byId(b.nodeId)
+    const has = b.kind === 'dcw' ? !!getDcwController().byId(b.nodeId) : b.kind === 'daq' ? !!getDaqNodeRepo().byId(b.nodeId) : true
     return !has
   }).map(b => b.id))
-  if (!cards.text) return { text: '绑定的节点均已不存在(可能被删除),请重新绑定。' }
+  // 配方操作面(v2:绑定配方的 Agent 在此直接看到"怎么做" —— 运行状态/绑定模式/认证/参数对照)
+  const recipeFace = recipeOperationFace(agentId)
+  if (!cards.text && !recipeFace) return { text: '绑定的节点均已不存在(可能被删除),请重新绑定。' }
   const staleNote = cards.stale > 0
     ? `
 (另有 ${cards.stale} 条失效绑定已自动清理)`
@@ -52,19 +54,24 @@ export async function toolMyIndustrialNodes(agentId: string): Promise<{ text: st
   }
   const insightBlock = insights.length > 0 ? `\n\n调控闭环状态:\n${insights.join('\n')}` : ''
   return {
-    text: `${cards.text}${staleNote}${insightBlock}
+    text: `${cards.text}${staleNote}${insightBlock}${recipeFace ? `\n\n${recipeFace}` : ''}
 
 ---
 通用规则:
-1. 一个 Agent 可绑定多个节点;先读本清单理解每个节点的物理意义与操作守则,再动手。
-2. 数控下发优先用 param_control(param, value) 以**工艺参数**寻址(key 语义稳定,跨批次/换配方不变);
-   dcw_control(node_id, value) 为节点直接寻址的兼容面。设定值受四层限界联锁
-   (节点安全量程 ∩ 工艺参数基准限界 ∩ 活动产品限界 ∩ 活动配方工艺窗口)逐层收窄,
-   越界一律拒绝 —— 用户与 Agent 一体约束,无旁路。下发前/后用 param_read(param) 读 PLC 当前值取证复核(被动观测免审批)。
-3. 数据获取 daq_query(不传 node_id = 全部数采节点),支持按产线/产品/配方/时间检索;解读数据时结合语义卡的判读方法。
+1. 一个 Agent 可绑定多个节点与多个配方;先读本清单理解每个节点/配方的物理意义、下发链路与操作守则,再动手。
+2. 参数写入与下发一律走你绑定的配方(权限模型 v2,直接写节点已禁用):
+   recipe_update(recipe_id, params[{node_id,value}], reason) 保存新版本 → recipe_apply(整批下发到运行中批次)
+   或 recipe_trial(候选整批试验,不写版本);劣化用 recipe_rollback(dispatch=true) 统一回退。
+   设定值受四层限界联锁(节点安全量程 ∩ 工艺参数基准限界 ∩ 活动产品限界 ∩ 活动配方工艺窗口)逐层收窄,
+   越界一律拒绝 —— 用户与 Agent 一体约束,无旁路;底层数控节点(PLC/MES)由配置层承接,你只面对工程量。
+   配方必须正在执行(运行门),未运行时任何操作被拒。
+3. 数据获取 daq_query(不传 node_id = 全部数采节点),支持按产线/产品/配方/时间检索;解读数据时结合语义卡的判读方法;
+   MES 数据用 mes_catalog / mes_fetch(检测向量/图像帧/表格/事件全格式;统计摘要回包,原文落盘)。
+   需要完整波形(非统计摘要)做深度分析时用 daq_export:自选节点全量原始时序导出为 CSV + manifest.json
+   (节点映射/语义/产线-配方上下文);把 export_id 交 diag_run 发起深度根因诊断,或把目录绝对路径交给其他 worker 离线分析。
 4. 改动设定后等待工艺响应(热惯性/传动惯量)再评估,避免连续大幅调整。
 5. 调控闭环:每次下发自动开一条优化记录(open);观察数采后用 dcw_judge 落判定(keep/rollback/uncertain);
-   判 rollback 后用 dcw_rollback 执行回退;dcw_journal 可查节点参数变更史。未判定前再下发,旧记录会被标记 superseded。
+   判 rollback 后用 recipe_rollback(dispatch=true, reason) 统一回退;dcw_journal 可查节点参数变更史。未判定前再下发,旧记录会被标记 superseded。
    若节点被他人的 open 记录阻塞(对方已消失),超时(30 分钟)后你可接管:dcw_judge 会带接管标记入册。
 6. 自查面:line_context 看你控制的产线/产品/配方全景(动手前必读,确认归属);
    ops_log 查你负责产线的运维日志(谁/何时做了什么,来源区分 Agent/用户/系统;
@@ -72,25 +79,56 @@ export async function toolMyIndustrialNodes(agentId: string): Promise<{ text: st
    recipe_versions 查配方参数版本史(谁改的/为什么/参数 diff)。
 7. 配方操控闭环(在线优化框架):验证过参数更优 → recipe_update 保存进配方(记录你的名字与原因,
    生成新版本);发现优化有问题 → recipe_rollback 回退到稳定版本(version)或已知良好批次
-   (to_last_good=true);运行中 PLC 当前值用 dcw_control 下发,配方定义供后续批次生效。`,
+   (to_last_good=true,dispatch=true 整批恢复运行中产线)。`,
   }
 }
 
 /** 工具:dcw_control —— 数控下发(鉴权 → 停线守卫 → 手动审批 → 安全联锁 → 回读语义结果)。
  *  调控闭环:下发自动开优化记录;args.hypothesis 声明本次假设(入册),args.task_id 关联任务。 */
 export async function toolDcwControl(agentId: string, args: { node_id?: string, value?: number | string, hypothesis?: string, task_id?: string }, channelId?: string): Promise<{ text: string, isError?: boolean }> {
+  // 权限模型 v2:Agent 不直接操作数控节点 —— 参数写入与下发全部收敛到绑定的 recipe
+  // (defense in depth:工具面已摘除定义,handler 侧仍拒绝,防直连 invoke 绕行)
+  void agentId
+  void args
+  void channelId
+  return {
+    text: '直接节点写控已禁用(权限模型 v2):Agent 不再直接操作数控节点。请改用绑定的配方完成同样动作 —— recipe_update(参数写入,生成新版本)/ recipe_apply(整批下发)/ recipe_trial(候选整批试验,不写版本)/ recipe_rollback(回退);均为带理由与 HITL 的配方面操作,治理联锁(量程/步长/限速)照常生效。',
+    isError: true,
+  }
+}
+
+/**
+ * v2 前的直写实现(工具面已摘除,但**治理链完整**:四层限界/HITL/60s 联锁/journal/open 记录)。
+ * 仍允许**平台内部治理工具**复用:optimization_explore(工艺优化 Channel 的闭环探索,
+ * profile 门控)的写入委托它执行 —— Agent 可调用面依然收敛在配方面,此处非 Agent 入口。
+ */
+export async function dcwControlGovernedInternal(agentId: string, args: { node_id?: string, value?: number | string, hypothesis?: string, task_id?: string }, channelId?: string): Promise<{ text: string, isError?: boolean }> {
+  return _toolDcwControlDisabled(agentId, args, channelId)
+}
+
+/** v2 前的直写实现(已停用;保留供回溯/内部审计阅读,不再被任何入口调用) */
+async function _toolDcwControlDisabled(agentId: string, args: { node_id?: string, value?: number | string, hypothesis?: string, task_id?: string }, channelId?: string): Promise<{ text: string, isError?: boolean }> {
   const twinGuard = guardTwinWrite(agentId, channelId)
   if (!twinGuard.allowed) return { text: `${twinGuard.code}: ${twinGuard.message}`, isError: true }
   const nodeId = String(args.node_id ?? '').trim()
   const value = Number(args.value)
   const repo = getAgentNodeBindingRepo()
   const binding: AgentNodeBinding | undefined = nodeId ? repo.find(agentId, nodeId, 'dcw') : undefined
-  if (!binding) {
+  // 权限模型 v2:配方绑定(kind=recipe)覆盖其参数节点 —— 该节点在绑定配方参数内即算授权
+  let recipeAuthorized = false
+  if (!binding && nodeId) {
+    const recipes = repo.byAgent(agentId).filter(b => b.kind === 'recipe')
+    recipeAuthorized = recipes.some((b) => {
+      const r = getDcwController().listRecipes().find(x => x.id === b.nodeId)
+      return r?.params.some(p => p.nodeId === nodeId) ?? false
+    })
+  }
+  if (!binding && !recipeAuthorized) {
     const mine = repo.byAgent(agentId).filter(b => b.kind === 'dcw')
     return {
       text: mine.length
         ? `无权操作节点 ${nodeId || '(空)'}。你有权控制的数控节点:${mine.map(b => b.nodeId).join(', ')}(可用 my_industrial_nodes 查看物理含义)。`
-        : '你尚未绑定任何数控节点,无权下发控制指令。请在数字孪生界面绑定数控节点。',
+        : '你尚未绑定任何数控节点,也无含该参数的配方绑定,无权下发控制指令(权限模型 v2:持有含该参数的配方绑定即可)。',
       isError: true,
     }
   }
@@ -99,8 +137,8 @@ export async function toolDcwControl(agentId: string, args: { node_id?: string,
   }
   const node = getDcwController().byId(nodeId)
   if (!node) {
-    // 节点已被删除 → 绑定失效自清理,提示重新绑定
-    repo.removeAgentNode(agentId, nodeId, 'dcw')
+    // 节点已被删除 → 绑定失效自清理,提示重新绑定(仅 dcw 直绑;配方路径无绑定可清)
+    if (binding) repo.removeAgentNode(agentId, nodeId, 'dcw')
     return { text: `数控节点 ${nodeId} 已不存在(可能被删除),原绑定已自动清理,请重新绑定。`, isError: true }
   }
   // 停用/解绑守卫:停用节点拒绝下发(与手动/配方同源语义,给出恢复路径)
@@ -110,8 +148,9 @@ export async function toolDcwControl(agentId: string, args: { node_id?: string,
   // 停线守卫:产线未开跑时手动写允许(调试),但提示当前无配方窗口约束
   const tpl = findDcwTemplate(node.templateKey)
 
-  // 手动确认模式:与 param_control 同源审批面(manual-approval),备注会回给 Agent
-  if (binding.mode === 'manual') {
+  // 手动确认模式:与 param_control 同源审批面(manual-approval),批准附言回进回执
+  let manualFeedback = ''
+  if (binding?.mode === 'manual') {
     const bd = limitsBreakdownOf(node)
     const ap = await requestManualApproval({
       agentId,
@@ -119,6 +158,7 @@ export async function toolDcwControl(agentId: string, args: { node_id?: string,
       detail: `${node.name}(${tpl?.ch ?? node.templateKey})设定 ${value}${node.unit},有效写入区间 ${bd.effective.min}~${bd.effective.max}${node.unit}(${bd.layers.map(l => l.label).join(' ∩ ')})`,
     })
     if (!ap.ok) return { text: ap.text, isError: ap.isError }
+    manualFeedback = ap.comment ?? ''
   }
 
   try {
@@ -139,7 +179,7 @@ export async function toolDcwControl(agentId: string, args: { node_id?: string,
       // 调控闭环回包:记录 id + 上一稳定锚 + 策略提示(安全网信息,Agent 据此规划判定)
       const rb = getRecipeRollBackManager()
       const stable = rb.journal({ nodeId, limit: 10 }).find(a => a.prevValue != null && a.prevValue !== a.newValue)
-      const policyHint = binding.mode === 'manual'
+      const policyHint = binding?.mode === 'manual'
         ? '本节点为手动确认模式:判定回退将推请用户确认'
         : '本节点为自动模式:越配方监控窗将触发系统自动回退'
       const loopTxt = [
@@ -147,8 +187,15 @@ export async function toolDcwControl(agentId: string, args: { node_id?: string,
         stable ? `上一稳定锚:${stable.prevValue}${node.unit}(可 dcw_rollback 回退)` : null,
         policyHint,
       ].filter(Boolean).join(';')
+      // ACK 鉴定如实表述(2026-10-08):ok 只是命令受理 —— 回读证实与仅链路受理必须区分,
+      // 不许对无回读驱动(mqtt/http-no-echo)虚报"回读一致"。
+      const ackTxt = outcome.ack === 'readback-verified'
+        ? `回读 ${outcome.readback != null ? `${outcome.readback}${node.unit}` : '-'}一致 [设备证实✓]`
+        : outcome.ack === 'transport-ack'
+          ? '设备侧未回读证实,仅链路受理 [未证实⚠,建议 daq_query 复测]'
+          : '无确认通道 [未证实⚠]'
       return {
-        text: `下发成功:${node.name}(${tpl?.ch ?? node.templateKey})设定 ${value}${node.unit} → PLC 原始值 ${outcome.raw ?? '-'};回读 ${outcome.readback != null ? `${outcome.readback}${node.unit}` : '不支持'}一致。${winTxt}。${outcome.message}\n[调控闭环] ${loopTxt}`,
+        text: `下发受理:${node.name}(${tpl?.ch ?? node.templateKey})设定 ${value}${node.unit} → PLC 原始值 ${outcome.raw ?? '-'};${ackTxt}。${winTxt}。${outcome.message}\n[调控闭环] ${loopTxt}${manualFeedback ? `\n[人工反馈] ${manualFeedback}` : ''}`,
       }
     }
     // 失败文案带自我纠正线索:当前保持原值 + 建议动作(缩小步进/稍后重试)

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

@@ -0,0 +1,104 @@
+/**
+ * 经验采集工具(exp_collect)—— 产线 Co-Pilot「经验工程师」Channel 的采集入口(计划 §5.1)。
+ *
+ * 行为:对可见产线(节点授权线 ∪ 频道绑线,权限口径 mirror ops_log 的 agentOpsScope)
+ * 逐线执行 collectEpisodes(平台动作锚账本增量归因 + 推断动作快照 diff 入待确认队列),
+ * 返回中文文本汇报:每条平台 episode 一行(时间/节点/旧→新/来源归因/证据锚/人工意见)、
+ * 推断 pending 计数与提示、经验注册表概况。纯只读采集(不写产线,只写 exp-state)。
+ */
+import { agentOpsScope, fmtAuditAt } from './ops-tools'
+import { collectEpisodes } from '../../exp/exp-collector'
+import { getExpStateRepo } from '../../exp/exp-state.repo'
+import { getDcwController } from '../../dcw/dcw-controller'
+import { getDcwLineRepo } from '../../dcw/dcw-line.repo'
+
+/** episode 来源 → 人话标签(汇报行内归因) */
+const EXP_SOURCE_LABEL: Record<string, string> = {
+  manual: '用户',
+  agent: 'Agent',
+  recipe: '配方/系统',
+  inferred: '推断',
+}
+
+/** 经验注册表概况(按置信度计数;key 前缀 = `${lineId}:`) */
+function registrySummary(lineId: string): string {
+  const registry = getExpStateRepo().getState().registry
+  let total = 0
+  let watch = 0
+  let cand = 0
+  let stable = 0
+  for (const [key, e] of Object.entries(registry)) {
+    if (!key.startsWith(`${lineId}:`)) continue
+    total++
+    if (e.confidence === '观察') watch++
+    else if (e.confidence === '候选') cand++
+    else stable++
+  }
+  if (total === 0) return '经验注册表:暂无条目(总结入库后登记)'
+  return `经验注册表:共 ${total} 条(观察 ${watch} / 候选 ${cand} / 稳 ${stable})`
+}
+
+/** 单条平台 episode 的汇报行(时间/节点/旧→新/来源归因/证据锚/人工意见) */
+function episodeLine(e: { at: string, source: string, actor: string, params: Array<{ nodeId: string, from: number | null, to: number, unit?: string }>, anchors: string[], comments: string[] }): string {
+  const src = EXP_SOURCE_LABEL[e.source] ?? e.source
+  const changes = e.params.map((p) => {
+    const node = getDcwController().byId(p.nodeId)
+    return `${node?.name ?? p.nodeId} ${p.from ?? '?'}→${p.to}${p.unit ?? (node?.unit ?? '')}`
+  }).join(';')
+  const anchors = e.anchors.length > 0 ? ` | 锚:${e.anchors.join(',')}` : ''
+  const comments = e.comments.length > 0 ? ` | 人工意见:${e.comments.join(' / ')}` : ''
+  return `- [${fmtAuditAt(e.at)}] ${changes} | 来源=${src} 操作者=${e.actor || '—'}${anchors}${comments}`
+}
+
+/** 工具:exp_collect —— 采集产线经验动作(平台动作归因 + 推断动作待确认;重复调用幂等)。 */
+export async function toolExpCollect(agentId: string, args: {
+  line_id?: string
+  lineId?: string
+} = {}): Promise<{ text: string, isError?: boolean }> {
+  const scope = agentOpsScope(agentId)
+  if (!scope) return { text: '你尚未绑定任何工业节点,所在频道也未绑定产线,无可采集的产线(采集权限跟随节点绑定或频道绑线)。', isError: true }
+  const readable = [...new Set([...scope.lineIds, ...scope.boundLineIds])]
+  const wanted = String(args.line_id ?? args.lineId ?? '').trim()
+  if (wanted && !readable.includes(wanted)) {
+    return { text: `无权采集产线 ${wanted}(你的可读产线:${readable.join(', ') || '(无)'})。`, isError: true }
+  }
+  const lineIds = wanted ? [wanted] : readable
+  if (lineIds.length === 0) return { text: '没有可采集的产线(绑定的节点均未挂线)。' }
+
+  const sections: string[] = []
+  let totalEpisodes = 0
+  let totalPending = 0
+  for (const lid of lineIds) {
+    const line = getDcwLineRepo().byId(lid)
+    try {
+      const { episodes, confirmations } = await collectEpisodes(lid)
+      totalEpisodes += episodes.length
+      totalPending += confirmations.pending
+      const parts: string[] = [`■ 产线 ${line?.name ?? lid}(${lid})`]
+      if (episodes.length === 0) {
+        parts.push('  平台动作:无新增(水位内无未消费的锚写入)')
+      }
+      else {
+        parts.push(`  平台动作 ${episodes.length} 条(已入账,待总结):`)
+        for (const e of episodes) parts.push(`  ${episodeLine(e)}`)
+      }
+      // 待总结作业队列:含历史入账的平台 episode 与"人工已确认转正"的推断 episode
+      // ——学习 Channel 的总结对象以本队列为准(本轮新增只在首轮出现,确认转正发生在轮间)
+      const workQueue = getExpStateRepo().listEpisodes({ lineId: lid, status: 'pending' })
+      const inferredReady = workQueue.filter(e => e.kind === 'inferred')
+      if (inferredReady.length > 0) {
+        parts.push(`  已确认的推断动作 ${inferredReady.length} 条(已入账,待总结):`)
+        for (const e of inferredReady) parts.push(`  ${episodeLine(e)} | 推断(人类已确认)`)
+      }
+      parts.push(`  推断动作:本轮新增 ${confirmations.added} 条待确认,累计 ${confirmations.pending} 条 —— 推断动作待人类在产线页确认后才会进入总结。`)
+      parts.push(`  ${registrySummary(lid)}`)
+      sections.push(parts.join('\n'))
+    }
+    catch (err) {
+      sections.push(`■ 产线 ${line?.name ?? lid}(${lid})\n  采集失败:${err instanceof Error ? err.message : String(err)}(本线跳过,不阻塞其他产线)`)
+    }
+  }
+  return {
+    text: `经验采集完成(可读产线 ${lineIds.length} 条,新增 episode ${totalEpisodes} 条,待确认累计 ${totalPending} 条):\n\n${sections.join('\n\n')}\n\n说明:平台动作=平台有写入留痕的变更(锚账本证据 + audit_log 来源归因 + 人工裁决意见),可直接构造「情境→动作→效果」三元组;推断动作=SET 变化且时间窗内平台无写入(疑似现场本地调整),仅入待确认队列,未经人工确认不会进入经验总结(铁律)。采集幂等:水位与哈希双剔重,重复调用不产生重复 episode;经验总结入库后用 markEpisode 推进状态(pending→summarized→done)。`,
+  }
+}