agentworkshop 0.8.6 → 0.8.8

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

@@ -1,26 +1,27 @@
 /**
- * Recipe 操作统一鉴权门(权限模型 v2 + 2026-10-28 节点级写授权双轨)。
+ * Recipe 操作统一鉴权门(权限模型 v2 + 2026-10-28 节点级写授权双轨 + 产线配方管理权)。
  *
- * 对产线的全部写动作仍收敛在配方管道上;授权面有两条轨(取并集):
+ * 对产线的全部写动作仍收敛在配方管道上;授权面有三条轨(取并集):
  *   ① 绑定门:
- *      - recipe 绑定(kind='recipe',nodeId 字段=配方 id)= **配方操作权**
+ *      - recipe 绑定(kind='recipe',nodeId 字段=配方 id)= **单配方操作权**
  *        (update/apply/trial/rollback 全部放行,维持权限模型 v2 语义);
- *      - dcw 节点绑定(kind='dcw')= **点位写授权**(2026-10-28 恢复,非直写入口):
- *        对「当前活动配方」的 trial/apply,只要本次覆盖的节点 ⊆ 自己的 dcw 绑定面
- *        即放行 —— 授权跟设备节点走(稳定),管控跟活动配方走(动态),换配方不停摆。
- *        版本操作(update/rollback)不授予:配方级操作权仍须 recipe 绑定。
- *      - 目标节点集缺省 = 配方全部参数(apply / 无 overrides 的 trial);
- *        trial 传本次 overrides 的节点集(只写声明节点,部分覆盖即拒)。
+ *      - line-recipe 绑定(kind='line-recipe',nodeId 字段=产线 id)= **产线配方管理权**
+ *        (2026-10-28 新增):对该产线**全部配方**(含未来新建)可 查看/新建/修改/回退;
+ *      - dcw 节点绑定(kind='dcw')= **点位写授权**(非直写入口):同时是下发范围的收窄器 ——
+ *        ▸ 下发授权规则(trial/apply):
+ *          - Agent 持有 recipe 级授权(单配方绑定 ∨ 产线管理权)且**未绑任何 dcw**:
+ *            默认可对该(线)配方全部参数下发(向下兼容,存量行为不变);
+ *          - Agent 绑了 dcw:下发覆盖集必须 ⊆ dcw 绑定面(部分覆盖即拒,列出缺失节点);
+ *          - Agent 无任何 recipe 级授权:覆盖集 ⊆ dcw 绑定面才放行(纯点位轨)。
+ *        ▸ 版本操作(update/rollback)只认 recipe 级授权:dcw 绑定不授予版本权。
  *   ② 认证门:recipe.access.requireAuth=true 时,只有 authorizedAgentIds 清单内的
  *      Agent 可操作(fail-closed:开认证但清单为空 = 无人可操作);
  *   ③ 运行门:配方必须**正在执行**(该产线存在本配方的活动批次)—— 未运行的配方
  *      一律不可操作(参数写入/下发/试验/回退同样受限);
- *   ④ HITL 判定:绑定 mode='manual' → 每次动作挂起等人工批准(必带 Agent 理由);
- *      mode='auto'(显式确认切换)→ 免批直执行。全局开关 security.recipeDispatchApproval
- *      保持兼容:开启时即便 auto 绑定也挂审批。节点级轨的 manual 语义跟随覆盖该批
- *      节点的 dcw 绑定(任一 manual 即挂审批)。
+ *   ④ HITL 判定:授权绑定的 mode='manual' → 每次动作挂起等人工批准(必带 Agent 理由);
+ *      mode='auto'(显式确认切换)→ 免批。dcw 点位轨覆盖该批次任一 manual 同样强制。
  *      线级总闸(2026-10-08):line.controlMode='manual'(缺省,fail-safe)时 auto 绑定
- *      也强制人工审批 —— 手动模式下人类必须过目每一次写动作。
+ *      也强制人工审批;频道层钳位(三模式)同理。
  */
 import { getAgentNodeBindingRepo, type AgentNodeBinding } from '../node-bindings.repo'
 import { getDcwController } from '../../dcw/dcw-controller'
@@ -69,8 +70,10 @@ function listNodes(ids: string[]): string {
   return ids.length > 0 ? ids.map(nodeLabel).join('、') : '(无)'
 }
 
-/** 统一鉴权门:绑定(配方级 ∪ 节点级)→ 二级认证 → 运行门;返回绑定与 HITL 判定(不做挂起,挂起由调用方执行)
- *  targetNodeIds:本次动作实际覆盖的节点集;缺省 = 配方全部参数(整批 apply)。 */
+/** 统一鉴权门:绑定(配方级 ∪ 产线管理级 ∪ 点位级)→ 二级认证 → 运行门;返回绑定与 HITL 判定(不做挂起,挂起由调用方执行)
+ *  targetNodeIds:本次动作实际覆盖的节点集;缺省 = 配方全部参数(整批 apply)。
+ *  下发规则:持 recipe 级授权(单配方 ∨ 产线管理)且未绑任何 dcw → 全参数放行(向下兼容);
+ *  绑了 dcw → 覆盖集 ⊆ dcw 绑定面;两者都无 → 纯点位轨(覆盖集 ⊆ dcw 面)。 */
 export function assertRecipeOperation(
   agentId: string,
   recipe: { id: string, name: string, lineId?: string, params?: Array<{ nodeId: string }>, access?: { requireAuth?: boolean, authorizedAgentIds?: string[] } },
@@ -78,9 +81,12 @@ export function assertRecipeOperation(
   targetNodeIds?: string[],
 ): RecipeGateResult {
   const opLabel = op === 'update' ? '参数写入' : op === 'dispatch' ? '下发' : op === 'trial' ? '试验下发' : '回退'
-  // ① 绑定门(双轨):recipe 绑定 = 配方操作权;dcw 绑定 = 点位写授权(仅 trial/apply)
+  // ① 绑定门(三轨):recipe=单配方操作权;line-recipe=产线配方管理权;dcw=点位写授权(兼下发收窄器)
   const bindings = getAgentNodeBindingRepo().byAgent(agentId)
   const recipeBinding = bindings.find(b => b.kind === 'recipe' && b.nodeId === recipe.id)
+  const lineBinding = recipe.lineId
+    ? bindings.find(b => b.kind === 'line-recipe' && b.nodeId === recipe.lineId)
+    : undefined
   const dcwBindings = bindings.filter(b => b.kind === 'dcw')
   const dcwBound = new Set(dcwBindings.map(b => b.nodeId))
   const recipeNodes = (recipe.params ?? []).map(p => p.nodeId).filter(Boolean)
@@ -88,30 +94,43 @@ export function assertRecipeOperation(
     .map(id => String(id ?? '').trim())
     .filter(Boolean)
   const versionOp = op === 'update' || op === 'rollback'
+  // 配方级授权锚:单配方绑定 或 产线管理权(版本操作 + 「无 dcw 即全参数下发」的载体)
+  const recipeLevelGrant = recipeBinding ?? lineBinding
   let coveringBindings: AgentNodeBinding[] = []
-  if (!recipeBinding) {
+  if (!recipeLevelGrant) {
     if (versionOp) {
       return {
         ok: false,
-        text: `无权${opLabel}配方「${recipe.name}」(${recipe.id}):节点绑定(dcw)只授予参数下发/试验权(点位授权),配方版本操作(参数保存/回退)需要绑定该配方(kind='recipe',配方级操作权)。请让用户或 lead 为你绑定该配方(recipe 绑定首绑默认 manual,每次动作需人工批准)。`,
+        text: `无权${opLabel}配方「${recipe.name}」(${recipe.id}):节点绑定(dcw)只授予参数下发/试验权(点位授权),配方版本操作(参数保存/回退)需要配方级授权 —— 绑定该配方(kind='recipe')或持有其产线的配方管理权(kind='line-recipe')。请让用户或 lead 为你授权(recipe 绑定首绑默认 manual,每次动作需人工批准)。`,
       }
     }
     if (targets.length === 0) {
       return {
         ok: false,
-        text: `无权${opLabel}配方「${recipe.name}」:配方没有参数节点,无法确认授权覆盖集。请先为配方配置参数节点,或让用户/lead 绑定该配方(kind='recipe')。`,
+        text: `无权${opLabel}配方「${recipe.name}」:配方没有参数节点,无法确认授权覆盖集。请先为配方配置参数节点,或让用户/lead 授予你配方级授权。`,
       }
     }
     const missing = targets.filter(id => !dcwBound.has(id))
     if (missing.length > 0) {
       return {
         ok: false,
-        text: `无权${opLabel}配方「${recipe.name}」:本次覆盖的节点中有 ${missing.length} 个不在你的数控节点绑定面内 —— ${listNodes(missing)}。你已绑定的可写节点:${listNodes([...dcwBound])}。请让用户或 lead 为你补绑这些节点(节点绑定 = 点位写授权),或改用已授权节点重试;若要对整批配方操作,也可改为绑定配方(kind='recipe')。`,
+        text: `无权${opLabel}配方「${recipe.name}」:本次覆盖的节点中有 ${missing.length} 个不在你的数控节点绑定面内 —— ${listNodes(missing)}。你已绑定的可写节点:${listNodes([...dcwBound])}。请让用户或 lead 为你补绑这些节点(节点绑定 = 点位写授权),或改用已授权节点重试;若要对整批配方操作,可请用户授予配方绑定(kind='recipe')或产线配方管理权(kind='line-recipe')。`,
       }
     }
     coveringBindings = dcwBindings.filter(b => targets.includes(b.nodeId))
   }
-  // ② 二级认证(用户在配方编辑里开启并勾选授权 Agent;双轨共用)
+  else if (dcwBindings.length > 0 && !versionOp) {
+    // 绑了 dcw = 下发范围收窄到这些点位(部分覆盖即拒);版本操作不受 dcw 收窄影响
+    const missing = targets.filter(id => !dcwBound.has(id))
+    if (missing.length > 0) {
+      return {
+        ok: false,
+        text: `下发被收窄:你已绑定数控节点,${opLabel}只能覆盖这些点位。本次覆盖的节点中有 ${missing.length} 个未绑定 —— ${listNodes(missing)}。你已绑定的可写节点:${listNodes([...dcwBound])}。请只对已绑定节点下发,或让用户/lead 补绑后再试(未绑定任何数控节点时才默认对配方全部参数放行)。`,
+      }
+    }
+    coveringBindings = dcwBindings.filter(b => targets.includes(b.nodeId))
+  }
+  // ② 二级认证(用户在配方编辑里开启并勾选授权 Agent;三轨共用)
   if (recipe.access?.requireAuth && !(recipe.access.authorizedAgentIds ?? []).includes(agentId)) {
     return {
       ok: false,
@@ -126,7 +145,7 @@ export function assertRecipeOperation(
       text: `配方「${recipe.name}」当前未在执行(产线上没有本配方的活动批次),按运行门约束${opLabel}被拒。请先由用户在产线开跑本配方,再进行参数写入/下发。`,
     }
   }
-  // ④ HITL 判定:manual 绑定 → 逐动作人工批准;auto → 免批。
+  // ④ HITL 判定:授权绑定 manual → 逐动作人工批准;auto → 免批。
   //    线级总闸(2026-10-08 生产化):line.controlMode='manual'(缺省)时,即便绑定为
   //    auto 也强制人工审批 —— 手动模式下人类必须过目每一次写动作。
   //    频道层钳位(2026-10-28 三模式):Agent 所属频道 executionMode='manual' 时同理强制;
@@ -136,18 +155,19 @@ export function assertRecipeOperation(
   // ⑤ 全局开关兼容位:security.recipeDispatchApproval 开启时即便 auto 也挂审批(保留语义)
   const globalGate = false // 由调用方按 settingOf('security.recipeDispatchApproval') 叠加(本模块不依赖设置服务)
   void globalGate
-  // 节点级轨的 manual 语义:覆盖本次批次的 dcw 绑定任一 manual 即挂审批(fail-safe)
+  // dcw 点位轨的 manual 语义:覆盖本次批点的 dcw 绑定任一 manual 即挂审批(fail-safe)
   const nodeManual = coveringBindings.some(b => b.mode === 'manual')
-  const binding = recipeBinding ?? coveringBindings[0]
+  const binding = recipeLevelGrant ?? coveringBindings[0]
   if (!binding) {
-    // 理论上不可达(targets 非空且全部已覆盖);fail-closed 防实现漂移
+    // 理论上不可达(配方级授权或全部覆盖必有其一);fail-closed 防实现漂移
     return { ok: false, text: `无权${opLabel}配方「${recipe.name}」:未找到有效授权绑定。` }
   }
   return { ok: true, binding, hitlRequired: binding.mode === 'manual' || nodeManual || lineManual || channelManual, activeContext: run }
 }
 
-/** 新建配方的授权门(尚无 recipe 可绑定):要求 Agent 在该线至少有一个写向绑定
- *  (dcw 节点或已有配方),并且 line 存在;manual 线/绑定 → 人工批准。
+/** 新建配方的授权门(尚无 recipe 可绑定):要求 Agent 在该线至少有一个授权锚
+ *  (dcw 节点、已有配方,或 2026-10-28 起的产线配方管理权 kind='line-recipe'),
+ *  并且 line 存在;manual 线/绑定 → 人工批准。
  *  频道绑线是只读扩权,不能单独作为新建配方的依据(否则只读频道可凭空造配方)。 */
 export function assertRecipeCreate(agentId: string, lineId: string): { ok: true, hitlRequired: boolean } | { ok: false, text: string } {
   if (!lineId) return { ok: false, text: '新建配方需要明确产线(line_id 或 source_recipe_id 可推断)。' }
@@ -155,6 +175,14 @@ export function assertRecipeCreate(agentId: string, lineId: string): { ok: true,
   let lineBound = false
   let manualBound = false
   for (const b of bindings) {
+    if (b.kind === 'line-recipe') {
+      // 产线配方管理权:对该线全部配方(含新建)的管理授权锚
+      if (b.nodeId === lineId) {
+        lineBound = true
+        if (b.mode === 'manual') manualBound = true
+      }
+      continue
+    }
     if (b.kind === 'recipe') {
       const r = getDcwController().listRecipes().find(x => x.id === b.nodeId)
       if (r?.lineId === lineId) {
@@ -174,7 +202,7 @@ export function assertRecipeCreate(agentId: string, lineId: string): { ok: true,
   if (!lineBound) {
     return {
       ok: false,
-      text: `无权在产线 ${lineId} 新建配方:你尚未绑定该产线的任何数控节点或配方。新建配方会创建可下发的参数基线,必须由用户/lead 先给你绑定该产线的节点或配方(绑定首绑默认 manual,人工批准)。`,
+      text: `无权在产线 ${lineId} 新建配方:你尚未持有该产线的任何授权锚(数控节点绑定、配方绑定或产线配方管理权)。新建配方会创建可下发的参数基线,必须由用户/lead 先授予 —— 绑定该线节点/配方,或授予产线配方管理权(kind='line-recipe';绑定首绑默认 manual,人工批准)。`,
     }
   }
   const lineManual = getDcwLineRepo().controlModeOf(lineId) === 'manual'

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

@@ -23,6 +23,7 @@ import { assertRecipeOpInterval } from '../../dcw/recipe-op-anchor'
 import { getDcwLineRepo } from '../../dcw/dcw-line.repo'
 import { recordOps } from '../../ops/ops'
 import { evaluateRecipeParamLimits } from '../../dcw/dcw-controller/write'
+import { GOVERNED_DISPATCH_HINT, RECOVERY_RETRY_HINT, RECOVERY_TRACE_HINT, RECOVERY_VERIFY_HINT } from './fallback-hints'
 import { amlActivityForLine } from './aml-activity'
 import { agentOpsScope, revalidateApprovedAction } from './ops-tools'
 
@@ -145,9 +146,10 @@ export async function toolRecipePropose(agentId: string, args: {
   // 权限模型 v2:持有该配方绑定(kind=recipe)即算"配方内授权";兼容历史 dcw 节点绑定
   const bindings = getAgentNodeBindingRepo().byAgent(agentId)
   const boundInRecipe = bindings.some(b => b.kind === 'recipe' && b.nodeId === recipeId)
+    || bindings.some(b => b.kind === 'line-recipe' && b.nodeId === recipe.lineId)
     || bindings.some(b => b.kind === 'dcw' && recipe.params.some(p => p.nodeId === b.nodeId))
   if (!boundInRecipe) {
-    return { text: `无权提交配方 ${recipeId} 的整包方案(需持有该配方的绑定;找 lead 授予配方操作权)。`, isError: true }
+    return { text: `无权提交配方 ${recipeId} 的整包方案(需持有该配方的绑定或其产线的配方管理权;找 lead 授予)。`, isError: true }
   }
   const line = getDcwLineRepo().byId(recipe.lineId)
 
@@ -303,7 +305,7 @@ export async function toolRecipePropose(agentId: string, args: {
     return {
       text: [
         `方案「${chosen.name}」已获批准,但整批下发启动失败:${err instanceof Error ? err.message : String(err)}`,
-        '产线未做任何变更;请等待节拍窗放行后用 dcw_control 逐节点直发本方案参数,或稍后重新提交 recipe_propose。',
+        `产线未做任何变更;请等待节拍窗放行后重新提交 recipe_propose 整批下发本方案参数 —— ${GOVERNED_DISPATCH_HINT}。`,
       ].join('\n'),
       isError: true,
     }
@@ -346,7 +348,7 @@ export async function toolRecipePropose(agentId: string, args: {
     return {
       text: [
         `整包下发失败:方案「${chosen.name}」已获批准,但整批下发 0/${run.results.length} 参数成功(典型:节点写入保持窗/节流未放行)。${runIdNote}${feedback}`,
-        '产线仍在运行原参数 —— 请等待约 60s 后用 dcw_control 逐节点直发本方案参数,或用 recipe_rollback(recipe_id, dispatch=true) 统一回退到已知良好版本;并把失败原因写入汇报提醒人类。',
+        `产线仍在运行原参数 —— 请${RECOVERY_RETRY_HINT},或用 recipe_rollback(recipe_id, to_last_good=true) 统一回退到已知良好版本;并把失败原因写入汇报提醒人类。`,
       ].join('\n'),
       isError: true,
     }
@@ -357,7 +359,7 @@ export async function toolRecipePropose(agentId: string, args: {
       text: [
         `整批下发 ACK 鉴定未全绿:方案「${chosen.name}」已获批并下发,但设备证实 ${acks.verified}/${acks.total},未证实 ${acks.unverified}(仅链路受理),失败 ${acks.failed}。${runIdNote}${feedback}`,
         ...rows,
-        '「未证实」=命令已发到链路但设备侧未确认生效(mqtt/http 等无回读驱动或回读超时);「失败」=写入被拒。请:①逐条核查未证实参数的产线侧真实状态(daq_query 复测);②必要时用 dcw_control 对未证实参数单独重发;③把未证实/失败清单写入汇报提醒人类,劣化风险下用 recipe_rollback(recipe_id, dispatch=true) 统一回退。',
+        `「未证实」=命令已发到链路但设备侧未确认生效(mqtt/http 等无回读驱动或回读超时);「失败」=写入被拒。请:①${RECOVERY_VERIFY_HINT};②${RECOVERY_TRACE_HINT};③把未证实/失败清单写入汇报提醒人类,劣化风险下用 recipe_rollback(recipe_id, dispatch=true) 统一回退。`,
       ].join('\n'),
       isError: true,
     }

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

@@ -57,6 +57,8 @@ export interface ToolRefFaces {
   channelLineId: string
   /** 频道绑线下的数采节点(v28 只读扩权面) */
   channelLineNodes: Set<string>
+  /** 产线配方管理权(kind='line-recipe'):lineId → 授权(2026-10-28) */
+  managedLines: Map<string, { mode: 'auto' | 'manual' }>
 }
 
 /** 解析调用者的合法引用面(只读,不缓存——绑定可在调用间隙被用户改写) */
@@ -94,7 +96,22 @@ export function resolveRefFaces(agentId: string): ToolRefFaces {
   if (channelLineId) {
     for (const n of getDaqNodeRepo().all()) if (n.lineId === channelLineId) channelLineNodes.add(n.id)
   }
-  return { agentId, boundNodes, writeFace, daqBoundNodes, boundRecipes, recipeLines, readableLines, channelLineId, channelLineNodes }
+  // 产线配方管理权:该线全部配方的参数进入写面(下发仍受「绑 dcw 即收窄」规则约束,
+  // 精确判定在 recipe-gate;预检面放宽到线配方参数,避免管理操作在预检被误拦)
+  const managedLines = new Map<string, { mode: 'auto' | 'manual' }>()
+  for (const b of bindings) {
+    if (b.kind !== 'line-recipe') continue
+    if (managedLines.has(b.nodeId)) continue
+    managedLines.set(b.nodeId, { mode: b.mode })
+    for (const r of getDcwController().listRecipes()) {
+      if (r.lineId !== b.nodeId) continue
+      for (const p of (r.params ?? [])) {
+        boundNodes.add(p.nodeId)
+        writeFace.add(p.nodeId)
+      }
+    }
+  }
+  return { agentId, boundNodes, writeFace, daqBoundNodes, boundRecipes, recipeLines, readableLines, channelLineId, channelLineNodes, managedLines }
 }
 
 // ===== 归属判定 =====
@@ -151,12 +168,15 @@ function denyNode(faces: ToolRefFaces, toolName: string, args: Record<string, un
   ], faces, hint, { param, value: id, lineId: row?.lineId })
 }
 
-/** 写面拒绝(2026-10-28):参数要写到的节点必须落在 W(a)=dcw 绑定 ∪ 绑定配方参数节点。
+/** 写面拒绝(2026-10-28):参数要写到的节点必须落在 W(a)=dcw 绑定 ∪ 绑定配方参数节点 ∪ 管理线配方参数。
  *  比 denyNode 更明确:读得到 ≠ 写得到(频道绑线只读扩权/他配方节点都不构成写授权)。 */
 function denyWriteNode(faces: ToolRefFaces, toolName: string, args: Record<string, unknown>, param: string, id: string, exists: boolean): HostToolResult {
   const row = exists ? nodeRow(id) : null
   const where = row ? `(节点「${row.name}」${row.lineId ? `,归属产线 ${row.lineId}` : ''})` : '(节点不存在或已删除)'
-  const hint = `该节点不在你的写授权面(节点绑定=点位写授权;配方绑定=配方操作权)。你的可写节点:${listOf(faces.writeFace)};你已绑定的配方参数节点也在此列。如需写入,请让用户或 lead 为你绑定该数控节点(dcw),或改用上述已授权节点;若要对整批配方操作,可请求绑定配方(kind='recipe')。`
+  const managedNote = faces.managedLines.size > 0
+    ? `你持有产线配方管理权的线:[${[...faces.managedLines.keys()].join(', ')}](仅覆盖这些线上的配方参数)。`
+    : ''
+  const hint = `该节点不在你的写授权面(节点绑定=点位写授权;配方绑定=配方操作权;产线管理权=该线配方参数)。你的可写节点:${listOf(faces.writeFace)}。${managedNote} 如需写入,请让用户或 lead 为你绑定该数控节点(dcw),或授予配方绑定/产线配方管理权。`
   return deny(toolName, args, [
     `工具调用被拒(写授权校验,${toolName}):参数节点「${id}」不在你的写授权面内${where}。`,
   ], faces, hint, { param, value: id, lineId: row?.lineId })

package/server/services/workshop/agents/mock-agent.ts

@@ -171,6 +171,10 @@ export class MockAgentImpl implements AgentInterface {
     // FAILED 且重试次数 < 3 → reassign 给空闲 worker(模式无关)
     // 回退窗:与规则引擎同源 —— 避免 worker 尚未消费新 assign 就被下一次重试换 lease。
     for (const task of snapshot.tasks) {
+      // 2026-10-30 修复:与规则引擎(rules.ts)同源补齐两道守卫 —— 根任务是 lead 编排
+      // 记录不得改派给 worker;ROOT_TIMEOUT 已是超时收口结果,不能被重试规则重新派发。
+      if (!task.parentId) continue
+      if (task.closeReason === 'ROOT_TIMEOUT') continue
       if (task.state === 'FAILED' && task.retryCount < 3 && failedRetryReady(task, now)) {
         const worker = this.pickWorker(pool, now, task.assigneeId)
         if (worker) {

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

@@ -2,10 +2,12 @@
  * AgentNodeBindingRepo —— Agent ↔ 工业对象绑定持久化(agent-node-bindings.json)。
  *
  * 一个绑定 = 某 Channel 内的 Agent 对某个工业对象的授权:
- *   - kind: 'daq' = 可查询数采; 'recipe' = 配方操作权(参数写入+下发+版本;nodeId 字段存 recipeId);
- *     'dcw' = 点位写授权(2026-10-28 恢复,非直写入口):对活动配方的 trial/apply,
- *     覆盖集 ⊆ 节点绑定面即放行;直写工具(param_control/dcw_control)仍恒拒,
- *     写路径 100% 收敛在配方管道(权限模型 v2)。
+ *   - kind: 'daq' = 可查询数采; 'recipe' = 单配方操作权(参数写入+下发+版本;nodeId 字段存 recipeId);
+ *     'dcw' = 点位写授权(2026-10-28 恢复,非直写入口):下发覆盖集 ⊆ 节点绑定面即放行,
+ *     且**绑了 dcw 就把下发范围收窄到这些点位**;直写工具(param_control/dcw_control)仍恒拒,
+ *     写路径 100% 收敛在配方管道(权限模型 v2);
+ *     'line-recipe' = 产线配方管理权(2026-10-28,nodeId 字段存 lineId):对该产线全部配方
+ *     (含未来新建)可 查看/新建/修改/回退;下发仍按 dcw 收窄规则(未绑任何 dcw = 全参数可发)。
  *   - mode: 'auto' = 工具调用自动执行; 'manual' = 每次执行需用户批准(可附备注)
  */
 
@@ -18,7 +20,7 @@ import { loadJsonFile, saveJsonFileAtomic } from '../json-store.mjs'
 
 const log = createLogger('workshop.node-bindings')
 
-export type AgentNodeBindingKind = 'dcw' | 'daq' | 'recipe'
+export type AgentNodeBindingKind = 'dcw' | 'daq' | 'recipe' | 'line-recipe'
 export type AgentNodeBindingMode = 'auto' | 'manual'
 
 /** 绑定级调试元数据(工况提示词组装与探索步长来源;优先于节点自带元数据) */
@@ -92,7 +94,7 @@ export class AgentNodeBindingRepo {
   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' && kind !== 'recipe') throw new AppError(400, ErrorCodes.VALIDATION_ERROR, `未知节点类型: ${kind}`)
+    if (kind !== 'dcw' && kind !== 'daq' && kind !== 'recipe' && kind !== 'line-recipe') throw new AppError(400, ErrorCodes.VALIDATION_ERROR, `未知节点类型: ${kind}`)
     if (mode !== 'auto' && mode !== 'manual') throw new AppError(400, ErrorCodes.VALIDATION_ERROR, `未知控制模式: ${mode}`)
     const prev = this.find(agentId, nodeId, kind)
     if (prev) {

package/server/services/workshop/agents/omp-agent/agentteam-audit.ts

@@ -0,0 +1,147 @@
+/**
+ * Opt-in, append-only raw tool-event capture for isolated AgentTeam experiments.
+ *
+ * The regular channel timeline intentionally stores compact summaries.  P12
+ * needs the original host-tool request/result and actor/task identity, so an
+ * isolated runner may set AW_AGENTTEAM_EVENT_LOG to a run-scoped JSONL file.
+ * Capture errors are sticky and cause subsequent OMP host-tool dispatches to
+ * fail closed.  This is not enabled unless the environment variable is set.
+ */
+import { closeSync, fsyncSync, openSync, writeSync } from 'node:fs'
+import { createHash, randomUUID } from 'node:crypto'
+import { resolve } from 'node:path'
+import type { AgentSessionEvent } from '../adapters/omp-rpc-client'
+
+export interface OmpAgentTeamAuditIdentity {
+  agentId: string
+  role: 'lead' | 'worker'
+  channelId: string
+  taskId?: string
+}
+
+let sequence = 0
+let captureFailure: string | null = null
+const recordedToolEvents = new Set<string>()
+
+const sensitiveKey = /(token|password|secret|api[-_]?key|authorization|cookie|credential)/i
+
+function redact(value: unknown, key = ''): unknown {
+  if (sensitiveKey.test(key)) return '[REDACTED]'
+  if (Array.isArray(value)) return value.map(item => redact(item))
+  if (value && typeof value === 'object') {
+    return Object.fromEntries(Object.entries(value as Record<string, unknown>).map(([k, v]) => [k, redact(v, k)]))
+  }
+  if (typeof value === 'string') {
+    return value
+      .replace(/\bBearer\s+[A-Za-z0-9._~+/-]+=*/gi, 'Bearer [REDACTED]')
+      .replace(/\b(?:sk[-_]|rk_live_|AKIA|ASIA|AIza|gh[pousr]_|github_pat_|xox[a-z]-)[A-Za-z0-9_-]{12,}\b/gi, '[REDACTED]')
+      .replace(/\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g, '[REDACTED]')
+      .replace(/((?:token|password|secret|api[-_]?key|authorization)\s*[:=]\s*)[^\s,;]+/gi, '$1[REDACTED]')
+  }
+  return value
+}
+
+function appendRecord(path: string, record: Record<string, unknown>): boolean {
+  let fd: number | undefined
+  let appended = false
+  try {
+    fd = openSync(path, 'a')
+    writeSync(fd, `${JSON.stringify(record)}\n`, undefined, 'utf8')
+    fsyncSync(fd)
+    appended = true
+  }
+  catch (error) {
+    captureFailure = error instanceof Error ? error.message : String(error)
+  }
+  finally {
+    if (fd !== undefined) {
+      try {
+        closeSync(fd)
+      }
+      catch (error) {
+        captureFailure ??= error instanceof Error ? error.message : String(error)
+      }
+    }
+  }
+  return appended && captureFailure === null
+}
+
+// A boot marker lets the runner distinguish the active process's audit sink
+// from a stale file left by an earlier attempt, before any goal task is made.
+const bootPath = process.env.AW_AGENTTEAM_EVENT_LOG?.trim()
+const bootRunId = process.env.AW_AGENTTEAM_RUN_ID?.trim()
+if (bootPath) {
+  if (!bootRunId) {
+    captureFailure = 'AW_AGENTTEAM_RUN_ID is required when AW_AGENTTEAM_EVENT_LOG is enabled'
+  }
+  else {
+    const sourceSeq = ++sequence
+    appendRecord(bootPath, {
+      schema_version: 1,
+      run_id: bootRunId,
+      event_id: `${process.pid}:${sourceSeq}:${randomUUID()}`,
+      source: 'aw-omp-agent-adapter',
+      source_seq: sourceSeq,
+      at_utc: new Date().toISOString(),
+      monotonic_ns: process.hrtime.bigint().toString(),
+      process_id: process.pid,
+      aw_mode: process.env.AW_MODE ?? null,
+      aw_home_sha256: process.env.AW_HOME
+        ? createHash('sha256').update(resolve(process.env.AW_HOME)).digest('hex')
+        : null,
+      event_type: 'capture_ready',
+    })
+  }
+}
+
+/** Returns true when capture is disabled or the event was durably appended. */
+export function recordOmpAgentTeamToolEvent(
+  event: AgentSessionEvent,
+  identity: OmpAgentTeamAuditIdentity,
+): boolean {
+  const path = process.env.AW_AGENTTEAM_EVENT_LOG?.trim()
+  if (!path) return true
+  if (captureFailure) return false
+  if (event.type !== 'tool_execution_start' && event.type !== 'tool_execution_end') return true
+
+  const runId = process.env.AW_AGENTTEAM_RUN_ID?.trim()
+  if (!runId) {
+    captureFailure = 'AW_AGENTTEAM_RUN_ID is required when AW_AGENTTEAM_EVENT_LOG is enabled'
+    return false
+  }
+
+  const toolCallId = typeof event.toolCallId === 'string' ? event.toolCallId : null
+  const dedupeKey = toolCallId === null
+    ? null
+    : JSON.stringify([runId, identity.agentId, toolCallId, event.type])
+  if (dedupeKey !== null && recordedToolEvents.has(dedupeKey)) return true
+
+  const seq = ++sequence
+  const base = {
+    schema_version: 1,
+    run_id: runId,
+    event_id: `${process.pid}:${seq}:${randomUUID()}`,
+    source: 'aw-omp-agent-adapter',
+    source_seq: seq,
+    at_utc: new Date().toISOString(),
+    monotonic_ns: process.hrtime.bigint().toString(),
+    actor_agent_id: identity.agentId,
+    actor_role: identity.role,
+    channel_id: identity.channelId,
+    task_id: identity.taskId ?? null,
+    tool_call_id: toolCallId,
+    event_type: event.type,
+    tool: typeof event.toolName === 'string' ? event.toolName : 'tool',
+  }
+  const record = event.type === 'tool_execution_start'
+    ? { ...base, request: redact(event.args ?? {}) }
+    : { ...base, response: redact(event.result ?? event.output ?? ''), is_error: event.isError === true }
+
+  const appended = appendRecord(path, record)
+  if (appended && dedupeKey !== null) recordedToolEvents.add(dedupeKey)
+  return appended
+}
+
+export function ompAgentTeamAuditFailure(): string | null {
+  return captureFailure
+}

package/server/services/workshop/agents/omp-agent/client.ts

@@ -87,7 +87,7 @@ export abstract class OmpRpcAgentImplClient extends OmpRpcAgentImplEventMapping
       }
 
       // 注册 host tools(按角色差异化:lead 全量,worker 剔除调度/团队管理专属工具)
-      client.onHostToolCall(req => this.handleHostTool(req))
+      client.onHostToolCall(req => this.handleHostTool(req, client))
       await client.send({ type: 'set_host_tools', tools: hostToolsForAgent(this.selfAgentId, this.agentRole, this.channelId) })
 
       // 上下文治理探测(feature-detect 一次;失败退化被动 usage 跟踪)+ 原生压缩兜底保持开启

package/server/services/workshop/agents/omp-agent/event-mapping.ts

@@ -9,9 +9,18 @@ import type { AgentSessionEvent, CompactionResult } from '../adapters/omp-rpc-cl
 import { log } from './helpers'
 import { randomUUID } from 'node:crypto'
 import { toolArgsPreview } from '../prompt-builder'
+import { recordOmpAgentTeamToolEvent } from './agentteam-audit'
 
 export abstract class OmpRpcAgentImplEventMapping extends OmpRpcAgentImplToolsSteer {
   protected mapOmpEvent(event: AgentSessionEvent, taskId: string | undefined): AgentEvent[] {
+    const supervisionLease = this.activeSupervisionToolLease
+    const knownTaskId = taskId
+      ?? (supervisionLease?.client === this.client && supervisionLease.rootActive && !supervisionLease.signal?.aborted
+        ? supervisionLease.rootId ?? undefined
+        : undefined)
+      ?? this.toolState.currentTaskId
+      ?? undefined
+
     switch (event.type) {
       case 'agent_start':
         return [{
@@ -43,6 +52,12 @@ export abstract class OmpRpcAgentImplEventMapping extends OmpRpcAgentImplToolsSt
       }
 
       case 'tool_execution_start': {
+        recordOmpAgentTeamToolEvent(event, {
+          agentId: this.selfAgentId,
+          role: this.agentRole,
+          channelId: this.channelId,
+          taskId: knownTaskId,
+        })
         const toolName = event.toolName ?? 'tool'
         return [{
           kind: 'status',
@@ -60,6 +75,12 @@ export abstract class OmpRpcAgentImplEventMapping extends OmpRpcAgentImplToolsSt
       }
 
       case 'tool_execution_end': {
+        recordOmpAgentTeamToolEvent(event, {
+          agentId: this.selfAgentId,
+          role: this.agentRole,
+          channelId: this.channelId,
+          taskId: knownTaskId,
+        })
         // 工具结果事件(2026-10-05 评审):此前只有 start,end 被默认分支静默丢弃 ——
         // 工具调用不可审计。end 帧带 isError 与结果摘要(短截断)。
         // 结果可能是字符串或结构化对象:对象直接 String() 会变成 "[object Object]",