agentworkshop 0.7.51 → 0.7.53

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

@@ -17,10 +17,26 @@ 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 +47,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 +89,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 +113,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 +130,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 +159,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 +172,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 +187,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 +238,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 +249,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)
@@ -327,16 +357,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 +384,20 @@ export async function toolRecipeRollback(agentId: string, args: {
     return { text: `不能回退到 v${version}(当前已是 v${recipe.version ?? 1};回退目标是更早的版本)。`, isError: true }
   }
   try {
+    if (dispatch) {
+      const { recipe: updated, run } = 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
+      return {
+        text: `统一回退完成:配方「${updated.name}」已生成 v${updated.version ?? 1},参数恢复为目标版本(${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 +408,105 @@ 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 }
   }
 }
+
+/** 工具: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 {
+    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}。注意:本次试验**未写入配方版本** —— 等待工艺惯性后 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 {
+    const run = await getDcwController().applyRecipe(recipeId)
+    const okN = run.results.filter(r => r.ok).length
+    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)})。用 daq_query 复测确认工艺响应。`,
+    }
+  }
+  catch (err) {
+    return { text: `配方下发失败:${err instanceof Error ? err.message : String(err)}`, isError: true }
+  }
+}

package/server/services/workshop/agents/node-bindings.repo.ts

@@ -38,6 +38,10 @@ export interface AgentNodeBinding {
   kind: AgentNodeBindingKind
   mode: AgentNodeBindingMode
   tuning?: AgentNodeBindingTuning
+  /** 委派来源:lead 经 team_grant_nodes / dispatch_task(grant_node_ids) 授予时 = lead 成员实例 id */
+  grantedByAgentId?: string
+  /** 委派时间(ISO;仅委派产生的绑定携带) */
+  grantedAt?: string
   createdAt: string
 }
 
@@ -83,7 +87,7 @@ export class AgentNodeBindingRepo {
     return this.list.find(b => b.agentId === agentId && b.nodeId === nodeId && b.kind === kind)
   }
 
-  bind(agentId: string, nodeId: string, kind: AgentNodeBindingKind, mode: AgentNodeBindingMode, tuning?: AgentNodeBindingTuning): AgentNodeBinding {
+  bind(agentId: string, nodeId: string, kind: AgentNodeBindingKind, mode: AgentNodeBindingMode, tuning?: AgentNodeBindingTuning, provenance?: { grantedByAgentId?: string }): AgentNodeBinding {
     if (!agentId) throw new AppError(400, ErrorCodes.VALIDATION_ERROR, 'agentId 必填')
     if (!nodeId) throw new AppError(400, ErrorCodes.VALIDATION_ERROR, 'nodeId 必填')
     if (kind !== 'dcw' && kind !== 'daq') throw new AppError(400, ErrorCodes.VALIDATION_ERROR, `未知节点类型: ${kind}`)
@@ -92,6 +96,10 @@ export class AgentNodeBindingRepo {
     if (prev) {
       prev.mode = mode
       if (tuning !== undefined) prev.tuning = normalizeTuning(tuning)
+      if (provenance?.grantedByAgentId) {
+        prev.grantedByAgentId = provenance.grantedByAgentId
+        prev.grantedAt = new Date().toISOString()
+      }
       this.flush()
       return prev
     }
@@ -102,6 +110,7 @@ export class AgentNodeBindingRepo {
       kind,
       mode,
       ...(tuning ? { tuning: normalizeTuning(tuning) } : {}),
+      ...(provenance?.grantedByAgentId ? { grantedByAgentId: provenance.grantedByAgentId, grantedAt: new Date().toISOString() } : {}),
       createdAt: new Date().toISOString(),
     }
     this.list.push(binding)

package/server/services/workshop/agents/node-delegation.ts

@@ -0,0 +1,150 @@
+/**
+ * node-delegation —— lead → worker 节点权限委派(核心校验面,宿主工具与 REST 共用)。
+ *
+ * 语义:lead 把**自己已绑定**的 DAQ/DCW 节点授权给同 Channel 的 worker:
+ *   - 节点必须是 leader 本人已有绑定的节点(权限不可超越授予者,hard rule);
+ *   - 目标必须是同 Channel 的启用 worker(不能授给 lead 自己/其他频道成员);
+ *   - 绑定逐 (nodeId, kind) 复制 leader 的 kind/tuning;mode 缺省随 leader,
+ *     显式传 mode 可覆盖(auto↔manual 均允许 —— mode 只决定是否走 HITL,不放大节点面);
+ *   - 委派产生的绑定带 grantedByAgentId/grantedAt 溯源;撤销时 leader 只能撤
+ *     「自己授予的」或「自己也持有的」绑定。
+ * 校验全部 fail-closed:任何节点不满足 → 整单拒绝并列出明细,不做部分授予。
+ */
+import { AppError, ErrorCodes } from '../../../utils/errors'
+import { getAgentNodeBindingRepo, type AgentNodeBinding, type AgentNodeBindingMode } from './node-bindings.repo'
+
+export interface DelegationMember {
+  id: string
+  role: 'lead' | 'worker'
+  enabled?: number
+}
+
+export interface DelegationGrantInput {
+  leaderAgentId: string
+  channelId: string
+  targetAgentId: string
+  nodeIds: string[]
+  members: DelegationMember[]
+  mode?: AgentNodeBindingMode
+}
+
+export interface DelegationPlanItem {
+  nodeId: string
+  kind: 'dcw' | 'daq'
+  mode: AgentNodeBindingMode
+  tuning?: AgentNodeBinding['tuning']
+}
+
+export interface DelegationPlan {
+  targetAgentId: string
+  grants: DelegationPlanItem[]
+}
+
+/** 前置校验 + 逐节点计划(fail-closed;不落库 —— 落库由调用方按计划执行) */
+export function planDelegation(input: DelegationGrantInput): DelegationPlan {
+  const leaderAgentId = String(input.leaderAgentId ?? '')
+  const targetAgentId = String(input.targetAgentId ?? '')
+  const nodeIds = (Array.isArray(input.nodeIds) ? input.nodeIds : []).map(x => String(x ?? '').trim()).filter(Boolean)
+  if (!leaderAgentId || !targetAgentId) throw new AppError(400, ErrorCodes.VALIDATION_ERROR, 'leaderAgentId 与 targetAgentId 必填')
+  if (!nodeIds.length) throw new AppError(400, ErrorCodes.VALIDATION_ERROR, 'node_ids 必填(要授予的节点 id 列表)')
+
+  const members = Array.isArray(input.members) ? input.members : []
+  const leader = members.find(m => m.id === leaderAgentId)
+  if (!leader || leader.role !== 'lead') {
+    throw new AppError(403, 'DELEGATION_NOT_LEAD', '只有频道 lead 可以分发节点权限')
+  }
+  const target = members.find(m => m.id === targetAgentId)
+  if (!target) {
+    throw new AppError(404, ErrorCodes.NOT_FOUND, `目标成员不在本频道: ${targetAgentId}(需传频道成员实例 id,可经 GET /api/workshop/channels/:id/agents 获取)`)
+  }
+  if (target.id === leaderAgentId) {
+    throw new AppError(400, ErrorCodes.VALIDATION_ERROR, '不能把节点权限授予 lead 自己(绑定面在 lead 名下已存在)')
+  }
+  if (target.role !== 'worker') {
+    throw new AppError(400, ErrorCodes.VALIDATION_ERROR, '只能向 worker 分发节点权限')
+  }
+  if (target.enabled === 0) {
+    throw new AppError(400, ErrorCodes.VALIDATION_ERROR, `目标成员已被停用: ${targetAgentId}`)
+  }
+
+  const repo = getAgentNodeBindingRepo()
+  const leaderBindings = repo.byAgent(leaderAgentId)
+  const missing: string[] = []
+  const grants: DelegationPlanItem[] = []
+  const seen = new Set<string>()
+  for (const nodeId of nodeIds) {
+    if (seen.has(nodeId)) continue
+    seen.add(nodeId)
+    const held = leaderBindings.filter(b => b.nodeId === nodeId)
+    if (!held.length) {
+      missing.push(nodeId)
+      continue
+    }
+    for (const h of held) {
+      grants.push({
+        nodeId,
+        kind: h.kind,
+        mode: input.mode ?? h.mode,
+        tuning: h.tuning ? { ...h.tuning } : undefined,
+      })
+    }
+  }
+  if (missing.length) {
+    throw new AppError(403, 'DELEGATION_NOT_OWNED', `以下节点不在 lead 的绑定面内,拒绝授予(权限不可超越授予者):${missing.join('、')}`)
+  }
+  return { targetAgentId, grants }
+}
+
+/** 执行授予:按计划逐条落库(已存在的绑定更新 mode/溯源,不重复建行) */
+export function applyDelegation(plan: DelegationPlan, leaderAgentId: string): AgentNodeBinding[] {
+  const repo = getAgentNodeBindingRepo()
+  return plan.grants.map((g) => {
+    const binding = repo.bind(plan.targetAgentId, g.nodeId, g.kind, g.mode, g.tuning, { grantedByAgentId: leaderAgentId })
+    return binding
+  })
+}
+
+export interface DelegationRevokeInput {
+  leaderAgentId: string
+  targetAgentId: string
+  nodeIds: string[]
+  members: DelegationMember[]
+}
+
+/** 撤销授予:可撤「自己授予的」或「自己也持有的」绑定;两者都不是 → 拒绝该节点 */
+export function revokeDelegation(input: DelegationRevokeInput): Array<{ nodeId: string, kind: 'dcw' | 'daq', revoked: boolean }> {
+  const leaderAgentId = String(input.leaderAgentId ?? '')
+  const targetAgentId = String(input.targetAgentId ?? '')
+  const nodeIds = (Array.isArray(input.nodeIds) ? input.nodeIds : []).map(x => String(x ?? '').trim()).filter(Boolean)
+  if (!leaderAgentId || !targetAgentId || !nodeIds.length) {
+    throw new AppError(400, ErrorCodes.VALIDATION_ERROR, 'leaderAgentId / targetAgentId / node_ids 必填')
+  }
+  const members = Array.isArray(input.members) ? input.members : []
+  const leader = members.find(m => m.id === leaderAgentId)
+  if (!leader || leader.role !== 'lead') {
+    throw new AppError(403, 'DELEGATION_NOT_LEAD', '只有频道 lead 可以撤销节点权限')
+  }
+  if (!members.some(m => m.id === targetAgentId)) {
+    throw new AppError(404, ErrorCodes.NOT_FOUND, `目标成员不在本频道: ${targetAgentId}`)
+  }
+
+  const repo = getAgentNodeBindingRepo()
+  const leaderNodes = new Set(repo.byAgent(leaderAgentId).map(b => b.nodeId))
+  const out: Array<{ nodeId: string, kind: 'dcw' | 'daq', revoked: boolean }> = []
+  for (const nodeId of nodeIds) {
+    const workerBindings = repo.byAgent(targetAgentId).filter(b => b.nodeId === nodeId)
+    if (!workerBindings.length) {
+      for (const kind of ['dcw', 'daq'] as const) out.push({ nodeId, kind, revoked: false })
+      continue
+    }
+    for (const b of workerBindings) {
+      const allowed = b.grantedByAgentId === leaderAgentId || leaderNodes.has(nodeId)
+      if (!allowed) {
+        out.push({ nodeId, kind: b.kind, revoked: false })
+        continue
+      }
+      out.push({ nodeId, kind: b.kind, revoked: repo.unbind(b.id) })
+    }
+  }
+  return out
+}

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

@@ -16,6 +16,8 @@ export const LEAD_ONLY_TOOL_NAMES = new Set([
   'update_team_agent',
   'remove_team_agent',
   'aml_model_promote',
+  'team_grant_nodes',
+  'team_revoke_nodes',
 ])
 
 /** Hybrid Twin 的直接写入工具:权限面(permission-scope)与目录注入面(host-tool-bridge/catalog)fail-closed 同源于本集合;dispatch 分发层的同款守卫为并行在飞改动,待其收敛后接入(勿在此重复第三份清单)。 */
@@ -25,4 +27,6 @@ export const HYBRID_TWIN_DIRECT_WRITE_TOOL_NAMES = new Set([
   'dcw_rollback',
   'recipe_update',
   'recipe_rollback',
+  'recipe_trial',
+  'recipe_apply',
 ])

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
 }