agentworkshop 0.7.44 → 0.7.46

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

@@ -0,0 +1,363 @@
+/**
+ * AML 作业与模型(aml_job_* / aml_leaderboard / aml_model_*)
+ * (由 server/services/workshop/agents/industrial-tools.ts 按职责拆出;内容逐行原文搬运)
+ */
+import { AML_AUDIT_KIND, amlErr, amlJobCard, amlNodeName, amlNodeUnit, fmtAmlNum } from './aml-dataset-tools'
+import { agentBadgeLabel } from '../agent-badge'
+import { alignToGrid } from '../../aml/clean'
+import { cancelJob, jobLogsTail, runtimeStatus, submitJob } from '../../aml/job-orchestrator'
+import { getActiveLineRun } from '../../dcw/line-run'
+import { getAgentNodeBindingRepo } from '../node-bindings.repo'
+import { getAmlRuntime } from '../../aml/runtime'
+import { getDaqNodeRepo } from '../../daq/daq-node.repo'
+import { getDcwProductRepo } from '../../dcw/dcw-product.repo'
+import { getDcwRecipeRepo } from '../../dcw/dcw-recipe.repo'
+import { getToolApprovals } from '../tool-approvals'
+import { predictProduction, readIoSpecFor } from '../../aml/predictor'
+import { recordOps } from '../../ops/ops'
+import { transitionModel } from '../../aml/model-registry'
+
+/** 工具:aml_job_submit —— 提交训练作业(train.py 全文内联;归因 agentId;队列 FIFO) */
+export async function toolAmlJobSubmit(agentId: string, args: {
+  dataset_id?: string
+  code?: string
+  change_note?: string
+  params?: Record<string, unknown>
+  seed?: number | string
+  purpose?: string
+  parent_experiment_id?: string
+  scene_id?: string
+  scene_version?: string
+  objective_id?: string
+  job_kind?: 'supervised' | 'physics_calibration' | 'hybrid_residual' | 'uncertainty_calibration'
+  physics_manifest?: Record<string, unknown>
+  twin_snapshot?: Record<string, unknown>
+  objective_profile?: Record<string, unknown>
+}): Promise<{ text: string, isError?: boolean }> {
+  const datasetId = String(args.dataset_id ?? '').trim()
+  const code = typeof args.code === 'string' ? args.code : ''
+  if (!datasetId) return amlErr('dataset_id 必填(aml_dataset_build 返回的 id)。')
+  if (!code.trim()) return amlErr('code 必填:train.py 全文(单文件;契约见工具说明)。')
+  if (code.length > 512_000) return amlErr(`code 过大(${Math.round(code.length / 1024)}KB),上限 500KB;精简训练代码(模型定义/训练循环拆薄)后重试。`)
+  if (!/\bimport\s+amlkit\b/.test(code)) {
+    return amlErr('code 必须 import amlkit(平台数据/进度/导出契约):amlkit.load_bundle(datasetPath) 取数、amlkit.report_progress(pct, note) 报进度、amlkit.export_torch_onnx(model, manifest) 导出。缺契约的作业必然失败。')
+  }
+  const purpose = args.purpose === 'quality_predict' ? 'quality_predict' : args.purpose === 'mpc_surrogate' ? 'mpc_surrogate' : undefined
+  const changeNote = String(args.change_note ?? '').trim()
+  if (!changeNote) return amlErr('change_note 必填:单组件改动纪律 —— 每次实验只改一个组件(网络结构/特征/超参之一),写清改了什么与预期,实验谱系靠它归因。')
+  try {
+    const job = submitJob({
+      datasetId,
+      purpose,
+      changeNote,
+      params: args.params && typeof args.params === 'object' && !Array.isArray(args.params) ? args.params : undefined,
+      seed: Number.isInteger(Number(args.seed)) ? Number(args.seed) : undefined,
+      parentExperimentId: String(args.parent_experiment_id ?? '').trim() || undefined,
+      code,
+      sceneId: String(args.scene_id ?? '').trim() || undefined,
+      sceneVersion: String(args.scene_version ?? '').trim() || undefined,
+      objectiveId: String(args.objective_id ?? '').trim() || undefined,
+      jobKind: args.job_kind,
+      physicsManifest: args.physics_manifest,
+      twinSnapshot: args.twin_snapshot,
+      objectiveProfile: args.objective_profile,
+      agent: { id: agentId },
+    })
+    const st = await runtimeStatus()
+    return {
+      text: [
+        `训练作业已提交:`,
+        `  job_id: ${job.id}`,
+        `  dataset: ${job.datasetId} | purpose=${job.purpose} | seed=${fmtAmlNum(Number(job.budget.seed ?? 42), 0)} | change_note: ${changeNote}`,
+        `  队列: 排队 ${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 看谱系与门禁。`,
+      ].join('\n'),
+    }
+  }
+  catch (err) {
+    return { text: `提交失败:${err instanceof Error ? err.message : String(err)}`, isError: true }
+  }
+}
+
+/** 工具:aml_job_status —— 作业状态(单作业详情 / 缺省列最近 10 个) */
+export async function toolAmlJobStatus(_agentId: string, args: { job_id?: string }): Promise<{ text: string, isError?: boolean }> {
+  const rt = getAmlRuntime()
+  const jobId = String(args.job_id ?? '').trim()
+  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 定位。` }
+  }
+  const jobs = rt.repo.job.list({ limit: 10 })
+  if (jobs.length === 0) {
+    return { text: '尚无训练作业。路径:aml_node_catalog 确认节点 → aml_dataset_build 组数据集 → aml_job_submit 提交训练。' }
+  }
+  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 查看单作业详情(指标/门禁逐项/错误)。` }
+}
+
+/** 工具:aml_job_logs —— 作业日志尾随(平台 ##AML 协议行 + 训练输出) */
+export async function toolAmlJobLogs(_agentId: string, args: { job_id?: string, lines?: number | string }): Promise<{ text: string, isError?: boolean }> {
+  const jobId = String(args.job_id ?? '').trim()
+  if (!jobId) return amlErr('job_id 必填(aml_job_status 不带参数可列出最近作业)。')
+  const job = getAmlRuntime().repo.job.get(jobId)
+  if (!job) return amlErr(`作业 ${jobId} 不存在。`)
+  const n = Math.min(Math.max(Number(args.lines) || 80, 5), 400)
+  const rows = jobLogsTail(jobId, n)
+  if (rows.length === 0) {
+    return { text: `作业 ${jobId} 暂无日志(${job.status === 'queued' ? '仍在排队,开跑后产生日志' : '日志未落盘或已被清理'});稍后重试或用 aml_job_status 看状态。` }
+  }
+  return { text: `作业 ${jobId} 日志尾(最近 ${rows.length} 行,时间正序;##AML 前缀行 = 平台协议事件):\n${rows.join('\n')}` }
+}
+
+/** 工具:aml_job_cancel —— 取消排队/运行中的作业(归因入册) */
+export async function toolAmlJobCancel(agentId: string, args: { job_id?: string }): Promise<{ text: string, isError?: boolean }> {
+  const jobId = String(args.job_id ?? '').trim()
+  if (!jobId) return amlErr('job_id 必填。')
+  const rt = getAmlRuntime()
+  const job = rt.repo.job.get(jobId)
+  if (!job) return amlErr(`作业 ${jobId} 不存在。`)
+  if (['done', 'failed', 'cancelled', 'timeout'].includes(job.status)) {
+    return amlErr(`作业 ${jobId} 已是终态(${job.status}),无需取消;aml_job_status 复核。`)
+  }
+  const ok = cancelJob(jobId, { id: agentId, kind: 'agent' })
+  if (!ok) return amlErr(`取消失败:作业 ${jobId} 不在排队/运行中(可能恰好结束);aml_job_status 复核。`)
+  const dataset = rt.repo.dataset.get(job.datasetId)
+  recordOps({
+    actor: agentId,
+    actorName: agentBadgeLabel(agentId),
+    actorKind: 'agent',
+    action: 'aml.job.cancel',
+    kind: AML_AUDIT_KIND,
+    summary: `取消训练作业 ${jobId}(原状态 ${job.status})`,
+    targetKind: 'aml_job',
+    targetId: jobId,
+    lineId: dataset?.lineId,
+    productId: dataset?.productId,
+    recipeId: dataset?.recipeId,
+  })
+  return { text: `作业 ${jobId} 已取消(运行中的会终止进程树)。数据集 ${job.datasetId} 仍可复用;需要重训直接 aml_job_submit。` }
+}
+
+/** 工具:aml_leaderboard —— 数据集的实验谱系与门禁对照(标当前最优) */
+export async function toolAmlLeaderboard(_agentId: string, args: { dataset_id?: string }): Promise<{ text: string, isError?: boolean }> {
+  const datasetId = String(args.dataset_id ?? '').trim()
+  if (!datasetId) return amlErr('dataset_id 必填(aml_dataset_build 返回的 id)。')
+  const rt = getAmlRuntime()
+  const dataset = rt.repo.dataset.get(datasetId)
+  if (!dataset) return amlErr(`数据集 ${datasetId} 不存在。`)
+  const exps = rt.repo.experiment.listByDataset(datasetId, 50)
+  if (exps.length === 0) {
+    return { text: `数据集 ${datasetId}(${dataset.rowCount} 行)尚无实验:aml_job_submit 提交训练后,此处给出谱系与门禁对照。` }
+  }
+  const parsed = exps.map((e) => {
+    let metrics: { oneStepTest?: { nrmse?: number }, rolloutTest?: { nrmse?: number } } = {}
+    let gates: { passed?: boolean } = {}
+    try {
+      metrics = JSON.parse(e.metricsJson)
+    }
+    catch { /* 无指标 */ }
+    try {
+      gates = JSON.parse(e.gatesJson)
+    }
+    catch { /* 无门禁 */ }
+    return { e, g1: metrics.oneStepTest?.nrmse ?? null, g2: metrics.rolloutTest?.nrmse ?? null, passed: gates.passed === true || e.status === 'gates_passed' }
+  })
+  const passers = parsed.filter(p => p.passed && p.g1 != null)
+  const bestId = passers.length > 0 ? passers.reduce((a, b) => ((a.g1 ?? Infinity) <= (b.g1 ?? Infinity) ? a : b)).e.id : null
+  const rows = parsed.map(p =>
+    `- ${p.e.id} [${p.e.status}] ${p.e.changeNote ? `「${p.e.changeNote.slice(0, 60)}」` : '(无备注)'}${p.e.parentExperimentId ? ` ← 父 ${p.e.parentExperimentId}` : ''} | G1=${fmtAmlNum(p.g1)}${p.g2 != null ? ` G2=${fmtAmlNum(p.g2)}` : ''} | 门禁 ${p.passed ? '通过' : '未通过'}${p.e.id === bestId ? ' ★当前最优' : ''}`)
+  const models = rt.repo.model.list({ limit: 100 }).filter(m => m.datasetId === datasetId)
+  const modelLines = models.map(m => `- ${m.id} [${m.stage}] purpose=${m.purpose}(实验 ${m.experimentId})`)
+  return {
+    text: [
+      `实验谱系(数据集 ${datasetId} · ${dataset.productId}/${dataset.recipeId} · ${exps.length} 条,新→旧):`,
+      ...rows,
+      modelLines.length > 0 ? `\n已登记模型(晋升对象;aml_leaderboard 最优 = 门禁通过且 G1 最小):` : null,
+      ...modelLines,
+      `\nG1=单步测试 NRMSE,G2=多步滚动 NRMSE(越小越好)。优化纪律:每次只改一个组件,change_note 写明;把最优模型推上生产用 aml_model_promote(lead 专属,需人工审批)。`,
+    ].filter(x => x !== null).join('\n'),
+  }
+}
+
+/** 工具:aml_model_promote —— 模型晋升 shadow/production(lead 专属;HITL 人工审批;流转入册由 transitionModel 内部完成) */
+export async function toolAmlModelPromote(agentId: string, args: { model_id?: string, to_stage?: string }): Promise<{ text: string, isError?: boolean }> {
+  // 治理硬守卫:晋升仅限 lead 实例(注入层过滤 + 分发层双重校验,HTTP 直调不可绕过)
+  const roleRow = getAmlRuntime().db.prepare('SELECT role FROM channel_agents WHERE id = ? AND enabled = 1').get(agentId) as { role?: string } | undefined
+  if (roleRow?.role !== 'lead') {
+    return amlErr(`aml_model_promote 为 lead 专属工具:实例 ${agentId}(role=${roleRow?.role ?? '未知'})无权晋升模型。请由团队 lead 发起,晋升需人工 HITL 批准。`)
+  }
+  const modelId = String(args.model_id ?? '').trim()
+  const toStage = String(args.to_stage ?? '').trim()
+  if (!modelId) return amlErr('model_id 必填(aml_leaderboard 的「已登记模型」段可查)。')
+  if (toStage !== 'shadow' && toStage !== 'production') return amlErr('to_stage 必须为 \'shadow\'(影子观测)或 \'production\'(生产生效)。')
+  const rt = getAmlRuntime()
+  const model = rt.repo.model.get(modelId)
+  if (!model) return amlErr(`模型 ${modelId} 不存在。`)
+  if (model.stage === toStage) return amlErr(`模型 ${modelId} 已是 ${toStage},无需流转。`)
+  // production 预检:同组 (product, recipe, purpose) 旧生产将被退役
+  let oldProdId: string | undefined
+  if (toStage === 'production') {
+    oldProdId = rt.repo.model
+      .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} 已有一条待审批的晋升请求,请等待用户处理后再发起新请求。`)
+  }
+  const detail = `AML 模型晋升:${modelId} ${model.stage} → ${toStage}(产品 ${model.productId} / 配方 ${model.recipeId} / purpose=${model.purpose}${oldProdId ? `;批准后原生产模型 ${oldProdId} 将自动退役` : ''})`
+  const ap = await approvals.request(agentId, modelId, 'dcw', detail, { title: 'AML 模型晋升审批' })
+  if (!ap.approved) {
+    return { text: `人工未批准:模型 ${modelId} 保持 ${model.stage} 阶段。用户备注:${ap.comment || '(无)'}。可回炉重训(aml_job_submit)或换候选模型后再申请。` }
+  }
+  try {
+    const r = transitionModel(modelId, toStage, agentBadgeLabel(agentId), 'agent')
+    // 归属审计已由 transitionModel 内部 recordOps(aml.model.promote)完成,此处不重复记录
+    return {
+      text: `晋升完成:${modelId} ${r.from} → ${toStage}。${r.retiredId ? `原生产模型 ${r.retiredId} 已自动退役。` : ''}${toStage === 'shadow'
+        ? '影子阶段:用 aml_model_reference 观测其预测与实际偏差,积累证据后再申请 production。'
+        : '该模型已作为生产模型生效:aml_model_reference 的影子参考即来自它;调控 Agent 调参前请先查它。'}`,
+    }
+  }
+  catch (err) {
+    return { text: `晋升失败:${err instanceof Error ? err.message : String(err)}(审批已通过;若为并发竞态可刷新状态重试)。`, isError: true }
+  }
+}
+
+/** 工具:aml_model_reference —— 生产模型影子参考:拉最近历史组装模型输入 → 预测未来目标轨迹(调参前先问影子模型) */
+export async function toolAmlModelReference(agentId: string, args: {
+  line_id?: string
+  product_id?: string
+  recipe_id?: string
+  purpose?: string
+  controls?: Record<string, number | string>
+  steps?: number | string
+}): Promise<{ text: string, isError?: boolean }> {
+  // 0. 绑定面:至少一个 daq 绑定;line_id 只缩不放
+  const repo = getAgentNodeBindingRepo()
+  const daqBindings = repo.byAgent(agentId).filter(b => b.kind === 'daq')
+  if (daqBindings.length === 0) {
+    return amlErr('你尚未绑定任何数采节点,无法组装影子参考所需的历史输入;请先绑定数采节点。')
+  }
+  const lineOf = (id: string): string => getDaqNodeRepo().byId(id)?.lineId ?? ''
+  const scopeLines = [...new Set(daqBindings.map(b => lineOf(b.nodeId)).filter(Boolean))]
+  const lineFilter = String(args.line_id ?? '').trim()
+  if (lineFilter && !scopeLines.includes(lineFilter)) {
+    return amlErr(`产线 ${lineFilter} 不在你的负责范围(你绑定节点覆盖:${scopeLines.join(', ') || '无'};绑定只缩不放)。`)
+  }
+  const purpose = args.purpose === 'quality_predict' ? 'quality_predict' : 'mpc_surrogate'
+
+  // 1. 解析 (productId, recipeId):参数给全用参数;缺省回退到候选产线的唯一活动批次
+  let productId = String(args.product_id ?? '').trim()
+  let recipeId = String(args.recipe_id ?? '').trim()
+  let resolveHow = '参数指定'
+  if (!productId || !recipeId) {
+    const candidateLines = lineFilter ? [lineFilter] : scopeLines
+    const runs = candidateLines
+      .map(lid => getActiveLineRun(lid))
+      .filter((r): r is NonNullable<ReturnType<typeof getActiveLineRun>> => !!r && !!r.productId && !!r.recipeId)
+    if (runs.length === 1) {
+      const run = runs[0]!
+      if (!productId) productId = run.productId
+      if (!recipeId) recipeId = run.recipeId
+      resolveHow = `产线 ${run.lineId} 唯一活动批次 ${run.runId.slice(0, 8)}(产品「${run.productName}」/配方「${run.recipeName}」)`
+    }
+    else if (runs.length === 0) {
+      return { text: `无法确定产品/配方:${candidateLines.length > 0 ? `产线 ${candidateLines.join(', ')}` : '你绑定节点所属产线'}当前无活动批次,且 product_id/recipe_id 未给全。请开跑后重试,或显式传 product_id 与 recipe_id(line_context 可查)。`, isError: true }
+    }
+    else {
+      return { text: `无法确定产品/配方:候选产线存在多个活动批次(${runs.map(r => `${r.lineId} → ${r.productName}/${r.recipeName}`).join('; ')})。请传 line_id 缩小范围,或显式传 product_id 与 recipe_id。`, isError: true }
+    }
+  }
+
+  // 2. 生产模型(无则指引建模范式)
+  const rt = getAmlRuntime()
+  const model = rt.repo.model.productionOf(productId, recipeId, purpose)
+  if (!model) {
+    const cands = rt.repo.model.list({ productId, recipeId, limit: 20 })
+    return { text: `尚无生产模型:(${productId}, ${recipeId}, ${purpose}) 下没有 stage=production 的模型。${cands.length > 0 ? `现有候选:${cands.map(m => `${m.id}(${m.stage})`).join(', ')} —— 请 lead 用 aml_model_promote 晋升(需人工审批)。` : '该三元组下还没有任何模型:aml_dataset_build → aml_job_submit 训练,门禁通过后申请晋升。在此之前调参请依据 dcw_journal 历史经验与 daq_query 证据。'}` }
+  }
+  // 3. 产线归属鉴权(绑定只缩不放;模型归属线经数据集追溯)
+  const ds = rt.repo.dataset.get(model.datasetId)
+  const modelLine = ds?.lineId ?? ''
+  if (modelLine && !scopeLines.includes(modelLine)) {
+    return amlErr(`模型 ${model.id} 归属产线 ${modelLine},不在你绑定节点覆盖的产线(${scopeLines.join(', ')})内;绑定只缩不放。`)
+  }
+
+  // 4. io 契约 → 拉最近历史 → 网格对齐 → 组 [H][nAll](原始物理量,顺序 = allNodes)
+  const io = readIoSpecFor(model.id)
+  const H = io.historySteps
+  const beatMs = io.beatMs
+  const now = Date.now()
+  const fromMs = now - H * beatMs - 5 * beatMs
+  const { getTsdb, tsdbReady } = await import('../../daq/storage')
+  await tsdbReady
+  const tsdb = getTsdb()
+  const columns = new Map<string, number[]>()
+  const shortage: string[] = []
+  for (const nodeId of io.allNodes) {
+    try {
+      const pts = await tsdb.query(nodeId, { fromMs, toMs: now, limit: Math.min(Math.max(H * 10, 600), 5000) })
+      const { grid } = alignToGrid(
+        pts.map(p => ({ at: p.at, value: p.value ?? p.avg ?? 0 })).filter(p => Number.isFinite(p.value)),
+        { beatMs, maxInterpMs: beatMs * 2 },
+      )
+      const tail = grid.slice(-H).map(g => g.value)
+      if (tail.length < H) {
+        shortage.push(`${amlNodeName(nodeId)}(${nodeId})仅 ${tail.length}/${H} 格点`)
+        continue
+      }
+      columns.set(nodeId, tail)
+    }
+    catch (err) {
+      shortage.push(`${amlNodeName(nodeId)}(${nodeId})查询失败:${err instanceof Error ? err.message : String(err)}`)
+    }
+  }
+  if (shortage.length > 0) {
+    return { text: `历史数据不足,无法组装模型输入:${shortage.join(';')}。需要从 ${new Date(fromMs).toISOString().slice(0, 16)} 起连续约 ${(H * beatMs / 60_000).toFixed(0)} 分钟的运行数据(产线须在跑);等数据积累后重试,或缩短 steps/换更短 history 的模型。`, isError: true }
+  }
+  const history: number[][] = []
+  for (let i = 0; i < H; i++) history.push(io.allNodes.map(n => columns.get(n)![i]!))
+
+  // 5. 控制轨迹:controls 映射(节点 id → 值,常数外推 steps 行);缺省行持最后观测
+  const steps = Math.max(1, Math.min(Number(args.steps) || io.horizonSteps, io.horizonSteps))
+  const lastRow = history[history.length - 1]!
+  const unknownKeys = args.controls ? Object.keys(args.controls).filter(k => !io.controlNodes.includes(k)) : []
+  const controlRow = io.controlNodes.map((c) => {
+    const provided = args.controls?.[c]
+    const v = provided != null ? Number(provided) : Number.NaN
+    return Number.isFinite(v) ? v : lastRow[io.allNodes.indexOf(c)]!
+  })
+  const controls: number[][] = Array.from({ length: steps }, () => [...controlRow])
+
+  // 6. 预测 + 人话报告
+  try {
+    const r = await predictProduction(productId, recipeId, purpose, { history, controls, steps })
+    const header = `步 | ${r.targetNodes.map(t => `${amlNodeName(t)}(${amlNodeUnit(t)})`).join(' | ')}`
+    const forecastLines = r.forecast.map((row, i) =>
+      `  ${i + 1}(+${fmtAmlNum(((i + 1) * r.beatMs) / 1000, 0)}s) | ${row.map(v => fmtAmlNum(v, 3)).join(' | ')}`)
+    const ctrlTxt = io.controlNodes.length > 0
+      ? io.controlNodes.map((c) => {
+          const provided = args.controls?.[c]
+          return `${amlNodeName(c)}=${Number.isFinite(Number(provided)) ? Number(provided) : `${fmtAmlNum(lastRow[io.allNodes.indexOf(c)], 3)}(持最后观测)`}${amlNodeUnit(c)}`
+        }).join(', ')
+      : '无控制节点'
+    return {
+      text: [
+        `影子模型参考(调参前先问影子模型;预测≠承诺,真实下发仍走 dcw_control 安全联锁):`,
+        `  模型 ${r.modelId}(stage=${r.stage},purpose=${purpose})| 三元组:产品 ${getDcwProductRepo().byId(productId)?.name ?? productId} / 配方 ${getDcwRecipeRepo().byId(recipeId)?.name ?? recipeId}(解析:${resolveHow})`,
+        `  输入:最近 ${H} 拍 × ${io.allNodes.length} 节点(beat=${beatMs}ms),截至 ${new Date(now).toISOString().slice(11, 19)};控制轨迹(共 ${steps} 步):${ctrlTxt}${unknownKeys.length > 0 ? `(已忽略非控制节点的键:${unknownKeys.join(', ')})` : ''}`,
+        `  预测(steps=${steps},每拍 ${beatMs / 1000}s):`,
+        `    ${header}`,
+        ...forecastLines,
+        `  假设: ${r.assumptions}`,
+        `\n用法:把候选设定值作为 controls 传入(键 = 控制节点 id)对比不同方案的预测轨迹;选定后 dcw_control 下发并 daq_query 复测。`,
+      ].join('\n'),
+    }
+  }
+  catch (err) {
+    return { text: `预测失败:${err instanceof Error ? err.message : String(err)}(模型 ${model.id};若为工件缺失可重训同规格数据集)。`, isError: true }
+  }
+}

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

@@ -0,0 +1,251 @@
+/**
+ * 数采查询与帧检索(daq_query / daq_frames)
+ * (由 server/services/workshop/agents/industrial-tools.ts 按职责拆出;内容逐行原文搬运)
+ */
+import { daqRuntimeSettings } from '../../settings'
+import { findDaqTemplate } from '../../daq/daq-templates'
+import { getActiveLineRun } from '../../dcw/line-run'
+import { getAgentNodeBindingRepo } from '../node-bindings.repo'
+import { getDaqNodeRepo } from '../../daq/daq-node.repo'
+import { getDcwController } from '../../dcw/dcw-controller'
+
+/**
+ * 数采目标集解析(工具共用鉴权面):Agent 绑定(kind=daq)为权限边界 ——
+ * node_id/line_id 只能缩小范围,不能放大(越权节点一律拒绝)。
+ */
+export function daqTargetsOf(agentId: string, nodeIdArg: unknown, lineIdArg: unknown):
+  { targets: string[], daqBindings: ReturnType<ReturnType<typeof getAgentNodeBindingRepo>['byAgent']> }
+  | { error: { text: string, isError: true } } {
+  const repo = getAgentNodeBindingRepo()
+  const daqBindings = repo.byAgent(agentId).filter(b => b.kind === 'daq')
+  if (daqBindings.length === 0) {
+    return { error: { text: '你尚未绑定任何数采节点,无权查询采集数据。请在数字孪生界面绑定数采节点。', isError: true } }
+  }
+  const wanted = nodeIdArg ? String(nodeIdArg) : ''
+  if (wanted && !daqBindings.some(b => b.nodeId === wanted)) {
+    return { error: { text: `无权查询节点 ${wanted}。你有权访问的数采节点:${daqBindings.map(b => b.nodeId).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 } }
+  }
+  let targets = wanted ? [wanted] : daqBindings.map(b => b.nodeId)
+  if (lineFilter && !wanted) {
+    const onLine = targets.filter(id => lineOf(id) === lineFilter)
+    if (onLine.length === 0) {
+      return { error: { text: `你绑定的数采节点中没有归属产线 ${lineFilter} 的(各节点归属:${daqBindings.map(b => `${b.nodeId}=${lineOf(b.nodeId) || '未分配'}`).join('; ')})。`, isError: true } }
+    }
+    targets = onLine
+  }
+  return { targets, daqBindings }
+}
+
+/**
+ * 工具:daq_query —— 数采数据检索(产线/产品/配方/批次/时间/节点;结果带物理语义)
+ *
+ * **默认作用域 = 当前活动批次**:调用方未显式给 `product_id`/`recipe_id`/`run_id`,
+ * 且该节点所属产线有活动批次(LineRun)时,自动按活动 `recipe_id` 过滤,并在结果头
+ * 打印 `批次 run/配方`。理由:样本在入库时逐条打标当轮配方,不默认识别"当前跑什么",
+ * Agent 很容易把上一轮配方的样本混进本轮判读(实测:不传过滤 10 点/均值 246.99,
+ * 只取当前配方 3 点/均值 247.99,差异足以改变 keep/rollback 结论)。
+ * 需要跨配方对比或历史复盘时显式传 `scope: 'all'`(或直接给 product_id/recipe_id/run_id)。
+ */
+export async function toolDaqQuery(agentId: string, args: {
+  node_id?: string
+  line_id?: string
+  product_id?: string
+  recipe_id?: string
+  run_id?: string
+  scope?: string
+  last_minutes?: number | string
+  from_ms?: number | string
+  to_ms?: number | string
+  bucket_ms?: number | string
+  limit?: number | string
+}): Promise<{ text: string, isError?: boolean }> {
+  const auth = daqTargetsOf(agentId, 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() : ''
+
+  const toMs = Number(args.to_ms) || Date.now()
+  const fromMs = Number(args.from_ms) || toMs - (Number(args.last_minutes) || 30) * 60_000
+  // 时间间隔参数(bucket_ms 降采样桶宽):缺省与下限来自 daq.query.*(live 配置,热重载)
+  const qCfg = daqRuntimeSettings().query
+  const rawBucket = Number(args.bucket_ms)
+  const bucketMs = Number.isFinite(rawBucket) && rawBucket > 0
+    ? Math.max(qCfg.minBucketMs, Math.min(3_600_000, Math.round(rawBucket)))
+    : qCfg.defaultBucketMs
+  const limit = Math.min(Number(args.limit) || 500, 2000)
+
+  // 显式过滤优先级:recipe_id / run_id / product_id(任一给出即完全按调用方口径)
+  const explicitProduct = args.product_id ? String(args.product_id) : ''
+  const explicitRecipe = args.recipe_id ? String(args.recipe_id) : ''
+  const explicitRun = args.run_id ? String(args.run_id) : ''
+  const explicitScoped = Boolean(explicitProduct || explicitRecipe || explicitRun)
+  /** scope=all:显式要求不过滤(跨配方/历史复盘),仅在无显式 id 时生效 */
+  const wantAll = !explicitScoped && String(args.scope ?? '').trim().toLowerCase() === 'all'
+
+  const { getTsdb, tsdbReady } = await import('../../daq/storage')
+  await tsdbReady
+  const tsdb = getTsdb()
+
+  const sections: string[] = []
+  /** 实际生效的过滤口径(逐节点累计,用于文末 provenance 与表头) */
+  const applied: Array<{ nodeId: string, lineId: string, runId?: string, recipeId?: string, source: 'explicit' | 'active-run' | 'none' }> = []
+  for (const nodeId of targets) {
+    const node = getDaqNodeRepo().byId(nodeId)
+    if (!node) continue
+    const tpl = findDaqTemplate(node.templateKey)
+    const ch = tpl?.ch ?? node.templateKey
+    // 默认口径:该节点所属产线的**活动批次**(未开跑 → 不过滤,保持原有语义)
+    const nodeLine = node.lineId || ''
+    const activeRun = !explicitScoped && !wantAll && nodeLine ? getActiveLineRun(nodeLine) : null
+    const scopeRun = explicitScoped
+      ? { runId: explicitRun || undefined, recipeId: explicitRecipe || undefined, productId: explicitProduct || undefined, source: 'explicit' as const }
+      : activeRun
+        ? { runId: activeRun.runId, recipeId: activeRun.recipeId, productId: activeRun.productId, source: 'active-run' as const }
+        : { runId: undefined, recipeId: undefined, productId: undefined, source: 'none' as const }
+    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 }>
+      // 是否有可用的打标过滤:显式 id、或活动批次(配方/批次 id 齐备)
+      const useTagged = Boolean(scopeRun.recipeId || scopeRun.runId || scopeRun.productId)
+      if (useTagged) {
+        const series = await tsdb.queryTagged({
+          lineId: nodeLine || undefined,
+          productId: scopeRun.productId,
+          recipeId: scopeRun.recipeId,
+          runId: scopeRun.runId,
+          nodeIds: [nodeId],
+          fromMs,
+          toMs,
+          bucketMs,
+          limit,
+        })
+        points = series.get(nodeId) ?? []
+      }
+      else {
+        points = await tsdb.query(nodeId, { fromMs, toMs, bucketMs, limit })
+      }
+      const scopeTag = scopeRun.source === 'explicit'
+        ? `批次过滤(显式)${scopeRun.runId ? ` run=${scopeRun.runId}` : ''}${scopeRun.recipeId ? ` 配方=${scopeRun.recipeId}` : ''}${scopeRun.productId ? ` 产品=${scopeRun.productId}` : ''}`
+        : scopeRun.source === 'active-run'
+          ? `当前活动批次 run=${scopeRun.runId ?? ''} 配方「${(scopeRun.recipeId && getDcwController().listRecipes().find(r => r.id === scopeRun.recipeId)?.name) || scopeRun.recipeId}」(${scopeRun.recipeId})(可直接把 run_id/recipe_id 回传给 daq_query 或 aml_dataset_build)`
+          : 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 ? `(降采样 ${bucketMs}ms)` : ''}\n  ${scopeTag}`
+      // 工况判读容器(具体判读在 values 计算后追加)
+      const readout: string[] = []
+      if (points.length === 0) {
+        sections.push(`${head}\n  窗口内无数据(产线未运行或过滤条件不匹配;仅产线运行中的样本被持久化打标)`)
+        continue
+      }
+      const values = points.map(p => p.value ?? p.avg ?? 0).filter(Number.isFinite)
+      const latest = values[values.length - 1]!
+      // 工况判读:最新值相对活动配方监控窗口/同线数控设定的位置(数据 → 语义)
+      const latestRaw = latest
+      const rw = node.lineId ? getActiveLineRun(node.lineId) : null
+      const recipeR = rw ? getDcwController().listRecipes().find(r => r.id === rw.recipeId) : undefined
+      const rwin = recipeR?.daqWindows?.find(w2 => w2.nodeId === nodeId)
+      if (rw && rwin) {
+        const inWin = (rwin.min == null || latestRaw >= rwin.min) && (rwin.max == null || latestRaw <= rwin.max)
+        readout.push(`活动配方「${rw.recipeName}」监控窗口 [${rwin.min ?? '-∞'}, ${rwin.max ?? '+∞'}]:当前 ${latestRaw}${node.unit} ${inWin ? '窗口内(正常)' : '**越限(该节点应已报警)**'}`)
+      }
+      {
+        const dcwAll = getDcwController().listViews().filter(d => d.lineId === node.lineId && d.value != null)
+        if (dcwAll.length > 0) {
+          readout.push(`同产线数控设定: ${dcwAll.map(d => `${d.name}=${d.value}${d.unit}`).join(';')}(判读时考虑设定↔实际量的耦合与滞后)`)
+        }
+      }
+      const avg = values.reduce((a, b) => a + b, 0) / values.length
+      const tail = points.slice(-12).map(p => `${new Date(p.at).toISOString().slice(11, 19)}=${p.value != null ? p.value : `avg ${Number((p.avg ?? 0).toFixed(2))}`}`)
+      sections.push(
+        `${head}\n  样本 ${values.length} 点 | 最新 ${latest}${node.unit} | 均值 ${Number(avg.toFixed(3))} | 最小 ${Math.min(...values)} | 最大 ${Math.max(...values)}\n  最近序列: ${tail.join('; ')}${readout.length > 0 ? `\n  工况判读: ${readout.join(' | ')}` : ''}`,
+      )
+    }
+    catch (err) {
+      sections.push(`■ ${node.name}:查询失败 ${err instanceof Error ? err.message : String(err)}`)
+    }
+  }
+  // 文末口径声明:逐节点列出**实际生效**的过滤来源(显式 / 活动批次 / 未过滤),
+  // 便于审计"这条结论用的是哪个批次的数据",也避免"以为默认过滤了其实没有"。
+  const scopedNodes = applied.filter(a => a.source !== 'none')
+  const unscoped = applied.filter(a => a.source === 'none')
+  const provLines: string[] = []
+  if (lineFilter) provLines.push(`产线 ${lineFilter}`)
+  if (explicitProduct) provLines.push(`产品 ${explicitProduct}`)
+  if (explicitRecipe) provLines.push(`配方 ${explicitRecipe}`)
+  if (explicitRun) provLines.push(`批次 ${explicitRun}`)
+  if (explicitScoped) provLines.push('—— 显式过滤值优先,逐样本打标精确切批')
+  else if (wantAll) provLines.push('—— scope=all:不做配方过滤,窗口内跨配方样本全部返回')
+  else if (scopedNodes.length > 0) {
+    const ids = [...new Set(scopedNodes.map(a => `${a.recipeId ?? '-'}${a.runId ? `@${a.runId}` : ''}`))]
+    provLines.push(`—— 默认作用域:仅当前活动批次 ${ids.join(', ')}(逐样本打标;跨配方对比请传 scope=all)`)
+  }
+  if (unscoped.length > 0) {
+    provLines.push(`—— 未过滤节点(所在产线未开跑,无活动批次可限定):${unscoped.map(a => a.nodeId).join(', ')}`)
+  }
+  const prov = provLines.length > 0 ? `\n(过滤条件:${provLines.join(' ')})` : ''
+  return { text: `数采数据查询结果(${targets.length} 个节点):\n\n${sections.join('\n\n')}${prov}\n\n数值均为经标定钩子处理后的真实物理量纲;调整工艺前请结合 my_industrial_nodes 的节点判读方法与操作守则。` }
+}
+/** 工具:daq_frames —— 多形态帧检索(v2:测厚/扫描仪多点轮廓与 CCD 图像元数据)。
+ *  向量返回点列摘要(≤16 点预览 + 派生指标);图像返回对象引用与内容 URL(像素不入 LLM)。 */
+export async function toolDaqFrames(agentId: string, args: {
+  node_id?: string
+  line_id?: string
+  kind?: string
+  last_minutes?: number | string
+  from_ms?: number | string
+  to_ms?: number | string
+  limit?: number | string
+}): Promise<{ text: string, isError?: boolean }> {
+  const auth = daqTargetsOf(agentId, args.node_id, args.line_id)
+  if ('error' in auth) return auth.error
+  const { targets } = auth
+  const kind = args.kind === 'vector' || args.kind === 'image' ? args.kind : undefined
+  const toMs = Number(args.to_ms) || Date.now()
+  const fromMs = Number(args.from_ms) || toMs - (Number(args.last_minutes) || 30) * 60_000
+  const limit = Math.min(Number(args.limit) || 20, 100)
+  const { getTsdb, tsdbReady } = await import('../../daq/storage')
+  await tsdbReady
+  const tsdb = getTsdb()
+
+  const sections: string[] = []
+  for (const nodeId of targets) {
+    const node = getDaqNodeRepo().byId(nodeId)
+    if (!node) continue
+    const tpl = findDaqTemplate(node.templateKey)
+    const signalKind = tpl?.signalKind ?? 'scalar'
+    if (signalKind === 'scalar') {
+      sections.push(`■ ${node.name}:单点标量节点(模板 ${node.templateKey}),无帧数据 —— 请用 daq_query 查时序数值。`)
+      continue
+    }
+    try {
+      const frames = await tsdb.queryFrames(nodeId, { fromMs, toMs, kind, limit })
+      if (frames.length === 0) {
+        sections.push(`■ ${node.name}(${tpl?.ch ?? node.templateKey}):窗口内无帧(产线未运行或过滤条件不匹配;仅产线运行中的帧被持久化)`)
+        continue
+      }
+      const head = `■ ${node.name}(${tpl?.ch ?? node.templateKey})形态 ${signalKind},帧数 ${frames.length},时间窗 ${new Date(fromMs).toISOString().slice(0, 16)} ~ ${new Date(toMs).toISOString().slice(0, 16)}`
+      const lines = frames.slice(0, 10).map((f) => {
+        const at = new Date(f.at).toISOString().slice(11, 19)
+        if (f.kind === 'vector') {
+          const pts = f.points ?? []
+          const preview = pts.slice(0, 16).map(p => Number(p.toFixed(3))).join(',')
+          return `  ${at} 轮廓 ${pts.length} 点[${preview}${pts.length > 16 ? ',…' : ''}] 指标 {${Object.entries(f.metrics).slice(0, 6).map(([k, v]) => `${k}=${v}`).join(', ')}}`
+        }
+        const width = f.meta.width ?? '?'
+        const height = f.meta.height ?? '?'
+        return `  ${at} 图像 ${width}x${height} ${f.meta.mime ?? 'image/png'} 对象=${String(f.meta.objectKey ?? '-').slice(-24)} 指标 {${Object.entries(f.metrics).slice(0, 4).map(([k, v]) => `${k}=${v}`).join(', ')}}(像素不入上下文;前端画廊可看)`
+      })
+      sections.push(`${head}\n${lines.join('\n')}${frames.length > 10 ? `\n  (仅展示最近 10 帧)` : ''}`)
+    }
+    catch (err) {
+      sections.push(`■ ${node.name}:帧查询失败 ${err instanceof Error ? err.message : String(err)}`)
+    }
+  }
+  return { text: `数采帧查询结果(${targets.length} 个节点):\n\n${sections.join('\n\n')}\n\n向量=多点工程量轮廓(完整点列前端可查);图像=像素在对象存储,指标供判读(brightness 过低=曝光不足/遮挡)。` }
+}