agentworkshop 0.7.52 → 0.7.54

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

@@ -11,16 +11,33 @@ import { getDcwLineRepo } from '../../dcw/dcw-line.repo'
 import { getDcwProductRepo } from '../../dcw/dcw-product.repo'
 import { getDcwRecipeRepo } from '../../dcw/dcw-recipe.repo'
 import { getOps } from '../../ops/ops'
+import { settingOf } from '../../settings'
 import { fanoutQuery, windowOf } from './audit-query'
 
 // ================================================================
 // 运维日志 / Recipe 变更史查询(Agent 自查面:负责产线 scoped)
 // ================================================================
 
-/** Agent 负责范围 = 绑定节点的全集(节点 id 集 + 这些节点所属产线集);无绑定 = 无范围 */
-export function agentOpsScope(agentId: string): { lineIds: string[], nodeIds: Set<string> } | null {
+/** v18:频道绑定产线(只读扩权)——经全局 manager 读;manager 未装配/未绑定 = null */
+function channelBoundLineId(agentId: string): string | null {
+  try {
+    const g = globalThis as typeof globalThis & {
+      __workshopManager?: { channelLineBindingOf(id: string): string | null }
+    }
+    return g.__workshopManager?.channelLineBindingOf(agentId) ?? null
+  }
+  catch {
+    return null
+  }
+}
+
+/** Agent 负责范围 = 绑定节点的全集(节点 id 集 + 这些节点所属产线集;写权限依据)
+ *  ∪ 频道绑定产线(boundLineIds;v18 只读扩权:日志/配方史/上下文可读,写仍走节点授权)。 */
+export function agentOpsScope(agentId: string): { lineIds: string[], nodeIds: Set<string>, boundLineIds: string[] } | null {
   const bindings = getAgentNodeBindingRepo().byAgent(agentId)
-  if (bindings.length === 0) return null
+  const boundLine = channelBoundLineId(agentId)
+  const boundLineIds = boundLine ? [boundLine] : []
+  if (bindings.length === 0 && boundLineIds.length === 0) return null
   const lineIds = new Set<string>()
   const nodeIds = new Set<string>()
   for (const b of bindings) {
@@ -31,7 +48,17 @@ export function agentOpsScope(agentId: string): { lineIds: string[], nodeIds: Se
     }
     catch { /* 节点刚被删等情况忽略 */ }
   }
-  return { lineIds: [...lineIds], nodeIds }
+  return { lineIds: [...lineIds], nodeIds, boundLineIds }
+}
+
+/** 读工具的可见产线全集 = 节点授权线 ∪ 频道绑定线(去重) */
+function readableLineIds(scope: { lineIds: string[], boundLineIds: string[] }): string[] {
+  return [...new Set([...scope.lineIds, ...scope.boundLineIds])]
+}
+
+/** 产线展示标注:仅频道绑定(非节点授权)的线标注只读来源 */
+function lineTag(lid: string, scope: { lineIds: string[], boundLineIds: string[] }): string {
+  return scope.lineIds.includes(lid) ? '' : '(频道绑定,只读)'
 }
 
 /** 配方参数的节点失效态(数据一致性展示/Agent 提示共用):null=正常 */
@@ -63,19 +90,20 @@ export async function toolOpsLog(agentId: string, args: {
   const audit = getOps()?.audit
   if (!audit) return { text: '审计仓储未装配(服务未就绪),请稍后重试。', isError: true }
   const scope = agentOpsScope(agentId)
-  if (!scope) return { text: '你尚未绑定任何工业节点,无日志可查(日志权限跟随节点绑定)。', isError: true }
+  if (!scope) return { text: '你尚未绑定任何工业节点,所在频道也未绑定产线,无日志可查(日志权限跟随节点绑定或频道绑线)。', isError: true }
   const nodeId = String(args.node_id ?? '').trim()
   const lineId = String(args.line_id ?? '').trim()
+  const readable = readableLineIds(scope)
   if (nodeId && !scope.nodeIds.has(nodeId))
     return { text: `无权查询节点 ${nodeId} 的日志(仅可查自己绑定的节点;用 my_industrial_nodes 查看绑定)。`, isError: true }
-  if (lineId && !scope.lineIds.includes(lineId))
-    return { text: `无权查询产线 ${lineId} 的日志(你的负责产线:${scope.lineIds.join(', ') || '(绑定节点均未分配产线)'})。`, isError: true }
+  if (lineId && !readable.includes(lineId))
+    return { text: `无权查询产线 ${lineId} 的日志(你的可读产线:${readable.join(', ') || '(无)'})。`, isError: true }
   const kind = String(args.kind ?? '').trim() || undefined
   const actorKind = String(args.actor_kind ?? '').trim() || undefined
   const mine = args.mine === true || args.mine === 'true'
   const { minutes, limit, from } = windowOf(args)
 
-  const lines = lineId ? [lineId] : scope.lineIds
+  const lines = lineId ? [lineId] : readable
   let rows = fanoutQuery(audit, lines, lid => ({ lineId: lid, kind, actorKind, actor: mine ? agentId : undefined, from, limit }))
   if (nodeId) rows = rows.filter(r => r.targetId === nodeId)
   rows.sort((a, b) => String(b.at).localeCompare(String(a.at)))
@@ -86,7 +114,7 @@ export async function toolOpsLog(agentId: string, args: {
     const src = OPS_ACTOR_LABEL[String(r.actorKind)] ?? String(r.actorKind)
     return `- [${fmtAuditAt(String(r.at))}] 来源=${src} 操作者=${String(r.actorName) || String(r.actor)} | ${String(r.action)} | ${String(r.summary)}`
   })
-  const scopeNote = lineId ? `产线 ${lineId}` : `负责产线 ${scope.lineIds.length} 条`
+  const scopeNote = lineId ? `产线 ${lineId}` : `可读产线 ${readable.length} 条`
   return {
     text: `运维日志(${scopeNote},近 ${minutes} 分钟,${rows.length} 条,新→旧):\n${body.join('\n')}\n\n说明:来源=Agent 的操作者格式为「Channel名/成员名」;需要节点级参数值变更史用 dcw_journal,配方下发/回退专门视图用 recipe_log。`,
   }
@@ -103,14 +131,15 @@ export async function toolRecipeLog(agentId: string, args: {
   const audit = getOps()?.audit
   if (!audit) return { text: '审计仓储未装配(服务未就绪),请稍后重试。', isError: true }
   const scope = agentOpsScope(agentId)
-  if (!scope) return { text: '你尚未绑定任何工业节点,无 Recipe 历史可查(权限跟随节点绑定)。', isError: true }
+  if (!scope) return { text: '你尚未绑定任何工业节点,所在频道也未绑定产线,无 Recipe 历史可查(权限跟随节点绑定或频道绑线)。', isError: true }
   const lineId = String(args.line_id ?? '').trim()
-  if (lineId && !scope.lineIds.includes(lineId))
-    return { text: `无权查询产线 ${lineId} 的 Recipe 历史(你的负责产线:${scope.lineIds.join(', ') || '(无)'})。`, isError: true }
+  const readable = readableLineIds(scope)
+  if (lineId && !readable.includes(lineId))
+    return { text: `无权查询产线 ${lineId} 的 Recipe 历史(你的可读产线:${readable.join(', ') || '(无)'})。`, isError: true }
   const recipeId = String(args.recipe_id ?? '').trim() || undefined
   const { minutes, limit, from } = windowOf(args)
 
-  const lines = lineId ? [lineId] : scope.lineIds
+  const lines = lineId ? [lineId] : readable
   const rows = fanoutQuery(audit, lines, lid => [
     { lineId: lid, kind: 'recipe', recipeId, from, limit },
     { lineId: lid, kind: 'rollback', recipeId, from, limit },
@@ -131,9 +160,8 @@ export async function toolRecipeLog(agentId: string, args: {
             : action
     return `- [${fmtAuditAt(String(r.at))}] ${tag} 来源=${src} 操作者=${String(r.actorName) || String(r.actor)} | ${String(r.summary)}${r.recipeId ? `(配方 ${String(r.recipeId).slice(0, 8)})` : ''}`
   })
-  return {
-    text: `Recipe 变更史(${lineId ? `产线 ${lineId}` : `负责产线 ${scope.lineIds.length} 条`},近 ${minutes} 分钟,${rows.length} 条,新→旧):\n${body.join('\n')}\n\n说明:配方下发=整批参数写命令;优化开窗=单次设定变更(含 Agent 假设);回退执行=已恢复基线值。节点级参数值逐笔历史用 dcw_journal(node_id)。`,
-  }
+  const text = `Recipe 变更史(${lineId ? `产线 ${lineId}` : `可读产线 ${readable.length} 条`},近 ${minutes} 分钟,${rows.length} 条,新→旧):\n${body.join('\n')}\n\n说明:配方下发=整批参数写命令;优化开窗=单次设定变更(含 Agent 假设);回退执行=已恢复基线值。节点级参数值逐笔历史用 dcw_journal(node_id)。`
+  return { text }
 }
 
 // ================================================================
@@ -145,11 +173,12 @@ export async function toolRecipeLog(agentId: string, args: {
  *  配方目标 vs PLC 当前值对照、lastGood 批次。 */
 export async function toolLineContext(agentId: string, args: { line_id?: string } = {}): Promise<{ text: string, isError?: boolean }> {
   const scope = agentOpsScope(agentId)
-  if (!scope) return { text: '你尚未绑定任何工业节点,暂无产线上下文(请先在数字孪生界面绑定节点)。' }
+  if (!scope) return { text: '你尚未绑定任何工业节点,所在频道也未绑定产线,暂无产线上下文(可在频道设置绑定产线获得只读上下文,或在数字孪生界面绑定节点)。' }
   const wanted = String(args.line_id ?? '').trim()
-  const lineIds = wanted ? [wanted] : scope.lineIds
-  if (wanted && !scope.lineIds.includes(wanted)) {
-    return { text: `产线 ${wanted} 不在你的负责范围(你绑定节点覆盖的产线:${scope.lineIds.join(', ') || '无'})。`, isError: true }
+  const readable = readableLineIds(scope)
+  const lineIds = wanted ? [wanted] : readable
+  if (wanted && !readable.includes(wanted)) {
+    return { text: `产线 ${wanted} 不在你的可读范围(节点授权与频道绑定覆盖:${readable.join(', ') || '无'})。`, isError: true }
   }
   if (lineIds.length === 0) return { text: '你绑定的节点均未分配产线(未挂线的节点没有产线/产品/配方上下文)。' }
 
@@ -159,7 +188,7 @@ export async function toolLineContext(agentId: string, args: { line_id?: string
     const run = getActiveLineRun(lid)
     const recipe = run?.recipeId ? getDcwController().listRecipes().find(r => r.id === run.recipeId) : undefined
     const parts: string[] = []
-    parts.push(`■ 产线 ${line?.name ?? lid}(${lid})· 状态:${run ? '运行中' : '待机/停线'}`)
+    parts.push(`■ 产线 ${line?.name ?? lid}(${lid})${lineTag(lid, scope)} · 状态:${run ? '运行中' : '待机/停线'}`)
     if (run) {
       parts.push(`  活动批次 ${run.runId.slice(0, 8)} · 产品「${run.productName}」(${run.productId}) · 开跑 ${run.startedAt.slice(11, 19)} · 已打标 ${run.taggedSamples} 样本`)
     }
@@ -210,7 +239,7 @@ export async function toolLineContext(agentId: string, args: { line_id?: string
     sections.push(parts.join('\n'))
   }
   return {
-    text: `你控制的产线全景(${sections.length} 条):\n\n${sections.join('\n\n')}\n\n说明:配方目标=开跑批次冻结的工艺窗口;PLC 当前值=实时读数。把验证过的最佳参数固化到配方用 recipe_update;回退配方到稳定版本用 recipe_rollback;逐节点参数变更史用 dcw_journal;配方版本史用 recipe_versions。`,
+    text: `你控制的产线全景(${sections.length} 条):\n\n${sections.join('\n\n')}\n\n说明:配方目标=开跑批次冻结的工艺窗口;PLC 当前值=实时读数;(频道绑定,只读)= 该线来自频道绑定的只读授权,可看日志/配方/状态,参数下发仍需节点授权。把验证过的最佳参数固化到配方用 recipe_update;回退配方到稳定版本用 recipe_rollback;逐节点参数变更史用 dcw_journal;配方版本史用 recipe_versions。`,
   }
 }
 
@@ -221,9 +250,11 @@ export async function toolRecipeVersions(agentId: string, args: { recipe_id?: st
   if (!recipeId) return { text: 'recipe_id 必填(line_context 可看到当前配方的 id)。', isError: true }
   const recipe = getDcwController().listRecipes().find(r => r.id === recipeId)
   if (!recipe) return { text: `配方 ${recipeId} 不存在。`, isError: true }
+  // 只读面:节点授权线 ∪ 频道绑定线均可看版本史(回退走 toolRecipeRollback 的写门)
   const scope = agentOpsScope(agentId)
-  if (!scope || !recipe.lineId || !scope.lineIds.includes(recipe.lineId)) {
-    return { text: `无权查看配方 ${recipeId} 的版本史(该配方不在你负责的产线上)。`, isError: true }
+  const readable = scope ? readableLineIds(scope) : []
+  if (!recipe.lineId || !readable.includes(recipe.lineId)) {
+    return { text: `无权查看配方 ${recipeId} 的版本史(该配方不在你可读的产线上)。`, isError: true }
   }
   const rows = getDcwController().recipeVersions(recipeId)
   const limit = Math.min(Number(args.limit) || 20, 50)
@@ -294,12 +325,18 @@ export async function toolRecipeUpdate(agentId: string, args: {
     })
     .map((p) => {
       const patch = list.find(x => String(x.node_id).trim() === p.nodeId)
-      if (!patch) return { nodeId: p.nodeId, templateRef: p.templateRef, value: p.value, min: p.min, max: p.max }
-      const out: { nodeId: string, templateRef?: string, value: number, min?: number, max?: number } = { nodeId: p.nodeId, templateRef: p.templateRef, value: Number(patch.value) }
+      // stepLimit 必须随行携带:丢了会被 normParams 视为"参数有变化"(同值也空转增版),
+      // 且配方层单步限幅被静默抹掉(退化为参数/节点层默认)——治理数据完整性
+      const out: { nodeId: string, templateRef?: string, value: number, min?: number, max?: number, stepLimit?: number } = {
+        nodeId: p.nodeId,
+        templateRef: p.templateRef,
+        value: patch ? Number(patch.value) : p.value,
+      }
       if (p.min != null) out.min = p.min
-      if (patch.min != null && Number.isFinite(Number(patch.min))) out.min = Number(patch.min)
+      if (patch?.min != null && Number.isFinite(Number(patch.min))) out.min = Number(patch.min)
       if (p.max != null) out.max = p.max
-      if (patch.max != null && Number.isFinite(Number(patch.max))) out.max = Number(patch.max)
+      if (patch?.max != null && Number.isFinite(Number(patch.max))) out.max = Number(patch.max)
+      if (p.stepLimit != null) out.stepLimit = p.stepLimit
       return out
     })
   const extra = list.filter(p => !recipe.params.some(x => x.nodeId === String(p.node_id).trim()))
@@ -327,16 +364,19 @@ export async function toolRecipeUpdate(agentId: string, args: {
 }
 
 /** 工具:recipe_rollback —— 回退配方参数到稳定版本(指定历史版本或已知良好批次快照)。
- *  生成新版本(非破坏,历史保留);不改运行中 PLC 当前值。 */
+ *  生成新版本(非破坏,历史保留);不改运行中 PLC 当前值。
+ *  v19 dispatch=true = **统一回退**:定义回退 + 该版本参数整批重下发到 PLC(批次级恢复)。 */
 export async function toolRecipeRollback(agentId: string, args: {
   recipe_id?: string
   version?: number | string
   to_last_good?: boolean | string
+  dispatch?: boolean | string
   reason?: string
 }): Promise<{ text: string, isError?: boolean }> {
   const recipeId = String(args.recipe_id ?? '').trim()
   const reason = String(args.reason ?? '').trim()
   const toLastGood = args.to_last_good === true || args.to_last_good === 'true'
+  const dispatch = args.dispatch === true || args.dispatch === 'true'
   const version = Number(args.version)
   if (!recipeId) return { text: 'recipe_id 必填。', isError: true }
   if (!reason) return { text: 'reason 必填:回退必须说明原因(如优化翻车/越限),便于版本史追溯。', isError: true }
@@ -351,6 +391,23 @@ export async function toolRecipeRollback(agentId: string, args: {
     return { text: `不能回退到 v${version}(当前已是 v${recipe.version ?? 1};回退目标是更早的版本)。`, isError: true }
   }
   try {
+    if (dispatch) {
+      const { recipe: updated, run, definitionNoop } = await getDcwController().rollbackRecipeAndDispatch(recipeId, {
+        version: toLastGood ? undefined : version,
+        toLastGood,
+        by: 'agent',
+        actorName: agentBadgeLabel(agentId),
+        actor: agentId,
+        description: reason,
+      })
+      const okN = run.results.filter(r => r.ok).length
+      const defNote = definitionNoop
+        ? `定义已在目标版本 v${updated.version ?? 1}(未生成新版本)`
+        : `已生成 v${updated.version ?? 1}`
+      return {
+        text: `统一回退完成:配方「${updated.name}」${defNote},参数恢复为目标版本(${toLastGood ? '已知良好批次冻结' : `v${version}`}),并已整批重下发到 PLC(${okN}/${run.results.length} 参数成功);原因:${reason}。\n用 daq_query 复测确认恢复效果;版本史用 recipe_versions 复核。`,
+      }
+    }
     const updated = getDcwController().revertRecipe(recipeId, {
       version: toLastGood ? undefined : version,
       toLastGood,
@@ -361,10 +418,166 @@ export async function toolRecipeRollback(agentId: string, args: {
       description: reason,
     })
     return {
-      text: `回退完成:配方「${updated.name}」已生成 v${updated.version ?? 1},参数恢复为目标版本(${toLastGood ? '已知良好批次冻结' : `v${version}`});原因:${reason}。\n运行中批次不受影响(仍按开跑冻结参数);新参数下次开跑生效。版本史用 recipe_versions 复核。`,
+      text: `回退完成:配方「${updated.name}」已生成 v${updated.version ?? 1},参数恢复为目标版本(${toLastGood ? '已知良好批次冻结' : `v${version}`});原因:${reason}。\n注意:仅回退了配方定义,运行中 PLC 未变动;要把恢复参数写入产线(统一回退),用 recipe_rollback 并带 dispatch=true。版本史用 recipe_versions 复核。`,
     }
   }
   catch (err) {
     return { text: `回退失败:${err instanceof Error ? err.message : String(err)}`, isError: true }
   }
 }
+
+/**
+ * v19.5 HITL 下发裁决门:security.recipeDispatchApproval 开启时,配方下发动作
+ * 不直接执行 —— 挂起等待人工裁决(复用 ToolApprovalService,人类批/拒理由原样回流):
+ *   批准       → 按原逻辑执行下发,回执附人工附言;
+ *   拒绝(可附指导)→ 工具回包携带人工指导文本,Agent 按指导修订候选后重新提交 ——
+ *   即"改好配方交给人类判断是否下发;不下发则人告诉 Agent 怎么修"的真实作业语义。
+ * 超时(默认 180s,security.hitl_timeout_ms)自动按拒绝收敛。
+ */
+async function hitlDispatchGate(agentId: string, detail: string, title: string): Promise<{ approved: boolean, comment: string }> {
+  const { getToolApprovals } = await import('../tool-approvals')
+  const decision = await getToolApprovals().request(agentId, 'recipe-dispatch', 'dcw', detail, { title })
+  return { approved: decision.approved, comment: decision.comment }
+}
+
+/** 工具:recipe_trial —— 多参数候选整批试验下发(v19 配方链路核心)。
+ *  候选值只覆盖列出节点(**必须是自己绑定的数控节点**);整批一次落产线,**不写配方版本** ——
+ *  复测判读:有进步/达标 → recipe_update 固化(同 id 版本+1);劣化 → recipe_rollback(dispatch=true) 统一回退。
+ *  受同线试验节拍卡控(默认 ≥5 分钟,防连发震荡);四层限界(量程∩参数∩产品)照常拦截。 */
+export async function toolRecipeTrial(agentId: string, args: {
+  recipe_id?: string
+  params?: Array<{ node_id?: string, value?: number | string }>
+  hypothesis?: string
+}): Promise<{ text: string, isError?: boolean }> {
+  const recipeId = String(args.recipe_id ?? '').trim()
+  const hypothesis = String(args.hypothesis ?? '').trim()
+  if (!recipeId) return { text: 'recipe_id 必填(line_context 可看到当前配方 id)。', isError: true }
+  if (!hypothesis) return { text: 'hypothesis 必填:试验必须声明依据(知识库条目/数据分析结论),便于审计追溯。', isError: true }
+  const list = (args.params ?? []).filter(p => p && String(p.node_id ?? '').trim() && Number.isFinite(Number(p.value)))
+    .map(p => ({ nodeId: String(p.node_id).trim(), value: Number(p.value) }))
+  if (list.length === 0) return { text: 'params 至少提供一条 {node_id, value}(value 必须为数字);试验的意义就是多参数一次整批改动。', isError: true }
+  const recipe = getDcwController().listRecipes().find(r => r.id === recipeId)
+  if (!recipe) return { text: `配方 ${recipeId} 不存在。`, isError: true }
+  const repo = getAgentNodeBindingRepo()
+  for (const p of list) {
+    const node = getDcwController().byId(p.nodeId)
+    if (!node) return { text: `节点 ${p.nodeId} 已删除,不能纳入试验。`, isError: true }
+    if (node.lineId !== recipe.lineId) return { text: `节点「${node.name}」不在配方「${recipe.name}」所在产线,不可混入试验。`, isError: true }
+    if (!node.enabled) return { text: `节点「${node.name}」已停用,试验被拒。`, isError: true }
+    if (!repo.find(agentId, p.nodeId, 'dcw')) {
+      return { text: `无权试验节点「${node.name}」(仅可改自己绑定的数控节点;缺授权找 lead 用 team_grant_nodes 授予)。`, isError: true }
+    }
+  }
+  try {
+    // v19.5 HITL 门:开启人工审批时,整批试验前先挂起等人工裁决(拒绝附指导 → 回给 Agent 修订)
+    let hitlNote = ''
+    if (settingOf('security.recipeDispatchApproval') === true) {
+      const gate = await hitlDispatchGate(
+        agentId,
+        `配方试验候选(整批 ${list.length} 参数):${list.map((p) => {
+          const node = getDcwController().byId(p.nodeId)
+          const old = recipe.params.find(x => x.nodeId === p.nodeId)?.value
+          return `${node?.name ?? p.nodeId} ${old ?? '?'}→${p.value}${node?.unit ?? ''}`
+        }).join(';')} | 假设:${hypothesis} | 批准=整批下发试验(不写版本);拒绝可附指导`,
+        '配方试验(整批候选)下发审批',
+      )
+      if (!gate.approved) {
+        return {
+          text: `人工未批准本次试验下发。人工指导:${gate.comment || '(无附言,仅不同意候选)'}。请按人工指导修订候选参数(必要时先 recipe_update 调整基线),然后重新提交 recipe_trial。`,
+        }
+      }
+      // 人工附言随批准回执回流(Agent 与审计都能看到放行时人的原话)
+      if (gate.comment) hitlNote = `\n人工附言:${gate.comment}`
+    }
+    const run = await getDcwController().applyRecipe(recipeId, { overrides: list, trial: true })
+    const okN = run.results.filter(r => r.ok).length
+    // 批次级留痕:试验动作入审计(逐参数写已有 write-audit;这里是"一次试验"粒度)
+    try {
+      const { recordOps } = await import('../../ops/ops')
+      recordOps({
+        actor: agentId, actorName: agentBadgeLabel(agentId), actorKind: 'agent',
+        action: 'recipe.trial', kind: 'recipe', targetKind: 'recipe', targetId: recipeId, recipeId, lineId: recipe.lineId,
+        summary: `配方试验整批下发(${okN}/${run.results.length} 成功,批次 ${run.id.slice(0, 8)}):${list.map(p => `${p.nodeId.slice(0, 8)}→${p.value}`).join(';')} | 假设:${hypothesis}`,
+      })
+    }
+    catch { /* 审计失败不影响试验结果 */ }
+    const changed = run.results.map((r) => {
+      const node = r.nodeId ? getDcwController().byId(r.nodeId) : undefined
+      const reason = r.ok ? '' : `(${String(r.message).slice(0, 60)})`
+      return `${node?.name ?? r.templateRef}→${r.value}${node?.unit ?? ''}${r.ok ? '' : ` 被拒${reason}`}`
+    }).join(';')
+    return {
+      text: `试验已整批下发(${okN}/${run.results.length} 成功,批次 ${run.id.slice(0, 8)}):${changed}。假设:${hypothesis}。${hitlNote}注意:本次试验**未写入配方版本** —— 等待工艺惯性后 daq_query 复测判读:有进步/达标 → recipe_update 把候选值固化进配方(同 id 版本+1);无进步/劣化 → recipe_rollback(recipe_id, dispatch=true, reason=…) 统一回退(定义回退+PLC 整批恢复)。`,
+    }
+  }
+  catch (err) {
+    return { text: `试验下发失败:${err instanceof Error ? err.message : String(err)}`, isError: true }
+  }
+}
+
+/** 工具:recipe_apply —— 把配方当前已固化参数整批下发到产线(改配方(recipe_update)之后用)。
+ *  与 recipe_trial 的区别:apply 下发的是**已固化版本**(无候选覆盖),用于"改配方 → 配方下发"链路的正式下发。 */
+export async function toolRecipeApply(agentId: string, args: {
+  recipe_id?: string
+  reason?: string
+}): Promise<{ text: string, isError?: boolean }> {
+  const recipeId = String(args.recipe_id ?? '').trim()
+  if (!recipeId) return { text: 'recipe_id 必填(line_context 可看到当前配方 id)。', isError: true }
+  const recipe = getDcwController().listRecipes().find(r => r.id === recipeId)
+  if (!recipe) return { text: `配方 ${recipeId} 不存在。`, isError: true }
+  const scope = agentOpsScope(agentId)
+  if (!scope || !recipe.lineId || !scope.lineIds.includes(recipe.lineId)) {
+    return { text: `无权下发配方 ${recipeId}(该配方不在你负责的产线上)。`, isError: true }
+  }
+  const boundInRecipe = getAgentNodeBindingRepo().byAgent(agentId)
+    .some(b => b.kind === 'dcw' && recipe.params.some(p => p.nodeId === b.nodeId))
+  if (!boundInRecipe) {
+    return { text: `无权下发配方 ${recipeId}(需持有该配方至少一个数控节点的授权;找 lead 用 team_grant_nodes 授予)。`, isError: true }
+  }
+  try {
+    // v19.5 HITL 门:开启人工审批时,正式下发前先挂起等人工裁决(拒绝附指导 → 回给 Agent 修订)
+    let hitlNote = ''
+    if (settingOf('security.recipeDispatchApproval') === true) {
+      const gate = await hitlDispatchGate(
+        agentId,
+        `配方正式下发:「${recipe.name}」v${recipe.version ?? 1} 全参数整批(${recipe.params.length} 项):${recipe.params.map((p) => {
+          const node = getDcwController().byId(p.nodeId)
+          return `${node?.name ?? p.nodeId}=${p.value}${node?.unit ?? ''}`
+        }).join(';')} | 批准=整批下发到 PLC;拒绝可附指导`,
+        '配方下发审批',
+      )
+      if (!gate.approved) {
+        return {
+          text: `人工未批准本次配方下发。人工指导:${gate.comment || '(无附言)'}。请按人工指导修订配方(recipe_update)后重新提交 recipe_apply。`,
+        }
+      }
+      // 人工附言随批准回执回流(与 recipe_trial 同口径)
+      if (gate.comment) hitlNote = `\n人工附言:${gate.comment}`
+    }
+    const run = await getDcwController().applyRecipe(recipeId)
+    const okN = run.results.filter(r => r.ok).length
+    // 逐参数标注:被跳过/失败的参数(节点停用/已删除/限界拒绝)必须透出给 Agent,
+    // 否则回包只见 N/N 成功数,无法定位哪些参数未生效(与 recipe_trial 的逐参数渲染同口径)。
+    const skipped = run.results.filter(r => !r.ok)
+      .map((r) => {
+        const node = r.nodeId ? getDcwController().byId(r.nodeId) : undefined
+        return `${node?.name ?? r.templateRef ?? r.nodeId ?? '?'}: ${String(r.message).slice(0, 80)}`
+      })
+    const skippedNote = skipped.length > 0 ? `\n未生效参数(${skipped.length}):\n  - ${skipped.join('\n  - ')}` : ''
+    try {
+      const { recordOps } = await import('../../ops/ops')
+      recordOps({
+        actor: agentId, actorName: agentBadgeLabel(agentId), actorKind: 'agent',
+        action: 'recipe.apply', kind: 'recipe', targetKind: 'recipe', targetId: recipeId, recipeId, lineId: recipe.lineId,
+        summary: `Agent 整批下发配方 v${recipe.version ?? 1}(${okN}/${run.results.length} 参数成功,批次 ${run.id.slice(0, 8)})${args.reason ? ` | 原因:${String(args.reason).trim()}` : ''}`,
+      })
+    }
+    catch { /* 审计失败不影响下发结果 */ }
+    return {
+      text: `配方「${recipe.name}」v${recipe.version ?? 1} 已整批下发(${okN}/${run.results.length} 参数成功,批次 ${run.id.slice(0, 8)})。${skippedNote}${hitlNote}用 daq_query 复测确认工艺响应。`,
+    }
+  }
+  catch (err) {
+    return { text: `配方下发失败:${err instanceof Error ? err.message : String(err)}`, isError: true }
+  }
+}

package/server/services/workshop/agents/industrial-context.ts

@@ -9,6 +9,7 @@
 
 import { getAgentNodeBindingRepo } from './node-bindings.repo'
 import { getDcwController } from '../dcw/dcw-controller'
+import { getDcwNodeRepo } from '../dcw/dcw-node.repo'
 import { getDcwLineRepo } from '../dcw/dcw-line.repo'
 import { getActiveLineRun } from '../dcw/line-run'
 import { findDcwTemplate } from '../dcw/dcw-templates'
@@ -18,6 +19,7 @@ import { findDaqTemplate } from '../daq/daq-templates'
 import { getDeviceTwinRepo } from '../assets/device-twin.repo'
 import { getRecipeRollBackManager } from '../dcw/recipe-rollback-manager'
 import { limitsBreakdownOf } from '../dcw/param-limits'
+import { MES_REST_DRIVER_KIND, mesCatalogEntryOf } from '../mes/mes-controller'
 
 /** 从属设备描述(名称/状态/实时遥测;数据驱动) */
 function describeTwin(bindId: string | null | undefined): string | null {
@@ -170,6 +172,23 @@ export function buildIndustrialContext(agentId: string): string {
     if (alarms.length > 0) {
       lines.push(`- **当前报警**: ${alarms.map(n => `${n.name} 实时 ${n.value ?? '?'}${n.unit} 处于报警态(越量程或越配方监控窗口)`)},应优先判读(设定-响应滞后 vs 真实异常)并处置`)
     }
+    // MES REST 点位段:本产线 mes-rest 节点 ≤30 条全量简列(>30 给前 30 + 检索指引);
+    // 只列语义面(名称/单位/量程/能力/desc),取数走 mes_fetch(原文不进 prompt)
+    try {
+      const mesEntries = getDcwNodeRepo().all()
+        .filter(n => n.lineId === lineId && n.driver === MES_REST_DRIVER_KIND)
+        .map(mesCatalogEntryOf)
+      if (mesEntries.length > 0) {
+        const MES_BRIEF_MAX = 30
+        const capOf = (e: { readable: boolean, writable: boolean, historyable: boolean }): string =>
+          [e.readable ? '读' : null, e.writable ? '写' : null, e.historyable ? '史' : null].filter(Boolean).join('/') || '-'
+        const shown = mesEntries.slice(0, MES_BRIEF_MAX)
+          .map(e => `  ${e.name}|${e.unit || '-'}|${e.min}~${e.max}|${capOf(e)}|${e.desc.slice(0, 40)}`)
+        const rest = mesEntries.length - shown.length
+        lines.push(`- MES REST 点位(${mesEntries.length} 条,名称|单位|量程|读写/历史能力|描述):\n${shown.join('\n')}${rest > 0 ? `\n  (其余 ${rest} 条未列出,用 mes_catalog 检索)` : ''}`)
+      }
+    }
+    catch { /* MES 面未就绪(单测/降级)不阻断简报 */ }
     sections.push(lines.join('\n'))
   }
   if (sections.length === 0) return ''

package/server/services/workshop/agents/tool-classes.ts

@@ -27,4 +27,16 @@ export const HYBRID_TWIN_DIRECT_WRITE_TOOL_NAMES = new Set([
   'dcw_rollback',
   'recipe_update',
   'recipe_rollback',
+  'recipe_trial',
+  'recipe_apply',
+])
+
+/** MES 数据集工具(只读面:点位目录/历史取数/数据集读取与清单)。
+ *  不落 HIGH_RISK、不写 PLC —— fetch 只写 CSV 数据集文件(护栏在 mes-controller 代码级:
+ *  绑线授权/窗口≤7天/行数≤5000/频次限流);权限面与目录注入面可同源引用本集合。 */
+export const MES_READ_TOOL_NAMES = new Set([
+  'mes_catalog',
+  'mes_fetch',
+  'mes_dataset_read',
+  'mes_datasets',
 ])

package/server/services/workshop/aml/dataset-builder.ts

@@ -194,7 +194,9 @@ export async function buildDataset(spec: AmlDatasetSpec, by: { id: string, kind:
       continue
     }
 
-    // 公共网格:[max(t0), min(t1)];逐节点最近邻对齐,网格点缺失计 NaN
+    // 公共网格:[max(t0), min(t1)];逐节点最近邻对齐,网格点缺失计 NaN。
+    // 全节点查空(如该 run 采样缺失/时序库丢数)时 g0/g1 保持 ±Infinity,
+    // 必须按丢弃处理 —— 否则 steps=Infinity 会把网格循环推到 RangeError(500)。
     let g0 = -Infinity
     let g1 = Infinity
     for (const n of order) {
@@ -206,7 +208,7 @@ export async function buildDataset(spec: AmlDatasetSpec, by: { id: string, kind:
       g0 = Math.max(g0, first.at)
       g1 = Math.min(g1, last.at)
     }
-    const steps = g1 > g0 ? Math.floor((g1 - g0) / beat) + 1 : 0
+    const steps = Number.isFinite(g0) && Number.isFinite(g1) && g1 > g0 ? Math.floor((g1 - g0) / beat) + 1 : 0
     if (steps < spec.window.historySteps + spec.window.horizonSteps + 2) {
       runsDropped.push({ runId: run.id, reason: `有效网格 ${steps} 步不足一个窗口` })
       continue

package/server/services/workshop/aml/job-orchestrator/process.ts

@@ -96,5 +96,6 @@ export function handleProtocolLine(run: RunningJob, rawLine: string): void {
   }
   else if (evt.type === 'error' && evt.message) {
     pushLog(run, `[error] ${evt.message}`)
+    run.lastProtocolError = String(evt.message).slice(0, 300) // 结题失败原因优先用它(见 start-job 评估段)
   }
 }

package/server/services/workshop/aml/job-orchestrator/shared.ts

@@ -31,6 +31,8 @@ export interface RunningJob {
   logLines: string[]
   protocolBadLines: number
   killed: boolean
+  /** 最近一条 ##AML error 协议消息(评估器的人读失败原因走 stdout;stderr 尾常为空) */
+  lastProtocolError?: string
 }
 
 export interface OrchestratorState {

package/server/services/workshop/aml/job-orchestrator/start-job.ts

@@ -140,8 +140,11 @@ export async function startJob(row: AmlJobRow): Promise<void> {
     const exit2 = await runPython(run, vpy, [evalScript, '--job', join(jobDir, 'job.json')], jobDir)
     if (run.killed) return
     if (exit2.code !== 0) {
-      rt.repo.job.fail(row.id, 'failed', `评估失败:${lastErrLine(exit2.errTail)}(永久错误不重试)`, new Date().toISOString())
-      experimentFail(run, `评估失败:${lastErrLine(exit2.errTail)}`)
+      // 失败原因优先取评估器的 ##AML error 协议消息(如「test 切分为空…」,人读可操作);
+      // stderr 尾兜底 —— 评估器把错误走 stdout 协议行时 errTail 常为空,只给 "exit" 无从排查。
+      const reason = run.lastProtocolError || lastErrLine(exit2.errTail)
+      rt.repo.job.fail(row.id, 'failed', `评估失败:${reason}(永久错误不重试)`, new Date().toISOString())
+      experimentFail(run, `评估失败:${reason}`)
       finishRun(run)
       return
     }

package/server/services/workshop/db/channel.repo.ts

@@ -11,7 +11,7 @@ import type { DatabaseSync } from 'node:sqlite'
 import type { ChannelRow } from './database'
 
 /** 查询列(蛇形列名 → 驼峰行字段) */
-const COLS = 'id, name, description, scenario_prompt AS scenarioPrompt, llm_json AS llmJson, lead_agent_id AS leadAgentId, workspace, enabled, owner_user_id AS ownerUserId, visibility, join_policy AS joinPolicy, approval_policy AS approvalPolicy, chat_enabled AS chatEnabled, version, created_at AS createdAt, updated_at AS updatedAt'
+const COLS = 'id, name, description, scenario_prompt AS scenarioPrompt, llm_json AS llmJson, lead_agent_id AS leadAgentId, workspace, enabled, owner_user_id AS ownerUserId, visibility, join_policy AS joinPolicy, approval_policy AS approvalPolicy, chat_enabled AS chatEnabled, version, line_id AS lineId, created_at AS createdAt, updated_at AS updatedAt'
 
 export interface ChannelCreateInput {
   name: string
@@ -99,6 +99,7 @@ export function createChannelRepo(db: DatabaseSync) {
         approvalPolicy: input.approvalPolicy ?? 'owner_only',
         chatEnabled: input.chatEnabled ?? 0,
         version: 1,
+        lineId: '',
         createdAt: now,
         updatedAt: now,
       }
@@ -189,5 +190,14 @@ export function createChannelRepo(db: DatabaseSync) {
     remove(id: string): void {
       removeStmt.run(id)
     },
+
+    /** v18:绑定/解绑产线(lineId=''=解绑)。只读扩权面:成员可读该线日志/配方/历史/状态;写仍走节点授权。 */
+    setLine(id: string, lineId: string): ChannelRow | undefined {
+      const current = selectById.get(id) as unknown as ChannelRow | undefined
+      if (!current) return undefined
+      db.prepare('UPDATE channels SET line_id = ?, updated_at = ? WHERE id = ?')
+        .run(lineId, new Date().toISOString(), id)
+      return { ...current, lineId, updatedAt: new Date().toISOString() }
+    },
   }
 }

package/server/services/workshop/db/database/migrations.ts

@@ -10,6 +10,8 @@ export function migrateGroupChatV17(db: DatabaseSync): void {
   migrateAddColumn(db, 'channels', 'approval_policy', 'TEXT NOT NULL DEFAULT \'owner_only\'')
   migrateAddColumn(db, 'channels', 'chat_enabled', 'INTEGER NOT NULL DEFAULT 0')
   migrateAddColumn(db, 'channels', 'version', 'INTEGER NOT NULL DEFAULT 1')
+  // v18:Channel 绑定产线(空串=未绑定;只读扩权面,见 ops-tools agentOpsScope)
+  migrateAddColumn(db, 'channels', 'line_id', 'TEXT NOT NULL DEFAULT \'\'')
   // 规范化非法值(历史手改/测试数据):未知取值一律回落到最保守档,不放宽权限
   db.exec(`UPDATE channels SET visibility = 'private' WHERE visibility NOT IN ('private', 'public')`)
   db.exec(`UPDATE channels SET join_policy = 'owner_approve' WHERE join_policy NOT IN ('open', 'owner_approve')`)

package/server/services/workshop/db/database/rows.ts

@@ -27,6 +27,8 @@ export interface ChannelRow {
   chatEnabled: number
   /** v17 乐观锁版本(每次设置变更 +1) */
   version: number
+  /** v18 绑定产线(空串=未绑定;只读扩权:成员可读该线日志/配方/历史/状态,写仍走节点授权) */
+  lineId: string
   createdAt: string
   updatedAt: string
 }

package/server/services/workshop/db/database/schema.ts

@@ -711,6 +711,38 @@ CREATE TABLE IF NOT EXISTS twin_update_runs (
 );
 CREATE UNIQUE INDEX IF NOT EXISTS uq_twin_update_active_dedup ON twin_update_runs(dedup_key) WHERE state IN ('queued','running','cooldown');
 
+-- v25: MES REST · CSV 数据集(Agent mes_fetch 异步取数的落盘事实源;铁律:MES 原文不进 prompt,工具面只回 stats+采样)
+CREATE TABLE IF NOT EXISTS mes_datasets (
+  id TEXT PRIMARY KEY,
+  line_id TEXT,
+  node_id TEXT,
+  node_name TEXT,
+  from_ts TEXT,
+  to_ts TEXT,
+  rows INTEGER DEFAULT 0,
+  sha256 TEXT,
+  file_path TEXT,
+  status TEXT DEFAULT 'ready',   -- running(取数中) | ready | failed
+  error TEXT,
+  created_by TEXT,
+  created_at TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_mes_datasets_line ON mes_datasets(line_id, created_at DESC);
+
+-- v25: MES REST · 取数作业(进程内异步执行的账本,绝不进调度循环;重启后遗留 running 由查询侧按 failed 呈现)
+CREATE TABLE IF NOT EXISTS mes_fetch_jobs (
+  id TEXT PRIMARY KEY,
+  dataset_id TEXT,
+  agent_id TEXT,
+  status TEXT DEFAULT 'running',  -- running | done | failed
+  rows INTEGER DEFAULT 0,
+  error TEXT,
+  created_at TEXT,
+  updated_at TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_mes_fetch_jobs_dataset ON mes_fetch_jobs(dataset_id);
+CREATE INDEX IF NOT EXISTS idx_mes_fetch_jobs_agent ON mes_fetch_jobs(agent_id, created_at DESC);
+
 CREATE INDEX IF NOT EXISTS idx_hitl_requests_agent ON hitl_requests(agent_id, status);`
 
 // ===== 默认种子数据(首轮初始化注入;owner NULL = 公共资源,所有登录用户只读共享) =====