agentworkshop 0.7.70 → 0.8.0

package/server/services/workshop/agents/hitl-decision/dispatcher.ts

@@ -1,96 +1,127 @@
-/**
- * 原生派发器注册与默认派发
- * (由 server/services/workshop/agents/hitl-decision.ts 按职责拆出;内容逐行原文搬运)
- */
-import type { AepHitlQuestion } from '../../../../../shared/workshop-protocol'
-import type { HitlActingUser, HitlDecisionPayload } from './shared'
-import { AppError } from '@/server/utils/errors'
-import { encodeHitlAnswers, resolveHitlRuntime } from '../hitl-registry'
-import { getToolApprovals, normalizeRecipeProposeDecision } from '../tool-approvals'
-import { resolveAnswers } from './answers'
-import { respondTerminalUi } from '../harness-terminal'
-
-// ============================================================================
-// 原生应答传导(可插拔:测试/嵌入场景替换;缺省走真实 adapter 面)
-// ============================================================================
-
-export interface HitlNativeDispatchContext {
-  kind: string
-  id: string
-  requestType: 'question' | 'approval'
-  channelId: string
-  agentId: string
-  /** 内存快照里的 pid(omp-dialog 终止对话框用) */
-  pid?: number
-  /** 问题列表(多问题答案按问题 id 对齐回传;来自持久化行,回落到内存快照) */
-  questions: AepHitlQuestion[]
-  decision: HitlDecisionPayload
-  user: HitlActingUser
-}
-
-export type HitlNativeDispatcher = (ctx: HitlNativeDispatchContext) => Promise<unknown> | unknown
-
-export const nativeDispatchers = new Map<string, HitlNativeDispatcher>()
-
-/** 注册/覆盖某 providerKind 的原生应答传导(测试与嵌入装配用) */
-export function registerHitlNativeDispatcher(kind: string, fn: HitlNativeDispatcher | null): void {
-  if (fn) nativeDispatchers.set(kind, fn)
-  else nativeDispatchers.delete(kind)
-}
-
-/** 默认传导:omp 对话框写 stdin;dcw 走工具审批服务;其余走 manager→adapter */
-export async function defaultDispatch(ctx: HitlNativeDispatchContext): Promise<unknown> {
-  const manager = resolveHitlRuntime()
-  const { decision } = ctx
-  if (ctx.kind === 'omp-dialog') {
-    // 保持既有 410 SESSION_GONE 语义:pid 缺失/进程已退出 = 会话不可用(确定性失败)
-    if (!ctx.pid) throw new AppError(410, 'SESSION_GONE', '对话框缺少 pid(进程已退出?)')
-    try {
-      respondTerminalUi(ctx.pid, {
-        id: ctx.id,
-        // 提问型 UI 提交的是 answers[];omp terminal 只认 value。
-        // 与 harness 路径同源编码:单答案 → 纯文本,多答案 → 信封。
-        value: encodeHitlAnswers(resolveAnswers(ctx.questions, decision), decision.value ?? ''),
-        confirmed: typeof decision.confirmed === 'boolean' ? decision.confirmed : undefined,
-        cancelled: decision.cancelled === true,
-      })
-    }
-    catch (err) {
-      throw new AppError(410, 'SESSION_GONE', `omp 会话不可用: ${err instanceof Error ? err.message : String(err)}`)
-    }
-    return { via: 'omp-terminal' }
-  }
-  if (ctx.kind === 'dcw-approval') {
-    // dcw 工具审批:与 hitl/respond 同语义(缺省视为拒绝,approved 必须显式 confirmed===true)。
-    // 产线 Co-Pilot P2:结构化审批单(recipe-propose,payload.schemaVersion=1)先经 fail-closed
-    // 归一 —— 无有效 choice 的「批准」一律按拒绝收敛;legacy 审批单(无 payload)完全不干预。
-    const pending = getToolApprovals().listPending().find(a => a.id === ctx.id)
-    const normalized = normalizeRecipeProposeDecision(pending, {
-      approved: decision.confirmed === true,
-      choice: decision.choice,
-    })
-    if (decision.confirmed === true && !normalized.approved) {
-      // fail-closed 降级:把有效裁决回写进决策载荷,使 hitl 行终态/审计/落定通知
-      // 与实际裁决(拒绝)一致,不留「已批准但未执行」的假态
-      decision.confirmed = false
-    }
-    const approval = getToolApprovals().decide(
-      ctx.id,
-      normalized.approved,
-      String(decision.comment ?? ''),
-      ctx.user.id,
-      ctx.user.name ?? '',
-      normalized.choice,
-    )
-    return { via: 'tool-approvals', approval }
-  }
-  if (!manager) throw new AppError(409, 'NOT_RESPONDABLE', 'Workshop 运行时未装配,无法应答该 harness 请求')
-  await manager.respondHarnessHitl(ctx.agentId, ctx.kind, ctx.id, {
-    confirmed: typeof decision.confirmed === 'boolean' ? decision.confirmed : undefined,
-    cancelled: decision.cancelled === true,
-    value: encodeHitlAnswers(resolveAnswers(ctx.questions, decision), decision.value),
-    response: typeof decision.response === 'string' ? decision.response : undefined,
-    comment: typeof decision.comment === 'string' ? decision.comment : undefined,
-  })
-  return { via: 'harness', harness: ctx.kind }
-}
+/**
+ * 原生派发器注册与默认派发
+ * (由 server/services/workshop/agents/hitl-decision.ts 按职责拆出;内容逐行原文搬运)
+ */
+import type { AepHitlQuestion } from '../../../../../shared/workshop-protocol'
+import type { HitlActingUser, HitlDecisionPayload } from './shared'
+import { AppError } from '@/server/utils/errors'
+import { encodeHitlAnswers, resolveHitlRuntime } from '../hitl-registry'
+import { getToolApprovals, normalizeRecipeProposeDecision } from '../tool-approvals'
+import { decideOptimizerDispatch, isOptimizerDispatchCard } from '../../optimization/dispatch.service'
+import { resolveAnswers } from './answers'
+import { respondTerminalUi } from '../harness-terminal'
+import { isProfileAdoptCard, decideProfileAdoption } from '../../optimization/profile-adopt.service'
+
+// ============================================================================
+// 原生应答传导(可插拔:测试/嵌入场景替换;缺省走真实 adapter 面)
+// ============================================================================
+
+export interface HitlNativeDispatchContext {
+  kind: string
+  id: string
+  requestType: 'question' | 'approval'
+  channelId: string
+  agentId: string
+  /** 内存快照里的 pid(omp-dialog 终止对话框用) */
+  pid?: number
+  /** 问题列表(多问题答案按问题 id 对齐回传;来自持久化行,回落到内存快照) */
+  questions: AepHitlQuestion[]
+  decision: HitlDecisionPayload
+  user: HitlActingUser
+}
+
+export type HitlNativeDispatcher = (ctx: HitlNativeDispatchContext) => Promise<unknown> | unknown
+
+export const nativeDispatchers = new Map<string, HitlNativeDispatcher>()
+
+/** 注册/覆盖某 providerKind 的原生应答传导(测试与嵌入装配用) */
+export function registerHitlNativeDispatcher(kind: string, fn: HitlNativeDispatcher | null): void {
+  if (fn) nativeDispatchers.set(kind, fn)
+  else nativeDispatchers.delete(kind)
+}
+
+/** 默认传导:omp 对话框写 stdin;dcw 走工具审批服务;其余走 manager→adapter */
+export async function defaultDispatch(ctx: HitlNativeDispatchContext): Promise<unknown> {
+  const manager = resolveHitlRuntime()
+  const { decision } = ctx
+  if (ctx.kind === 'omp-dialog') {
+    // 保持既有 410 SESSION_GONE 语义:pid 缺失/进程已退出 = 会话不可用(确定性失败)
+    if (!ctx.pid) throw new AppError(410, 'SESSION_GONE', '对话框缺少 pid(进程已退出?)')
+    try {
+      respondTerminalUi(ctx.pid, {
+        id: ctx.id,
+        // 提问型 UI 提交的是 answers[];omp terminal 只认 value。
+        // 与 harness 路径同源编码:单答案 → 纯文本,多答案 → 信封。
+        value: encodeHitlAnswers(resolveAnswers(ctx.questions, decision), decision.value ?? ''),
+        confirmed: typeof decision.confirmed === 'boolean' ? decision.confirmed : undefined,
+        cancelled: decision.cancelled === true,
+      })
+    }
+    catch (err) {
+      throw new AppError(410, 'SESSION_GONE', `omp 会话不可用: ${err instanceof Error ? err.message : String(err)}`)
+    }
+    return { via: 'omp-terminal' }
+  }
+  if (ctx.kind === 'dcw-approval') {
+    // dcw 工具审批:与 hitl/respond 同语义(缺省视为拒绝,approved 必须显式 confirmed===true)。
+    // 产线 Co-Pilot P2:结构化审批单(recipe-propose,payload.schemaVersion=1)先经 fail-closed
+    // 归一 —— 无有效 choice 的「批准」一律按拒绝收敛;legacy 审批单(无 payload)完全不干预。
+    const pending = getToolApprovals().listPending().find(a => a.id === ctx.id)
+    const normalized = normalizeRecipeProposeDecision(pending, {
+      approved: decision.confirmed === true,
+      choice: decision.choice,
+    })
+    if (decision.confirmed === true && !normalized.approved) {
+      // fail-closed 降级:把有效裁决回写进决策载荷,使 hitl 行终态/审计/落定通知
+      // 与实际裁决(拒绝)一致,不留「已批准但未执行」的假态
+      decision.confirmed = false
+    }
+    // SW5/D13 单一咽喉:optimizer-recipe:* 卡一律走 dispatch 链(八项重验→抢占→写→回读→审计);
+    // 业务拒绝在咽喉内 decide() 落定,hitl 行终态与实际裁决一致
+    // OW-adopt 单一咽喉:optimizer-profile:* 卡 → 采纳裁决(批准=发布+重绑)
+    if (pending && isProfileAdoptCard(pending.nodeId)) {
+      const result = await decideProfileAdoption({
+        cardId: ctx.id,
+        nodeId: pending.nodeId,
+        approved: normalized.approved,
+        comment: String(decision.comment ?? ''),
+        actingUser: { id: ctx.user.id, name: ctx.user.name ?? ctx.user.id },
+        via: 'hitl/respond',
+      })
+      if (result.handled) {
+        return { via: 'profile-adopt', result: { approved: result.approved, comment: result.comment, code: result.code, published: result.published } }
+      }
+    }
+    if (pending && isOptimizerDispatchCard(pending.nodeId)) {
+      const result = await decideOptimizerDispatch({
+        cardId: ctx.id,
+        approved: normalized.approved,
+        comment: String(decision.comment ?? ''),
+        choice: normalized.choice,
+        actingUser: { id: ctx.user.id, name: ctx.user.name ?? ctx.user.id },
+        via: 'hitl/respond',
+      })
+      if (result.handled) {
+        return { via: 'optimizer-dispatch', result: { approved: result.approved, comment: result.comment, code: result.code, execution: result.execution } }
+      }
+    }
+    const approval = getToolApprovals().decide(
+      ctx.id,
+      normalized.approved,
+      String(decision.comment ?? ''),
+      ctx.user.id,
+      ctx.user.name ?? '',
+      normalized.choice,
+    )
+    return { via: 'tool-approvals', approval }
+  }
+  if (!manager) throw new AppError(409, 'NOT_RESPONDABLE', 'Workshop 运行时未装配,无法应答该 harness 请求')
+  await manager.respondHarnessHitl(ctx.agentId, ctx.kind, ctx.id, {
+    confirmed: typeof decision.confirmed === 'boolean' ? decision.confirmed : undefined,
+    cancelled: decision.cancelled === true,
+    value: encodeHitlAnswers(resolveAnswers(ctx.questions, decision), decision.value),
+    response: typeof decision.response === 'string' ? decision.response : undefined,
+    comment: typeof decision.comment === 'string' ? decision.comment : undefined,
+  })
+  return { via: 'harness', harness: ctx.kind }
+}

package/server/services/workshop/agents/host-tool-bridge/catalog.ts

@@ -12,10 +12,14 @@ import { getChannelTwinProfile } from '../../aml/twin/channel-profile'
 import { amlTwinFeatureFlags } from '../../aml/twin/feature-flags'
 import { applyChannelToolPolicy } from '../../tools/policy'
 import type { ToolExclusion } from '../../tools/types'
+import { registerToolReferenceDeclarations } from '../tool-reference-spec'
 
 /** host tool 定义(外置 .AgentWorkShop/prompts/host-tools.json;加载器缓存) */
 export const HOST_TOOLS: RpcHostToolDefinition[] = loadHostToolDefs()
 
+// WP5:定义自带的引用面声明装配进单一声明表(tool-verify 执行期查表;声明在注册时生效)
+registerToolReferenceDeclarations(HOST_TOOLS)
+
 // 工具分类常量已上收零依赖叶子模块 agents/tool-classes(权限面/测试在 nitro 之外可用);此处 re-export 保持导入路径兼容
 export { LEAD_ONLY_TOOL_NAMES, HYBRID_TWIN_DIRECT_WRITE_TOOL_NAMES } from '../tool-classes'
 
@@ -38,6 +42,14 @@ export const AML_OPTIMIZATION_TOOL_NAMES = new Set([
   'twin_snapshot_create', 'twin_trial_run', 'mpc_optimize', 'twin_gate_evaluate', 'optimization_explore', 'twin_bayes_optimize',
 ])
 
+/**
+ * 优化器工具族(G4):零写设备;仅 aml_optimization / hybrid_twin 注入,
+ * 且 solve/status/cancel/plan_get 还要求该 Agent 有有效绑定(per-agent 再裁一次)。
+ */
+export const OPTIMIZER_TOOL_NAMES = new Set([
+  'optimizer_capabilities', 'optimizer_solve', 'optimizer_status', 'optimizer_cancel', 'optimizer_plan_get',
+])
+
 /** 仅 aml 模式(已绑定模型)可执行的工具;探索模式下 dispatch 层 fail-closed 拒绝。 */
 export const AML_MODEL_BACKED_TOOL_NAMES = new Set([
   'twin_trial_run', 'mpc_optimize', 'twin_bayes_optimize',
@@ -183,16 +195,16 @@ export function scopeHostToolsForRole(role: 'lead' | 'worker', channelId?: strin
   const flags = amlTwinFeatureFlags()
   let scoped: RpcHostToolDefinition[]
   if (kind === 'aml_training') {
-    // 训练面:剔除优化族(gate 保留 —— 模型晋升前需门禁评估);训练族显式补齐(host-tools.json 全量已含)
+    // 训练面:剔除优化族与优化器族(gate 保留 —— 模型晋升前需门禁评估)
     scoped = narrow(
       base,
-      t => !AML_OPTIMIZATION_TOOL_NAMES.has(t.name) || t.name === 'twin_gate_evaluate',
+      t => (!AML_OPTIMIZATION_TOOL_NAMES.has(t.name) || t.name === 'twin_gate_evaluate') && !OPTIMIZER_TOOL_NAMES.has(t.name),
       'PROFILE_DENIED',
-      `当前 Channel 档位(${kind})不开放该工具(训练面与优化执行面互斥)`,
+      `当前 Channel 档位(${kind})不开放该工具(训练面不求解)`,
     )
   }
   else if (kind === 'aml_optimization') {
-    // 优化面:剔除训练族(gate 保留 —— 绑定校验需门禁);优化族显式补齐(含新工具)
+    // 优化面:剔除训练族(gate 保留);优化器族保留(per-agent 再按绑定裁剪)
     scoped = narrow(
       base,
       t => !AML_TRAINING_TOOL_NAMES.has(t.name) || t.name === 'twin_gate_evaluate',
@@ -222,9 +234,10 @@ export function scopeHostToolsForRole(role: 'lead' | 'worker', channelId?: strin
           base,
           t => !HYBRID_TWIN_TOOL_NAMES.has(t.name)
             && !AML_TRAINING_TOOL_NAMES.has(t.name)
-            && !AML_OPTIMIZATION_TOOL_NAMES.has(t.name),
+            && !AML_OPTIMIZATION_TOOL_NAMES.has(t.name)
+            && !OPTIMIZER_TOOL_NAMES.has(t.name),
           'PROFILE_DENIED',
-          '当前 Channel 为 legacy 档位,不开放孪生/训练/优化族工具',
+          '当前 Channel 为 legacy 档位,不开放孪生/训练/优化/优化器族工具',
         )
   }
 

package/server/services/workshop/agents/host-tool-bridge/description-budget.ts

@@ -0,0 +1,34 @@
+/**
+ * 工具描述预算折叠(WP6)—— 零依赖叶子模块,便于单测。
+ *
+ * 折叠必须确定性:调用方先按 id 排序,本模块按顺序稳定截断,同一绑定面两次编译
+ * 输出逐字节相同(否则 tools/list_changed 会因截断边界抖动持续刷屏)。
+ * env AW_DESC_BUDGET=0 关闭折叠(回退全量拼接)。
+ */
+export const RESOURCES_GUIDE = ';完整清单用 industrial_resources 分页查询'
+
+export function descBudget(env: Record<string, string | undefined> = process.env): number {
+  const n = Number(env.AW_DESC_BUDGET ?? 400)
+  return Number.isFinite(n) && n >= 0 ? n : 400
+}
+
+export function sortedById<T extends { id: string }>(items: T[]): T[] {
+  return [...items].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
+}
+
+export function foldList(prefix: string, items: string[], guide = RESOURCES_GUIDE, budget = descBudget()): string {
+  const full = `${prefix}${items.join('、')}`
+  if (budget === 0 || full.length <= budget) return full
+  const head: string[] = []
+  let used = prefix.length + guide.length + 16
+  for (const it of items) {
+    // 首项必须保留:配方条目携带完整参数面,单条即可超预算——空折叠(「等 N 项」
+    // 前无任何条目)会把绑定面整体隐藏,模型连绑了哪个配方/节点都看不到,
+    // per-agent 描述增强("不必先探测绑定面")失效。预算只对第 2 项起收紧。
+    if (head.length > 0 && used + it.length + 1 > budget) break
+    head.push(it)
+    used += it.length + 1
+  }
+  const more = head.length < items.length ? ` 等 ${items.length} 项` : ''
+  return `${prefix}${head.join('、')}${more}${guide}`
+}

package/server/services/workshop/agents/host-tool-bridge/dispatch.ts

@@ -12,14 +12,18 @@
  */
 import { getChannelPluginsRepo } from '../../db/channel-plugins.repo'
 import { getChannelTwinProfile, modelBackedToolPolicyFor, type AmlChannelProfileKind } from '../../aml/twin/channel-profile'
+import { getAmlRuntime } from '../../aml/runtime'
+import { getDcwLineRepo } from '../../dcw/dcw-line.repo'
 import { AML_TRAINING_TOOL_NAMES, AML_MODEL_BACKED_TOOL_NAMES, HOST_TOOLS } from './catalog'
 import { twinWriteGuard } from '../../aml/twin/feature-flags'
 import { listPluginTools, pluginOfTool } from '../plugin-tools'
+import { auditPluginToolCall, governPluginToolCall } from '../plugin-governance'
 import type { HostToolBridgeContext, HostToolCall, HostToolResult } from './types'
 import { INDUSTRIAL_TOOL_NAMES, dispatchIndustrialTool } from './tools/industrial'
 import { guardIndustrialToolGrant } from '../industrial/grant-guard'
 import { verifyIndustrialToolCall } from '../industrial/tool-verify'
 import { checkToolAgainstScope } from '../../runtime/permission-scope'
+import { optimizerDispatchGate, legacyMpcAliasGate } from './optimizer-gate'
 import { channelToolGate } from '../../tools/policy'
 import type { WorkshopPermissionScope } from '../../../../../shared/workshop-protocol'
 import { handleCompleteTask, handleReportProgress } from './tools/progress'
@@ -41,6 +45,56 @@ export async function dispatchHostTool(ctx: HostToolBridgeContext, req: HostTool
 /** 内置工具名(插件同名注册不参与分发:注入面已显示内置定义,执行面必须同源) */
 const BUILTIN_TOOL_NAMES = new Set(HOST_TOOLS.map(t => t.name))
 
+/** 优化器绑定 id 列表(不存在/表未建 → 空,fail-closed 由调用方处理)。 */
+function listBindingIds(agentId: string): string[] {
+  try {
+    return (getAmlRuntime().db.prepare('SELECT id FROM optimizer_bindings WHERE channel_agent_id = ?').all(agentId) as Array<{ id: string }>).map(r => r.id)
+  }
+  catch {
+    return []
+  }
+}
+
+/**
+ * 已绑定 AML 模型是否存在通过的优化资格报告(旧 mpc_optimize 迁移门控)。
+ * 资格必须**按模型自身谱系**溯源,不能按产线放行:
+ *   model → dataset.spec_ref/spec_version → process_model_eligibility(同 spec/version)。
+ * 作用域由产线性质决定(simulated → simulation,否则 real),模拟资格不得授权真实线。
+ */
+export function boundModelHasEligibility(modelId: string): boolean {
+  try {
+    const db = getAmlRuntime().db
+    const model = db.prepare(
+      `SELECT m.line_id AS lineId, m.product_id AS productId, m.recipe_id AS recipeId,
+              d.spec_ref AS specRef, d.spec_version AS specVersion
+       FROM aml_models m JOIN aml_datasets d ON d.id = m.dataset_id
+       WHERE m.id = ?`,
+    ).get(modelId) as { lineId: string, productId: string, recipeId: string, specRef: string, specVersion: number | null } | undefined
+    if (!model?.specRef) return false
+    const line = getDcwLineRepo().byId(model.lineId)
+    const scope = line?.simulated === true ? 'simulation' : 'real'
+    const rows = db.prepare(
+      `SELECT e.report_json AS report FROM process_model_eligibility e
+       JOIN process_model_specs s ON s.id = e.spec_id AND s.version = e.spec_version
+       WHERE e.spec_id = ? AND e.spec_version = ? AND e.scope = ?
+         AND s.line_id = ? AND s.product_id = ? AND s.recipe_id = ?
+         AND e.optimization_eligible = 1
+       ORDER BY e.created_at DESC LIMIT 50`,
+    ).all(model.specRef, model.specVersion ?? 1, scope, model.lineId, model.productId, model.recipeId) as Array<{ report: string }>
+    return rows.some((r) => {
+      try {
+        return JSON.parse(r.report || '{}').optimizationEligible === true
+      }
+      catch {
+        return false
+      }
+    })
+  }
+  catch {
+    return false
+  }
+}
+
 /** 工具结果统一出口上限:超长文本截断+尾注(2026-10-05 评审;export/diag 类可经 optOut 放行) */
 const TOOL_RESULT_MAX_CHARS = 16_000
 const TRUNCATE_OPT_OUT_TOOLS = new Set(['daq_export', 'diag_run'])
@@ -97,10 +151,16 @@ async function dispatchHostToolInner(ctx: HostToolBridgeContext, req: HostToolCa
         isError: true,
       }
     }
+    // 平台侧插件治理(WP4b/WP8):kb 入库 HITL + 声明式引用校验;原生/REST/MCP 同源
+    const governed = await governPluginToolCall(identity, req.toolName, req.arguments ?? {}, pluginTool)
+    if (governed) return governed
     try {
-      return await pluginTool.handler(req.arguments ?? {}, identity)
+      const result = await pluginTool.handler(req.arguments ?? {}, identity)
+      auditPluginToolCall(identity, req.toolName, result)
+      return result
     }
     catch (err) {
+      auditPluginToolCall(identity, req.toolName, { text: err instanceof Error ? err.message : String(err), isError: true })
       return {
         text: `工具执行异常(${req.toolName}): ${err instanceof Error ? err.message : String(err)}`,
         isError: true,
@@ -117,6 +177,17 @@ async function dispatchHostToolInner(ctx: HostToolBridgeContext, req: HostToolCa
   //  - 场景/spec/校准请求族:hybrid_twin + 训练 Channel;
   //  - 训练族(aml_job/dataset 等):工艺优化 Channel 拒绝(边训边优被结构禁止)。
   const twinKind: AmlChannelProfileKind = getChannelTwinProfile(identity.channelId).profile
+  // G4.6:旧 mpc_optimize 在既无 Profile 绑定也无 AML 模型绑定时不再返回调参方案
+  {
+    const profile = getChannelTwinProfile(identity.channelId)
+    const legacy = legacyMpcAliasGate({
+      toolName: req.toolName,
+      hasOptimizerBinding: listBindingIds(identity.agentId).length > 0,
+      hasBoundModel: Boolean(profile.boundModelId),
+      hasEligibleModel: profile.boundModelId ? boundModelHasEligibility(profile.boundModelId) : false,
+    })
+    if (!legacy.allowed) return { text: `${legacy.code}: ${legacy.message}`, isError: true }
+  }
   const isTwinTool = req.toolName.startsWith('twin_') || ['mpc_optimize', 'optimization_explore'].includes(req.toolName)
   if (isTwinTool) {
     const isSceneFamily = /^twin_(scene|physics|provider|calibration)/.test(req.toolName)
@@ -149,6 +220,17 @@ async function dispatchHostToolInner(ctx: HostToolBridgeContext, req: HostToolCa
     return { text: `工艺优化 Channel 不承担建模与训练(职责解耦):${req.toolName} 仅限 AML 训练 Channel 使用。请在此专注 goal 探索与模型驱动寻优。`, isError: true }
   }
 
+  // Optimizer 工具显式门控(G4.3 / B.8.2 #3-#4):
+  // 注入面隐藏不是安全边界 —— REST/MCP 直调必须在这里被同样拒绝。
+  {
+    const gate = optimizerDispatchGate({
+      toolName: req.toolName,
+      twinKind,
+      bindingCount: req.toolName.startsWith('optimizer_') ? listBindingIds(identity.agentId).length : 0,
+    })
+    if (!gate.allowed) return { text: `${gate.code}: ${gate.message}`, isError: true }
+  }
+
   // 所有真实写入口在统一分发层再做一次服务端 fail-closed 守卫；工具目录隐藏不是安全边界。
   if (['dcw_control', 'param_control', 'dcw_rollback', 'recipe_create', 'recipe_update', 'recipe_rollback', 'recipe_trial', 'recipe_apply'].includes(req.toolName)) {
     // Profile 级写面(2026-10-18):观察面零写、训练面无产线写、优化面只认 optimization_explore。

package/server/services/workshop/agents/host-tool-bridge/optimizer-gate.ts

@@ -0,0 +1,72 @@
+/**
+ * Optimizer 工具门控(纯函数,无 Nitro/DB 依赖):
+ * dispatch 与验收脚本共用同一判定,避免"注入面隐藏但当 REST/MCP 直调仍可执行"。
+ */
+export const OPTIMIZER_PREFIX = 'optimizer_'
+
+export interface OptimizerGateInput {
+  toolName: string
+  /** Channel 档位(legacy / aml_training / aml_optimization / hybrid_twin / exp-miner / line-doctor) */
+  twinKind: string
+  /** 该 Agent 实例的有效绑定数(capabilities 允许 0) */
+  bindingCount: number
+}
+
+export interface OptimizerGateResult {
+  allowed: boolean
+  /** 拒绝时的可判定错误码(前缀)与可读指引 */
+  code?: 'OPTIMIZER_CHANNEL_DISABLED' | 'OPTIMIZER_PROFILE_DENIED' | 'BINDING_NOT_FOUND' | 'OPTIMIZATION_NOT_ELIGIBLE'
+  message?: string
+}
+
+export function optimizerDispatchGate(input: OptimizerGateInput): OptimizerGateResult {
+  const { toolName, twinKind, bindingCount } = input
+  if (!toolName.startsWith(OPTIMIZER_PREFIX)) return { allowed: true }
+  if (twinKind === 'legacy') {
+    return {
+      allowed: false,
+      code: 'OPTIMIZER_CHANNEL_DISABLED',
+      message: 'Channel 未启用 Twin profile,优化器工具拒绝执行。请先把 Channel 档位切到 aml_optimization(工艺优化)或 hybrid_twin。',
+    }
+  }
+  if (twinKind !== 'aml_optimization' && twinKind !== 'hybrid_twin') {
+    return {
+      allowed: false,
+      code: 'OPTIMIZER_PROFILE_DENIED',
+      message: `${toolName} 仅在工艺优化(aml_optimization)或 hybrid_twin Channel 可用(当前 profile=${twinKind})。`,
+    }
+  }
+  // capabilities 允许无绑定(用于解释为什么不可用);其余四个必须存在有效绑定
+  if (toolName !== 'optimizer_capabilities' && bindingCount < 1) {
+    return {
+      allowed: false,
+      code: 'BINDING_NOT_FOUND',
+      message: `该 Agent 未绑定优化器 Profile;先在 Channel 设置中绑定后再调用 ${toolName}。`,
+    }
+  }
+  return { allowed: true }
+}
+
+/**
+ * 旧 `mpc_optimize` 别名迁移(G4.6):
+ *  - 有优化器绑定 → 允许(新 Profile 路径仍应优先用 optimizer_solve);
+ *  - 无绑定但有已绑定的 AML 模型**且该模型有优化资格** → 允许(既有 AML 模型驱动流程);
+ *  - 有模型但无优化资格 / 两者皆无 → 拒绝并给"先绑定/先辨识"引导,不再返回可操作调参方案。
+ */
+export function legacyMpcAliasGate(input: { toolName: string, hasOptimizerBinding: boolean, hasBoundModel: boolean, hasEligibleModel?: boolean }): OptimizerGateResult {
+  if (input.toolName !== 'mpc_optimize') return { allowed: true }
+  if (input.hasOptimizerBinding) return { allowed: true }
+  if (input.hasBoundModel && input.hasEligibleModel) return { allowed: true }
+  if (input.hasBoundModel) {
+    return {
+      allowed: false,
+      code: 'OPTIMIZATION_NOT_ELIGIBLE',
+      message: '当前绑定的 AML 模型没有通过的优化资格报告(辨识不足/OOD/动作证据缺失)。请先完成 AML 数据集资格评估与模型晋级,或绑定优化器 Profile 后用 optimizer_solve。',
+    }
+  }
+  return {
+    allowed: false,
+    code: 'BINDING_NOT_FOUND',
+    message: 'mpc_optimize 需要已绑定优化器 Profile 或已绑定且具备优化资格的 AML 模型;当前两者皆无。请先在 Channel 设置中绑定 Profile,或完成 AML 训练与资格评估后再寻优。',
+  }
+}

package/server/services/workshop/agents/host-tool-bridge/per-agent.ts

@@ -9,10 +9,12 @@
  * 只读装配:不改变工具集合(角色/插件/档位过滤仍由 hostToolsForRole 决定),
  * 仅在描述尾部追加可见资源清单。无绑定 → 原样返回,零行为变化。
  */
-import { hostToolsForRole } from './catalog'
+import { hostToolsForRole, OPTIMIZER_TOOL_NAMES } from './catalog'
 import { getAgentNodeBindingRepo } from '../node-bindings.repo'
 import { getDaqController } from '../../daq/daq-controller'
 import { getDcwController } from '../../dcw/dcw-controller'
+import { listBindingsForAgent } from '../../optimization/binding.service'
+import { foldList as foldListImpl, sortedById } from './description-budget'
 
 /** 需要追加“可见资源”描述的工具族 */
 const DAQ_TOOLS = new Set(['daq_query', 'daq_frames', 'daq_export'])
@@ -83,32 +85,65 @@ export function agentToolResources(agentId: string): AgentToolResourceView {
   return out
 }
 
-const listText = (items: Array<{ id: string, name: string, unit?: string }>): string =>
-  items.map(x => `${x.name}(${x.id}${x.unit ? `,${x.unit}` : ''})`).join('、')
+/**
+ * WP6 描述预算:大绑定面不再全量拼进 description(撑上下文 + 放大 10s 轮询载荷 + 触发
+ * 无意义 list_changed)。折叠确定性由 description-budget 叶子模块保证。
+ * env AW_DESC_BUDGET=0 关闭折叠(回退原行为)。
+ */
+const foldList = (prefix: string, items: string[]): string => foldListImpl(prefix, items)
 
-/** 在角色过滤后的工具面上追加 Agent 绑定资源描述 */
+/** 在角色过滤后的工具面上追加 Agent 绑定资源描述 + 优化器绑定裁剪 */
 export function hostToolsForAgent(agentId: string, role: 'lead' | 'worker', channelId?: string) {
   const tools = hostToolsForRole(role, channelId)
+  // G4.3 #10:无有效绑定时移除 solve/status/cancel/plan_get(保留 capabilities 作解释入口);
+  // 多绑定时在描述中列出 bindingId(solve 需显式选择)。过滤不改变返回类型。
+  const bindings = listOptimizerBindings(agentId)
+  const filtered = bindings.length
+    ? tools
+    : tools.filter(t => !OPTIMIZER_REQUIRES_BINDING.has(t.name))
+  const optimizerLine = bindings.length
+    ? `\n\n本 Agent 的优化器绑定:${bindings.map(b => `${b.id}(profile ${b.profileVersion},${b.mode};能力:${b.capabilities.join('/')})`).join('; ')}${bindings.length > 1 ? '\n多绑定:调用 optimizer_solve 必须显式传 binding_id。' : ''}`
+    : ''
   const res = agentToolResources(agentId)
-  const lineOnlyDaq = res.daqLineNodes.filter(n => !res.daqNodes.some(x => x.id === n.id))
-  if (res.daqNodes.length === 0 && lineOnlyDaq.length === 0 && res.recipes.length === 0) return tools
+  // WP6:排序保证同一绑定面确定性输出(折叠/不折叠都稳定)
+  const sortedDaq = sortedById(res.daqNodes)
+  const sortedRecipes = sortedById(res.recipes)
+  const sortedMes = sortedById(res.mesNodes)
+  const lineOnlyDaq = sortedById(res.daqLineNodes.filter(n => !sortedDaq.some(x => x.id === n.id)))
+  if (sortedDaq.length === 0 && lineOnlyDaq.length === 0 && sortedRecipes.length === 0 && !bindings.length) return filtered
   const daqParts = [
-    res.daqNodes.length > 0 ? `本 Agent 直接绑定的数采节点(仅这些可查):${listText(res.daqNodes)}` : '',
-    lineOnlyDaq.length > 0 ? `频道绑线只读数采节点(可查):${listText(lineOnlyDaq)}` : '',
+    sortedDaq.length > 0 ? foldList(`本 Agent 直接绑定的数采节点(仅这些可查):`, sortedDaq.map(x => `${x.name}(${x.id}${x.unit ? `,${x.unit}` : ''})`)) : '',
+    lineOnlyDaq.length > 0 ? foldList(`频道绑线只读数采节点(可查):`, lineOnlyDaq.map(x => `${x.name}(${x.id}${x.unit ? `,${x.unit}` : ''})`)) : '',
   ].filter(Boolean)
   const daqLine = daqParts.length > 0 ? `\n\n${daqParts.join('\n')}` : ''
-  const recipeLine = res.recipes.length > 0
-    ? `\n\n本 Agent 已绑定的配方(仅这些可写/下发):${res.recipes.map(r => `${r.name}(${r.id},v${r.version};参数:${r.params.map(p => `${p.name}(${p.nodeId})`).join('、') || '无'})`).join(';')}`
+  const recipeLine = sortedRecipes.length > 0
+    ? foldList(
+        `\n\n本 Agent 已绑定的配方(仅这些可写/下发):`,
+        sortedRecipes.map(r => `${r.name}(${r.id},v${r.version};参数:${r.params.map(p => `${p.name}(${p.nodeId})`).join('、') || '无'})`),
+      )
     : ''
-  const mesLine = res.mesNodes.length > 0
-    ? `\n\n本 Agent 可经配方参数面取数的 MES 点位:${listText(res.mesNodes)}`
+  const mesLine = sortedMes.length > 0
+    ? foldList(`\n\n本 Agent 可经配方参数面取数的 MES 点位:`, sortedMes.map(x => `${x.name}(${x.id}${x.unit ? `,${x.unit}` : ''})`))
     : ''
-  return tools.map((t) => {
+  return filtered.map((t) => {
     let suffix = ''
     if (DAQ_TOOLS.has(t.name)) suffix = daqLine
     else if (RECIPE_TOOLS.has(t.name)) suffix = recipeLine
     else if (MES_TOOLS.has(t.name)) suffix = mesLine
+    else if (OPTIMIZER_TOOL_NAMES.has(t.name)) suffix = optimizerLine
     if (!suffix) return t
     return { ...t, description: `${t.description ?? ''}${suffix}` }
   })
 }
+
+/** 优化器中必须绑定才能注入/调用的四个工具(capabilities 始终保留)。 */
+const OPTIMIZER_REQUIRES_BINDING = new Set(['optimizer_solve', 'optimizer_status', 'optimizer_cancel', 'optimizer_plan_get'])
+
+function listOptimizerBindings(agentId: string): Array<{ id: string, profileVersion: string, mode: string, capabilities: string[] }> {
+  try {
+    return listBindingsForAgent(agentId).map(b => ({ id: b.id, profileVersion: b.profileVersion, mode: b.mode, capabilities: b.capabilities as string[] }))
+  }
+  catch {
+    return []
+  }
+}