agentworkshop 0.8.3 → 0.8.5

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

@@ -1,104 +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)。`,
-  }
-}
+/**
+ * 经验采集工具(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)。`,
+  }
+}

package/server/services/workshop/agents/industrial/grant-guard.ts

@@ -32,6 +32,8 @@ const WRITE_TOOLS = new Set([
   // 产线管理面(启停直接改物理状态与批次窗口)
   'line_start',
   'line_stop',
+  // 团队节点授权:建立的是含写面的授权表(须持 operate;撤权是收敛动作,只按 readonly 复核)
+  'team_grant_nodes',
   // 模型采纳(OW-adopt):改变求解器运行的模型工件(控制面写向,HITL 卡裁决)
   'optimizer_profile_propose',
   // 本体(ONT):知识起草与发布提议属产线域写向动作(不写设备,但会改变控制侧知识来源)
@@ -45,12 +47,49 @@ const WRITE_TOOLS = new Set([
 
 /** 无需复核的纯协作/管理面工具(不触达产线数据) */
 const GRANT_EXEMPT = new Set([
-  'team_grant_nodes',
-  'team_revoke_nodes',
   'aml_activity',
   'exp_collect',
 ])
 
+/**
+ * 团队节点委派/随任务授权:不在 INDUSTRIAL_TOOL_NAMES(走 workspace 分发面),
+ * 但建立/回收的是产线节点授权 —— 必须并入 grant 复核。
+ * dispatch_task 仅在携带 grant_node_ids 时由 dispatch 调用(普通派发不改变授权面)。
+ */
+export const TEAM_DELEGATION_TOOL_NAMES = new Set(['team_grant_nodes', 'team_revoke_nodes', 'dispatch_task'])
+
+/** 工具所需产线权限:写族要求 operate,其余只读复核(单测可独立断言) */
+export function grantNeedOf(toolName: string): 'operate' | 'readonly' {
+  return WRITE_TOOLS.has(toolName) ? 'operate' : 'readonly'
+}
+
+/** 权限结论:operate 覆盖一切;readonly 仅满足只读动作 */
+export function grantAllowed(mode: LineMode, need: 'operate' | 'readonly'): boolean {
+  return mode === 'operate' || (need === 'readonly' && mode === 'readonly')
+}
+
+/** 遗留无主 channel(owner NULL)豁免:存量数据兼容;新建 channel 均有属主 */
+export function grantOwnerExempt(ownerUserId: string | null | undefined): boolean {
+  return !ownerUserId
+}
+
+/** 团队委派类参数解析:node_ids/nodeIds(数组或逗号串)与随任务授权 grant_node_ids。
+ *  **并集**而非优先级链 —— 同一请求里同时带 node_ids 与 grant_node_ids 时,两组目标线都要复核
+ *  (否则可用 node_ids 遮蔽 grant_node_ids,让授权落到未授权产线)。 */
+export function delegatedNodeIdsOf(args: Record<string, unknown>): string[] {
+  const one = (v: unknown) => (typeof v === 'string' || typeof v === 'number') && String(v).trim() ? String(v).trim() : ''
+  const out: string[] = []
+  for (const raw of [args.node_ids, args.nodeIds, args.grant_node_ids, args.grantNodeIds]) {
+    if (Array.isArray(raw)) out.push(...raw.map(one).filter(Boolean))
+    else if (typeof raw === 'string') out.push(...raw.split(',').map(one).filter(Boolean))
+    else {
+      const v = one(raw)
+      if (v) out.push(v)
+    }
+  }
+  return [...new Set(out)]
+}
+
 function draftLineId(draftJson: string): string {
   try {
     return (JSON.parse(draftJson || '{}') as { lineId?: string }).lineId ?? ''
@@ -91,7 +130,9 @@ async function resolveTargetLines(agentId: string, toolName: string, args: Recor
   const lineArg = one(args.line_id ?? args.lineId)
   if (lineArg) lines.add(lineArg)
   const ids = Array.isArray(args.ids) ? args.ids.map(one).filter(Boolean) : []
-  for (const id of ids) {
+  // 团队委派工具用 node_ids/nodeIds/grant_node_ids;逐节点映射产线,避免撤权者绕过
+  const delegatedIds = delegatedNodeIdsOf(args)
+  for (const id of [...ids, ...delegatedIds]) {
     const l = await nodeIdLine(id)
     if (l) lines.add(l)
   }
@@ -210,8 +251,9 @@ function deny(identity: GuardIdentity, toolName: string, args: Record<string, un
  * 工业工具分发前的 grant 复核。通过 → 静默返回;
  * 不通过 → 返回面向 agent 的工具错误文本(fail-closed,不做部分放行)。
  */
-export async function guardIndustrialToolGrant(identity: GuardIdentity, toolName: string, args: Record<string, unknown>): Promise<{ text: string, isError: true } | null> {
-  if (!INDUSTRIAL_TOOL_NAMES.has(toolName) || GRANT_EXEMPT.has(toolName)) return null
+export async function guardIndustrialToolGrant(identity: GuardIdentity, toolName: string, args: Record<string, unknown>, needOverride?: 'operate' | 'readonly'): Promise<{ text: string, isError: true } | null> {
+  if (GRANT_EXEMPT.has(toolName)) return null
+  if (!INDUSTRIAL_TOOL_NAMES.has(toolName) && !TEAM_DELEGATION_TOOL_NAMES.has(toolName)) return null
   if (!identity.channelId) return null
   try {
     const { getWorkshopManager } = await import('@/server/plugins/workshop')
@@ -221,14 +263,15 @@ export async function guardIndustrialToolGrant(identity: GuardIdentity, toolName
       return deny(identity, toolName, args, `工具调用被拒:所属频道不存在或已删除(channel=${identity.channelId.slice(0, 8)})。`, 'channel_missing')
     }
     // 遗留无主 channel 豁免(存量兼容;新 channel 均有属主)
-    if (!channel.ownerUserId) return null
-    const owner = userRepository.findById(channel.ownerUserId)
+    const ownerUserId = channel.ownerUserId ?? ''
+    if (grantOwnerExempt(ownerUserId)) return null
+    const owner = userRepository.findById(ownerUserId)
     if (!owner) {
       return deny(identity, toolName, args, '工具调用被拒:频道属主账号不存在(fail-closed)。请联系管理员。', 'owner_missing')
     }
     if (owner.role === 'admin') return null
 
-    const need: LineMode = WRITE_TOOLS.has(toolName) ? 'operate' : 'readonly'
+    const need = needOverride ?? grantNeedOf(toolName)
     const resolved = await resolveTargetLines(identity.agentId, toolName, args ?? {})
     // P1-6:频道绑线并入复核集 —— line_start/line_stop 等产线管理工具的目标产线
     // 来自频道绑线(ch.lineId)而非调用参数,agent 无节点绑定时 resolveTargetLines
@@ -239,7 +282,7 @@ export async function guardIndustrialToolGrant(identity: GuardIdentity, toolName
     if (lineSet.size === 0) return null
     for (const lineId of lineSet) {
       const mode = lineMode({ id: owner.id, role: owner.role }, lineId)
-      const ok = mode === 'operate' || (need === 'readonly' && mode === 'readonly')
+      const ok = grantAllowed(mode, need)
       if (!ok) {
         const what = need === 'operate' ? '写控/下发' : '读取'
         return deny(

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

@@ -16,7 +16,7 @@ import { getDcwParamRepo } from '../../dcw/param-map.repo'
 import { getOps } from '../../ops/ops'
 import { settingOf } from '../../settings'
 import { fanoutQuery, windowOf } from './audit-query'
-import { assertRecipeCreate, assertRecipeOperation, recipeApprovalPayload } from './recipe-gate'
+import { assertRecipeCreate, assertRecipeOperation, recipeApprovalPayload, type ActiveRecipeContext } from './recipe-gate'
 
 // ================================================================
 // 运维日志 / Recipe 变更史查询(Agent 自查面:负责产线 scoped)
@@ -779,7 +779,7 @@ export async function toolRecipeUpdate(agentId: string, args: {
           const old = recipe.params.find(x => x.nodeId === String(p.node_id).trim())?.value
           return { nodeId: String(p.node_id).trim(), name: node?.name ?? String(p.node_id), from: old ?? null, to: Number(p.value), unit: node?.unit }
         }),
-        runId: gate.activeRunId,
+        context: gate.activeContext,
       }) },
     )
     if (!gateDecision.approved) {
@@ -788,7 +788,7 @@ export async function toolRecipeUpdate(agentId: string, args: {
       }
     }
     if (gateDecision.comment) hitlNote = `\n人工附言:${gateDecision.comment}`
-    const stale = await revalidateApprovedAction(agentId, recipe, 'update', 'recipe_update', { recipe_id: recipeId })
+    const stale = await revalidateApprovedAction(agentId, recipe, 'update', 'recipe_update', { recipe_id: recipeId }, gate.activeContext)
     if (stale) return stale
   }
   // 旧值快照(repo.update 原地改写 recipe.params,事后再取会把 before 读成新值)
@@ -887,7 +887,7 @@ export async function toolRecipeRollback(agentId: string, args: {
       recipe.id,
       `${emergency ? '【应急豁免频控】' : ''}配方回退:「${recipe.name}」→ ${toLastGood ? '已知良好批次冻结' : `v${version}`}${dispatch ? '(统一回退:定义回退+整批重下发)' : '(仅定义回退)'} | 理由:${reason} | 批准=执行回退;拒绝可附指导`,
       `${emergency ? '【应急】' : ''}配方回退审批`,
-      { payload: { ...recipeApprovalPayload('rollback', recipe.id, recipe.name, { reason, runId: gate.activeRunId }), ...(emergency ? { emergency: true } : {}) } },
+      { payload: { ...recipeApprovalPayload('rollback', recipe.id, recipe.name, { reason, context: gate.activeContext }), ...(emergency ? { emergency: true } : {}) } },
     )
     gateApprovalId = gateDecision.id
     if (!gateDecision.approved) {
@@ -896,11 +896,15 @@ export async function toolRecipeRollback(agentId: string, args: {
       }
     }
     if (gateDecision.comment) hitlNote = `\n人工附言:${gateDecision.comment}`
-    const stale = await revalidateApprovedAction(agentId, recipe, 'rollback', 'recipe_rollback', { recipe_id: recipeId })
+    const stale = await revalidateApprovedAction(agentId, recipe, 'rollback', 'recipe_rollback', { recipe_id: recipeId }, gate.activeContext)
     if (stale) return stale
   }
   try {
     if (dispatch) {
+      if (gate.hitlRequired) {
+        const staleAtDispatch = approvedContextError(agentId, recipe, 'rollback', gate.activeContext)
+        if (staleAtDispatch) return staleAtDispatch
+      }
       const { recipe: updated, run, definitionNoop } = await getDcwController().rollbackRecipeAndDispatch(recipeId, {
         version: toLastGood ? undefined : version,
         toLastGood,
@@ -979,23 +983,46 @@ async function hitlDispatchGate(agentId: string, recipeId: string, detail: strin
 }
 
 /**
- * 审批返回「批准」后的二次授权复核(2026-10-18):审批可能挂起数分钟,
- * 期间绑定/产线授权/运行批次都可能被撤销。批准不等于授权仍然有效:
+ * 审批返回「批准」后的二次状态复核:审批可能挂起数分钟,
+ * 期间绑定/产线授权/活动产线上下文都可能变化。批准不等于授权与上下文仍然有效:
  *  - 重新跑 assertRecipeOperation(绑定/二级认证/运行门);
+ *  - 将当前 line/product/recipe/run 元组与审批时快照比较,变化即拒绝;
  *  - 重新跑 grant-guard(频道属主的产线 grant,收权即失活)。
- * 任一失败 → 本次不执行,回包说明原因(Agent 可据此重新申请)。
+ * 任一失败 → 本次不执行,回包说明原因(Agent 可据此核实上下文并重新申请)。
  */
+function approvedContextError(
+  agentId: string,
+  recipe: { id: string, name: string, lineId?: string, access?: { requireAuth?: boolean, authorizedAgentIds?: string[] } },
+  op: 'update' | 'dispatch' | 'trial' | 'rollback',
+  expectedContext: ActiveRecipeContext,
+): { text: string, isError: true } | null {
+  const currentGate = assertRecipeOperation(agentId, recipe, op)
+  if (!currentGate.ok) {
+    return { text: `人工已批准,但审批期间授权已失效,本次未执行:${currentGate.text}`, isError: true }
+  }
+  const current = currentGate.activeContext
+  if (current.lineId !== expectedContext.lineId
+    || current.runId !== expectedContext.runId
+    || current.recipeId !== expectedContext.recipeId
+    || current.productId !== expectedContext.productId) {
+    return {
+      text: '人工已批准,但审批期间产线/产品/配方/批次上下文已变化,本次未执行。请核查当前运行上下文后重新提交。',
+      isError: true,
+    }
+  }
+  return null
+}
+
 export async function revalidateApprovedAction(
   agentId: string,
   recipe: { id: string, name: string, lineId?: string, access?: { requireAuth?: boolean, authorizedAgentIds?: string[] } },
   op: 'update' | 'dispatch' | 'trial' | 'rollback',
   toolName: string,
   args: Record<string, unknown>,
+  expectedContext: ActiveRecipeContext,
 ): Promise<{ text: string, isError: true } | null> {
-  const again = assertRecipeOperation(agentId, recipe, op)
-  if (!again.ok) {
-    return { text: `人工已批准,但审批期间授权已失效,本次未执行:${again.text}`, isError: true }
-  }
+  const initialContextError = approvedContextError(agentId, recipe, op, expectedContext)
+  if (initialContextError) return initialContextError
   try {
     // manager 未装配(单测/嵌入)→ 只做绑定与运行门复核;装配后叠加产线 grant 复核
     const g = globalThis as typeof globalThis & {
@@ -1011,6 +1038,11 @@ export async function revalidateApprovedAction(
   catch (err) {
     return { text: `人工已批准,但审批后权限复核不可用,本次未执行:${err instanceof Error ? err.message : String(err)}。请稍后重试。`, isError: true }
   }
+  // Grant lookup is asynchronous. Re-read the active tuple after that await so
+  // queued line/run changes cannot pass between the initial comparison and the
+  // caller's dispatch continuation.
+  const changedAfterGrantCheck = approvedContextError(agentId, recipe, op, expectedContext)
+  if (changedAfterGrantCheck) return changedAfterGrantCheck
   return null
 }
 
@@ -1086,7 +1118,7 @@ export async function toolRecipeTrial(agentId: string, args: {
             const old = recipe.params.find(x => x.nodeId === p.nodeId)?.value
             return { nodeId: p.nodeId, name: node?.name ?? p.nodeId, from: old ?? null, to: p.value, unit: node?.unit }
           }),
-          runId: gate.activeRunId,
+          context: gate.activeContext,
         }), ...(emergency ? { emergency: true } : {}) } },
       )
       gateApprovalId = gateDecision.id
@@ -1097,8 +1129,10 @@ export async function toolRecipeTrial(agentId: string, args: {
       }
       // 人工附言随批准回执回流(Agent 与审计都能看到放行时人的原话)
       if (gateDecision.comment) hitlNote = `\n人工附言:${gateDecision.comment}`
-      const stale = await revalidateApprovedAction(agentId, recipe, 'trial', 'recipe_trial', { recipe_id: recipeId })
+      const stale = await revalidateApprovedAction(agentId, recipe, 'trial', 'recipe_trial', { recipe_id: recipeId }, gate.activeContext)
       if (stale) return stale
+      const staleAtDispatch = approvedContextError(agentId, recipe, 'trial', gate.activeContext)
+      if (staleAtDispatch) return staleAtDispatch
     }
     const run = await getDcwController().applyRecipe(recipeId, { overrides: list, trial: true, agentDispatch: true, agentApprovalId: gateApprovalId, emergency })
     // ACK 鉴定三段口径(2026-10-08):ok 只是命令受理,未证实/失败必须如实回给 Agent
@@ -1187,7 +1221,7 @@ export async function toolRecipeApply(agentId: string, args: {
             const node = getDcwController().byId(p.nodeId)
             return { nodeId: p.nodeId, name: node?.name ?? p.nodeId, from: null, to: p.value, unit: node?.unit }
           }),
-          runId: gate.activeRunId,
+          context: gate.activeContext,
         }), recipeVersion: dispatch.version, ...(emergency ? { emergency: true } : {}) } },
       )
       gateApprovalId = gateDecision.id
@@ -1198,7 +1232,7 @@ export async function toolRecipeApply(agentId: string, args: {
       }
       // 人工附言随批准回执回流(与 recipe_trial 同口径)
       if (gateDecision.comment) hitlNote = `\n人工附言:${gateDecision.comment}`
-      const stale = await revalidateApprovedAction(agentId, recipe, 'dispatch', 'recipe_apply', { recipe_id: recipeId })
+      const stale = await revalidateApprovedAction(agentId, recipe, 'dispatch', 'recipe_apply', { recipe_id: recipeId }, gate.activeContext)
       if (stale) return stale
     }
     // 放在最后一次 await 之后,与 applyRecipe 的同步取值/建批之间不再让出执行权。
@@ -1206,6 +1240,10 @@ export async function toolRecipeApply(agentId: string, args: {
     if (!currentRecipe || JSON.stringify(currentRecipe) !== approvedDefinition) {
       return { text: '配方在审批期间已变更,与本次审批展示的快照不一致,本次未执行。请核查最新配方后重新提交 recipe_apply。', isError: true }
     }
+    if (gate.hitlRequired) {
+      const staleAtDispatch = approvedContextError(agentId, recipe, 'dispatch', gate.activeContext)
+      if (staleAtDispatch) return staleAtDispatch
+    }
     // 完整覆盖集让控制器复制每个已批准值,逐参数异步写期间也不再共享可变配方参数。
     const run = await getDcwController().applyRecipe(recipeId, { overrides: dispatch.params, agentDispatch: true, agentApprovalId: gateApprovalId, emergency })
     // ACK 鉴定三段口径(2026-10-08):ok 只是命令受理,未证实/失败必须如实回给 Agent

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

@@ -1,69 +1,69 @@
-/**
- * 工艺参数语义面辅助(参数引用解析/量程文本/写容差)与 param_control 的 v2 禁用桩
- * (由 server/services/workshop/agents/industrial-tools.ts 按职责拆出;内容逐行原文搬运)
- */
-import type { DcwParamView } from '../../../../../shared/dcw-protocol'
-import { getDcwController } from '../../dcw/dcw-controller'
-import { getDcwParamRepo } from '../../dcw/param-map.repo'
-import { limitsBreakdownOf } from '../../dcw/param-limits'
-
-/** 读/设定偏差对照容差(与服务端回读死区同口径) */
-export function writeToleranceOf(node: { decimals: number, min: number, max: number }): number {
-  return Math.max(0.5 * 10 ** -node.decimals, (node.max - node.min) * 0.005)
-}
-
-/** 工艺参数解析(param_control/param_read 共用):pp-id 优先,其次按 key;跨产线同名需 line_id 消歧 */
-export function resolveParamRef(ref: string, lineId?: string): { ok: true, param: DcwParamView } | { ok: false, text: string, isError: true } {
-  const repo = getDcwParamRepo()
-  const trimmed = String(ref ?? '').trim()
-  if (!trimmed) {
-    return { ok: false, text: 'param 必填:工艺参数 id(pp-*)或参数 key(见 my_industrial_nodes)。', isError: true }
-  }
-  const row = trimmed.startsWith('pp-') ? repo.byId(trimmed) : undefined
-  if (row) {
-    const view = repo.viewOf(row)
-    if (!view) return { ok: false, text: `工艺参数 ${trimmed} 的执行节点已不存在(映射悬空)。`, isError: true }
-    if (lineId && view.lineId !== lineId) {
-      return { ok: false, text: `工艺参数 ${view.key} 不属于产线 ${lineId}(实际归属:${view.lineId || '未分配'})。`, isError: true }
-    }
-    return { ok: true, param: view }
-  }
-  const hits = repo.byKey(trimmed)
-    .map(r => repo.viewOf(r))
-    .filter((v): v is DcwParamView => v != null)
-  const scoped = lineId ? hits.filter(v => v.lineId === lineId) : hits
-  if (scoped.length === 1) return { ok: true, param: scoped[0]! }
-  if (scoped.length === 0) {
-    const catalog = repo.listViews().slice(0, 12).map(v => `${v.key}(${v.name})`).join('、')
-    return { ok: false, text: `未找到工艺参数「${trimmed}」${lineId ? `(产线 ${lineId})` : ''}。可用参数:${catalog || '无 —— 请先让用户创建写控节点生成参数面'}。`, isError: true }
-  }
-  return { ok: false, text: `工艺参数「${trimmed}」命中 ${scoped.length} 条同名映射,请附加 line_id 消歧或改用参数 id(${scoped.map(v => v.id).join(' / ')})。`, isError: true }
-}
-
-/** 参数面权限摘要(工具回包统一口径;不透出寄存器等 PLC 寻址细节) */
-export function paramLimitsText(param: DcwParamView): string {
-  const node = getDcwController().byId(param.nodeId)
-  if (!node) return '执行节点已删除'
-  const bd = limitsBreakdownOf(node)
-  const layers = bd.layers.filter(l => l.min != null || l.max != null).map(l => l.label).join(' ∩ ')
-  return `有效写入区间 ${bd.effective.min}~${bd.effective.max}${param.unit}(约束层:${layers || '无'});单步上限=${bd.stepLimit == null ? '未配置' : `${bd.stepLimit}${param.unit}`}(${bd.stepLimitSource});Agent写入间隔≥60s`
-}
-
-/** 工具:param_control —— 按工艺参数下发设定值(推荐的参数语义寻址面)。
- *  权限沿用节点绑定(参数 → 执行节点);限界联锁(参数基准 ∩ 产品 ∩ 配方 ∩ 节点安全量程)
- *  在网关咽喉点统一生效。args.hypothesis 声明本次假设(入册),args.task_id 关联任务。 */
-export async function toolParamControl(agentId: string, args: {
-  param?: string
-  value?: number | string
-  hypothesis?: string
-  task_id?: string
-  line_id?: string
-}, channelId?: string): Promise<{ text: string, isError?: boolean }> {
-  void agentId
-  void args
-  void channelId
-  return {
-    text: '参数直写已禁用(权限模型 v2):Agent 不再直接改写运行中的工艺参数。请改用绑定的配方 —— recipe_update(写入新版本)/ recipe_apply(整批下发)/ recipe_trial(候选试验);治理联锁与 HITL 在配方面照常生效。',
-    isError: true,
-  }
-}
+/**
+ * 工艺参数语义面辅助(参数引用解析/量程文本/写容差)与 param_control 的 v2 禁用桩
+ * (由 server/services/workshop/agents/industrial-tools.ts 按职责拆出;内容逐行原文搬运)
+ */
+import type { DcwParamView } from '../../../../../shared/dcw-protocol'
+import { getDcwController } from '../../dcw/dcw-controller'
+import { getDcwParamRepo } from '../../dcw/param-map.repo'
+import { limitsBreakdownOf } from '../../dcw/param-limits'
+
+/** 读/设定偏差对照容差(与服务端回读死区同口径) */
+export function writeToleranceOf(node: { decimals: number, min: number, max: number }): number {
+  return Math.max(0.5 * 10 ** -node.decimals, (node.max - node.min) * 0.005)
+}
+
+/** 工艺参数解析(param_control/param_read 共用):pp-id 优先,其次按 key;跨产线同名需 line_id 消歧 */
+export function resolveParamRef(ref: string, lineId?: string): { ok: true, param: DcwParamView } | { ok: false, text: string, isError: true } {
+  const repo = getDcwParamRepo()
+  const trimmed = String(ref ?? '').trim()
+  if (!trimmed) {
+    return { ok: false, text: 'param 必填:工艺参数 id(pp-*)或参数 key(见 my_industrial_nodes)。', isError: true }
+  }
+  const row = trimmed.startsWith('pp-') ? repo.byId(trimmed) : undefined
+  if (row) {
+    const view = repo.viewOf(row)
+    if (!view) return { ok: false, text: `工艺参数 ${trimmed} 的执行节点已不存在(映射悬空)。`, isError: true }
+    if (lineId && view.lineId !== lineId) {
+      return { ok: false, text: `工艺参数 ${view.key} 不属于产线 ${lineId}(实际归属:${view.lineId || '未分配'})。`, isError: true }
+    }
+    return { ok: true, param: view }
+  }
+  const hits = repo.byKey(trimmed)
+    .map(r => repo.viewOf(r))
+    .filter((v): v is DcwParamView => v != null)
+  const scoped = lineId ? hits.filter(v => v.lineId === lineId) : hits
+  if (scoped.length === 1) return { ok: true, param: scoped[0]! }
+  if (scoped.length === 0) {
+    const catalog = repo.listViews().slice(0, 12).map(v => `${v.key}(${v.name})`).join('、')
+    return { ok: false, text: `未找到工艺参数「${trimmed}」${lineId ? `(产线 ${lineId})` : ''}。可用参数:${catalog || '无 —— 请先让用户创建写控节点生成参数面'}。`, isError: true }
+  }
+  return { ok: false, text: `工艺参数「${trimmed}」命中 ${scoped.length} 条同名映射,请附加 line_id 消歧或改用参数 id(${scoped.map(v => v.id).join(' / ')})。`, isError: true }
+}
+
+/** 参数面权限摘要(工具回包统一口径;不透出寄存器等 PLC 寻址细节) */
+export function paramLimitsText(param: DcwParamView): string {
+  const node = getDcwController().byId(param.nodeId)
+  if (!node) return '执行节点已删除'
+  const bd = limitsBreakdownOf(node)
+  const layers = bd.layers.filter(l => l.min != null || l.max != null).map(l => l.label).join(' ∩ ')
+  return `有效写入区间 ${bd.effective.min}~${bd.effective.max}${param.unit}(约束层:${layers || '无'});单步上限=${bd.stepLimit == null ? '未配置' : `${bd.stepLimit}${param.unit}`}(${bd.stepLimitSource});Agent写入间隔≥60s`
+}
+
+/** 工具:param_control —— 按工艺参数下发设定值(推荐的参数语义寻址面)。
+ *  权限沿用节点绑定(参数 → 执行节点);限界联锁(参数基准 ∩ 产品 ∩ 配方 ∩ 节点安全量程)
+ *  在网关咽喉点统一生效。args.hypothesis 声明本次假设(入册),args.task_id 关联任务。 */
+export async function toolParamControl(agentId: string, args: {
+  param?: string
+  value?: number | string
+  hypothesis?: string
+  task_id?: string
+  line_id?: string
+}, channelId?: string): Promise<{ text: string, isError?: boolean }> {
+  void agentId
+  void args
+  void channelId
+  return {
+    text: '参数直写已禁用(权限模型 v2):Agent 不再直接改写运行中的工艺参数。请改用绑定的配方 —— recipe_update(写入新版本)/ recipe_apply(整批下发)/ recipe_trial(候选试验);治理联锁与 HITL 在配方面照常生效。',
+    isError: true,
+  }
+}