agentworkshop 0.8.2 → 0.8.3

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/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, type ActiveRecipeContext } from './recipe-gate'
+import { assertRecipeCreate, assertRecipeOperation, recipeApprovalPayload } 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 }
         }),
-        context: gate.activeContext,
+        runId: gate.activeRunId,
       }) },
     )
     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 }, gate.activeContext)
+    const stale = await revalidateApprovedAction(agentId, recipe, 'update', 'recipe_update', { recipe_id: recipeId })
     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, context: gate.activeContext }), ...(emergency ? { emergency: true } : {}) } },
+      { payload: { ...recipeApprovalPayload('rollback', recipe.id, recipe.name, { reason, runId: gate.activeRunId }), ...(emergency ? { emergency: true } : {}) } },
     )
     gateApprovalId = gateDecision.id
     if (!gateDecision.approved) {
@@ -896,15 +896,11 @@ 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 }, gate.activeContext)
+    const stale = await revalidateApprovedAction(agentId, recipe, 'rollback', 'recipe_rollback', { recipe_id: recipeId })
     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,
@@ -983,46 +979,23 @@ 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 initialContextError = approvedContextError(agentId, recipe, op, expectedContext)
-  if (initialContextError) return initialContextError
+  const again = assertRecipeOperation(agentId, recipe, op)
+  if (!again.ok) {
+    return { text: `人工已批准,但审批期间授权已失效,本次未执行:${again.text}`, isError: true }
+  }
   try {
     // manager 未装配(单测/嵌入)→ 只做绑定与运行门复核;装配后叠加产线 grant 复核
     const g = globalThis as typeof globalThis & {
@@ -1038,11 +1011,6 @@ 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
 }
 
@@ -1118,7 +1086,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 }
           }),
-          context: gate.activeContext,
+          runId: gate.activeRunId,
         }), ...(emergency ? { emergency: true } : {}) } },
       )
       gateApprovalId = gateDecision.id
@@ -1129,10 +1097,8 @@ 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 }, gate.activeContext)
+      const stale = await revalidateApprovedAction(agentId, recipe, 'trial', 'recipe_trial', { recipe_id: recipeId })
       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
@@ -1221,7 +1187,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 }
           }),
-          context: gate.activeContext,
+          runId: gate.activeRunId,
         }), recipeVersion: dispatch.version, ...(emergency ? { emergency: true } : {}) } },
       )
       gateApprovalId = gateDecision.id
@@ -1232,7 +1198,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 }, gate.activeContext)
+      const stale = await revalidateApprovedAction(agentId, recipe, 'dispatch', 'recipe_apply', { recipe_id: recipeId })
       if (stale) return stale
     }
     // 放在最后一次 await 之后,与 applyRecipe 的同步取值/建批之间不再让出执行权。
@@ -1240,10 +1206,6 @@ 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,
+  }
+}

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

@@ -20,19 +20,12 @@ import { getActiveLineRun } from '../../dcw/line-run'
 
 export type RecipeOp = 'update' | 'dispatch' | 'trial' | 'rollback' | 'create'
 
-export type ActiveRecipeContext = {
-  lineId: string
-  runId: string
-  recipeId: string
-  productId: string
-}
-
 export type RecipeGateResult
-  = | { ok: true, binding: AgentNodeBinding, hitlRequired: boolean, activeContext: ActiveRecipeContext }
+  = | { ok: true, binding: AgentNodeBinding, hitlRequired: boolean, activeRunId: string }
     | { ok: false, text: string }
 
 /** 运行门:该配方当前是否有活动批次(未结束的 run) */
-export function activeRunOfRecipe(recipeId: string): ActiveRecipeContext | null {
+export function activeRunOfRecipe(recipeId: string): { id: string } | null {
   const run = getDcwController().listRuns().find(r => r.recipeId === recipeId && !r.endedAt)
   if (!run) return null
   // 反僵尸交叉校验(鲁棒性):DB 行未结束 ≠ 产线在运行 —— 多次 apply/崩溃/重启会泄漏
@@ -40,13 +33,8 @@ export function activeRunOfRecipe(recipeId: string): ActiveRecipeContext | null
   // 权威运行态是 line-run 注册表(内存+line-runs.json 落盘,崩溃可恢复):
   // run 所属产线必须在注册表中运行,且注册表的活跃批次就是本批次。
   const active = getActiveLineRun(run.lineId)
-  if (!active || active.runId !== run.id || active.recipeId !== recipeId) return null
-  return {
-    lineId: active.lineId,
-    runId: active.runId,
-    recipeId: active.recipeId,
-    productId: active.productId,
-  }
+  if (!active || active.runId !== run.id) return null
+  return { id: run.id }
 }
 
 /** 统一鉴权门:绑定 → 二级认证 → 运行门;返回绑定与 HITL 判定(不做挂起,挂起由调用方执行) */
@@ -86,7 +74,7 @@ export function assertRecipeOperation(
   // ⑤ 全局开关兼容位:security.recipeDispatchApproval 开启时即便 auto 也挂审批(保留语义)
   const globalGate = false // 由调用方按 settingOf('security.recipeDispatchApproval') 叠加(本模块不依赖设置服务)
   void globalGate
-  return { ok: true, binding, hitlRequired: binding.mode === 'manual' || lineManual, activeContext: run }
+  return { ok: true, binding, hitlRequired: binding.mode === 'manual' || lineManual, activeRunId: run.id }
 }
 
 /** 新建配方的授权门(尚无 recipe 可绑定):要求 Agent 在该线至少有一个写向绑定
@@ -128,7 +116,6 @@ export function assertRecipeCreate(agentId: string, lineId: string): { ok: true,
 export function recipeApprovalPayload(op: RecipeOp, recipeId: string, recipeName: string, extra: {
   reason: string
   params?: Array<{ nodeId: string, name: string, from: number | null, to: number, unit?: string }>
-  context?: ActiveRecipeContext
   runId?: string
 }): Record<string, unknown> {
   return {
@@ -139,6 +126,6 @@ export function recipeApprovalPayload(op: RecipeOp, recipeId: string, recipeName
     recipeName,
     reason: extra.reason,
     ...(extra.params ? { params: extra.params } : {}),
-    ...(extra.context ? { context: { ...extra.context }, runId: extra.context.runId } : extra.runId ? { runId: extra.runId } : {}),
+    ...(extra.runId ? { runId: extra.runId } : {}),
   }
 }

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

@@ -278,7 +278,7 @@ export async function toolRecipePropose(agentId: string, args: {
   }
 
   // 批准不等于授权仍有效:复核绑定/认证/运行门/产线 grant(审批期间可能被撤销)
-  const stale = await revalidateApprovedAction(agentId, recipe, 'dispatch', 'recipe_propose', { recipe_id: recipeId }, gate.activeContext)
+  const stale = await revalidateApprovedAction(agentId, recipe, 'dispatch', 'recipe_propose', { recipe_id: recipeId })
   if (stale) return stale
 
   // ---------- ⑦b 批准(choice 已由 decide 链 fail-closed 归一):选定包整批下发 ----------