agentworkshop 0.8.6 → 0.8.8

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

@@ -31,17 +31,27 @@ export function daqTargetsOf(agentId: string, nodeIdArg: unknown, lineIdArg: unk
   if (readable.size === 0) {
     return { error: { text: '你尚未绑定任何数采节点,频道也未绑定产线,无权查询采集数据。请在数字孪生界面绑定数采节点,或将频道绑定到目标产线(绑线后可只读查询该线数采数据)。', isError: true } }
   }
-  const wanted = nodeIdArg ? String(nodeIdArg) : ''
-  if (wanted && !readable.has(wanted)) {
-    return { error: { text: `无权查询节点 ${wanted}。你有权访问的数采节点:${[...readable].join(', ')}`, isError: true } }
+  const wantedList = (Array.isArray(nodeIdArg)
+    ? nodeIdArg.map(v => String(v))
+    : String(nodeIdArg ?? '').split(','))
+    .map(s => s.trim())
+    .filter(Boolean)
+  if (wantedList.length > 20) {
+    return { error: { text: `一次最多查询 20 个数采节点(收到 ${wantedList.length});请分组查询或按 line_id 过滤。`, isError: true } }
+  }
+  for (const w of wantedList) {
+    if (!readable.has(w)) {
+      return { error: { text: `无权查询节点 ${w}。你有权访问的数采节点:${[...readable].join(', ')}`, isError: true } }
+    }
   }
   const lineFilter = lineIdArg ? String(lineIdArg).trim() : ''
   const lineOf = (id: string): string => getDaqNodeRepo().byId(id)?.lineId ?? ''
-  if (lineFilter && wanted && lineOf(wanted) !== lineFilter) {
-    return { error: { text: `节点 ${wanted} 不属于产线 ${lineFilter}(实际归属:${lineOf(wanted) || '未分配'}),line_id 与 node_id 过滤冲突。`, isError: true } }
+  const wrongLine = lineFilter ? wantedList.filter(id => lineOf(id) !== lineFilter) : []
+  if (wrongLine.length > 0) {
+    return { error: { text: `节点 ${wrongLine.join(', ')} 不属于产线 ${lineFilter}(实际归属:${wrongLine.map(id => lineOf(id) || '未分配').join('/')}),line_id 与 node_id 过滤冲突。`, isError: true } }
   }
-  let targets = wanted ? [wanted] : [...readable]
-  if (lineFilter && !wanted) {
+  let targets = wantedList.length > 0 ? wantedList : [...readable]
+  if (lineFilter && wantedList.length === 0) {
     const onLine = targets.filter(id => lineOf(id) === lineFilter)
     if (onLine.length === 0) {
       return { error: { text: `你有权访问的数采节点中没有归属产线 ${lineFilter} 的(各节点归属:${[...readable].map(id => `${id}=${lineOf(id) || '未分配'}`).join('; ')})。`, isError: true } }
@@ -61,42 +71,64 @@ export function daqTargetsOf(agentId: string, nodeIdArg: unknown, lineIdArg: unk
  * 只取当前配方 3 点/均值 247.99,差异足以改变 keep/rollback 结论)。
  * 需要跨配方对比或历史复盘时显式传 `scope: 'all'`(或直接给 product_id/recipe_id/run_id)。
  */
+/** 时间参数解析:epoch 毫秒 或 ISO 8601(含 date-only、带时区偏移);非法 → null(调用方必须报错) */
+function epochOfArg(v: unknown): number | null {
+  if (v == null) return null
+  const s = String(v).trim()
+  if (!s) return null
+  if (/^\d+$/.test(s)) {
+    const n = Number(s)
+    return Number.isFinite(n) && n > 0 ? n : null
+  }
+  const ms = Date.parse(s)
+  return Number.isFinite(ms) ? ms : null
+}
+
 export async function toolDaqQuery(agentId: string, args: {
   node_id?: string
+  /** 多字段查询(逗号分隔或数组;与 node_id 二选一,最多 20 个) */
+  node_ids?: string | string[]
   line_id?: string
   product_id?: string
   recipe_id?: string
   run_id?: string
   scope?: string
   last_minutes?: number | string
+  /** 起始时间:ISO 8601(如 2026-10-01T08:00:00+08:00)或 epoch 毫秒 */
+  from?: string | number
+  /** 结束时间:同上;缺省 = now */
+  to?: string | number
   from_ms?: number | string
   to_ms?: number | string
   bucket_ms?: number | string
   limit?: number | string
   agg?: string
 }): Promise<{ text: string, isError?: boolean }> {
-  const auth = daqTargetsOf(agentId, args.node_id, args.line_id)
+  const auth = daqTargetsOf(agentId, args.node_ids ?? args.node_id, args.line_id)
   if ('error' in auth) return auth.error
   const { targets } = auth
   const lineFilter = args.line_id ? String(args.line_id).trim() : ''
 
   // 参数校验:显式传入的非法值必须报错,不能静默回退(否则 Agent 以为按自己的窗口/条数查了)
   const provided = (v: unknown): boolean => v !== undefined && v !== null && String(v).trim() !== ''
-  if (provided(args.to_ms) && (!Number.isFinite(Number(args.to_ms)) || Number(args.to_ms) <= 0)) {
-    return { text: `to_ms 必须是正的 epoch 毫秒(收到 ${String(args.to_ms)})。`, isError: true }
+  const toArg = args.to ?? args.to_ms
+  const fromArg = args.from ?? args.from_ms
+  const toParsed = epochOfArg(toArg)
+  if (provided(toArg) && toParsed == null) {
+    return { text: `to 必须是 ISO 8601 时间(如 2026-10-01T08:00:00+08:00)或正的 epoch 毫秒(收到 ${String(toArg)})。`, isError: true }
   }
-  if (provided(args.from_ms) && (!Number.isFinite(Number(args.from_ms)) || Number(args.from_ms) <= 0)) {
-    return { text: `from_ms 必须是正的 epoch 毫秒(收到 ${String(args.from_ms)})。`, isError: true }
+  const fromParsed = epochOfArg(fromArg)
+  if (provided(fromArg) && fromParsed == null) {
+    return { text: `from 必须是 ISO 8601 时间(如 2026-10-01T08:00:00+08:00)或正的 epoch 毫秒(收到 ${String(fromArg)})。`, isError: true }
   }
   if (provided(args.last_minutes) && (!Number.isFinite(Number(args.last_minutes)) || Number(args.last_minutes) <= 0)) {
     return { text: `last_minutes 必须大于 0(收到 ${String(args.last_minutes)})。`, isError: true }
   }
-  const toMs = provided(args.to_ms) ? Number(args.to_ms) : Date.now()
-  const fromMs = provided(args.from_ms)
-    ? Number(args.from_ms)
-    : toMs - (provided(args.last_minutes) ? Number(args.last_minutes) : 30) * 60_000
+  const toMs = toParsed ?? Date.now()
+  const fromMs = fromParsed
+    ?? toMs - (provided(args.last_minutes) ? Number(args.last_minutes) : 30) * 60_000
   if (fromMs >= toMs) {
-    return { text: `时间窗非法:from_ms(${fromMs})必须小于 to_ms(${toMs})。`, isError: true }
+    return { text: `时间窗非法:from(${fromMs})必须小于 to(${toMs})。`, isError: true }
   }
   // 聚合口径:avg(缺省)/min/max 作用于降采样桶;最新值始终取库内最后一条原始样本
   const aggRaw = String(args.agg ?? '').trim().toLowerCase()
@@ -126,9 +158,13 @@ export async function toolDaqQuery(agentId: string, args: {
   /** scope=all:显式要求不过滤(跨配方/历史复盘),仅在无显式 id 时生效 */
   const wantAll = !explicitScoped && String(args.scope ?? '').trim().toLowerCase() === 'all'
 
-  const { getTsdb, tsdbReady } = await import('../../daq/storage')
+  const { getTsdb, tsdbReady, tsdbQueryHistory, tsdbRetentionInfo } = await import('../../daq/storage')
   await tsdbReady
   const tsdb = getTsdb()
+  // 分层保留:窗口早于原始样本保留期 → 自动改走 1m/1h 聚合(不静默返回空)
+  const rawRetentionH = tsdbRetentionInfo().rawRetentionH
+  const rawCutoffMs = Date.now() - rawRetentionH * 3_600_000
+  const needHistory = fromMs < rawCutoffMs
   // 各节点库内最新样本(用于「库内滞后」;查询本身走 tail 取窗口末尾,末元素才是最新)
   let latestMap = new Map<string, { tsMs: number, value: number }>()
   try {
@@ -161,9 +197,31 @@ export async function toolDaqQuery(agentId: string, args: {
     applied.push({ nodeId, lineId: nodeLine, runId: scopeRun.runId, recipeId: scopeRun.recipeId, source: scopeRun.source })
     try {
       let points: Array<{ at: number, value?: number, avg?: number, min?: number, max?: number, cnt?: number }>
+      let historyNote = ''
       // 是否有可用的打标过滤:显式 id、或活动批次(配方/批次 id 齐备)
       const useTagged = Boolean(scopeRun.recipeId || scopeRun.runId || scopeRun.productId)
-      if (useTagged) {
+      if (needHistory) {
+        // 超出原始保留期:走分层历史(1m/1h 聚合;跨边界时老段聚合 + 新段原始)
+        const h = await tsdbQueryHistory(nodeId, {
+          fromMs,
+          toMs,
+          bucketMs,
+          limit,
+          lineId: nodeLine || undefined,
+          productId: scopeRun.productId,
+          recipeId: scopeRun.recipeId,
+          runId: scopeRun.runId,
+        })
+        points = h.points
+        const label = h.resolution === 'minute'
+          ? '1 分钟聚合'
+          : h.resolution === 'hour' ? '1 小时聚合' : h.resolution === 'mixed' ? '聚合+原始拼接' : '原始样本'
+        historyNote = `数据分辨率=${label};${h.coverage.note}`
+        if (h.coverage.availableFromMs != null && h.coverage.availableFromMs > fromMs) {
+          historyNote += `;实际最早可查 ${new Date(h.coverage.availableFromMs).toISOString().slice(0, 16)}`
+        }
+      }
+      else if (useTagged) {
         const series = await queryTaggedLatest(tsdb, {
           lineId: nodeLine || undefined,
           productId: scopeRun.productId,
@@ -187,7 +245,8 @@ export async function toolDaqQuery(agentId: string, args: {
           : wantAll
             ? '全量窗口(scope=all,不做配方过滤)'
             : '未过滤(该产线当前未开跑 → 无活动批次可限定)'
-      const head = `■ ${node.name}(${ch})单位 ${node.unit},正常量程 ${node.min}~${node.max}${node.unit},当前状态 ${node.state},时间窗 ${new Date(fromMs).toISOString().slice(0, 16)} ~ ${new Date(toMs).toISOString().slice(0, 16)}(降采样 ${bucketMs}ms,聚合 ${agg})\n  ${scopeTag}`
+      // 表头携带节点 id(2026-10-30):多节点查询时模型/人可把数值精确回指到节点
+      const head = `■ ${node.name}[id=${nodeId}](${ch})单位 ${node.unit},正常量程 ${node.min}~${node.max}${node.unit},当前状态 ${node.state},时间窗 ${new Date(fromMs).toISOString().slice(0, 16)} ~ ${new Date(toMs).toISOString().slice(0, 16)}(降采样 ${bucketMs}ms,聚合 ${agg})\n  ${scopeTag}${historyNote ? `\n  ${historyNote}` : ''}`
       // 工况判读容器(具体判读在 values 计算后追加)
       const readout: string[] = []
       if (points.length === 0) {

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

@@ -54,8 +54,18 @@ export async function toolMyIndustrialNodes(agentId: string): Promise<{ text: st
     catch { /* 节点刚被删等情况忽略 */ }
   }
   const insightBlock = insights.length > 0 ? `\n\n调控闭环状态:\n${insights.join('\n')}` : ''
+  // 产线配方管理权面(2026-10-28):列出管理线、配方数与能力边界(含下发收窄规则)
+  const managedBindings = bindings.filter(x => x.kind === 'line-recipe')
+  const managedBlock = managedBindings.length > 0
+    ? `\n\n产线配方管理权:\n${managedBindings.map((b) => {
+      const line = getDcwController().listLines().find(l => l.id === b.nodeId)
+      const count = getDcwController().listRecipes().filter(r => r.lineId === b.nodeId).length
+      const dcwCount = bindings.filter(x => x.kind === 'dcw').length
+      return `- 产线「${line?.name ?? b.nodeId}」(${b.nodeId}) mode=${b.mode}:当前 ${count} 个配方;可 查看/新建(recipe_create)/修改(recipe_update)/回退(recipe_rollback);下发规则:${dcwCount > 0 ? '你已绑定数控节点 —— 只能下发这些点位' : '你未绑定任何数控节点 —— 默认可对线上配方全部参数下发'}`
+    }).join('\n')}`
+    : ''
   return {
-    text: `${cards.text}${staleNote}${insightBlock}${recipeFace ? `\n\n${recipeFace}` : ''}
+    text: `${cards.text}${staleNote}${insightBlock}${recipeFace ? `\n\n${recipeFace}` : ''}${managedBlock}
 
 ---
 通用规则:
@@ -188,6 +198,7 @@ async function dcwControlGovernedLegacy(agentId: string, args: { node_id?: strin
     return { text: '自动模式下发必须附带 hypothesis(本次假设与依据:数采证据/判定结论)。请先 daq_query 取数判读,再带依据下发。', isError: true }
   }
   let manualFeedback = ''
+  let approvalId = ''
   if (needsApproval) {
     const bd = limitsBreakdownOf(node)
     const via = recipeBinding && authorizedRecipe
@@ -208,6 +219,7 @@ async function dcwControlGovernedLegacy(agentId: string, args: { node_id?: strin
         : undefined,
     })
     if (!ap.ok) return { text: ap.text, isError: true }
+    approvalId = ap.approvalId
     manualFeedback = ap.comment ?? ''
   }
 
@@ -232,6 +244,7 @@ async function dcwControlGovernedLegacy(agentId: string, args: { node_id?: strin
       actorName: agentBadgeLabel(agentId),
       taskId: args.task_id ? String(args.task_id) : undefined,
       hypothesis: args.hypothesis ? String(args.hypothesis) : '',
+      approvalId: approvalId || undefined,
       // 台账口径(三模式):该次写入发生时的频道生效执行模式(事后审计"这条写入当时是什么模式")
       executionMode: execMode,
     }

package/server/services/workshop/agents/industrial/fallback-hints.ts

@@ -0,0 +1,31 @@
+/**
+ * 恢复/下发指引提示的单一事实源(single source of truth;纯常量、零依赖,
+ * 与 tool-classes.ts 同风格:可在 nitro 之外导入)。
+ *
+ * 守门声明:新增或修改 Agent 可见的恢复/下发提示,必须引用本模块导出的常量,
+ * 不得在各工具文件手抄;全部引用方禁止出现 dcw_control / dcw_read 字样
+ * (权限模型 v2:dcw_control 为恒拒桩,dcw_read 从不存在 ——
+ * tests/recovery-hints.test.ts 对引用方全文扫描强制)。
+ *
+ * 权限模型 v2 下的合法恢复/下发路径(2026-10-28 复核):
+ *   整批回退       = 写入保持窗/节拍窗放行后重新 recipe_rollback(dispatch=true);
+ *   复测核实       = daq_query(DAQ 无法验证的设定值 → 人工现场确认并升级);
+ *   溯源           = dcw_journal / recipe_versions;
+ *   逐节点受治理写 = 仅工艺优化 Channel 档位的 optimization_explore;
+ *   直写族恒拒     = 任何文案不得建议"逐节点直发",产线/配方链路频道只能整批重试。
+ */
+
+/** 整批重试(恢复):写入保持窗/节拍窗未放行导致整批 0/N 时,唯一合法重试路径 —— 等待约 60s 放行后重新整批重下发;逐节点直发路径不存在。 */
+export const RECOVERY_RETRY_HINT = '等待约 60s(节点写入保持窗/节拍窗放行)后重新调用 recipe_rollback(dispatch=true) 整批重下发目标版本(逐节点直发路径不存在)'
+
+/** 复测核实(恢复):daq_query 复测产线侧现值;DAQ 无法验证的设定值不做逐节点补写,转人工现场确认并升级。 */
+export const RECOVERY_VERIFY_HINT = '用 daq_query 复测产线侧现值确认真实生效;DAQ 无法验证的设定值逐条标记待人工现场确认并升级给人类(不得逐节点直发补写)'
+
+/** 溯源(恢复):本次下发台账与配方版本历史的查询入口。 */
+export const RECOVERY_TRACE_HINT = '本次下发的台账与版本历史用 dcw_journal / recipe_versions 溯源复核'
+
+/** 治理下发路径:逐节点直写已禁用,真实下发只走配方面整批或工艺优化面的受治理探索步。 */
+export const GOVERNED_DISPATCH_HINT = '真实下发路径仅两条:配方链路整批(recipe_trial / recipe_apply / recipe_rollback),或工艺优化 Channel 的 optimization_explore(受治理的逐节点探索步,联锁照常)'
+
+/** 优化探索分档:optimization_explore 仅存在于工艺优化 Channel 档位;产线/配方链路频道没有逐节点写工具,不得在文案中建议逐节点直发。 */
+export const OPT_EXPLORE_HINT = '仅工艺优化 Channel 档位可用 optimization_explore 做受治理的逐节点探索步;产线/配方链路频道无逐节点写工具,参数变更一律整批走配方链路'

package/server/services/workshop/agents/industrial/manual-approval.ts

@@ -21,7 +21,7 @@ export async function requestManualApproval(args: {
    * 配方授权路径传「绑定配方仍存在且仍包含该参数节点」——否则批准时绑定已解除仍会执行。
    */
   verify?: () => boolean
-}): Promise<{ ok: true, comment: string } | { ok: false, text: string, isError: true }> {
+}): Promise<{ ok: true, comment: string, approvalId: string } | { ok: false, text: string, isError: true }> {
   const action = args.action ?? '下发'
   const pendingText = action === '回退'
     ? '你对该节点已有一条待审批指令,请等待用户处理后再发新的回退请求(避免审批堆积)。'
@@ -53,5 +53,5 @@ export async function requestManualApproval(args: {
     }
   }
   // 批准附言随回执:人类可在批准时留反馈(缺省空),原样回流给 Agent
-  return { ok: true, comment: ap.comment ?? '' }
+  return { ok: true, comment: ap.comment ?? '', approvalId: ap.id }
 }

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

@@ -13,10 +13,14 @@ import { getDcwProductRepo } from '../../dcw/dcw-product.repo'
 import { getDcwRecipeRepo } from '../../dcw/dcw-recipe.repo'
 import { assertRecipeOpInterval } from '../../dcw/recipe-op-anchor'
 import { getDcwParamRepo } from '../../dcw/param-map.repo'
-import { getOps } from '../../ops/ops'
+import { getOps, recordOps } from '../../ops/ops'
 import { settingOf } from '../../settings'
 import { fanoutQuery, windowOf } from './audit-query'
 import { assertRecipeCreate, assertRecipeOperation, recipeApprovalPayload, type ActiveRecipeContext } from './recipe-gate'
+import { RECOVERY_RETRY_HINT, RECOVERY_TRACE_HINT, RECOVERY_VERIFY_HINT } from './fallback-hints'
+import { approvalOnlyTrialReceipt } from './bench-approval-only'
+import { currentToolInvocation } from '../governance-harness-audit'
+import { executionModeOfAgent } from '../execution-mode'
 
 // ================================================================
 // 运维日志 / Recipe 变更史查询(Agent 自查面:负责产线 scoped)
@@ -553,9 +557,15 @@ export async function toolRecipeCreate(agentId: string, args: {
   }
   if (!lineId) return { text: '无法确定产线:请提供 line_id 或 source_recipe_id(from_run_id 也可推断)。', isError: true }
   if (!readable.includes(lineId)) return { text: `无权在产线 ${lineId} 新建配方(你的可读产线:${readable.join(', ') || '(无)'})。`, isError: true }
-  const productId = String(args.product_id ?? '').trim() || source?.productId || (run?.productId ?? '')
+  let productId = String(args.product_id ?? '').trim() || source?.productId || (run?.productId ?? '')
+  if (!productId && lineId) {
+    // 只给 line_id 时:该线仅挂一个产品则自动归属(与"只传 line_id 即可操作"的工具哲学一致;
+    // 多产品歧义仍要求显式 product_id,fail-closed)
+    const lineProducts = getDcwProductRepo().all().filter(p => p.lineId === lineId)
+    if (lineProducts.length === 1) productId = lineProducts[0]!.id
+  }
   const product = productId ? getDcwProductRepo().byId(productId) : undefined
-  if (!productId || !product) return { text: `产品 ${productId || '(未提供)'} 不存在;新配方必须归属产品(product_id 或源配方可推断)。`, isError: true }
+  if (!productId || !product) return { text: `产品 ${productId || '(未提供)'} 不存在;新配方必须归属产品(product_id、源配方推断,或该产线恰好只挂一个产品时自动归属)。`, isError: true }
   if (product.lineId !== lineId) return { text: `产品「${product.name}」归属产线 ${product.lineId},与目标产线 ${lineId} 不一致。`, isError: true }
   if (source && source.lineId !== lineId) return { text: `源配方「${source.name}」归属产线 ${source.lineId},与目标产线 ${lineId} 不一致。`, isError: true }
 
@@ -945,10 +955,10 @@ export async function toolRecipeRollback(agentId: string, args: {
         ? `定义已在目标版本 v${updated.version ?? 1}(未生成新版本)`
         : `已生成 v${updated.version ?? 1}`
       // 整批重下发全部失败(典型:节点写入保持窗/节流未放行)→ 响亮失败:定义已回退但产线仍运行
-      // 旧参数,Agent 必须知道并稍后重发(再调本工具会再生成一个回退版本,或用 dcw_control 直发)。
+      // 旧参数,Agent 必须知道并稍后重发(再调本工具会再生成一个回退版本,或按 RECOVERY_RETRY_HINT 整批重试)。
       if (run.results.length > 0 && okN === 0) {
         return {
-          text: `回退部分失败:配方「${updated.name}」${defNote},但整批重下发 0/${run.results.length} 参数成功(节点写入保持窗/节流未放行)。产线仍在运行旧参数 —— 等待约 60s 后重新调用 recipe_rollback(dispatch=true,回退目标 v${updated.version ?? 1}),或用 dcw_control 逐节点直发;原因:${reason}。`,
+          text: `回退部分失败:配方「${updated.name}」${defNote},但整批重下发 0/${run.results.length} 参数成功(节点写入保持窗/节流未放行)。产线仍在运行旧参数 —— ${RECOVERY_RETRY_HINT}(回退目标 v${updated.version ?? 1});原因:${reason}。`,
           isError: true,
         }
       }
@@ -957,7 +967,7 @@ export async function toolRecipeRollback(agentId: string, args: {
         return {
           text: [
             `统一回退执行,但 ACK 鉴定未全绿:配方「${updated.name}」${defNote},设备证实 ${acks.verified}/${acks.total},未证实 ${acks.unverified},失败 ${acks.failed}(回退目标:${toLastGood ? '已知良好批次冻结' : `v${version}`});原因:${reason}。${hitlNote}`,
-            '「未证实」参数可能未真正恢复到目标值 —— 请立即用 daq_query/dcw_read 核实产线侧现值,必要时 dcw_control 逐节点直发目标值,并把清单写入汇报提醒人类。',
+            `「未证实」参数可能未真正恢复到目标值 —— 请立即核实:${RECOVERY_VERIFY_HINT},并把清单写入汇报提醒人类。`,
           ].join('\n'),
           isError: true,
         }
@@ -993,7 +1003,24 @@ export async function toolRecipeRollback(agentId: string, args: {
  *   即"改好配方交给人类判断是否下发;不下发则人告诉 Agent 怎么修"的真实作业语义。
  * 超时(默认 security.recipe_dispatch_timeout_ms,30min)自动按拒绝收敛。
  */
-async function hitlDispatchGate(agentId: string, recipeId: string, detail: string, title: string, opts?: { payload?: unknown }): Promise<{ approved: boolean, comment: string, id: string }> {
+async function hitlDispatchGate(agentId: string, recipeId: string, detail: string, title: string, opts?: {
+  payload?: unknown
+  trialTargets?: Array<{ id: string, driver: string, driverConfig: Record<string, unknown> }>
+  lineId?: string
+}): Promise<{ approved: boolean, comment: string, id: string, approval_bypassed?: true }> {
+  if (opts?.trialTargets) {
+    const receipt = approvalOnlyTrialReceipt({ recipeId, line: getDcwLineRepo().byId(opts.lineId ?? ''), nodes: opts.trialTargets })
+    if (receipt) {
+      recordOps({
+        actor: agentId, actorName: agentBadgeLabel(agentId), actorKind: 'agent',
+        action: 'recipe.approval.bypassed', kind: 'recipe', targetKind: 'recipe', targetId: recipeId,
+        lineId: opts.lineId ?? '', recipeId,
+        summary: '隔离模拟器审批消融:仅跳过人工审批等待,无人工批准记录',
+        detail: receipt,
+      })
+      return { approved: true, comment: '', id: '', approval_bypassed: true }
+    }
+  }
   const { getToolApprovals } = await import('../tool-approvals')
   const timeoutMs = Number(settingOf('security.recipe_dispatch_timeout_ms')) || undefined
   // nodeId = `recipe:<id>`:审批卡分流键(与 recipe-propose:<id> 平行;kind 保持 'dcw' 兼容既有裁决端点)
@@ -1019,10 +1046,12 @@ function approvedContextError(
   op: 'update' | 'dispatch' | 'trial' | 'rollback',
   expectedContext: ActiveRecipeContext,
   targetNodeIds?: string[],
+  approvalBypassed = false,
 ): { text: string, isError: true } | null {
+  const prefix = approvalBypassed ? '实验审批已旁路,但执行前' : '人工已批准,但审批期间'
   const currentGate = assertRecipeOperation(agentId, recipe, op, targetNodeIds)
   if (!currentGate.ok) {
-    return { text: `人工已批准,但审批期间授权已失效,本次未执行:${currentGate.text}`, isError: true }
+    return { text: `${prefix}授权已失效,本次未执行:${currentGate.text}`, isError: true }
   }
   const current = currentGate.activeContext
   if (current.lineId !== expectedContext.lineId
@@ -1030,7 +1059,7 @@ function approvedContextError(
     || current.recipeId !== expectedContext.recipeId
     || current.productId !== expectedContext.productId) {
     return {
-      text: '人工已批准,但审批期间产线/产品/配方/批次上下文已变化,本次未执行。请核查当前运行上下文后重新提交。',
+      text: `${prefix}产线/产品/配方/批次上下文已变化,本次未执行。请核查当前运行上下文后重新提交。`,
       isError: true,
     }
   }
@@ -1054,9 +1083,11 @@ export async function revalidateApprovedAction(
   toolName: string,
   args: Record<string, unknown>,
   expectedContext: ActiveRecipeContext,
+  approvalBypassed = false,
 ): Promise<{ text: string, isError: true } | null> {
+  const prefix = approvalBypassed ? '实验审批已旁路,但执行前' : '人工已批准,但审批期间'
   const targetNodeIds = targetNodesFromArgs(op, args)
-  const initialContextError = approvedContextError(agentId, recipe, op, expectedContext, targetNodeIds)
+  const initialContextError = approvedContextError(agentId, recipe, op, expectedContext, targetNodeIds, approvalBypassed)
   if (initialContextError) return initialContextError
   try {
     // manager 未装配(单测/嵌入)→ 只做绑定与运行门复核;装配后叠加产线 grant 复核
@@ -1067,16 +1098,16 @@ export async function revalidateApprovedAction(
     if (channelId) {
       const { guardIndustrialToolGrant } = await import('./grant-guard')
       const denied = await guardIndustrialToolGrant({ agentId, channelId }, toolName, args)
-      if (denied) return { text: `人工已批准,但审批期间产线授权已被收回,本次未执行:${denied.text}`, isError: true }
+      if (denied) return { text: `${prefix}产线授权已被收回,本次未执行:${denied.text}`, isError: true }
     }
   }
   catch (err) {
-    return { text: `人工已批准,但审批后权限复核不可用,本次未执行:${err instanceof Error ? err.message : String(err)}。请稍后重试。`, isError: true }
+    return { text: `${prefix}权限复核不可用,本次未执行:${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, targetNodeIds)
+  const changedAfterGrantCheck = approvedContextError(agentId, recipe, op, expectedContext, targetNodeIds, approvalBypassed)
   if (changedAfterGrantCheck) return changedAfterGrantCheck
   return null
 }
@@ -1106,7 +1137,7 @@ export async function toolRecipeTrial(agentId: string, args: {
   params?: Array<{ node_id?: string, value?: number | string }>
   hypothesis?: string
   emergency?: boolean | string
-}): Promise<{ text: string, isError?: boolean }> {
+}): Promise<{ text: string, isError?: boolean, approval_bypassed?: true }> {
   const hypothesis = String(args.hypothesis ?? '').trim()
   const emergency = args.emergency === true || args.emergency === 'true'
   if (!hypothesis) return { text: 'hypothesis 必填:试验必须声明依据(知识库条目/数据分析结论),便于审计追溯与人工审批判断。', isError: true }
@@ -1120,6 +1151,9 @@ export async function toolRecipeTrial(agentId: string, args: {
   // 权限模型 v2 + 2026-10-28 双轨:recipe 绑定 ∨ 本次候选覆盖集 ⊆ dcw 节点绑定面
   const gate = assertRecipeOperation(agentId, recipe, 'trial', list.map(p => p.nodeId))
   if (!gate.ok) return { text: gate.text, isError: true }
+  if (process.env.AW_BENCH_APPROVAL_ONLY === '1' && !gate.hitlRequired) {
+    return { text: 'Approval-only trial refused: the normal manual approval gate must remain enabled', isError: true }
+  }
   for (const p of list) {
     const node = getDcwController().byId(p.nodeId)
     if (!node) return { text: `节点 ${p.nodeId} 已删除,不能纳入试验。`, isError: true }
@@ -1136,6 +1170,7 @@ export async function toolRecipeTrial(agentId: string, args: {
     // HITL 门:manual 绑定(或全局开关)时,整批试验前先挂起等人工裁决(拒绝附指导 → 回给 Agent 修订)
     let hitlNote = ''
     let gateApprovalId = ''
+    let approvalBypassed = false
     if (gate.hitlRequired) {
       const gateDecision = await hitlDispatchGate(
         agentId,
@@ -1146,7 +1181,7 @@ export async function toolRecipeTrial(agentId: string, args: {
           return `${node?.name ?? p.nodeId} ${old ?? '?'}→${p.value}${node?.unit ?? ''}`
         }).join(';')} | 假设:${hypothesis} | 批准=整批下发试验(不写版本);拒绝可附指导`,
         `${emergency ? '【应急】' : ''}配方试验(整批候选)下发审批`,
-        { payload: { ...recipeApprovalPayload('trial', recipe.id, recipe.name, {
+        { lineId: recipe.lineId, trialTargets: list.map(p => getDcwController().byId(p.nodeId)!), payload: { ...recipeApprovalPayload('trial', recipe.id, recipe.name, {
           reason: hypothesis,
           params: list.map((p) => {
             const node = getDcwController().byId(p.nodeId)
@@ -1157,23 +1192,35 @@ export async function toolRecipeTrial(agentId: string, args: {
         }), ...(emergency ? { emergency: true } : {}) } },
       )
       gateApprovalId = gateDecision.id
+      approvalBypassed = gateDecision.approval_bypassed === true
       if (!gateDecision.approved) {
         return {
           text: `人工未批准本次试验下发。人工指导:${gateDecision.comment || '(无附言,仅不同意候选)'}。请按人工指导修订候选参数(必要时先 recipe_update 调整基线),然后重新提交 recipe_trial。`,
         }
       }
       // 人工附言随批准回执回流(Agent 与审计都能看到放行时人的原话)
-      if (gateDecision.comment) hitlNote = `\n人工附言:${gateDecision.comment}`
-      const stale = await revalidateApprovedAction(agentId, recipe, 'trial', 'recipe_trial', { recipe_id: recipeId, params: list.map(p => ({ node_id: p.nodeId })) }, gate.activeContext)
-      if (stale) return stale
-      const staleAtDispatch = approvedContextError(agentId, recipe, 'trial', gate.activeContext, list.map(p => p.nodeId))
-      if (staleAtDispatch) return staleAtDispatch
+      if (approvalBypassed) hitlNote = '\n实验审批旁路:approval_bypassed=true;仅用于隔离模拟器,未获得人工批准。'
+      else if (gateDecision.comment) hitlNote = `\n人工附言:${gateDecision.comment}`
+      const stale = await revalidateApprovedAction(agentId, recipe, 'trial', 'recipe_trial', { recipe_id: recipeId, params: list.map(p => ({ node_id: p.nodeId })) }, gate.activeContext, approvalBypassed)
+      if (stale) return { ...stale, ...(approvalBypassed ? { approval_bypassed: true as const } : {}) }
+      const staleAtDispatch = approvedContextError(agentId, recipe, 'trial', gate.activeContext, list.map(p => p.nodeId), approvalBypassed)
+      if (staleAtDispatch) return { ...staleAtDispatch, ...(approvalBypassed ? { approval_bypassed: true as const } : {}) }
     }
     // 2026-10-28 执行点复核(双轨授权,D13 同款):审批/节拍等待期间绑定可能被撤销,
     // 下发前最后一次同步重算覆盖集 —— 收回即失活,不把授权变更带进写入。
     const execGate = assertRecipeOperation(agentId, recipe, 'trial', list.map(p => p.nodeId))
     if (!execGate.ok) return { text: `下发前授权复核未通过,本次未执行:${execGate.text}`, isError: true }
-    const run = await getDcwController().applyRecipe(recipeId, { overrides: list, trial: true, agentDispatch: true, agentApprovalId: gateApprovalId, emergency })
+    // Recheck the qualified driver/PID after the asynchronous grant revalidation.
+    if (approvalBypassed) approvalOnlyTrialReceipt({ recipeId, line: getDcwLineRepo().byId(recipe.lineId), nodes: list.map(p => getDcwController().byId(p.nodeId)!) })
+    const invocation = currentToolInvocation()
+    const run = await getDcwController().applyRecipe(recipeId, {
+      overrides: list, trial: true, agentDispatch: true, agentApprovalId: gateApprovalId, emergency,
+      agentTrialMeta: {
+        actor: agentId, actorName: agentBadgeLabel(agentId), hypothesis,
+        ...(invocation?.agentId === agentId && invocation.taskId ? { taskId: invocation.taskId } : {}),
+        executionMode: executionModeOfAgent(agentId),
+      },
+    })
     // ACK 鉴定三段口径(2026-10-08):ok 只是命令受理,未证实/失败必须如实回给 Agent
     const acks = run.ackSummary ?? { verified: run.results.filter(r => r.ok).length, unverified: 0, failed: run.results.filter(r => !r.ok).length, total: run.results.length }
     // 批次级留痕:试验动作入审计(逐参数写已有 write-audit;这里是"一次试验"粒度)
@@ -1184,7 +1231,7 @@ export async function toolRecipeTrial(agentId: string, args: {
         action: 'recipe.trial', kind: 'recipe', targetKind: 'recipe', targetId: recipeId, recipeId, lineId: recipe.lineId, productId: recipe.productId,
         level: acks.failed > 0 ? 'error' : acks.unverified > 0 ? 'warn' : 'info',
         summary: `${emergency ? '【应急】' : ''}配方试验整批下发(证实 ${acks.verified}/${acks.total},未证实 ${acks.unverified},失败 ${acks.failed},批次 ${run.id.slice(0, 8)}):${list.map(p => `${p.nodeId.slice(0, 8)}→${p.value}`).join(';')} | 假设:${hypothesis}`,
-        detail: { runId: run.id, ackSummary: acks, ...(emergency ? { emergency: true } : {}) },
+        detail: { runId: run.id, ackSummary: acks, ...(emergency ? { emergency: true } : {}), ...(approvalBypassed ? { approval_bypassed: true } : {}) },
       })
     }
     catch { /* 审计失败不影响试验结果 */ }
@@ -1205,10 +1252,12 @@ export async function toolRecipeTrial(agentId: string, args: {
           '「未证实」=命令已发到链路但设备侧未确认生效;请用 daq_query 复测这些参数的真实状态后再判读试验效果,必要时对未证实参数单独重发或 recipe_rollback 统一回退,并写入汇报提醒人类。',
         ].join('\n'),
         isError: true,
+        ...(approvalBypassed ? { approval_bypassed: true as const } : {}),
       }
     }
     return {
       text: `试验已整批下发并全部设备证实(${acks.verified}/${acks.total},批次 ${run.id.slice(0, 8)}):${changed}。假设:${hypothesis}。${hitlNote}注意:本次试验**未写入配方版本** —— 等待工艺惯性后 daq_query 复测判读:有进步/达标 → recipe_update 把候选值固化进配方(同 id 版本+1);无进步/劣化 → recipe_rollback(recipe_id, dispatch=true, reason=…) 统一回退(定义回退+PLC 整批恢复)。`,
+      ...(approvalBypassed ? { approval_bypassed: true as const } : {}),
     }
   }
   catch (err) {
@@ -1321,7 +1370,7 @@ export async function toolRecipeApply(agentId: string, args: {
         text: [
           `配方「${dispatch.name}」v${dispatch.version} 整批下发 ACK 鉴定未全绿(证实 ${acks.verified}/${acks.total},未证实 ${acks.unverified},失败 ${acks.failed},批次 ${run.id.slice(0, 8)})。${hitlNote}`,
           `${skippedNote}${unverifiedNote}`,
-          '请用 daq_query 复测未证实参数的真实状态;必要时 dcw_control 单独重发或 recipe_rollback(dispatch=true) 统一回退,并把清单写入汇报提醒人类。',
+          `${RECOVERY_VERIFY_HINT};必要时用 recipe_rollback(dispatch=true) 统一回退,${RECOVERY_TRACE_HINT},并把清单写入汇报提醒人类。`,
         ].filter(Boolean).join('\n'),
         isError: true,
       }