agentworkshop 0.8.4 → 0.8.5

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

@@ -17,15 +17,23 @@ import { getAgentNodeBindingRepo, type AgentNodeBinding } from '../node-bindings
 import { getDcwController } from '../../dcw/dcw-controller'
 import { getDcwLineRepo } from '../../dcw/dcw-line.repo'
 import { getActiveLineRun } from '../../dcw/line-run'
+import { executionModeOfAgent } from '../execution-mode'
 
 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, activeRunId: string }
+  = | { ok: true, binding: AgentNodeBinding, hitlRequired: boolean, activeContext: ActiveRecipeContext }
     | { ok: false, text: string }
 
 /** 运行门:该配方当前是否有活动批次(未结束的 run) */
-export function activeRunOfRecipe(recipeId: string): { id: string } | null {
+export function activeRunOfRecipe(recipeId: string): ActiveRecipeContext | null {
   const run = getDcwController().listRuns().find(r => r.recipeId === recipeId && !r.endedAt)
   if (!run) return null
   // 反僵尸交叉校验(鲁棒性):DB 行未结束 ≠ 产线在运行 —— 多次 apply/崩溃/重启会泄漏
@@ -33,8 +41,13 @@ export function activeRunOfRecipe(recipeId: string): { id: string } | null {
   // 权威运行态是 line-run 注册表(内存+line-runs.json 落盘,崩溃可恢复):
   // run 所属产线必须在注册表中运行,且注册表的活跃批次就是本批次。
   const active = getActiveLineRun(run.lineId)
-  if (!active || active.runId !== run.id) return null
-  return { id: run.id }
+  if (!active || active.runId !== run.id || active.recipeId !== recipeId) return null
+  return {
+    lineId: active.lineId,
+    runId: active.runId,
+    recipeId: active.recipeId,
+    productId: active.productId,
+  }
 }
 
 /** 统一鉴权门:绑定 → 二级认证 → 运行门;返回绑定与 HITL 判定(不做挂起,挂起由调用方执行) */
@@ -70,11 +83,14 @@ export function assertRecipeOperation(
   // ④ HITL 判定:manual 绑定 → 逐动作人工批准;auto → 免批。
   //    线级总闸(2026-10-08 生产化):line.controlMode='manual'(缺省)时,即便绑定为
   //    auto 也强制人工审批 —— 手动模式下人类必须过目每一次写动作(fail-safe)。
+  //    频道层钳位(2026-10-28 三模式):Agent 所属频道 executionMode='manual' 时同理强制;
+  //    'auto'(中性缺省)/'observe'(分发层已拒写,不可达)不改变本判定。
   const lineManual = recipe.lineId ? getDcwLineRepo().controlModeOf(recipe.lineId) === 'manual' : false
+  const channelManual = executionModeOfAgent(agentId) === 'manual'
   // ⑤ 全局开关兼容位:security.recipeDispatchApproval 开启时即便 auto 也挂审批(保留语义)
   const globalGate = false // 由调用方按 settingOf('security.recipeDispatchApproval') 叠加(本模块不依赖设置服务)
   void globalGate
-  return { ok: true, binding, hitlRequired: binding.mode === 'manual' || lineManual, activeRunId: run.id }
+  return { ok: true, binding, hitlRequired: binding.mode === 'manual' || lineManual || channelManual, activeContext: run }
 }
 
 /** 新建配方的授权门(尚无 recipe 可绑定):要求 Agent 在该线至少有一个写向绑定
@@ -109,13 +125,15 @@ export function assertRecipeCreate(agentId: string, lineId: string): { ok: true,
     }
   }
   const lineManual = getDcwLineRepo().controlModeOf(lineId) === 'manual'
-  return { ok: true, hitlRequired: manualBound || lineManual }
+  const channelManual = executionModeOfAgent(agentId) === 'manual'
+  return { ok: true, hitlRequired: manualBound || lineManual || channelManual }
 }
 
 /** 审批单载荷(结构化;前端审批卡渲染理由/参数/批次) */
 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 {
@@ -126,6 +144,6 @@ export function recipeApprovalPayload(op: RecipeOp, recipeId: string, recipeName
     recipeName,
     reason: extra.reason,
     ...(extra.params ? { params: extra.params } : {}),
-    ...(extra.runId ? { runId: extra.runId } : {}),
+    ...(extra.context ? { context: { ...extra.context }, runId: extra.context.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 })
+  const stale = await revalidateApprovedAction(agentId, recipe, 'dispatch', 'recipe_propose', { recipe_id: recipeId }, gate.activeContext)
   if (stale) return stale
 
   // ---------- ⑦b 批准(choice 已由 decide 链 fail-closed 归一):选定包整批下发 ----------

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

@@ -22,6 +22,8 @@ import { getRecipeRollBackManager } from '../dcw/recipe-rollback-manager'
 import { limitsBreakdownOf } from '../dcw/param-limits'
 import { MES_REST_DRIVER_KIND, mesCatalogEntryOf } from '../mes/mes-controller'
 import { getDcwParamRepo } from '../dcw/param-map.repo'
+import { promptLocaleOf, tr, type PromptLocale } from './prompt-i18n'
+import { executionModeOfAgent } from './execution-mode'
 
 /** 从属设备描述(名称/状态/实时遥测;数据驱动) */
 function describeTwin(bindId: string | null | undefined): string | null {
@@ -38,7 +40,7 @@ function describeTwins(node: { deviceIds?: string[], deviceBindingId?: string |
 }
 
 /** 数控节点语义卡:模板 semantics(或节点覆盖)× 实时数据合成 */
-function dcwSemanticCard(nodeId: string, mode: string): string | null {
+function dcwSemanticCard(nodeId: string, mode: string, locale: PromptLocale = 'zh'): string | null {
   const node = getDcwController().byId(nodeId)
   if (!node) return null
   const tpl = findDcwTemplate(node.templateKey)
@@ -55,33 +57,35 @@ function dcwSemanticCard(nodeId: string, mode: string): string | null {
   const param = recipe?.params.find(p => p.nodeId === nodeId)
   const twinDesc = describeTwins(node).join(' | ') || null
   const stepProfile = limitsBreakdownOf(node)
-  const stepText = stepProfile.stepLimit == null ? '未配置(探索阶段禁止无界写入)' : `${Number(stepProfile.stepLimit.toFixed(node.decimals))}${node.unit}(来源:${stepProfile.stepLimitSource})`
+  const stepText = stepProfile.stepLimit == null
+    ? tr(locale, '未配置(探索阶段禁止无界写入)', 'not configured (unbounded writes are forbidden during exploration)')
+    : `${Number(stepProfile.stepLimit.toFixed(node.decimals))}${node.unit}(${tr(locale, '来源:', 'source:')}${stepProfile.stepLimitSource})`
   const route = isMes
-    ? '写入经 MES 集成下发(REST API;多字段接口由 writeHook 只组装本节点声明的字段,writeCheckHook 二次校验回执)'
-    : `写入经驱动 ${node.driver} 下发 PLC(寄存器/换算封装在驱动配置内,你只面对工程量)`
+    ? tr(locale, '写入经 MES 集成下发(REST API;多字段接口由 writeHook 只组装本节点声明的字段,writeCheckHook 二次校验回执)', 'Writes are dispatched through the MES integration (REST API; multi-field endpoints are assembled by writeHook for this node only, with writeCheckHook verifying the acknowledgement)')
+    : tr(locale, `写入经驱动 ${node.driver} 下发 PLC(寄存器/换算封装在驱动配置内,你只面对工程量)`, `Writes go through driver ${node.driver} to the PLC (register scaling is encapsulated in the driver config; you only deal in engineering units)`)
 
   const lines = [
-    `#### ◆ ${node.name} [id=${nodeId}]${isMes ? '[MES 集成点位]' : ''}`,
-    `- 物理量: ${tpl?.ch ?? node.templateKey},单位 ${node.unit},精度 ${node.decimals} 位小数`,
+    `#### ◆ ${node.name} [id=${nodeId}]${isMes ? tr(locale, '[MES 集成点位]', '[MES integration point]') : ''}`,
+    tr(locale, `- 物理量: ${tpl?.ch ?? node.templateKey},单位 ${node.unit},精度 ${node.decimals} 位小数`, `- Physical quantity: ${tpl?.ch ?? node.templateKey}, unit ${node.unit}, precision ${node.decimals} decimals`),
   ]
-  if (sem) lines.push(`- 工艺语义: ${sem}${nodeSem ? '' : tplSem ? '(来自模板)' : '(来自 MES 点位描述)'}`)
-  else lines.push(`- 工艺语义: (待补)该节点未填写工艺语义 —— 物理量 ${tpl?.ch ?? node.templateKey};请让用户在模板/节点语义中补充物理机理与调参守则后再做大幅调整`)
-  lines.push(`- 安全量程: [${node.min}, ${node.max}] ${node.unit}(硬联锁,越界即拒)`)
+  if (sem) lines.push(tr(locale, `- 工艺语义: ${sem}${nodeSem ? '' : tplSem ? '(来自模板)' : '(来自 MES 点位描述)'}`, `- Process semantics: ${sem}${nodeSem ? '' : tplSem ? ' (from template)' : ' (from MES point description)'}`))
+  else lines.push(tr(locale, `- 工艺语义: (待补)该节点未填写工艺语义 —— 物理量 ${tpl?.ch ?? node.templateKey};请让用户在模板/节点语义中补充物理机理与调参守则后再做大幅调整`, `- Process semantics: (missing) no semantics configured for this node — physical quantity ${tpl?.ch ?? node.templateKey}; ask the user to add the physical mechanism and tuning rules before large adjustments`))
+  lines.push(tr(locale, `- 安全量程: [${node.min}, ${node.max}] ${node.unit}(硬联锁,越界即拒)`, `- Safe range: [${node.min}, ${node.max}] ${node.unit} (hard interlock; out-of-range writes are rejected)`))
   if (param && (param.min != null || param.max != null)) {
-    lines.push(`- 活动配方「${recipe!.name}」工艺窗口: [${param.min ?? '-∞'}, ${param.max ?? '+∞'}] ${node.unit}(软联锁,配方目标值 ${param.value}${node.unit ?? ''})`)
+    lines.push(tr(locale, `- 活动配方「${recipe!.name}」工艺窗口: [${param.min ?? '-∞'}, ${param.max ?? '+∞'}] ${node.unit}(软联锁,配方目标值 ${param.value}${node.unit ?? ''})`, `- Active recipe "${recipe!.name}" process window: [${param.min ?? '-∞'}, ${param.max ?? '+∞'}] ${node.unit} (soft interlock; recipe target ${param.value}${node.unit ?? ''})`))
   }
   else if (run) {
-    lines.push(`- 活动配方「${run.recipeName}」未对本节点设窗口(全局量程生效)`)
+    lines.push(tr(locale, `- 活动配方「${run.recipeName}」未对本节点设窗口(全局量程生效)`, `- Active recipe "${run.recipeName}" has no window for this node (global range applies)`))
   }
-  lines.push(`- 当前设定: ${node.value != null ? `${node.value}${node.unit}` : '未下发'},状态 ${node.state},所属产线「${line?.name ?? '未分配'}」`)
-  if (twinDesc) lines.push(`- 从属设备: ${twinDesc};你的写入经 PLC 下发后反映到该设备的物理行为`)
-  lines.push(`- 下发链路: ${route};参数写入与下发一律走你绑定的配方(recipe_update 保存版本 / recipe_apply 整批下发 / recipe_trial 候选试验),四层限界(量程∩参数∩产品∩配方)与单步上限在配方面照常生效`)
-  lines.push(`- 操作守则: 单次调幅硬上限 ≤${stepText};下发后等待工艺响应再评估;目标值必须落在窗口内;${mode === 'manual' ? '**手动确认模式**,每次下发会请求用户批准,请在下发前说明理由' : mode === 'recipe' ? '经配方绑定操作:绑定 manual 时逐动作人工批准,auto 直接执行(配方未在运行时不可操作)' : '自动模式,直接执行'}`)
+  lines.push(tr(locale, `- 当前设定: ${node.value != null ? `${node.value}${node.unit}` : '未下发'},状态 ${node.state},所属产线「${line?.name ?? '未分配'}」`, `- Current setpoint: ${node.value != null ? `${node.value}${node.unit}` : 'not dispatched'}, state ${node.state}, line "${line?.name ?? 'unassigned'}"`))
+  if (twinDesc) lines.push(tr(locale, `- 从属设备: ${twinDesc};你的写入经 PLC 下发后反映到该设备的物理行为`, `- Bound device: ${twinDesc}; your writes reach the PLC and affect this device's physical behavior`))
+  lines.push(tr(locale, `- 下发链路: ${route};参数写入与下发一律走你绑定的配方(recipe_update 保存版本 / recipe_apply 整批下发 / recipe_trial 候选试验),四层限界(量程∩参数∩产品∩配方)与单步上限在配方面照常生效`, `- Dispatch path: ${route}; all parameter writes go through your bound recipe (recipe_update saves a version / recipe_apply dispatches the batch / recipe_trial runs a candidate). The four-layer limits (range ∩ parameter ∩ product ∩ recipe) and per-step cap still apply`))
+  lines.push(tr(locale, `- 操作守则: 单次调幅硬上限 ≤${stepText};下发后等待工艺响应再评估;目标值必须落在窗口内;${mode === 'manual' ? '**手动确认模式**,每次下发会请求用户批准,请在下发前说明理由' : mode === 'recipe' ? '经配方绑定操作:绑定 manual 时逐动作人工批准,auto 直接执行(配方未在运行时不可操作)' : '自动模式,直接执行'}`, `- Operating rules: hard per-step cap <= ${stepText}; wait for the process response before re-evaluating; targets must stay inside the window; ${mode === 'manual' ? '**manual approval mode**: every dispatch asks the user, so state your rationale first' : mode === 'recipe' ? 'recipe-bound operation: manual mode approves each action, auto executes directly (no operation while the recipe is not running)' : 'automatic mode, execute directly'}`))
   return lines.join('\n')
 }
 
 /** 数采节点语义卡 */
-function daqSemanticCard(nodeId: string, mode: string): string | null {
+function daqSemanticCard(nodeId: string, mode: string, locale: PromptLocale = 'zh'): string | null {
   const node = getDaqNodeRepo().byId(nodeId)
   if (!node) return null
   const tpl = findDaqTemplate(node.templateKey)
@@ -95,29 +99,42 @@ function daqSemanticCard(nodeId: string, mode: string): string | null {
 
   const lines = [
     `#### ◇ ${node.name} [id=${nodeId}]`,
-    `- 物理量: ${tpl?.ch ?? node.templateKey},单位 ${node.unit},正常量程 [${node.min}, ${node.max}] ${node.unit}`,
+    tr(locale, `- 物理量: ${tpl?.ch ?? node.templateKey},单位 ${node.unit},正常量程 [${node.min}, ${node.max}] ${node.unit}`, `- Physical quantity: ${tpl?.ch ?? node.templateKey}, unit ${node.unit}, normal range [${node.min}, ${node.max}] ${node.unit}`),
   ]
-  if (sem) lines.push(`- 采集语义: ${sem}`)
-  else lines.push(`- 采集语义: (待补)该节点未填写采集语义 —— 物理量 ${tpl?.ch ?? node.templateKey};请让用户在模板/节点语义中补充测点含义与判读方法`)
+  if (sem) lines.push(tr(locale, `- 采集语义: ${sem}`, `- Measurement semantics: ${sem}`))
+  else lines.push(tr(locale, `- 采集语义: (待补)该节点未填写采集语义 —— 物理量 ${tpl?.ch ?? node.templateKey};请让用户在模板/节点语义中补充测点含义与判读方法`, `- Measurement semantics: (missing) no semantics configured — physical quantity ${tpl?.ch ?? node.templateKey}; ask the user to add the point meaning and interpretation method`))
   if (node.warnLow != null || node.warnHigh != null) {
-    lines.push(`- 预警带: [${node.warnLow ?? '-∞'}, ${node.warnHigh ?? '+∞'}] ${node.unit}(出带=warn,越量程=alarm)`)
+    lines.push(tr(locale, `- 预警带: [${node.warnLow ?? '-∞'}, ${node.warnHigh ?? '+∞'}] ${node.unit}(出带=warn,越量程=alarm)`, `- Warning band: [${node.warnLow ?? '-∞'}, ${node.warnHigh ?? '+∞'}] ${node.unit} (outside band = warn, outside range = alarm)`))
   }
-  if (win) lines.push(`- 活动配方「${recipe!.name}」监控窗口: [${win.min ?? '-∞'}, ${win.max ?? '+∞'}] ${node.unit}(实时值越限 → 节点标红 + 孪生告警)`)
-  lines.push(`- 实时值: ${node.value != null ? `${node.value}${node.unit}` : '暂无数据'}${fresh != null ? `( ${fresh}s 前更新)` : ''},状态 ${node.state},采样 ${node.effectiveInterval(1000)}ms,驱动 ${node.driver},所属产线「${line?.name ?? '未分配'}」`)
-  if (twinDesc) lines.push(`- 从属设备: ${twinDesc};量测的是该设备的真实过程量`)
-  lines.push(`- 数据获取: daq_query(node_id='${nodeId}');${mode === 'manual' ? '手动确认模式' : '查询自动执行'}`)
+  if (win) lines.push(tr(locale, `- 活动配方「${recipe!.name}」监控窗口: [${win.min ?? '-∞'}, ${win.max ?? '+∞'}] ${node.unit}(实时值越限 → 节点标红 + 孪生告警)`, `- Active recipe "${recipe!.name}" monitoring window: [${win.min ?? '-∞'}, ${win.max ?? '+∞'}] ${node.unit} (out-of-window = node red + twin alarm)`))
+  lines.push(tr(locale, `- 实时值: ${node.value != null ? `${node.value}${node.unit}` : '暂无数据'}${fresh != null ? `( ${fresh}s 前更新)` : ''},状态 ${node.state},采样 ${node.effectiveInterval(1000)}ms,驱动 ${node.driver},所属产线「${line?.name ?? '未分配'}」`, `- Live value: ${node.value != null ? `${node.value}${node.unit}` : 'no data'}${fresh != null ? ` (updated ${fresh}s ago)` : ''}, state ${node.state}, sampling ${node.effectiveInterval(1000)}ms, driver ${node.driver}, line "${line?.name ?? 'unassigned'}"`))
+  if (twinDesc) lines.push(tr(locale, `- 从属设备: ${twinDesc};量测的是该设备的真实过程量`, `- Bound device: ${twinDesc}; this point measures the device's real process variable`))
+  lines.push(tr(locale, `- 数据获取: daq_query(node_id='${nodeId}');${mode === 'manual' ? '手动确认模式' : '查询自动执行'}`, `- Data access: daq_query(node_id='${nodeId}'); ${mode === 'manual' ? 'manual approval mode' : 'queries run automatically'}`))
   return lines.join('\n')
 }
 
 /** 工具:my_industrial_nodes 的语义卡视图(绑定节点 dcw/daq 全集 ∪ 绑定配方的参数节点) */
-export function nodeSemanticCards(agentId: string): { text: string, stale: number } {
+export function nodeSemanticCards(agentId: string, localeInput?: PromptLocale): { text: string, stale: number } {
+  const locale = localeInput ?? promptLocaleOf(agentId)
   const repo = getAgentNodeBindingRepo()
   const bindings = repo.byAgent(agentId)
   const cards: string[] = []
   let stale = 0
   const seen = new Set<string>()
+  // 执行模式卡(2026-10-28 三模式计划 M2):让 Agent 一开始就知道本频道的执行档位与后果
+  const execMode = executionModeOfAgent(agentId)
+  let modeCard: string
+  if (execMode === 'observe') {
+    modeCard = tr(locale, '### ⚙ 频道执行模式:observe(观察)—— 本频道为只读分析档:控制下发/配方操作/启停线工具均不可用,请专注数采集、台账查询与分析;若认为需要调整参数,请在结论中建议并由人执行', '### ⚙ Channel execution mode: observe (read-only) — control dispatch / recipe operations / line start-stop tools are unavailable; focus on data collection, ledger queries and analysis; suggest parameter changes in your conclusions and let a human execute them')
+  }
+  else if (execMode === 'manual') {
+    modeCard = tr(locale, '### ⚙ 频道执行模式:manual(手动)—— 本频道所有下发/配方/回退动作都会挂起等人工批准:下发前必须说明依据(数采/MES 证据),审批卡会向人类展示你的理由', '### ⚙ Channel execution mode: manual — every dispatch / recipe / rollback action waits for human approval: state your evidence (DAQ/MES) first; the approval card shows your rationale to the human')
+  }
+  else {
+    modeCard = tr(locale, '### ⚙ 频道执行模式:auto(默认,频道不加额外约束)—— 是否人工批准由产线总闸与你的绑定模式决定;自动执行的下发必须附带 hypothesis 依据,四层限界/单步上限/运行门照常生效', '### ⚙ Channel execution mode: auto (default; no extra channel-level constraint) — human approval is decided by the line master switch and your binding mode; automatic dispatches must carry a hypothesis, and the four-layer limits / step cap / run gate still apply')
+  }
   for (const b of bindings) {
-    const card = b.kind === 'dcw' ? dcwSemanticCard(b.nodeId, b.mode) : b.kind === 'daq' ? daqSemanticCard(b.nodeId, b.mode) : null
+    const card = b.kind === 'dcw' ? dcwSemanticCard(b.nodeId, b.mode, locale) : b.kind === 'daq' ? daqSemanticCard(b.nodeId, b.mode, locale) : null
     if (card) {
       cards.push(card)
       seen.add(b.nodeId)
@@ -134,12 +151,12 @@ export function nodeSemanticCards(agentId: string): { text: string, stale: numbe
     for (const p of recipe.params) {
       if (seen.has(p.nodeId)) continue
       seen.add(p.nodeId)
-      const card = dcwSemanticCard(p.nodeId, 'recipe')
-      if (card) cards.push(`${card}\n(来源:绑定配方「${recipe.name}」的参数)`)
+      const card = dcwSemanticCard(p.nodeId, 'recipe', locale)
+      if (card) cards.push(`${card}\n${tr(locale, `(来源:绑定配方「${recipe.name}」的参数)`, `(source: parameter of bound recipe "${recipe.name}")`)}`)
       else stale++
     }
   }
-  return { text: cards.join('\n\n'), stale }
+  return { text: `${modeCard}\n\n${cards.join('\n\n')}`, stale }
 }
 
 /**
@@ -147,7 +164,8 @@ export function nodeSemanticCards(agentId: string): { text: string, stale: numbe
  * 每个绑定配方:名称/描述/版本/运行状态/绑定模式(manual=逐动作 HITL;auto=免批)/
  * 二级认证状态 + 参数对照表(参数 key|描述|执行节点|目标值|窗口)。
  */
-export function recipeOperationFace(agentId: string): string {
+export function recipeOperationFace(agentId: string, localeInput?: PromptLocale): string {
+  const locale = localeInput ?? promptLocaleOf(agentId)
   const repo = getAgentNodeBindingRepo()
   const bindings = repo.byAgent(agentId).filter(b => b.kind === 'recipe')
   if (bindings.length === 0) return ''
@@ -160,23 +178,23 @@ export function recipeOperationFace(agentId: string): string {
     const run = getDcwController().listRuns().find(r => r.recipeId === recipe.id && !r.endedAt)
     const access = recipe.access
     const head = [
-      `#### ▣ 配方「${recipe.name}」[id=${recipe.id}] v${recipe.version ?? 1}`,
-      `- 运行状态: ${run ? `**执行中**(批次 ${run.id.slice(0, 8)},可操作)——参数写入/下发/试验/回退均已放行` : '**未运行**(运行门:未在执行的配方不可操作;请由用户开跑后再操作)'}`,
-      `- 绑定模式: ${b.mode === 'manual' ? '**manual** —— 你的每次参数写入/下发/试验/回退都会挂起等人工批准;reason 必填且要给出判断依据(数采/MES 证据),审批卡会向人类展示' : '**auto** —— 免人工批准直接执行,但仍受四层限界与运行门约束'}`,
-      `- 二级认证: ${access?.requireAuth ? `已开启(授权清单 ${access.authorizedAgentIds?.length ?? 0} 人;你在清单内才能操作)` : '未开启(绑定即可操作)'}`,
-      recipe.description ? `- 配方说明: ${recipe.description.slice(0, 160)}` : null,
+      tr(locale, `#### ▣ 配方「${recipe.name}」[id=${recipe.id}] v${recipe.version ?? 1}`, `#### ▣ Recipe "${recipe.name}" [id=${recipe.id}] v${recipe.version ?? 1}`),
+      tr(locale, `- 运行状态: ${run ? `**执行中**(批次 ${run.id.slice(0, 8)},可操作)——参数写入/下发/试验/回退均已放行` : '**未运行**(运行门:未在执行的配方不可操作;请由用户开跑后再操作)'}`, `- Run state: ${run ? `**running** (batch ${run.id.slice(0, 8)}, operable) — parameter writes/dispatch/trials/rollback are allowed` : '**not running** (run gate: a recipe that is not executing cannot be operated; ask the user to start the line)'}`),
+      tr(locale, `- 绑定模式: ${b.mode === 'manual' ? '**manual** —— 你的每次参数写入/下发/试验/回退都会挂起等人工批准;reason 必填且要给出判断依据(数采/MES 证据),审批卡会向人类展示' : '**auto** —— 免人工批准直接执行,但仍受四层限界与运行门约束'}`, `- Binding mode: ${b.mode === 'manual' ? '**manual** — every parameter write/dispatch/trial/rollback waits for human approval; reason is required and must cite evidence; the approval card shows it to the human' : '**auto** — executes without human approval, still bounded by the four-layer limits and run gate'}`),
+      tr(locale, `- 二级认证: ${access?.requireAuth ? `已开启(授权清单 ${access.authorizedAgentIds?.length ?? 0} 人;你在清单内才能操作)` : '未开启(绑定即可操作)'}`, `- Secondary auth: ${access?.requireAuth ? `enabled (${access.authorizedAgentIds?.length ?? 0} authorized agents; you must be on the list)` : 'disabled (binding is sufficient)'}`),
+      recipe.description ? tr(locale, `- 配方说明: ${recipe.description.slice(0, 160)}`, `- Recipe description: ${recipe.description.slice(0, 160)}`) : null,
     ].filter(Boolean) as string[]
     const rows = recipe.params.map((p) => {
       const node = getDcwController().byId(p.nodeId)
       const pv = paramViews.get(p.nodeId)
       const desc = pv?.desc ?? node?.semantics ?? ''
-      const win = (p.min != null || p.max != null) ? `,窗口 ${p.min ?? '-∞'}~${p.max ?? '+∞'}${node?.unit ?? ''}` : ''
-      return `  - ${node?.name ?? p.nodeId}:目标 ${p.value}${node?.unit ?? ''}${win} | 参数键 ${pv?.key ?? '-'}${desc ? ` | ${desc.slice(0, 80)}` : ''}`
+      const win = (p.min != null || p.max != null) ? tr(locale, `,窗口 ${p.min ?? '-∞'}~${p.max ?? '+∞'}${node?.unit ?? ''}`, `, window ${p.min ?? '-∞'}~${p.max ?? '+∞'}${node?.unit ?? ''}`) : ''
+      return tr(locale, `  - ${node?.name ?? p.nodeId}:目标 ${p.value}${node?.unit ?? ''}${win} | 参数键 ${pv?.key ?? '-'}${desc ? ` | ${desc.slice(0, 80)}` : ''}`, `  - ${node?.name ?? p.nodeId}: target ${p.value}${node?.unit ?? ''}${win} | key ${pv?.key ?? '-'}${desc ? ` | ${desc.slice(0, 80)}` : ''}`)
     })
-    sections.push([...head, '- 参数对照(目标值/窗口/参数键/描述):', ...rows].join('\n'))
+    sections.push([...head, tr(locale, '- 参数对照(目标值/窗口/参数键/描述):', '- Parameters (target/window/key/description):'), ...rows].join('\n'))
   }
   if (sections.length === 0) return ''
-  return `### 你绑定的配方(操作面;动作入口 recipe_update/recipe_apply/recipe_trial/recipe_rollback)\n${sections.join('\n\n')}`
+  return tr(locale, `### 你绑定的配方(操作面;动作入口 recipe_update/recipe_apply/recipe_trial/recipe_rollback)\n${sections.join('\n\n')}`, `### Your bound recipes (operation surface; entry points recipe_update/recipe_apply/recipe_trial/recipe_rollback)\n${sections.join('\n\n')}`)
 }
 
 /** 参数面视图(参数面未就绪时返回空,不阻断语义卡) */
@@ -189,8 +207,18 @@ function getDcwParamRepoSafe(): Array<{ nodeId: string, key: string, desc?: stri
   }
 }
 
+/** MES 点位能力标签(纯函数;zh=读/写/史/钩,en=R/W/H/HK) */
+export function mesCapabilityLabel(
+  e: { readable: boolean, writable: boolean, historyable: boolean, format: string, hooked: boolean },
+  locale: PromptLocale = 'zh',
+): string {
+  const hist = e.historyable ? (e.format !== 'scalar' ? tr(locale, `史·${e.format}`, `H·${e.format}`) : tr(locale, '史', 'H')) : null
+  return [e.readable ? tr(locale, '读', 'R') : null, e.writable ? tr(locale, '写', 'W') : null, hist, e.hooked ? tr(locale, '钩', 'HK') : null].filter(Boolean).join('/') || '-'
+}
+
 /** 产线工况简报(注入每次回合 prompt;只描述 Agent 绑定节点/绑定配方所在的产线) */
-export function buildIndustrialContext(agentId: string): string {
+export function buildIndustrialContext(agentId: string, localeInput?: PromptLocale): string {
+  const locale = localeInput ?? promptLocaleOf(agentId)
   const bindings = getAgentNodeBindingRepo().byAgent(agentId)
   const dcwIds = bindings.filter(b => b.kind === 'dcw').map(b => b.nodeId)
   const daqIds = bindings.filter(b => b.kind === 'daq').map(b => b.nodeId)
@@ -216,36 +244,36 @@ export function buildIndustrialContext(agentId: string): string {
     const line = getDcwLineRepo().byId(lineId)
     if (!line) continue
     const run = getActiveLineRun(lineId)
-    const lines: string[] = [`### 产线「${line.name}」(id=${lineId},光晕色 ${line.color})`]
+    const lines: string[] = [tr(locale, `### 产线「${line.name}」(id=${lineId},光晕色 ${line.color})`, `### Line "${line.name}" (id=${lineId}, halo color ${line.color})`)]
     // 场景描述(产线本体说明:工艺场景/规格/闭环目标 —— 用户在建线/编辑产线时填写,
     // 是场景语义最丰富的一手描述;不注入则 Agent 对这条产线是干什么的毫无概念)
-    if (line.description?.trim()) lines.push(`- 场景说明: ${line.description.trim().slice(0, 260)}`)
+    if (line.description?.trim()) lines.push(tr(locale, `- 场景说明: ${line.description.trim().slice(0, 260)}`, `- Scenario description: ${line.description.trim().slice(0, 260)}`))
     if (run) {
       const elapsedMin = Math.round((Date.now() - Date.parse(run.startedAt)) / 60_000)
-      lines.push(`- 工况:**运行中**,批次 ${run.runId.slice(0, 8)},产品「${run.productName}」× 配方「${run.recipeName}」,已运行 ${elapsedMin} 分钟,已采集 ${run.taggedSamples} 打标样本`)
+      lines.push(tr(locale, `- 工况:**运行中**,批次 ${run.runId.slice(0, 8)},产品「${run.productName}」× 配方「${run.recipeName}」,已运行 ${elapsedMin} 分钟,已采集 ${run.taggedSamples} 打标样本`, `- Condition: **running**, batch ${run.runId.slice(0, 8)}, product "${run.productName}" x recipe "${run.recipeName}", ${elapsedMin} min elapsed, ${run.taggedSamples} tagged samples`))
       const recipe = getDcwController().listRecipes().find(r => r.id === run.recipeId)
       const product = recipe ? getDcwProductRepo().byId(recipe.productId) : undefined
-      if (product?.description?.trim()) lines.push(`- 产品说明(${product.name}): ${product.description.trim().slice(0, 160)}`)
+      if (product?.description?.trim()) lines.push(tr(locale, `- 产品说明(${product.name}): ${product.description.trim().slice(0, 160)}`, `- Product description (${product.name}): ${product.description.trim().slice(0, 160)}`))
       if (recipe) {
         const params = recipe.params
           .map((p) => {
             const n = getDcwController().byId(p.nodeId)
-            const win = (p.min != null || p.max != null) ? ` 窗口 ${p.min ?? '-∞'}~${p.max ?? '+∞'}${n?.unit ?? ''}` : ''
+            const win = (p.min != null || p.max != null) ? tr(locale, ` 窗口 ${p.min ?? '-∞'}~${p.max ?? '+∞'}${n?.unit ?? ''}`, ` window ${p.min ?? '-∞'}~${p.max ?? '+∞'}${n?.unit ?? ''}`) : ''
             return `${n?.name ?? p.nodeId}=${p.value}${n?.unit ?? ''}${win}`
           })
           .join(';')
-        lines.push(`- 配方工艺参数: ${params}`)
+        lines.push(tr(locale, `- 配方工艺参数: ${params}`, `- Recipe process parameters: ${params}`))
         const wins = (recipe.daqWindows ?? [])
           .map((w) => {
             const n = getDaqNodeRepo().byId(w.nodeId)
             return `${n?.name ?? w.nodeId} ∈ [${w.min ?? '-∞'}, ${w.max ?? '+∞'}]${n?.unit ?? ''}`
           })
           .join(';')
-        if (wins) lines.push(`- 数采监控窗口(越限即报警): ${wins}`)
+        if (wins) lines.push(tr(locale, `- 数采监控窗口(越限即报警): ${wins}`, `- DAQ monitoring windows (out-of-window alarms): ${wins}`))
       }
     }
     else {
-      lines.push('- 工况:**停线**(无活动批次;写入仅受节点全局量程约束,数采暂停)')
+      lines.push(tr(locale, '- 工况:**停线**(无活动批次;写入仅受节点全局量程约束,数采暂停)', '- Condition: **line stopped** (no active batch; writes are bounded only by global node range, DAQ paused)'))
     }
     const twinNames = new Set<string>()
     for (const id of [...dcwIds, ...daqIds]) {
@@ -256,7 +284,7 @@ export function buildIndustrialContext(agentId: string): string {
         if (desc) twinNames.add(desc)
       }
     }
-    if (twinNames.size > 0) lines.push(`- 关联设备孪生: ${Array.from(twinNames).join(' | ')}`)
+    if (twinNames.size > 0) lines.push(tr(locale, `- 关联设备孪生: ${Array.from(twinNames).join(' | ')}`, `- Associated device twins: ${Array.from(twinNames).join(' | ')}`))
     // 当前报警透出(只报本 Agent 绑定的数采节点):越限即报警是工况里最需要
     // Agent 优先感知的事实 —— 不注入的话,Agent 只能靠 daq_query 事后发现
     // 类型谓词(不收窄就无法在下游安全读 n.name/n.value/n.unit):
@@ -265,7 +293,7 @@ export function buildIndustrialContext(agentId: string): string {
       .map(id => getDaqNodeRepo().byId(id))
       .filter((n): n is DaqNode => !!n && n.lineId === lineId && n.state === 'alarm')
     if (alarms.length > 0) {
-      lines.push(`- **当前报警**: ${alarms.map(n => `${n.name} 实时 ${n.value ?? '?'}${n.unit} 处于报警态(越量程或越配方监控窗口)`)},应优先判读(设定-响应滞后 vs 真实异常)并处置`)
+      lines.push(tr(locale, `- **当前报警**: ${alarms.map(n => `${n.name} 实时 ${n.value ?? '?'}${n.unit} 处于报警态(越量程或越配方监控窗口)`)},应优先判读(设定-响应滞后 vs 真实异常)并处置`, `- **Active alarms**: ${alarms.map(n => `${n.name} live ${n.value ?? '?'}${n.unit} is in alarm (out of range or out of recipe window)`)}, prioritize diagnosis (setpoint-response lag vs real fault) and act`))
     }
     // MES REST 点位段:本产线 mes-rest 节点 ≤30 条全量简列(>30 给前 30 + 检索指引);
     // 只列语义面(名称/单位/量程/能力/desc),取数走 mes_fetch(原文不进 prompt)
@@ -275,21 +303,17 @@ export function buildIndustrialContext(agentId: string): string {
         .map(mesCatalogEntryOf)
       if (mesEntries.length > 0) {
         const MES_BRIEF_MAX = 30
-        const capOf = (e: { readable: boolean, writable: boolean, historyable: boolean, format: string, hooked: boolean }): string => {
-          const hist = e.historyable ? (e.format !== 'scalar' ? '史·' + e.format : '史') : null
-          return [e.readable ? '读' : null, e.writable ? '写' : null, hist, e.hooked ? '钩' : null].filter(Boolean).join('/') || '-'
-        }
         const shown = mesEntries.slice(0, MES_BRIEF_MAX)
-          .map(e => `  ${e.name}|${e.unit || '-'}|${e.min}~${e.max}|${capOf(e)}|${e.desc.slice(0, 40)}`)
+          .map(e => `  ${e.name}|${e.unit || '-'}|${e.min}~${e.max}|${mesCapabilityLabel(e, locale)}|${e.desc.slice(0, 40)}`)
         const rest = mesEntries.length - shown.length
-        lines.push(`- MES REST 点位(${mesEntries.length} 条,名称|单位|量程|读写与格式能力(史·vector=检测向量,史·image=图像帧,钩=取数后自动下沉处理)|描述):\n${shown.join('\n')}${rest > 0 ? `\n  (其余 ${rest} 条未列出,用 mes_catalog 检索)` : ''}`)
+        lines.push(tr(locale, `- MES REST 点位(${mesEntries.length} 条,名称|单位|量程|读写与格式能力(史·vector=检测向量,史·image=图像帧,钩=取数后自动下沉处理)|描述):\n${shown.join('\n')}${rest > 0 ? `\n  (其余 ${rest} 条未列出,用 mes_catalog 检索)` : ''}`, `- MES REST points (${mesEntries.length}; name|unit|range|capabilities (H·vector=inspection vector, H·image=image frame, HK=post-fetch sink)|description):\n${shown.join('\n')}${rest > 0 ? `\n  (${rest} more not listed; use mes_catalog to search)` : ''}`))
       }
     }
     catch { /* MES 面未就绪(单测/降级)不阻断简报 */ }
     sections.push(lines.join('\n'))
   }
   if (sections.length === 0) return ''
-  return `## 产线工况简报(实时;每次回合自动注入)\n${sections.join('\n\n')}`
+  return tr(locale, `## 产线工况简报(实时;每次回合自动注入)\n${sections.join('\n\n')}`, `## Line condition brief (live; injected every turn)\n${sections.join('\n\n')}`)
 }
 
 /**
@@ -299,55 +323,108 @@ export function buildIndustrialContext(agentId: string): string {
  * 七步闭环(v2.1):观察 → 理解 → 假设 → 设定 → 判定 → 回退/保持 → 复盘;
  * 每次下发自动开优化记录、判定入册、回退可审计 —— 闭环由系统记账,Agent 负责判断质量。
  */
-export function industrialLoopGuide(agentId: string): string {
+export function industrialLoopGuide(agentId: string, localeInput?: PromptLocale): string {
+  const locale = localeInput ?? promptLocaleOf(agentId)
   const bindings = getAgentNodeBindingRepo().byAgent(agentId)
   if (bindings.length === 0) return ''
   // 权限模型 v2:写面收敛到 recipe(节点直写工具已摘除);hasDcw 仅剩存量兼容绑定
   const hasRecipe = bindings.some(b => b.kind === 'recipe')
   const hasManualRecipe = bindings.some(b => b.kind === 'recipe' && b.mode === 'manual')
   const steps: string[] = [
-    '1. 观察:daq_query / mes_fetch 获取绑定产线的真实时序数据(数采/检测/MES 多源;支持按产品/配方/时间窗过滤),结合返回的工况判读理解当前状态。',
-    '2. 理解:my_industrial_nodes 与 line_context 读取语义卡 —— 物理量含义/单位/安全量程/活动配方工艺窗口/单次调幅步进,以及调控闭环状态(进行中的优化记录/上次良好值/最近判定)。',
+    tr(locale, '1. 观察:daq_query / mes_fetch 获取绑定产线的真实时序数据(数采/检测/MES 多源;支持按产品/配方/时间窗过滤),结合返回的工况判读理解当前状态。', '1. Observe: use daq_query / mes_fetch to obtain real time-series from the bound line (DAQ/inspection/MES; filterable by product/recipe/time window), and read the returned condition summary to understand the current state.'),
+    tr(locale, '2. 理解:my_industrial_nodes 与 line_context 读取语义卡 —— 物理量含义/单位/安全量程/活动配方工艺窗口/单次调幅步进,以及调控闭环状态(进行中的优化记录/上次良好值/最近判定)。', '2. Understand: read semantic cards via my_industrial_nodes and line_context — physical meaning/unit/safe range/active recipe window/per-step cap, plus loop state (open optimization record/last good value/latest verdict).'),
   ]
   if (hasRecipe) {
     steps.push(
-      '3. 假设:调参前先声明假设与理由 —— 目标值 + 预期效果 + 判断依据(数采/MES 证据);目标必须落在「安全量程 ∩ 活动配方工艺窗口」内,优先小步幅(≤量程 2%)、单向逼近。理由必填且会被人类在审批卡上看到。',
-      '4. 设定:对绑定的配方操作 —— recipe_trial(候选整批试验,不写版本)或 recipe_update(写入新版本)+ recipe_apply(整批下发);治理联锁(量程∩参数∩产品∩配方 + 步长 + 限速)在配方面照常生效,底层数控节点(PLC/MES)由配置层承接,无需关心差异。运行中的批次一次只改本配方绑定的参数;等待工艺响应,勿连续大幅调整。',
-      '5. 判定:daq_query / mes_fetch 复测窗口数据后落判定 —— keep(达标/有进步:无动作或 recipe_update 固化候选值)/ rollback(劣化)/ uncertain(证据不足,继续观察)。判定必须引用具体数值与时间窗证据。注意:判定直接以复测数据对照你的假设陈述,不要调用 dcw_judge —— 那是旧直写时代的优化记录面(opt-* 记录),配方面链路(批次 rr-*)不产生该记录,调用必报「不存在」。',
-      '6. 回退/保持:判 rollback 后用 recipe_rollback(dispatch=true, reason=…) 统一回退(定义回退+参数整批恢复),回退后复测确认;回退冷却期内禁止同向重写。增益趋零/杠杆失效时,如实汇报实测增益并上报请求决策(换杠杆/调目标/接受当前点),而非盲目加码。',
-      '7. 复盘:recipe_versions / dcw_journal 查看变更史与写历史;达标候选值用 recipe_update 固化为新版本(带 reason),rollback 的结论写进共享记忆修正下次假设 —— 禁止重复已失败的调参方向。',
+      tr(locale, '3. 假设:调参前先声明假设与理由 —— 目标值 + 预期效果 + 判断依据(数采/MES 证据);目标必须落在「安全量程 ∩ 活动配方工艺窗口」内,优先小步幅(≤量程 2%)、单向逼近。理由必填且会被人类在审批卡上看到。', '3. Hypothesize: before tuning, state the hypothesis and rationale — target + expected effect + evidence (DAQ/MES); the target must lie inside "safe range ∩ active recipe window", prefer small monotonic steps (<=2% of range). The rationale is required and shown to the human on the approval card.'),
+      tr(locale, '4. 设定:对绑定的配方操作 —— recipe_trial(候选整批试验,不写版本)或 recipe_update(写入新版本)+ recipe_apply(整批下发);治理联锁(量程∩参数∩产品∩配方 + 步长 + 限速)在配方面照常生效,底层数控节点(PLC/MES)由配置层承接,无需关心差异。运行中的批次一次只改本配方绑定的参数;等待工艺响应,勿连续大幅调整。', '4. Set: operate on the bound recipe — recipe_trial (candidate batch without version) or recipe_update (new version) + recipe_apply (dispatch batch); governance interlocks (range ∩ parameter ∩ product ∩ recipe + step + rate) still apply on the recipe face, and PLC/MES differences are absorbed by config. Change only parameters bound to this recipe at a time, and wait for the process response before further large adjustments.'),
+      tr(locale, '5. 判定:daq_query / mes_fetch 复测窗口数据后落判定 —— keep(达标/有进步:无动作或 recipe_update 固化候选值)/ rollback(劣化)/ uncertain(证据不足,继续观察)。判定必须引用具体数值与时间窗证据。注意:判定直接以复测数据对照你的假设陈述,不要调用 dcw_judge —— 那是旧直写时代的优化记录面(opt-* 记录),配方面链路(批次 rr-*)不产生该记录,调用必报「不存在」。', '5. Decide: re-measure with daq_query / mes_fetch, then record keep (target met/improved: no action or recipe_update to persist the candidate) / rollback (degraded) / uncertain (insufficient evidence; keep observing). Cite concrete numbers and time windows. Do NOT call dcw_judge — that is the legacy direct-write optimization ledger (opt-* records); the recipe path (rr-* batches) does not create those records and the call will always report "not found".'),
+      tr(locale, '6. 回退/保持:判 rollback 后用 recipe_rollback(dispatch=true, reason=…) 统一回退(定义回退+参数整批恢复),回退后复测确认;回退冷却期内禁止同向重写。增益趋零/杠杆失效时,如实汇报实测增益并上报请求决策(换杠杆/调目标/接受当前点),而非盲目加码。', '6. Roll back / hold: after rollback, use recipe_rollback(dispatch=true, reason=…) to restore the definition and parameters together, then re-measure; same-direction rewrites are forbidden during the cooldown. If gain approaches zero or the lever fails, report measured gain and escalate for a decision (change lever/target/accept current point) instead of blindly pushing harder.'),
+      tr(locale, '7. 复盘:recipe_versions / dcw_journal 查看变更史与写历史;达标候选值用 recipe_update 固化为新版本(带 reason),rollback 的结论写进共享记忆修正下次假设 —— 禁止重复已失败的调参方向。', '7. Review: inspect change/write history via recipe_versions / dcw_journal; persist a good candidate with recipe_update (with reason), and write rollback conclusions into shared memory to correct the next hypothesis — never repeat a failed direction.'),
     )
   }
   else {
-    steps.push('3. 判读:你是量测侧 —— 数据越过配方监控窗口会触发节点报警与孪生告警;判读时区分「同线数控设定-响应滞后」与「真实过程异常」,结论引用具体数值与时间窗。')
+    steps.push(tr(locale, '3. 判读:你是量测侧 —— 数据越过配方监控窗口会触发节点报警与孪生告警;判读时区分「同线数控设定-响应滞后」与「真实过程异常」,结论引用具体数值与时间窗。', '3. Interpret: you are on the measurement side — data leaving the recipe window triggers node and twin alarms; distinguish "same-line setpoint/response lag" from a real process fault, citing concrete numbers and time windows.'))
   }
   if (hasManualRecipe) {
-    steps.push('8. 权限边界:你绑定的配方为 manual 模式 —— 每次参数写入/下发/试验/回退前必须给出理由并等待人类批准(批准附言会随结果返回,请响应其关切;审批 30 分钟窗内无人裁决=默认拒绝);经显式确认切到 auto 的配方免批,但同样受联锁与运行门约束(配方未在执行时一律不可操作)。')
+    steps.push(tr(locale, '8. 权限边界:你绑定的配方为 manual 模式 —— 每次参数写入/下发/试验/回退前必须给出理由并等待人类批准(批准附言会随结果返回,请响应其关切;审批 30 分钟窗内无人裁决=默认拒绝);经显式确认切到 auto 的配方免批,但同样受联锁与运行门约束(配方未在执行时一律不可操作)。', '8. Permission boundary: your recipe is in manual mode — every parameter write/dispatch/trial/rollback requires a rationale and human approval (the approval comment is returned with the result; address it; no decision within 30 minutes = default deny). Recipes explicitly switched to auto skip approval but still obey interlocks and the run gate (no operation while the recipe is not executing).'))
   }
-  steps.push(`${steps.length + 1}. 数值口径:工具返回的采集/设定值均为经标定钩子处理后的真实物理量纲;引用数值时带上单位与时间,便于人工复核。`)
-  const history = recentOptimizationNotes(agentId)
-  return `## 工业调控作业环(你的节点操作方法论,每回合生效)\n${steps.join('\n')}${history}`
+  steps.push(tr(locale, `${steps.length + 1}. 数值口径:工具返回的采集/设定值均为经标定钩子处理后的真实物理量纲;引用数值时带上单位与时间,便于人工复核。`, `${steps.length + 1}. Units: all sampled/setpoint values returned by tools are real engineering units after calibration hooks; cite units and timestamps so a human can verify.`))
+  const history = recentOptimizationNotes(agentId, locale)
+  return tr(locale, `## 工业调控作业环(你的节点操作方法论,每回合生效)\n${steps.join('\n')}${history}`, `## Industrial control loop (your node operating method, active every turn)\n${steps.join('\n')}${history}`)
 }
 
 /** 经验注入:该 Agent 绑定数控节点的最近优化记录结论(keep/rollback 统计),跨任务积累 */
-function recentOptimizationNotes(agentId: string): string {
+function recentOptimizationNotes(agentId: string, locale: PromptLocale = 'zh'): string {
   try {
     const rb = getRecipeRollBackManager()
-    const dcwIds = getAgentNodeBindingRepo().byAgent(agentId).filter(b => b.kind === 'dcw').map(b => b.nodeId)
-    if (dcwIds.length === 0) return ''
-    const lines: string[] = []
-    for (const nodeId of dcwIds.slice(0, 3)) {
-      const records = rb.records({ nodeId, limit: 20 })
-      if (records.length === 0) continue
-      const keep = records.filter(r => r.judge?.verdict === 'keep').length
-      const roll = records.filter(r => r.judge?.verdict === 'rollback' || r.status === 'rolled-back').length
-      const last = records.find(r => r.judge)
-      lines.push(`- ${records[0]!.nodeName}:近 ${records.length} 次调控(keep ${keep}/rollback ${roll})${last?.judge ? `,最近判定 ${last.judge.verdict}(${last.judge.reason.slice(0, 60)})` : ''}`)
-    }
+    const bindings = getAgentNodeBindingRepo().byAgent(agentId)
+    const dcwNodes = bindings.filter(b => b.kind === 'dcw').map(b => b.nodeId)
+    const recipes = bindings.filter(b => b.kind === 'recipe').map((b) => {
+      const r = getDcwController().listRecipes().find(x => x.id === b.nodeId)
+      return { recipeId: b.nodeId, name: r?.name ?? b.nodeId, paramNodeIds: (r?.params ?? []).map(p => p.nodeId) }
+    })
+    if (dcwNodes.length === 0 && recipes.length === 0) return ''
+    const lines = optimizationNoteLines({
+      dcwNodes,
+      recipes,
+      recordsOf: filter => rb.records({ ...filter, limit: 20 }),
+    }, locale)
     if (lines.length === 0) return ''
-    return `\n\n## 优化经验台账(你绑定节点的近期调控结论;避免重复已失败方向)\n${lines.join('\n')}`
+    return tr(locale, `\n\n## 优化经验台账(你绑定节点的近期调控结论;避免重复已失败方向)\n${lines.join('\n')}`, `\n\n## Optimization experience ledger (recent verdicts for your bound nodes; avoid repeating failed directions)\n${lines.join('\n')}`)
   }
   catch {
     return ''
   }
 }
+
+export interface OptimizationNoteSource {
+  /** 直接绑定的数控节点 id(旧链路 dcw-*) */
+  dcwNodes: string[]
+  /** 配方绑定(recipe 链路 rr-*;OptimizationRecord.recipeId 匹配;无匹配退参数节点维度) */
+  recipes: Array<{ recipeId: string, name: string, paramNodeIds?: string[] }>
+  recordsOf: (filter: { nodeId?: string, recipeId?: string }) => Array<{
+    nodeName: string
+    status: string
+    judge?: { verdict: string, reason: string } | null
+  }>
+}
+
+/**
+ * 纯装配(便于单测):dcw 节点按 nodeId、配方按 recipeId 聚合近期判定。
+ * 配方无记录时如实提示一行 —— 避免模型把「空」误判成查询失败而反复重试。
+ */
+export function optimizationNoteLines(src: OptimizationNoteSource, locale: PromptLocale = 'zh'): string[] {
+  const lines: string[] = []
+  for (const nodeId of src.dcwNodes.slice(0, 3)) {
+    const records = src.recordsOf({ nodeId })
+    if (records.length === 0) continue
+    const keep = records.filter(r => r.judge?.verdict === 'keep').length
+    const roll = records.filter(r => r.judge?.verdict === 'rollback' || r.status === 'rolled-back').length
+    const last = records.find(r => r.judge)
+    lines.push(tr(locale, `- ${records[0]!.nodeName}:近 ${records.length} 次调控(keep ${keep}/rollback ${roll})${last?.judge ? `,最近判定 ${last.judge.verdict}(${last.judge.reason.slice(0, 60)})` : ''}`, `- ${records[0]!.nodeName}: last ${records.length} tunings (keep ${keep}/rollback ${roll})${last?.judge ? `, latest verdict ${last.judge.verdict}(${last.judge.reason.slice(0, 60)})` : ''}`))
+  }
+  for (const { recipeId, name, paramNodeIds } of src.recipes.slice(0, 3)) {
+    let records = src.recordsOf({ recipeId })
+    // 无 recipeId 匹配 → 退参数节点维度(旧 dcw 链路记录仍可复用)
+    if (records.length === 0 && paramNodeIds?.length) {
+      const byNode = paramNodeIds.flatMap(nodeId => src.recordsOf({ nodeId }))
+      const seen = new Set<string>()
+      records = byNode.filter((r) => {
+        const key = `${r.nodeName}|${r.status}|${r.judge?.reason ?? ''}`
+        if (seen.has(key)) return false
+        seen.add(key)
+        return true
+      }).slice(0, 20)
+    }
+    if (records.length === 0) {
+      lines.push(tr(locale, `- ${name}:暂无历史调控记录(该配方尚无可复用的调参结论)`, `- ${name}: no tuning history yet (no reusable conclusion for this recipe)`))
+      continue
+    }
+    const keep = records.filter(r => r.judge?.verdict === 'keep').length
+    const roll = records.filter(r => r.judge?.verdict === 'rollback' || r.status === 'rolled-back').length
+    const last = records.find(r => r.judge)
+    lines.push(tr(locale, `- ${name}(配方):近 ${records.length} 次调控(keep ${keep}/rollback ${roll})${last?.judge ? `,最近判定 ${last.judge.verdict}(${last.judge.reason.slice(0, 60)})` : ''}`, `- ${name}(recipe): last ${records.length} tunings (keep ${keep}/rollback ${roll})${last?.judge ? `, latest verdict ${last.judge.verdict}(${last.judge.reason.slice(0, 60)})` : ''}`))
+  }
+  return lines
+}