agentworkshop 0.7.53 → 0.7.58

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

@@ -41,6 +41,76 @@ export const AML_MODEL_BACKED_TOOL_NAMES = new Set([
   'twin_trial_run', 'mpc_optimize', 'twin_bayes_optimize',
 ])
 
+/**
+ * 产线 Co-Pilot 观察面档位(2026-10-01 计划 §5.2/§5.3):
+ * exp-miner(经验工程师)/ line-doctor(诊断工程师)是**零写**只读档位 ——
+ * 核心工业工具按白名单注入(channel_plugins 只过滤插件挡不住核心族,白名单是核心族唯一的排除机制),
+ * 直接写族(agents/tool-classes 清单)在尾部 writesBlocked 再兜底过滤一道。
+ * kb_agent/diag_run/diag_status 等 KB/诊断工具走 rag-bridge/diag-bridge 插件面,照常按频道插件开关注入,不进本白名单。
+ */
+/** 只读观察读面(两档共用,全部只读;exp_collect 由经验采集底座注册,此处按名引用) */
+export const OBSERVER_READ_TOOL_NAMES = new Set([
+  'ops_log',
+  'recipe_log',
+  'recipe_versions',
+  'line_context',
+  'dcw_journal',
+  'daq_query',
+  'exp_collect',
+])
+
+/**
+ * line-doctor 追加面(P2 生效):AML 只读查询族 + 结构化下发族。
+ * aml_activity = 优化循环活动自查(recipe_propose 提交前的硬闸自查,只读);
+ * recipe_propose = 整包方案审批提交(**不是直写**:批准与选定包由人类在审批卡裁决,
+ * 未携带有效 choice 的批准按拒绝收敛;执行走既有 applyRecipe 审批管线)。
+ */
+export const LINE_DOCTOR_AML_TOOL_NAMES = new Set([
+  'aml_model_find',
+  'aml_model_reference',
+  'aml_leaderboard',
+  'twin_gate_evaluate',
+  'aml_activity',
+  'recipe_propose',
+])
+
+/** 观察面档位保留的协作面:消息/记忆/任务执行流(零产线写语义;lead 治理面照旧按角色剔除) */
+export const OBSERVER_COLLAB_TOOL_NAMES = new Set([
+  'send_message_to_agent',
+  'broadcast_message',
+  'poll_messages',
+  'read_channel_mail',
+  'list_other_teams',
+  'save_memory',
+  'search_memory',
+  'search_other_teams_memory',
+  'send_cross_channel_message',
+  'submit_task',
+  'complete_task',
+  'report_progress',
+  'refuse_task',
+  'cancel_task',
+  'get_my_task_queue',
+  'get_task_details',
+  'list_channel_tasks',
+  'list_team_agents',
+])
+
+/** 观察面档位允许注入的核心工具全集(纯派生;单测断言「工具面零写」的单一事实源) */
+export function observerAllowedToolNames(kind: 'exp-miner' | 'line-doctor'): Set<string> {
+  return new Set([
+    ...OBSERVER_READ_TOOL_NAMES,
+    ...OBSERVER_COLLAB_TOOL_NAMES,
+    ...(kind === 'line-doctor' ? LINE_DOCTOR_AML_TOOL_NAMES : []),
+  ])
+}
+
+/** 观察面档位的核心工具装配(纯函数:按白名单过滤 base;单测对合成目录与真实 HOST_TOOLS 各断言一层) */
+export function scopedToolsForObserverProfile(kind: 'exp-miner' | 'line-doctor', base: RpcHostToolDefinition[]): RpcHostToolDefinition[] {
+  const allowed = observerAllowedToolNames(kind)
+  return base.filter(t => allowed.has(t.name))
+}
+
 /** AML 治理/重负载动作之外,产线直接写工具的声明源已上收 agents/tool-classes(见文件头 re-export)。 */
 
 /** 占位符动态注入:工具描述里的运行时配置值(每次装配实时计算,配置热重载后 Agent 拿到新值) */
@@ -67,6 +137,7 @@ function applyDescriptionPlaceholders(tools: RpcHostToolDefinition[]): RpcHostTo
  * 尾部合并插件注册工具(roles 过滤,缺省双角色可用;channelId 给定且该团队有显式
  * 插件开关时,关闭的插件其工具不注入 —— 防不需要插件的 channel 上下文被污染)。
  * AML 解耦:aml_training/aml_optimization Channel 按面注入(训练族与优化族互斥);
+ * 产线 Co-Pilot 观察面(exp-miner/line-doctor)按白名单注入,物理零写;
  * hybrid_twin 保持全功能面;legacy 无 twin 工具。
  * 全 harness 共用:omp 经 set_host_tools 下发;其余引擎经 MCP 桥 tools/list 拉取。
  */
@@ -86,14 +157,27 @@ export function hostToolsForRole(role: 'lead' | 'worker', channelId?: string): R
     // 优化面:剔除训练族(gate 保留 —— 绑定校验需门禁);优化族显式补齐(含新工具)
     scoped = base.filter(t => !AML_TRAINING_TOOL_NAMES.has(t.name) || t.name === 'twin_gate_evaluate')
   }
+  else if (kind === 'exp-miner' || kind === 'line-doctor') {
+    // 产线 Co-Pilot 观察面(经验工程师/诊断工程师):核心工具按白名单注入 —— 物理零写(白名单不含任何写族)
+    scoped = scopedToolsForObserverProfile(kind, base)
+  }
   else {
     const hybrid = channelId ? kind === 'hybrid_twin' : false
-    scoped = hybrid ? base : base.filter(t => !HYBRID_TWIN_TOOL_NAMES.has(t.name))
+    // legacy:孪生/训练/优化三族全族摘除(dispatch 对 legacy 拒绝这些工具 —— 注入面与
+    // 分发守卫同口径,免得 worker 对着必拒工具烧 token 试错;2026-10-04 工具面评审实测
+    // legacy worker 注入 73 工具其中 ~14 个 dispatch 必拒)。
+    scoped = hybrid
+      ? base
+      : base.filter(t => !HYBRID_TWIN_TOOL_NAMES.has(t.name)
+        && !AML_TRAINING_TOOL_NAMES.has(t.name)
+        && !AML_OPTIMIZATION_TOOL_NAMES.has(t.name))
   }
   // 直写工具守卫:hybrid 沿用 bounded_auto 开关;工艺优化 Channel 一律不给 dcw 直写
-  // (真实写入统一走 optimization_explore 的治理链),训练 Channel 无写语义。
+  // (真实写入统一走 optimization_explore 的治理链),训练 Channel 无写语义;
+  // 观察面档位(exp-miner/line-doctor)零写 —— 白名单已不含写族,此处再兜底一道(两处同源 tool-classes 清单)。
   const writesBlocked = Boolean(profile?.profile === 'hybrid_twin' && (!flags.governedWriteEnabled || !flags.boundedAutoEnabled || profile.controlPolicy !== 'bounded_auto'))
     || kind === 'aml_optimization' || kind === 'aml_training'
+    || kind === 'exp-miner' || kind === 'line-doctor'
   const out = writesBlocked ? scoped.filter(t => !HYBRID_TWIN_DIRECT_WRITE_TOOL_NAMES.has(t.name)) : [...scoped]
   // 团队级插件开关:显式配置过的 channel 按行过滤;未配置(无行)= 全启用,向后兼容
   const channelOff = channelId

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

@@ -17,6 +17,7 @@ import { twinWriteGuard } from '../../aml/twin/feature-flags'
 import { listPluginTools, pluginOfTool } from '../plugin-tools'
 import type { HostToolBridgeContext, HostToolCall, HostToolResult } from './types'
 import { INDUSTRIAL_TOOL_NAMES, dispatchIndustrialTool } from './tools/industrial'
+import { guardIndustrialToolGrant } from '../industrial/grant-guard'
 import { handleCompleteTask, handleReportProgress } from './tools/progress'
 import { handleCancelTask, handleDispatchTask, handleGetMyTaskQueue, handleGetTaskDetails, handleListChannelTasks, handleReassignTask, handleRefuseTask, handleSubmitTask, handleUpdateTask } from './tools/tasks'
 import { handleGrantNodes, handleRevokeNodes } from './tools/team-delegation'
@@ -28,7 +29,27 @@ import { handleCreateTeamAgent, handleGetQueueOverview, handleListTeamAgents, ha
  * 分发一次 host tool 调用(全引擎唯一入口):
  * 插件工具优先 → workspace 面 → 工业工具族 → 插件兜底 → 未知工具。
  */
+/** 统一出口:所有工具结果经截断收口(单点修改,全族生效) */
 export async function dispatchHostTool(ctx: HostToolBridgeContext, req: HostToolCall): Promise<HostToolResult> {
+  return truncateToolResult(await dispatchHostToolInner(ctx, req), req.toolName)
+}
+
+/** 工具结果统一出口上限:超长文本截断+尾注(2026-10-05 评审;export/diag 类可经 optOut 放行) */
+const TOOL_RESULT_MAX_CHARS = 16_000
+const TRUNCATE_OPT_OUT_TOOLS = new Set(['daq_export', 'diag_run'])
+function truncateToolResult(result: HostToolResult, toolName: string): HostToolResult {
+  if (TRUNCATE_OPT_OUT_TOOLS.has(toolName)) return result
+  const text = result.text ?? ''
+  if (text.length <= TOOL_RESULT_MAX_CHARS) return result
+  const head = text.slice(0, TOOL_RESULT_MAX_CHARS)
+  return {
+    ...result,
+    text: head + `
+[truncated: ${text.length} → ${TOOL_RESULT_MAX_CHARS} 字符;请收窄时间窗/减少点位/分页后重试]`,
+  }
+}
+
+async function dispatchHostToolInner(ctx: HostToolBridgeContext, req: HostToolCall): Promise<HostToolResult> {
   const identity = ctx.identity
   const state = ctx.state
   // 插件工具分发(ctx.omp.registerTool 注册的自定义工具;不依赖 workspace,优先于内置面)
@@ -105,6 +126,9 @@ export async function dispatchHostTool(ctx: HostToolBridgeContext, req: HostTool
   // 工业工具族不依赖 workspace(只按 agentId 查绑定与节点),先于 workspace 门控执行 ——
   // 否则 worker 首回合前的 REST/MCP 直调(my_industrial_nodes 等)会被误拒
   if (INDUSTRIAL_TOOL_NAMES.has(req.toolName)) {
+    // 权限模型 v3:运行时 grant 复核(收权即失活;绑定面是静态授权,撤销后此处拦截)
+    const denied = await guardIndustrialToolGrant(identity, req.toolName, args)
+    if (denied) return denied
     return await dispatchIndustrialTool(identity.agentId, req.toolName, args, identity.channelId)
   }
 
@@ -196,6 +220,7 @@ export async function dispatchHostTool(ctx: HostToolBridgeContext, req: HostTool
       case 'param_read':
       case 'daq_query':
       case 'daq_frames':
+      case 'daq_export':
       case 'dcw_judge':
       case 'dcw_rollback':
       case 'dcw_journal':

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

@@ -9,7 +9,11 @@
  * 该族**不依赖 workspace**,由 dispatch 在 workspace 门控之前分流(保持原分发顺序)。
  */
 import type { HostToolResult } from '../types'
-import { toolAmlDatasetBuild, toolAmlDatasetStats, toolAmlJobCancel, toolAmlJobLogs, toolAmlJobStatus, toolAmlJobSubmit, toolAmlLeaderboard, toolAmlModelFind, toolAmlModelPromote, toolAmlModelReference, toolAmlNodeCatalog, toolAmlTrainingPlanCreate, toolAmlTrainingPlanList, toolAmlTrainingPlanTrain, toolDaqFrames, toolDaqQuery, toolDcwControl, toolDcwJudge, toolDcwJournal, toolDcwRead, toolDcwRollback, toolLineContext, toolMyIndustrialNodes, toolOpsLog, toolParamControl, toolParamRead, toolRecipeApply, toolRecipeLog, toolRecipeRollback, toolRecipeTrial, toolRecipeUpdate, toolRecipeVersions, toolOptimizationExplore, toolTwinProviderCatalog, toolTwinSceneDiscover, toolTwinSceneCompile, toolTwinSceneFreeze, toolTwinSceneRead, toolTwinPhysicsSpecDraft, toolTwinPhysicsSpecValidate, toolTwinPhysicsSpecCompile, toolTwinSnapshotCreate, toolTwinTrialRun, toolMpcOptimize, toolTwinGateEvaluate, toolTwinBayesOptimize, toolTwinCalibrationRequest } from '../../industrial'
+import { toolLineStart, toolLineStop, toolLineStatus, toolAmlDatasetBuild, toolAmlDatasetStats, toolAmlJobCancel, toolAmlJobLogs, toolAmlJobStatus, toolAmlJobSubmit, toolAmlLeaderboard, toolAmlModelFind, toolAmlModelPromote, toolAmlModelReference, toolAmlNodeCatalog, toolAmlTrainingPlanCreate, toolAmlTrainingPlanList, toolAmlTrainingPlanTrain, toolDaqExport, toolDaqFrames, toolDaqQuery, toolDcwControl, toolDcwJudge, toolDcwJournal, toolDcwRead, toolDcwRollback, toolLineContext, toolMesCatalog, toolMesDatasetRead, toolMesDatasets, toolMesFetch, toolMyIndustrialNodes, toolOpsLog, toolParamControl, toolParamRead, toolRecipeApply, toolRecipeLog, toolRecipeRollback, toolRecipeTrial, toolRecipeUpdate, toolRecipeVersions, toolOptimizationExplore, toolTwinProviderCatalog, toolTwinSceneDiscover, toolTwinSceneCompile, toolTwinSceneFreeze, toolTwinSceneRead, toolTwinPhysicsSpecDraft, toolTwinPhysicsSpecValidate, toolTwinPhysicsSpecCompile, toolTwinSnapshotCreate, toolTwinTrialRun, toolMpcOptimize, toolTwinGateEvaluate, toolTwinBayesOptimize, toolTwinCalibrationRequest } from '../../industrial'
+
+import { toolExpCollect } from '../../industrial/exp-tools'
+import { toolRecipePropose } from '../../industrial/recipe-propose-tools'
+import { toolAmlActivity } from '../../industrial/aml-activity'
 
 type IndustrialToolHandler = (agentId: string, args: Record<string, unknown>, channelId?: string) => Promise<HostToolResult>
 
@@ -50,6 +54,7 @@ const INDUSTRIAL_HANDLERS = new Map<string, IndustrialToolHandler>([
   ['param_control', (agentId, args, channelId) => toolParamControl(agentId, args as { param?: string, value?: number | string, hypothesis?: string, task_id?: string, line_id?: string }, channelId)],
   ['param_read', (agentId, args) => toolParamRead(agentId, args as { param?: string, line_id?: string })],
   ['daq_query', (agentId, args) => toolDaqQuery(agentId, args as Parameters<typeof toolDaqQuery>[1])],
+  ['daq_export', (agentId, args) => toolDaqExport(agentId, args as Parameters<typeof toolDaqExport>[1])],
   ['daq_frames', (agentId, args) => toolDaqFrames(agentId, args as Parameters<typeof toolDaqFrames>[1])],
   ['dcw_judge', (agentId, args) => toolDcwJudge(agentId, args as { record_id?: string, verdict?: string, reason?: string })],
   ['dcw_rollback', (agentId, args) => toolDcwRollback(agentId, args as { record_id?: string, node_id?: string, to?: string })],
@@ -59,9 +64,20 @@ const INDUSTRIAL_HANDLERS = new Map<string, IndustrialToolHandler>([
   ['line_context', (agentId, args) => toolLineContext(agentId, args as { line_id?: string })],
   ['recipe_versions', (agentId, args) => toolRecipeVersions(agentId, args as { recipe_id?: string, limit?: number | string })],
   ['recipe_update', (agentId, args) => toolRecipeUpdate(agentId, args as Parameters<typeof toolRecipeUpdate>[1])],
-  ['recipe_rollback', (agentId, args) => toolRecipeRollback(agentId, args as Parameters<typeof toolRecipeRollback>[1])],
-  ['recipe_trial', (agentId, args) => toolRecipeTrial(agentId, args as Parameters<typeof toolRecipeTrial>[1])],
+  ['recipe_rollback', (agentId, args) => toolRecipeRollback(agentId, args as Parameters<typeof toolRecipeRollback>[1])],
+  ['recipe_trial', (agentId, args) => toolRecipeTrial(agentId, args as Parameters<typeof toolRecipeTrial>[1])],
   ['recipe_apply', (agentId, args) => toolRecipeApply(agentId, args as Parameters<typeof toolRecipeApply>[1])],
+  ['mes_catalog', (agentId, args) => toolMesCatalog(agentId, args as Parameters<typeof toolMesCatalog>[1])],
+  ['mes_fetch', (agentId, args) => toolMesFetch(agentId, args as Parameters<typeof toolMesFetch>[1])],
+  ['mes_dataset_read', (agentId, args) => toolMesDatasetRead(agentId, args as Parameters<typeof toolMesDatasetRead>[1])],
+  ['mes_datasets', (agentId, args) => toolMesDatasets(agentId, args as Parameters<typeof toolMesDatasets>[1])],
+  ['exp_collect', (agentId, args) => toolExpCollect(agentId, args as { line_id?: string, lineId?: string })],
+  // 产线 Co-Pilot P2(诊断工程师下发面):整包方案审批 + AML 活动硬闸自查
+  ['recipe_propose', (agentId, args) => toolRecipePropose(agentId, args as Parameters<typeof toolRecipePropose>[1])],
+  ['line_start', (agentId, args, channelId) => toolLineStart(agentId, args as Parameters<typeof toolLineStart>[1], channelId)],
+  ['line_stop', (agentId, args, channelId) => toolLineStop(agentId, args as Parameters<typeof toolLineStop>[1], channelId)],
+  ['line_status', (agentId, args, channelId) => toolLineStatus(agentId, args as Parameters<typeof toolLineStatus>[1], channelId)],
+  ['aml_activity', (agentId, args) => toolAmlActivity(agentId, args as { line_id?: string })],
 ])
 
 /** 工业工具名集合(与 INDUSTRIAL_HANDLERS 同源;dispatch 据此在 workspace 门控前分流) */

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

@@ -25,7 +25,10 @@ export async function handleSearchMemory(args: Record<string, unknown>, ws: Agen
     ].filter(Boolean).join(' · ')
     return `  [${provenance}] ${s.title}\n    ${s.content}`
   })
-  return { text: `记忆检索结果(${snippets.length} 条, scope=${scope}):\n${lines.join('\n')}` }
+  // 召回度量透出(2026-10-05 记忆治理最小版):hit/miss 计数随每次检索可见
+  const { memoryRecallStats } = await import('@/server/services/workshop/runtime/memory/recall')
+  const st = memoryRecallStats()
+  return { text: `记忆检索结果(${snippets.length} 条, scope=${scope};召回度量 hits=${st.hits}/misses=${st.misses}/命中率=${st.hitRate}):\n${lines.join('\n')}` }
 }
 
 export async function handleSaveMemory(args: Record<string, unknown>, ws: AgentWorkspace): Promise<HostToolResult> {

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

@@ -30,6 +30,12 @@ export async function handleSendMessageToAgent(
     metadata['x-aw-in-reply-to'] = inReplyTo
     if (priority === 'task') priority = 'immediate'
   }
+  // 线程根(2026-10-05 最小版,近似):x-aw-thread-root = 被回复消息 id(直接父)。
+  // 不做跨消息闭包查询(工具层无消息寻址 API);poll 侧对批次内链做闭包折叠,
+  // 链式深层回复在折叠视图中仍归入其首层线程。存储走 metadata_json(零迁移)。
+  if (inReplyTo) {
+    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
@@ -121,17 +127,45 @@ export async function handlePollMessages(
       messageId: trigger.messageId,
     }
   }
-  const text = msgs.map((m, i) => {
-    const from = m.metadata?.['x-aw-from-agent'] ?? '?'
-    const reply = m.metadata?.['x-aw-in-reply-to']
-      ? ` (回复 ${String(m.metadata['x-aw-in-reply-to']).slice(0, 8)}…)`
-      : ''
-    const needReply = m.metadata?.['x-aw-require-reply'] === 'true'
-      ? ` [需回复:用 send_message_to_agent 回 ${from},in_reply_to=${m.messageId}]`
-      : ''
-    const body = m.parts.map(p => 'text' in p ? p.text : '').join(' ')
-    return `  [${i + 1}/${msgs.length}] [from ${from}]${needReply}${reply} ${body.slice(0, 2000)}`
-  }).join('\n')
+  const text = (() => {
+    // 线程折叠(2026-10-05 最小版):批次内按 x-aw-thread-root 闭包分组,
+    // 同线程 ≥2 条折叠为首条+计数(收件箱可读性;assign 投递不参与折叠)。
+    type Fold = { idx: number, from: string, needReply: string, reply: string, body: string }
+    const rootOf = (m: (typeof msgs)[number]): string => {
+      const root = m.metadata?.['x-aw-thread-root']
+      return typeof root === 'string' && msgs.some(x => x.messageId === root) ? root : m.messageId
+    }
+    const groups = new Map<string, Fold[]>()
+    msgs.forEach((m, i) => {
+      const from = String(m.metadata?.['x-aw-from-agent'] ?? '?')
+      const needReply = m.metadata?.['x-aw-require-reply'] === 'true'
+        ? ` [需回复:用 send_message_to_agent 回 ${from},in_reply_to=${m.messageId}]`
+        : ''
+      const reply = m.metadata?.['x-aw-in-reply-to']
+        ? ` (回复 ${String(m.metadata['x-aw-in-reply-to']).slice(0, 8)}…)`
+        : ''
+      const body = m.parts.map(p => 'text' in p ? p.text : '').join(' ')
+      const fold: Fold = { idx: i + 1, from, needReply, reply, body }
+      const key = rootOf(m)
+      const arr = groups.get(key) ?? []
+      arr.push(fold)
+      groups.set(key, arr)
+    })
+    const rendered: string[] = []
+    let seq = 0
+    for (const [, folds] of groups) {
+      seq += 1
+      const first = folds[0]!
+      if (folds.length >= 2) {
+        const heads = folds.map(f => `[${f.idx}] ${f.from}: ${f.body.slice(0, 200)}${f.needReply}`).join('\n        ')
+        rendered.push(`  [线程 ${seq} · ${folds.length} 条]\n        ${heads}`)
+      }
+      else {
+        rendered.push(`  [${first.idx}/${msgs.length}] [from ${first.from}]${first.needReply}${first.reply} ${first.body.slice(0, 2000)}`)
+      }
+    }
+    return rendered.join('\n')
+  })()
   return {
     text:
       `未消费消息(${msgs.length},已读即取):\n${text}`

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

@@ -12,14 +12,18 @@ export async function handleSubmitTask(args: Record<string, unknown>, state: Hos
   const title = String(args.title ?? '').trim()
   const description = args.description as string | undefined
   if (!title) return { text: 'submit_task 需要非空 title', isError: true }
+  // budget_minutes:长工业链路显式预算(分钟;如 8 步巡检链在 15min 默认预算下会被处决)
+  const budgetRaw = Number(args.budget_minutes)
+  const budgetMinutes = Number.isFinite(budgetRaw) && budgetRaw > 0 ? Math.round(budgetRaw) : undefined
   const task = await ws.submitTask({
     title,
     description,
+    budgetMinutes,
     sourceChatMessageId: state.sourceChatMessageId ?? undefined,
     sourceChatDeliveryId: state.sourceChatDeliveryId ?? undefined,
   })
   return {
-    text: `根任务 ${task.id} 已登记(assignee=你,state=${task.state})。若需要专业分工:对每个子任务调用 dispatch_task(parent_task_id=${task.id}, assignee_id=..., title=..., description=含目标/上下文/交付格式/验收标准/边界);若你自己就能回答,直接 complete_task(task_id=${task.id}, summary=..., deliverable=...) 并把结论回给提问者。`,
+    text: `根任务 ${task.id} 已登记(assignee=你,state=${task.state}${budgetMinutes ? `,预算=${budgetMinutes}min` : ''})。若需要专业分工:对每个子任务调用 dispatch_task(parent_task_id=${task.id}, assignee_id=..., title=..., description=含目标/上下文/交付格式/验收标准/边界);若你自己就能回答,直接 complete_task(task_id=${task.id}, summary=..., deliverable=...) 并把结论回给提问者。`,
   }
 }
 

package/server/services/workshop/agents/industrial/aml-activity.ts

@@ -0,0 +1,131 @@
+/**
+ * AML 优化循环活动状态(产线 Co-Pilot P2:只读查询 + `aml_activity` 工具)。
+ *
+ * 权威信号(按可用性组合,任一命中即「活动」;时间互斥是 recipe_propose 的硬闸,
+ * 误报方向安全 —— 只会把下发降级为建议报告,不会漏禁):
+ *   ① 绑定该产线的 Channel profile:非 legacy 档位 + 绑定模型 stage='production'
+ *      +(control_policy 非 recommendation_only 或 optimization_mode='aml')
+ *      —— 投用中的优化 Channel 是真实的「双写者」;
+ *   ② aml_jobs 最近 running/queued 的优化作业,经 datasetId 联查 dataset.lineId
+ *      (AmlJobRow 无 lineId 列);训练在跑 = 循环在动。
+ *   注:不再用 audit 的 optimization.* 事件做兜底 —— 平台对每次 Agent 写都会记
+ *   优化开窗(写路径 afterWrite),该口径会把普通 Agent 写误判成 AML 循环活动,
+ *   令 Co-Pilot 被硬禁 30 分钟(实测假阳性,2026-10-01 主套件抓出后移除)。
+ */
+import { getAmlRuntime } from '../../aml/runtime'
+import { getDcwLineRepo } from '../../dcw/dcw-line.repo'
+import { agentOpsScope } from './ops-tools'
+
+/** 信号②:仍在跑的作业状态(queued 起步,evaluating 收尾;done/failed/cancelled/interrupted/timeout 不算) */
+const ACTIVE_JOB_STATUSES = ['queued', 'provisioning', 'training', 'evaluating'] as const
+
+export interface AmlActivity {
+  active: boolean
+  reasons: string[]
+}
+
+/**
+ * 信号归并(纯函数,可测):两路信号的理由行归并去重;任一理由即 active。
+ * 单路信号自身异常由调用方消化(try/catch 后按「无信号」传入),不在此吞错。
+ */
+export function combineAmlActivitySignals(signals: {
+  profileReasons: string[]
+  jobReasons: string[]
+}): AmlActivity {
+  const reasons = [...signals.profileReasons, ...signals.jobReasons]
+    .map(r => r.trim())
+    .filter(r => r.length > 0)
+  const seen = new Set<string>()
+  const unique = reasons.filter((r) => {
+    if (seen.has(r)) return false
+    seen.add(r)
+    return true
+  })
+  return { active: unique.length > 0, reasons: unique }
+}
+
+/** 信号①:绑定该产线的 Channel profile 投用判定(异常按无信号) */
+function profileSignal(lineId: string): string[] {
+  try {
+    const rt = getAmlRuntime()
+    const rows = rt.db.prepare(`
+      SELECT p.channel_id AS channelId, p.profile AS profile, p.control_policy AS controlPolicy,
+             p.optimization_mode AS optimizationMode, p.bound_model_id AS boundModelId
+      FROM aml_channel_profiles p
+      JOIN channels c ON c.id = p.channel_id
+      WHERE c.line_id = ? AND c.enabled = 1
+    `).all(lineId) as Array<{ channelId: string, profile: string, controlPolicy: string, optimizationMode: string | null, boundModelId: string | null }>
+    const reasons: string[] = []
+    for (const r of rows) {
+      if (!r.profile || r.profile === 'legacy') continue
+      // 投用判定:绑定模型须在 production(候选/退役不算);控制策略须非「仅建议」,
+      // 或显式 aml 优化模式(策略缺省 recommendation_only 的 aml 模式 Channel 仍是真实写者)
+      if (!r.boundModelId) continue
+      const policyActive = (r.controlPolicy && r.controlPolicy !== 'recommendation_only') || r.optimizationMode === 'aml'
+      if (!policyActive) continue
+      const model = rt.repo.model.get(r.boundModelId)
+      if (!model || model.stage !== 'production') continue
+      reasons.push(`频道 ${r.channelId} 已投用 AML 优化模型 ${r.boundModelId}(production,策略 ${r.controlPolicy || '默认'}${r.optimizationMode === 'aml' ? ',aml 模式' : ''})`)
+    }
+    return reasons
+  }
+  catch {
+    // AML 运行时未装配/查询失败 = 该路信号不可用(不阻断其余信号)
+    return []
+  }
+}
+
+/** 信号②:在跑优化作业经 datasetId 联查产线(异常按无信号) */
+function jobSignal(lineId: string): string[] {
+  try {
+    const rt = getAmlRuntime()
+    const reasons: string[] = []
+    for (const status of ACTIVE_JOB_STATUSES) {
+      for (const job of rt.repo.job.list({ status, limit: 50 })) {
+        const ds = rt.repo.dataset.get(job.datasetId)
+        if (ds?.lineId !== lineId) continue
+        reasons.push(`AML 优化作业 ${job.id.slice(0, 8)} 进行中(${status},数据集 ${job.datasetId.slice(0, 8)})`)
+      }
+    }
+    return reasons
+  }
+  catch {
+    return []
+  }
+}
+
+/** 产线 AML 优化循环活动判定(内部查询面;recipe_propose 硬闸与 aml_activity 工具共用) */
+export function amlActivityForLine(lineId: string): AmlActivity {
+  return combineAmlActivitySignals({
+    profileReasons: profileSignal(lineId),
+    jobReasons: jobSignal(lineId),
+  })
+}
+
+/** 工具:aml_activity —— 查询产线 AML 优化循环是否活动(硬闸自查面;只读,不下发)。 */
+export async function toolAmlActivity(agentId: string, args: {
+  line_id?: string
+} = {}): Promise<{ text: string, isError?: boolean }> {
+  const scope = agentOpsScope(agentId)
+  if (!scope) return { text: '你尚未绑定任何工业节点,所在频道也未绑定产线,无产线可查(权限跟随节点绑定或频道绑线)。', isError: true }
+  const readable = [...new Set([...scope.lineIds, ...scope.boundLineIds])]
+  const wanted = String(args.line_id ?? '').trim()
+  if (wanted && !readable.includes(wanted)) {
+    return { text: `无权查询产线 ${wanted} 的 AML 活动状态(你的可读产线:${readable.join(', ') || '(无)'})。`, isError: true }
+  }
+  const lineIds = wanted ? [wanted] : readable
+  if (lineIds.length === 0) return { text: '没有可查询的产线(绑定的节点均未挂线)。' }
+
+  const sections = lineIds.map((lid) => {
+    const line = getDcwLineRepo().byId(lid)
+    const state = amlActivityForLine(lid)
+    const head = `■ 产线 ${line?.name ?? lid}(${lid}):AML 优化循环${state.active ? '**活动**' : '不活动'}`
+    if (!state.active) {
+      return `${head}\n  判定依据:两路信号(频道投用模型 / 在跑优化作业)均无命中。`
+    }
+    return `${head}\n${state.reasons.map(r => `  - ${r}`).join('\n')}`
+  })
+  return {
+    text: `AML 优化循环活动状态(产线 ${lineIds.length} 条):\n\n${sections.join('\n\n')}\n\n说明:活动 = 存在投用中的 AML 优化 Channel(production 模型)或在跑的优化作业。**活动期间禁止整包下发(recipe_propose 会被硬闸拒绝)**,请降级为建议报告;时间互斥是防「双写者」的铁律,不适用于单参数只读查询。普通 Agent 参数写的优化记录不计入(非 AML 循环)。`,
+  }
+}

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

@@ -147,6 +147,8 @@ export async function toolAmlDatasetBuild(agentId: string, args: {
   run_ids?: string[]
   from_ms?: number | string
   to_ms?: number | string
+  /** D7 熔断逃生口:确需重建同规格数据集时显式传 true */
+  force?: boolean
 }): Promise<{ text: string, isError?: boolean }> {
   const lineId = String(args.line_id ?? '').trim()
   const productId = String(args.product_id ?? '').trim()
@@ -198,6 +200,25 @@ export async function toolAmlDatasetBuild(agentId: string, args: {
       purpose,
       note: args.note ? String(args.note) : undefined,
     })
+    // D7 熔断(2026-10-06):同规格指纹 10 分钟内重复构建 → 拒绝并指向既有数据集。
+    // 实测某 lead 重试循环 15 分钟连续构建 30 个同 sha256 数据集,烧穿 2GB 磁盘配额。
+    // spec 由 parseDatasetSpec 规范化,同参调用 specJson 逐字相同,可作指纹。
+    if (args.force !== true) {
+      const specKey = JSON.stringify(spec)
+      const recentDup = getAmlRuntime().repo.dataset.list({ limit: 50 })
+        .filter(d => Date.now() - Date.parse(d.createdAt) < 10 * 60_000)
+        .find((d) => {
+          try {
+            return JSON.stringify(JSON.parse(d.specJson)) === specKey
+          }
+          catch {
+            return false
+          }
+        })
+      if (recentDup) {
+        return { text: `熔断:10 分钟内已构建过同规格数据集 ${recentDup.id}(sha256 ${String(recentDup.sha256 ?? '').slice(0, 12)}…)。重复构建只会烧穿磁盘配额(实测 15 分钟 30 个/2GB)——直接用该 dataset_id 提交训练即可。确因数据已更新需要重建,请传 force=true。`, isError: true }
+      }
+    }
     const { dataset, report } = await buildDataset(spec, { id: agentId, kind: 'agent' })
     recordOps({
       actor: agentId,

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

@@ -14,6 +14,7 @@ import { createTrainingPlan, listTrainingPlans, runPlanTraining } from '../../am
 import { getDcwProductRepo } from '../../dcw/dcw-product.repo'
 import { getDcwRecipeRepo } from '../../dcw/dcw-recipe.repo'
 import { getToolApprovals } from '../tool-approvals'
+import { claimToolResult } from '../../runtime/platform-notice'
 import { predictProduction, readIoSpecFor } from '../../aml/predictor'
 import { recordOps } from '../../ops/ops'
 import { transitionModel } from '../../aml/model-registry'
@@ -87,7 +88,7 @@ export async function toolAmlJobSubmit(agentId: string, args: {
         `  dataset: ${job.datasetId} | purpose=${job.purpose} | seed=${fmtAmlNum(Number(job.budget.seed ?? 42), 0)} | change_note: ${changeNote}`,
         args.model_name || args.model_description ? `  模型标识: name=${String(args.model_name ?? '(缺省派生)')} | description=${String(args.model_description ?? '(缺省派生)').slice(0, 80) || '(缺省派生)'}` : `  模型标识: 注册时自动派生「产线·配方·优化目标」label(可传 model_name/model_description 自拟)`,
         `  队列: 排队 ${st.queued} 个(含本作业)/ 在跑 ${st.running} 个 | python ${st.python.ok ? (st.python.version ?? 'ok') : `不可用(${st.python.reason ?? '?'};作业会失败,请联系用户修复环境)`}`,
-        `\n用 aml_job_status { job_id: "${job.id}" } 看状态/阶段/门禁,aml_job_logs { job_id: "${job.id}" } 看日志尾;训练完成后 aml_leaderboard 看谱系与门禁。`,
+        `用 aml_job_status { job_id: "${job.id}" } 看状态/阶段/门禁,aml_job_logs { job_id: "${job.id}" } 看日志尾。作业完成后平台会自动回执结果到你的信箱并唤醒你(无需持续轮询);期间可继续其他任务。`,
       ].join('\n'),
     }
   }
@@ -103,14 +104,19 @@ export async function toolAmlJobStatus(_agentId: string, args: { job_id?: string
   if (jobId) {
     const job = rt.repo.job.get(jobId)
     if (!job) return amlErr(`作业 ${jobId} 不存在(aml_job_status 不带参数可列出最近 10 个)。`)
-    return { text: `${amlJobCard(job)}\n\n轮询建议:training 阶段 30~60s 查一次;终态(done/failed)后看门禁与错误,失败原因可 in aml_job_logs 定位。` }
+    // 终态经轮询面亲自看到 → 认领结果所有权,取消平台的事后补送(先到先得,省一跳无谓回合)
+    if (['done', 'failed', 'cancelled'].includes(job.status)) claimToolResult('aml_job', jobId)
+    return { text: `${amlJobCard(job)}\n\n轮询建议:training 阶段 30~60s 查一次;终态(done/failed)后看门禁与错误,失败原因可 in aml_job_logs 定位。训练完成后平台也会自动回执到你的信箱,无需持续轮询。` }
   }
   const jobs = rt.repo.job.list({ limit: 10 })
   if (jobs.length === 0) {
     return { text: '尚无训练作业。路径:aml_node_catalog 确认节点 → aml_dataset_build 组数据集 → aml_job_submit 提交训练。' }
   }
+  for (const j of jobs) {
+    if (['done', 'failed', 'cancelled'].includes(j.status)) claimToolResult('aml_job', j.id)
+  }
   const rows = jobs.map(j => `- ${j.id} [${j.status}] ${j.stage || '-'} ${j.progress}% dataset=${j.datasetId}${j.error ? ` | 错误: ${j.error.slice(0, 100)}` : ''}`)
-  return { text: `最近 ${jobs.length} 个作业(新→旧):\n${rows.join('\n')}\n\n传 job_id 查看单作业详情(指标/门禁逐项/错误)。` }
+  return { text: `最近 ${jobs.length} 个作业(新→旧):\n${rows.join('\n')}\n\n传 job_id 查看单作业详情(指标/门禁逐项/错误)。训练完成后平台会自动回执到你的信箱。` }
 }
 
 /** 工具:aml_job_logs —— 作业日志尾随(平台 ##AML 协议行 + 训练输出) */