agentworkshop 0.8.6 → 0.8.8

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

@@ -29,6 +29,8 @@ export interface AgentToolResourceView {
   daqLineNodes: Array<{ id: string, name: string, unit: string }>
   /** Agent 显式绑定的数控节点(kind=dcw)= 点位写授权面(2026-10-28 双轨授权) */
   writeNodes: Array<{ id: string, name: string, unit: string }>
+  /** 产线配方管理权(kind=line-recipe):该 Agent 可管理全部配方的产线 */
+  managedLines: Array<{ id: string, name: string }>
   recipes: Array<{ id: string, name: string, version: number, params: Array<{ nodeId: string, name: string, unit: string }> }>
   mesNodes: Array<{ id: string, name: string, unit: string }>
 }
@@ -48,7 +50,7 @@ function channelLineOf(agentId: string): string {
 
 /** 读取 Agent 的绑定面(只读;异常降级为空,绝不影响工具注入) */
 export function agentToolResources(agentId: string): AgentToolResourceView {
-  const out: AgentToolResourceView = { daqNodes: [], daqLineNodes: [], writeNodes: [], recipes: [], mesNodes: [] }
+  const out: AgentToolResourceView = { daqNodes: [], daqLineNodes: [], writeNodes: [], managedLines: [], recipes: [], mesNodes: [] }
   if (!agentId) return out
   try {
     const bindings = getAgentNodeBindingRepo().byAgent(agentId)
@@ -70,6 +72,11 @@ export function agentToolResources(agentId: string): AgentToolResourceView {
         const n = dcw.byId(b.nodeId)
         if (n) out.writeNodes.push({ id: n.id, name: n.name, unit: n.unit ?? '' })
       }
+      else if (b.kind === 'line-recipe') {
+        // 产线配方管理权:该线全部配方(含未来新建)可 查看/新建/修改/回退
+        const line = dcw.listLines().find(l => l.id === b.nodeId)
+        if (line) out.managedLines.push({ id: line.id, name: line.name })
+      }
       else if (b.kind === 'recipe') {
         const r = dcw.listRecipes().find(x => x.id === b.nodeId)
         if (!r) continue
@@ -117,10 +124,11 @@ export function hostToolsForAgent(agentId: string, role: 'lead' | 'worker', chan
   // WP6:排序保证同一绑定面确定性输出(折叠/不折叠都稳定)
   const sortedDaq = sortedById(res.daqNodes)
   const sortedWrite = sortedById(res.writeNodes)
+  const sortedManaged = sortedById(res.managedLines)
   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 && sortedWrite.length === 0 && sortedRecipes.length === 0 && !bindings.length) return filtered
+  if (sortedDaq.length === 0 && lineOnlyDaq.length === 0 && sortedWrite.length === 0 && sortedManaged.length === 0 && sortedRecipes.length === 0 && !bindings.length) return filtered
   const daqParts = [
     sortedDaq.length > 0 ? foldList(tr(locale, `本 Agent 直接绑定的数采节点(仅这些可查):`, `DAQ nodes bound directly to this agent (queryable):`), sortedDaq.map(x => `${x.name}(${x.id}${x.unit ? `,${x.unit}` : ''})`)) : '',
     lineOnlyDaq.length > 0 ? foldList(tr(locale, `频道绑线只读数采节点(可查):`, `Read-only DAQ nodes from the channel line binding:`), lineOnlyDaq.map(x => `${x.name}(${x.id}${x.unit ? `,${x.unit}` : ''})`)) : '',
@@ -132,6 +140,12 @@ export function hostToolsForAgent(agentId: string, role: 'lead' | 'worker', chan
         sortedWrite.map(x => `${x.name}(${x.id}${x.unit ? `,${x.unit}` : ''})`),
       )
     : ''
+  const managedLine = sortedManaged.length > 0
+    ? foldList(
+        tr(locale, `\n\n本 Agent 持有的产线配方管理权(可 查看/新建/修改/回退 该线全部配方;下发仍受点位绑定约束:未绑定任何数控节点时默认可对配方全部参数下发,绑了数控节点则只能下发这些点位):`, `\n\nLine recipe-management grants of this agent (view/create/update/rollback ALL recipes on these lines; dispatch still follows point-binding rules: with no DCW bindings at all, all recipe params are dispatchable; with DCW bindings, only those points):`),
+        sortedManaged.map(x => `${x.name}(${x.id})`),
+      )
+    : ''
   const recipeLine = sortedRecipes.length > 0
     ? foldList(
         tr(locale, `\n\n本 Agent 已绑定的配方(仅这些可写/下发):`, `\n\nRecipes bound to this agent (writable/dispatchable):`),
@@ -144,7 +158,7 @@ export function hostToolsForAgent(agentId: string, role: 'lead' | 'worker', chan
   return filtered.map((t) => {
     let suffix = ''
     if (DAQ_TOOLS.has(t.name)) suffix = daqLine
-    else if (RECIPE_TOOLS.has(t.name)) suffix = `${recipeLine}${writeLine}`
+    else if (RECIPE_TOOLS.has(t.name)) suffix = `${recipeLine}${writeLine}${managedLine}`
     else if (MES_TOOLS.has(t.name)) suffix = mesLine
     else if (OPTIMIZER_TOOL_NAMES.has(t.name)) suffix = optimizerLine
     if (!suffix) return t

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

@@ -14,15 +14,21 @@ export async function handleSendMessageToAgent(
 ): Promise<HostToolResult> {
   const toAgentId = args.to_agent_id as string
   const message = args.message as string
+  // 2026-10-30 修复:参数完全来自 LLM,缺省/空 message 会把 parts 序列化成 [{}] 静默
+  // 送达空消息(白烧对端一个回合,发送方还收到「已发送」)。fail-closed 校验。
+  if (!toAgentId || typeof message !== 'string' || !message.trim()) {
+    return { text: '缺少 to_agent_id,或 message 为空 —— 空消息不会投递,请给出实际内容', isError: true }
+  }
   // 回执自动实时:回复(in_reply_to)默认提升为 immediate——
   // 接收方正等待该结果,realtime 路由会把回复直接注入其运行中的会话
   let priority = (args.priority as string | undefined) ?? 'task'
   const metadata: Record<string, unknown> = {}
   if (args.require_reply === true) metadata['x-aw-require-reply'] = 'true'
   let inReplyTo = args.in_reply_to as string | undefined
-  // 自动关联兜底:LLM 省略 in_reply_to 时,按待回执上下文盖章
+  // 自动关联兜底:LLM 省略 in_reply_to 时,按待回执上下文盖章。
+  // 2026-10-30 修复:replyContext 是「发送成功」才消费的票据 —— 原实现先清后发,
+  // 发送失败即永久丢失线程关联与 immediate 提升;现在成功才清,失败保留供重试盖章。
   const replyCtx = state.replyContext
-  state.replyContext = null
   if (!inReplyTo && replyCtx && replyCtx.fromId === toAgentId) {
     inReplyTo = replyCtx.messageId
   }
@@ -37,11 +43,19 @@ export async function handleSendMessageToAgent(
     metadata['x-aw-thread-root'] = inReplyTo
   }
   metadata['x-aw-msg-priority'] = priority
-  const sent = await ws.sendMessage({ toAgentId, parts: [{ text: message }], metadata })
-  const triggerNote = inReplyTo
-    ? `(回复 ${inReplyTo.slice(0, 8)}…,已实时推送给对方)`
-    : metadata['x-aw-require-reply'] === 'true' ? '(已要求对方回复)' : ''
-  return { text: `消息 ${sent.messageId.slice(0, 8)}… 已发送给 ${toAgentId}(priority=${priority})${triggerNote}` }
+  try {
+    const sent = await ws.sendMessage({ toAgentId, parts: [{ text: message }], metadata })
+    state.replyContext = null
+    const triggerNote = inReplyTo
+      ? `(回复 ${inReplyTo.slice(0, 8)}…,已实时推送给对方)`
+      : metadata['x-aw-require-reply'] === 'true' ? '(已要求对方回复)' : ''
+    return { text: `消息 ${sent.messageId.slice(0, 8)}… 已发送给 ${toAgentId}(priority=${priority})${triggerNote}` }
+  }
+  catch (err) {
+    // 发送失败:保留待回执票据,重试仍可自动盖 in_reply_to
+    state.replyContext = replyCtx
+    throw err
+  }
 }
 
 export async function handleSendCrossChannelMessage(args: Record<string, unknown>, ws: AgentWorkspace): Promise<HostToolResult> {
@@ -202,15 +216,34 @@ export async function handleBroadcastMessage(
   ws: AgentWorkspace,
 ): Promise<HostToolResult> {
   const message = args.message as string
+  // 2026-10-30 修复:与 send_message_to_agent 同口径,空广播不再静默送达全员。
+  if (typeof message !== 'string' || !message.trim()) {
+    return { text: 'message 为空 —— 广播内容不能为空串', isError: true }
+  }
   const priority = (args.priority as string | undefined) ?? 'task'
   const agents = await ws.listAgents()
   const others = agents.filter(a => a.id !== identity.agentId)
+  // 2026-10-30 修复:广播是无幂等键的扇出写 —— 原实现中途失败直接抛错,前面成员已
+  // 收到而 LLM 见错重试 → 重复投递。改为逐个收集结果,如实回报送达/失败名单,
+  // 失败者建议单点补发而非全量重试。
+  const delivered: string[] = []
+  const failed: string[] = []
   for (const agent of others) {
-    await ws.sendMessage({
-      toAgentId: agent.id,
-      parts: [{ text: message }],
-      metadata: { 'x-aw-msg-priority': priority },
-    })
+    try {
+      await ws.sendMessage({
+        toAgentId: agent.id,
+        parts: [{ text: message }],
+        metadata: { 'x-aw-msg-priority': priority },
+      })
+      delivered.push(agent.id)
+    }
+    catch {
+      failed.push(agent.id)
+    }
+  }
+  const parts = [`广播完成:送达 ${delivered.length}/${others.length} 个 agent(priority=${priority})`]
+  if (failed.length) {
+    parts.push(`失败 ${failed.length} 个:${failed.map(id => id.slice(0, 8)).join('、')} —— 请用 send_message_to_agent 对失败者单点补发,不要重复全量广播`)
   }
-  return { text: `已广播给 ${others.length} 个 agent(priority=${priority})` }
+  return { text: parts.join('\n'), isError: delivered.length === 0 && others.length > 0 }
 }

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

@@ -11,11 +11,28 @@ export async function handleReportProgress(
   args: Record<string, unknown>,
   state: HostToolSessionState,
   ws: AgentWorkspace,
+  activeRootTaskId?: string,
 ): Promise<HostToolResult> {
-  const progress = args.progress as number
   const message = args.message as string | undefined
-  const taskId = state.currentTaskId
+  // 2026-10-30 修复:progress 来自异构 LLM(七引擎),字符串化数字/越界值是高频形态;
+  // 原样落库会污染看门狗与前端进度显示。钳到 [0,100],非数字显式拒绝。
+  const rawProgress = Number(args.progress)
+  if (!Number.isFinite(rawProgress)) return { text: 'progress 必须是数字(0-100)', isError: true }
+  const progress = Math.max(0, Math.min(100, rawProgress))
+  // 2026-10-30 修复:lead 监督回合不经过 workerTurn,session.currentTaskId 恒空;
+  // 分发层已验证的 activeRootTaskId(lease.rootId)是唯一可靠上下文,作为兜底回退。
+  const taskId = state.currentTaskId ?? activeRootTaskId
   if (!taskId) return { text: '无当前任务上下文', isError: true }
+  // 2026-10-30 修复(fail-open):终态任务上 manager 有意丢弃进度写入(活性信号不得写
+  // 终态),但旧实现照样回报「进度已上报」—— 迟到回合的 Agent 误信进度已同步,继续在
+  // 僵尸任务上作业烧 token。与 complete_task 同口径给诚实回执,推动转向队列下一项。
+  const current = await ws.getTask(taskId).catch(() => null)
+  if (current && current.state !== 'SUBMITTED' && current.state !== 'ASSIGNED' && current.state !== 'WORKING' && current.state !== 'WAITING') {
+    return {
+      text: `任务 ${taskId} 已终态(${current.state}),进度写入被忽略 —— 该任务已由平台收口,这不是你的错误,请停止在该任务上作业,转向队列下一项。`,
+      isError: true,
+    }
+  }
   await ws.reportTask({ taskId, progress, message })
   return { text: `进度已上报: ${progress}%${message ? ` (${message})` : ''}` }
 }
@@ -24,17 +41,24 @@ export async function handleCompleteTask(
   args: Record<string, unknown>,
   state: HostToolSessionState,
   ws: AgentWorkspace,
+  activeRootTaskId?: string,
 ): Promise<HostToolResult> {
   const summary = args.summary as string
   const deliverable = args.deliverable as string | undefined
-  const taskId = (args.task_id as string | undefined) ?? state.currentTaskId
+  // 2026-10-30 修复:lead 收口链 —— 显式 task_id > 会话态 > 监督租约根任务。
+  // 此前 lead 无 task_id 时恒报「无任务 ID」,根任务只能被看门狗取消收口(三次实机复现)。
+  const taskId = (args.task_id as string | undefined) ?? state.currentTaskId ?? activeRootTaskId
   if (!taskId) return { text: '无任务 ID', isError: true }
-  // 父任务保护:有未完成子任务时拒绝完成(lead 须等 worker 交付)
+  // 父任务保护:有未收口子任务时拒绝完成(lead 须等 worker 交付;失败/取消分支用 supersede 处置)
   const allTasks = await ws.listTasks()
-  const incompleteChildren = allTasks.filter(t => t.parentId === taskId && t.state !== 'COMPLETED')
+  const incompleteChildren = allTasks.filter(t => t.parentId === taskId && t.state !== 'COMPLETED' && !t.supersededByTaskId)
   if (incompleteChildren.length > 0) {
+    const unresolved = incompleteChildren.filter(t => t.state === 'FAILED' || t.state === 'CANCELED')
+    const hint = unresolved.length > 0
+      ? '失败/取消分支请先派发替代任务并用 supersede 工具(或 REST POST /tasks/:id/supersede)显式处置'
+      : '等待子任务交付后再收口'
     return {
-      text: `任务 ${taskId} 有 ${incompleteChildren.length} 个未通过验收的子任务(包含失败/取消)。请先解决或重新指派，再由 Lead 检查交付物并提交验收总结。`,
+      text: `任务 ${taskId} 有 ${incompleteChildren.length} 个未收口的子任务: ${incompleteChildren.map(t => `「${t.title}」(${t.state})`).join(', ')}。${hint}，再由 Lead 检查交付物并提交验收总结。`,
       isError: true,
     }
   }
@@ -82,3 +106,21 @@ export async function handleCompleteTask(
     return { text: `任务 ${taskId} 已完成(状态已同步为 COMPLETED)。` }
   }
 }
+
+/** (lead)显式替代:把 FAILED/CANCELED 子任务分支标记为被替代任务覆盖(整改计划 2026-10-30 F1) */
+export async function handleSupersedeTask(
+  args: Record<string, unknown>,
+  _state: HostToolSessionState,
+  ws: AgentWorkspace,
+): Promise<HostToolResult> {
+  const taskId = (args.task_id as string | undefined) ?? (args.taskId as string | undefined)
+  const replacementTaskId = (args.replacement_task_id as string | undefined) ?? (args.replacementTaskId as string | undefined)
+  const reason = args.reason as string | undefined
+  if (!taskId || !replacementTaskId) {
+    return { text: '参数缺失:需要 task_id(失败/取消的分支任务)与 replacement_task_id(覆盖其工作的替代任务)', isError: true }
+  }
+  const superseded = await ws.supersedeTask(taskId, replacementTaskId, reason)
+  return {
+    text: `分支「${superseded.title}」(${superseded.state})已标记为被 ${replacementTaskId.slice(0, 8)} 替代,不再阻塞父任务收口。失败事实保留在任务记录中;现在可对父任务检查交付并 complete_task。`,
+  }
+}

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

@@ -5,6 +5,7 @@
  */
 import type { AgentWorkspace } from '../../agent-interface'
 import type { WorkspaceTask } from '../../../types/task'
+import { TERMINAL_TASK_STATES } from '../../../types/task'
 import { extractTaskMode } from '../../../runtime/execution-mode'
 import type { HostToolBridgeContext, HostToolResult, HostToolSessionState } from '../types'
 
@@ -27,15 +28,49 @@ export async function handleSubmitTask(args: Record<string, unknown>, state: Hos
   }
 }
 
-export async function handleDispatchTask(args: Record<string, unknown>, ws: AgentWorkspace, identity?: HostToolBridgeContext['identity']): Promise<HostToolResult> {
+export async function handleDispatchTask(args: Record<string, unknown>, ws: AgentWorkspace, identity?: HostToolBridgeContext['identity'], activeRootTaskId?: string): Promise<HostToolResult> {
   const assigneeId = args.assignee_id as string
   const title = args.title as string
   const description = args.description as string | undefined
-  const parentTaskId = args.parent_task_id as string | undefined
+  const rawParentTaskId = args.parent_task_id
+  if (rawParentTaskId != null && typeof rawParentTaskId !== 'string') {
+    return { text: 'parent_task_id 必须是字符串', isError: true }
+  }
+  const requestedParentTaskId = typeof rawParentTaskId === 'string' ? rawParentTaskId.trim() || undefined : undefined
+  let parentTaskId = requestedParentTaskId
   const routeReason = args.route_reason as string | undefined
+  if (activeRootTaskId) {
+    if (identity?.role !== 'lead') {
+      return { text: '拒绝:当前调用没有 lead 监督任务上下文，不能按活动根任务派发。', isError: true }
+    }
+    if (requestedParentTaskId && requestedParentTaskId !== activeRootTaskId) {
+      return { text: `拒绝:parent_task_id 必须匹配当前活动根任务 ${activeRootTaskId}。`, isError: true }
+    }
+    const rootTask = await ws.getTask(activeRootTaskId).catch(() => null)
+    if (!rootTask || TERMINAL_TASK_STATES[rootTask.state] || rootTask.assigneeId !== identity.agentId) {
+      return { text: '拒绝:活动根任务不存在、已结束或不属于当前 lead。', isError: true }
+    }
+    parentTaskId = activeRootTaskId
+  }
+  // 重复派发守卫(真实场景实测:lead 模型可能对同一目标重复派发,引发协调风暴):
+  // 同父任务下已存在同标题非终态子任务 → 不再创建,直接指路既有任务。
+  // 2026-10-30 前移到授权之前:原顺序先落库 grant_node_ids 再判重,判重命中时授权
+  // (grant_mode=auto 还会摘除逐次人工审批)已生效却无任务上下文 —— 悬空授权面,
+  // 且 lead 每次重复派发尝试都会重放授权,把偶发幻觉放大成常态越权面。
+  const dup = await ws.listTasks()
+  const existing = dup.find(t =>
+    t.parentId === parentTaskId
+    && t.title === title
+    && t.state !== 'COMPLETED' && t.state !== 'FAILED' && t.state !== 'CANCELED')
+  if (existing) {
+    return {
+      text: `未创建:同父任务下已存在同标题进行中子任务 ${existing.id}("${existing.title}",state=${existing.state},assignee=${existing.assigneeId})。请勿重复派发;若需跟进请对该任务 notify 或 reassign。`,
+    }
+  }
   // 派发时随任务授予节点权限(lead 专属;grant_node_ids ⊆ lead 自身绑定面,fail-closed):
   // 任一节点不满足则整单拒绝,任务不创建 —— 避免 worker 拿到任务却没有节点权限的半途态。
   let grantNote = ''
+  let grantedNodeIds: string[] = []
   const rawGrant = args.grant_node_ids ?? args.grantNodeIds
   if (rawGrant != null && identity) {
     const { grantNodesForDispatch } = await import('./team-delegation')
@@ -44,22 +79,25 @@ export async function handleDispatchTask(args: Record<string, unknown>, ws: Agen
     const grantMode = args.grant_mode === 'manual' || args.grant_mode === 'auto' ? (args.grant_mode as 'auto' | 'manual') : undefined
     const grant = await grantNodesForDispatch(identity, assigneeId, grantNodeIds, grantMode, ws, args.grant_confirm)
     if (!grant.ok) return { text: `未派发:${grant.text}\n请先用 team_grant_nodes 确认你持有这些节点,或修正 node id 后重试。`, isError: true }
+    grantedNodeIds = grantNodeIds
     grantNote = `\n${grant.text}`
   }
-  // 重复派发守卫(真实场景实测:lead 模型可能对同一目标重复派发,引发协调风暴):
-  // 同父任务下已存在同标题非终态子任务 → 不再创建,直接指路既有任务
-  const dup = await ws.listTasks()
-  const existing = dup.find(t =>
-    t.parentId === parentTaskId
-    && t.title === title
-    && t.state !== 'COMPLETED' && t.state !== 'FAILED' && t.state !== 'CANCELED')
-  if (existing) {
-    return {
-      text: `未创建:同父任务下已存在同标题进行中子任务 ${existing.id}("${existing.title}",state=${existing.state},assignee=${existing.assigneeId})。请勿重复派发;若需跟进请对该任务 notify 或 reassign。`,
+  try {
+    const task = await ws.dispatchTask({ assigneeId, title, description, parentTaskId, routeReason })
+    return { text: `子任务 ${task.id} 已创建并指派 → ${assigneeId}(父任务 ${parentTaskId ?? '无'},标题: ${title}${routeReason ? `,路由理由: ${routeReason}` : ''})${grantNote}` }
+  }
+  catch (err) {
+    // 2026-10-30 修复(授权-任务绑定不变量):manager 侧判重 409/父任务终态/harness
+    // 不可用/预算超限等拒绝发生在授权落库之后 —— 任务没创建,节点授权已生效。
+    // 失败即回滚本轮授权再如实回报,杜绝「派发失败留下无任务授权」。
+    if (grantedNodeIds.length && identity) {
+      const { revokeNodesForDispatchRollback } = await import('./team-delegation')
+      const revoked = await revokeNodesForDispatchRollback(identity, assigneeId, grantedNodeIds, ws)
+      grantNote = revoked > 0 ? `\n(派发失败,已回滚本轮 ${revoked} 条随单授权)` : '\n(派发失败;随单授权回滚未完成,请用 team_revoke_nodes 手工核销)'
     }
+    const msg = err instanceof Error ? err.message : String(err)
+    return { text: `未派发:${msg}${grantNote}`, isError: true }
   }
-  const task = await ws.dispatchTask({ assigneeId, title, description, parentTaskId, routeReason })
-  return { text: `子任务 ${task.id} 已创建并指派 → ${assigneeId}(父任务 ${parentTaskId ?? '无'},标题: ${title}${routeReason ? `,路由理由: ${routeReason}` : ''})${grantNote}` }
 }
 
 export async function handleRefuseTask(args: Record<string, unknown>, ws: AgentWorkspace): Promise<HostToolResult> {

package/server/services/workshop/agents/host-tool-bridge/tools/team-delegation.ts

@@ -19,7 +19,8 @@ function membersOf(ws: MembersView): Promise<DelegationMember[]> {
 }
 
 function summaryText(bindings: Array<{ nodeId: string, kind: string, mode: string }>): string {
-  const lines = bindings.map(b => `  - ${b.kind === 'daq' ? '数采' : '写控'} ${b.nodeId}(mode=${b.mode})`)
+  const kindLabel: Record<string, string> = { 'daq': '数采', 'dcw': '写控', 'line-recipe': '产线配方管理' }
+  const lines = bindings.map(b => `  - ${kindLabel[b.kind] ?? b.kind} ${b.nodeId}(mode=${b.mode})`)
   return `\n${lines.join('\n')}`
 }
 
@@ -106,3 +107,23 @@ export async function grantNodesForDispatch(identity: HostToolBridgeContext['ide
     return { ok: false, text: msg }
   }
 }
+
+/**
+ * 2026-10-30 新增:dispatch 失败回滚 —— 尽力撤销 grantNodesForDispatch 刚落库的授权。
+ * 授权-任务绑定不变量:任务没创建,授权不得残留(尤其 grant_mode=auto 摘过人工审批的)。
+ * 返回实际撤销条数;任何异常按 0 处理(调用方如实标注"请手工核销")。
+ */
+export async function revokeNodesForDispatchRollback(identity: HostToolBridgeContext['identity'], assigneeId: string, nodeIds: string[], ws: MembersView): Promise<number> {
+  try {
+    const results = revokeDelegation({
+      leaderAgentId: identity.agentId,
+      targetAgentId: assigneeId,
+      nodeIds,
+      members: await membersOf(ws),
+    })
+    return results.filter(r => r.revoked).length
+  }
+  catch {
+    return 0
+  }
+}

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

@@ -25,7 +25,7 @@ export interface HostToolSessionState {
 
 /** 桥上下文:impl 注入身份与 workspace 取值器 */
 export interface HostToolBridgeContext {
-  identity: { agentId: string, channelId: string, role: 'lead' | 'worker', name: string }
+  identity: { agentId: string, channelId: string, role: 'lead' | 'worker', name: string, harness?: string }
   state: HostToolSessionState
   getWorkspace(): AgentWorkspace | null
 }

package/server/services/workshop/agents/industrial/aml-job-tools.ts

@@ -19,6 +19,7 @@ import { predictProduction, readIoSpecFor } from '../../aml/predictor'
 import { recordOps } from '../../ops/ops'
 import { transitionModel } from '../../aml/model-registry'
 import { resolveRefFaces } from './tool-verify'
+import { GOVERNED_DISPATCH_HINT } from './fallback-hints'
 
 /** 工具:aml_job_submit —— 提交训练作业(train.py 全文内联;归因 agentId;队列 FIFO) */
 export async function toolAmlJobSubmit(agentId: string, args: {
@@ -236,7 +237,7 @@ export async function toolAmlModelPromote(agentId: string, args: { model_id?: st
       .list({ stage: 'production', productId: model.productId, recipeId: model.recipeId, limit: 50 })
       .find(m => m.id !== modelId && m.purpose === model.purpose)?.id
   }
-  // 同模型挂起审批去重(防审批面板堆积,与 dcw_control 同纪律)
+  // 同模型挂起审批去重(防审批面板堆积,与配方面治理下发同纪律)
   const approvals = getToolApprovals()
   if (approvals.hasPendingFor(agentId, modelId)) {
     return amlErr(`模型 ${modelId} 已有一条待审批的晋升请求,请等待用户处理后再发起新请求。`)
@@ -249,8 +250,9 @@ export async function toolAmlModelPromote(agentId: string, args: { model_id?: st
   try {
     const r = transitionModel(modelId, toStage, agentBadgeLabel(agentId), 'agent')
     // 归属审计已由 transitionModel 内部 recordOps(aml.model.promote)完成,此处不重复记录
+    const warnText = (r.warnings ?? []).length > 0 ? `⚠ ${r.warnings!.join('；')}。` : ''
     return {
-      text: `晋升完成:${modelId} ${r.from} → ${toStage}。${r.retiredId ? `原生产模型 ${r.retiredId} 已自动退役。` : ''}${toStage === 'shadow'
+      text: `晋升完成:${modelId} ${r.from} → ${toStage}。${r.retiredId ? `原生产模型 ${r.retiredId} 已自动退役。` : ''}${warnText}${toStage === 'shadow'
         ? '影子阶段:用 aml_model_reference 观测其预测与实际偏差,积累证据后再申请 production。'
         : '该模型已作为生产模型生效:aml_model_reference 的影子参考即来自它;调控 Agent 调参前请先查它。'}`,
     }
@@ -471,7 +473,7 @@ export async function toolAmlModelReference(agentId: string, args: {
       : '无控制节点'
     return {
       text: [
-        `影子模型参考(调参前先问影子模型;预测≠承诺,真实下发仍走 dcw_control 安全联锁):`,
+        `影子模型参考(调参前先问影子模型;预测≠承诺,真实下发不走逐节点直写 —— ${GOVERNED_DISPATCH_HINT}):`,
         `  模型 ${r.modelId}「${model.label || '(未打标)'}」(stage=${r.stage},purpose=${purpose}${model.objectiveId ? `,objective=${model.objectiveId}` : ''})| 三元组:产品 ${getDcwProductRepo().byId(productId)?.name ?? productId} / 配方 ${getDcwRecipeRepo().byId(recipeId)?.name ?? recipeId}(解析:${resolveHow})`,
         model.description ? `  模型说明: ${model.description}` : null,
         `  输入:最近 ${H} 拍 × ${io.allNodes.length} 节点(beat=${beatMs}ms),截至 ${new Date(now).toISOString().slice(11, 19)};控制轨迹(共 ${steps} 步):${ctrlTxt}${unknownKeys.length > 0 ? `(已忽略非控制节点的键:${unknownKeys.join(', ')})` : ''}`,
@@ -479,7 +481,7 @@ export async function toolAmlModelReference(agentId: string, args: {
         `    ${header}`,
         ...forecastLines,
         `  假设: ${r.assumptions}`,
-        `\n用法:把候选设定值作为 controls 传入(键 = 控制节点 id)对比不同方案的预测轨迹;选定后 dcw_control 下发并 daq_query 复测。`,
+        `\n用法:把候选设定值作为 controls 传入(键 = 控制节点 id)对比不同方案的预测轨迹;选定后经配方面/优化面受治理下发(${GOVERNED_DISPATCH_HINT}),下发后 daq_query 复测。`,
       ].filter(x => x !== null).join('\n'),
     }
   }

package/server/services/workshop/agents/industrial/bench-approval-only.ts

@@ -0,0 +1,117 @@
+import { execFileSync } from 'node:child_process'
+import { createHash } from 'node:crypto'
+import { lstatSync, readFileSync, realpathSync } from 'node:fs'
+import { basename, dirname, isAbsolute, join, resolve } from 'node:path'
+
+type TrialTarget = { id: string, driver: string, driverConfig: Record<string, unknown> }
+type Qualification = {
+  schema_version: number
+  run_id: string
+  aw_home: string
+  aw_base: string
+  sim_base: string
+  simulator_root: string
+  simulator_pid: number
+  line_id: string
+  recipe_id: string
+  expires_at_utc: string
+  nodes: Array<{ node_id: string, driver: string, driver_config_sha256: string, host?: string, port?: number }>
+}
+
+export type ApprovalOnlyTrialReceipt = { approval_bypassed: true, run_id: string }
+
+function loopbackUrl(raw: string | undefined, label: string): URL {
+  const url = new URL(raw ?? '')
+  if (!['http:', 'https:'].includes(url.protocol) || !['127.0.0.1', 'localhost', '[::1]'].includes(url.hostname)
+    || !url.port || url.username || url.password || url.search || url.hash || !['', '/'].includes(url.pathname)) {
+    throw new Error(`${label} must be an explicit loopback service URL`)
+  }
+  return url
+}
+
+function targetEndpoint(node: TrialTarget): { host: string, port: number } | null {
+  if (node.driver === 'mock') return null
+  let host: string
+  let port: number
+  if (node.driver === 'opcua') {
+    const endpoint = new URL(String(node.driverConfig.endpoint ?? ''))
+    if (endpoint.protocol !== 'opc.tcp:' || endpoint.username || endpoint.password) throw new Error('unsupported OPC UA simulator endpoint')
+    host = endpoint.hostname
+    port = Number(endpoint.port)
+  }
+  else if (node.driver === 'modbus-tcp' || node.driver === 'modbus-rtu') {
+    host = String(node.driverConfig.host ?? '')
+    port = Number(node.driverConfig.port)
+  }
+  else throw new Error(`driver ${node.driver} is not permitted for approval-only trials`)
+  if (!['127.0.0.1', 'localhost', '[::1]', '::1'].includes(host) || !Number.isInteger(port) || port < 1024 || port > 65535) {
+    throw new Error('approval-only trials require loopback simulator driver endpoints')
+  }
+  return { host, port }
+}
+
+function assertListener(port: number, pid: number): void {
+  const rows = execFileSync('netstat.exe', ['-ano', '-p', 'tcp'], { encoding: 'utf8', timeout: 8000, maxBuffer: 4 * 1024 * 1024 })
+    .split(/\r?\n/).map(line => line.trim().split(/\s+/))
+    .filter(parts => parts[0] === 'TCP' && parts[3]?.toUpperCase() === 'LISTENING' && parts[1]?.endsWith(`:${port}`))
+  if (!rows.length || rows.some(parts => Number(parts[4]) !== pid || !['127.0.0.1', '[::1]'].includes(parts[1]!.slice(0, -(String(port).length + 1))))) {
+    throw new Error(`simulator ownership or loopback binding is unverified for port ${port}`)
+  }
+}
+
+/** This switch has no tool argument or UI setting. Its qualification file stays in
+ * the disposable AW_HOME and must be renewed for each run before bypassing HITL. */
+export function approvalOnlyTrialReceipt(input: {
+  recipeId: string
+  line: { id: string, simulated?: boolean } | undefined
+  nodes: TrialTarget[]
+}): ApprovalOnlyTrialReceipt | null {
+  const requested = process.env.AW_BENCH_APPROVAL_ONLY
+  if (requested == null || requested === '' || requested === '0') return null
+  try {
+    if (requested !== '1') throw new Error('AW_BENCH_APPROVAL_ONLY must be 1 or disabled')
+    const runId = process.env.AW_AGENTTEAM_RUN_ID ?? ''
+    if (!/^[a-zA-Z0-9_-]{8,80}$/.test(runId) || process.env.AW_BENCH_APPROVAL_ONLY_ACK !== runId) throw new Error('run confirmation mismatch')
+    if (process.env.AW_MODE !== 'home' || (process.env.AW_BENCH_MODE && process.env.AW_BENCH_MODE !== '0')) throw new Error('home mode is required and AW_BENCH_MODE must be disabled')
+    const rawHome = process.env.AW_HOME ?? ''
+    if (!isAbsolute(rawHome)) throw new Error('an explicit isolated AW_HOME is required')
+    const home = realpathSync(rawHome)
+    if (basename(home) !== 'aw-home' || basename(dirname(home)) !== 'runtime' || !basename(dirname(dirname(home))).startsWith(runId)) {
+      throw new Error('AW_HOME must be this run\'s runtime/aw-home directory')
+    }
+    const aw = loopbackUrl(process.env.AW_BASE, 'AW_BASE')
+    const sim = loopbackUrl(process.env.SIM_BASE, 'SIM_BASE')
+    if (Number(sim.port) === 4010 || Number(aw.port) === 3001) throw new Error('shared default service ports are forbidden')
+    const qualificationPath = join(home, 'approval-only-qualification.json')
+    if (!lstatSync(qualificationPath).isFile() || lstatSync(qualificationPath).isSymbolicLink()) throw new Error('qualification must be a regular run-private file')
+    const q = JSON.parse(readFileSync(qualificationPath, 'utf8')) as Qualification
+    const expiry = Date.parse(q.expires_at_utc)
+    if (q.schema_version !== 1 || q.run_id !== runId || resolve(q.aw_home) !== home || q.aw_base !== aw.origin || q.sim_base !== sim.origin
+      || !Number.isFinite(expiry) || expiry <= Date.now() || expiry - Date.now() > 3_600_000) throw new Error('qualification is mismatched or expired')
+    if (!input.line?.simulated || q.line_id !== input.line.id || q.recipe_id !== input.recipeId || input.nodes.length !== 1 || !Array.isArray(q.nodes)) {
+      throw new Error('the qualified simulated line, recipe and targets are required')
+    }
+    const endpoints = input.nodes.map((node) => {
+      const allowed = q.nodes.filter(entry => entry.node_id === node.id)
+      const hash = createHash('sha256').update(JSON.stringify(node.driverConfig)).digest('hex')
+      if (allowed.length !== 1 || allowed[0]!.driver !== node.driver || allowed[0]!.driver_config_sha256 !== hash) throw new Error('target or driver configuration differs from qualification')
+      const endpoint = targetEndpoint(node)
+      if (endpoint && (allowed[0]!.host !== endpoint.host || allowed[0]!.port !== endpoint.port)) throw new Error('driver endpoint differs from qualification')
+      return endpoint
+    }).filter((endpoint): endpoint is { host: string, port: number } => endpoint !== null)
+    if (endpoints.length) {
+      if (process.platform !== 'win32') throw new Error('simulator PID verification is supported only on Windows')
+      const simRoot = realpathSync(q.simulator_root)
+      if (simRoot !== realpathSync(join(dirname(home), 'simulator')) || !Number.isInteger(q.simulator_pid) || q.simulator_pid <= 0) throw new Error('private simulator root/PID mismatch')
+      const commandLine = execFileSync('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', `(Get-CimInstance Win32_Process -Filter "ProcessId=${q.simulator_pid}").CommandLine`], { encoding: 'utf8', timeout: 8000, maxBuffer: 64 * 1024 })
+        .replaceAll('\\', '/').toLowerCase()
+      if (!commandLine.includes(`${simRoot.replaceAll('\\', '/').toLowerCase()}/src/server/index.ts`)) throw new Error('simulator PID does not own this run\'s entry point')
+      assertListener(Number(aw.port), process.pid)
+      for (const port of new Set([Number(sim.port), ...endpoints.map(endpoint => endpoint.port)])) assertListener(port, q.simulator_pid)
+    }
+    return { approval_bypassed: true, run_id: runId }
+  }
+  catch (err) {
+    throw new Error(`Approval-only trial refused: ${err instanceof Error ? err.message : String(err)}`, { cause: err })
+  }
+}