agentworkshop 0.7.52 → 0.7.53

package/server/plugins/backup.ts

@@ -53,7 +53,41 @@ async function backupOne(src: string, target: string): Promise<void> {
   }
 }
 
-async function backupOnce(dataDir: string): Promise<void> {
+/** 数据目录内的 JSON 仓储/状态文件(kv、参数面、节点绑定、插件 kv 等)+ 上级配置根的 config.yml/runtime-settings.json */
+async function backupFlatFiles(dataDir: string, backupDir: string, stamp: string): Promise<void> {
+  const bundleDir = resolve(backupDir, `files-${stamp}`)
+  mkdirSync(bundleDir, { recursive: true })
+  const targets: Array<{ src: string, name: string }> = []
+  // dataDir 下所有 .json(逐文件拷贝,目录型子树由各自仓储自轮转,不整树递归)
+  try {
+    for (const f of readdirSync(dataDir, { withFileTypes: true })) {
+      if (f.isFile() && f.name.endsWith('.json')) targets.push({ src: resolve(dataDir, f.name), name: f.name })
+    }
+  }
+  catch { /* 数据目录不可读时跳过 JSON 面 */ }
+  // 配置根(config.yml + runtime-settings.json)——重建实例的"怎么做"半边
+  try {
+    const homeMod = await import('@/shared/config/home.mjs')
+    const rm = homeMod.resolveRunMode({ cwd: process.cwd(), env: process.env })
+    for (const cfg of ['config.yml', 'runtime-settings.json']) {
+      const p = resolve(rm.configRoot, cfg)
+      if (existsSync(p)) targets.push({ src: p, name: cfg })
+    }
+  }
+  catch { /* 模式解析失败只降级 JSON 面 */ }
+  for (const t of targets) {
+    try {
+      const tmp = resolve(bundleDir, `${t.name}.tmp`)
+      await copyFileAsync(t.src, tmp)
+      renameSync(tmp, resolve(bundleDir, t.name))
+    }
+    catch (err) {
+      console.error(`[backup] ${t.name} 快照失败:`, err instanceof Error ? err.message : err)
+    }
+  }
+}
+
+export async function backupOnce(dataDir: string): Promise<void> {
   const backupDir = resolve(dataDir, 'backups')
   mkdirSync(backupDir, { recursive: true })
   const stamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19)
@@ -69,6 +103,8 @@ async function backupOnce(dataDir: string): Promise<void> {
       console.error(`[backup] ${file} 快照失败:`, err instanceof Error ? err.message : err)
     }
   }
+  // JSON 仓储 + 配置面快照(三库之外的可重建性半边)
+  await backupFlatFiles(dataDir, backupDir, stamp)
   // 轮转:每库仅保留最近 backup.keep 份(按文件名内时间戳倒序;env BACKUP_KEEP 兼容)
   const keep = Math.max(1, backupSettings().keep)
   for (const file of DB_FILES) {
@@ -83,9 +119,28 @@ async function backupOnce(dataDir: string): Promise<void> {
       catch { /* 轮转失败不致命 */ }
     }
   }
+  // files-<stamp>/ 目录同 keep 轮转
+  const fileBundles = readdirSync(backupDir)
+    .filter(f => f.startsWith('files-') && !f.includes('.'))
+    .sort()
+    .reverse()
+  for (const stale of fileBundles.slice(keep)) {
+    try {
+      rmSync(resolve(backupDir, stale), { recursive: true })
+    }
+    catch { /* 轮转失败不致命 */ }
+  }
   console.log('[backup] 快照完成 →', backupDir)
   // R4:记录最近一次成功备份时间,供 /api/metrics 观测
   g.__awBackupLastAt = new Date().toISOString()
+  // 备份成败留痕(audit_log;动态导入避免插件装载期循环依赖)
+  void import('../services/workshop/ops/ops').then(({ recordOps }) => {
+    recordOps({
+      actor: 'system', actorName: 'backup', actorKind: 'system',
+      action: 'system.backup.run', kind: 'system',
+      summary: `数据库快照完成(${DB_FILES.length} 库 + JSON/配置)→ ${backupDir}`,
+    })
+  }).catch(() => {})
 }
 
 export default function backupPlugin() {

package/server/plugins-builtin/diag-bridge/host/plugin.mjs

@@ -68,17 +68,24 @@ export default {
         if (Date.now() - last < AUTO_COOLDOWN_MS) return
         const now = Date.now()
         ctx.kv.set(`cooldown:${line}`, now) // 先占冷却,防同窗连发
-        startDiagnosis(ctx, {
-          line,
-          fromMs: now - 60 * MIN,
-          toMs: now,
-          question: `${line} 产线该时窗数据深度根因诊断(自动触发:节点 ${s.nodeId} 采样值 ${s.value} ${rule.op === 'lt' ? '<' : '>'} ${rule.value})`,
-          scene: `${line}_auto`,
-          source: 'auto',
-        }).then((r) => {
-          if (r.ok) ctx.logger.warn(`自动诊断已发起:产线 ${line} runId=${r.runId}(节点 ${s.nodeId}=${s.value} 越限)`)
-          else ctx.logger.warn(`自动诊断发起失败(产线 ${line}): ${r.error}`)
-        }).catch(() => {})
+        // 首拍竞态:开线后首个越限样本即刻触发,快照查询早于 tsdb 首次刷盘(TSDB_FLUSH_MS=500ms)
+        // → 时窗查空失败。空窗失败定向重试(≤3 次、间隔 5s,总窗 ≤20s);冷却不回滚,仍只此一次派发。
+        const question = `${line} 产线该时窗数据深度根因诊断(自动触发:节点 ${s.nodeId} 采样值 ${s.value} ${rule.op === 'lt' ? '<' : '>'} ${rule.value})`
+        const attempt = (n) => {
+          startDiagnosis(ctx, {
+            line,
+            fromMs: now - 60 * MIN,
+            toMs: now,
+            question,
+            scene: `${line}_auto`,
+            source: 'auto',
+          }).then((r) => {
+            if (r.ok) ctx.logger.warn(`自动诊断已发起:产线 ${line} runId=${r.runId}(节点 ${s.nodeId}=${s.value} 越限)`)
+            else if (n < 3 && String(r.error ?? '').includes('无数采样本')) setTimeout(() => attempt(n + 1), 5000)
+            else ctx.logger.warn(`自动诊断发起失败(产线 ${line}): ${r.error}`)
+          }).catch(() => {})
+        }
+        attempt(0)
       }
       catch { /* 钩子内绝不抛 */ }
     })

package/server/repositories/user.repository.ts

@@ -139,7 +139,8 @@ function importLegacyWorkshopUsers(d: DatabaseSync): void {
     insertUser.run(row.id, row.name, email, hashPassword(randomPassword()), 'user', 'active', row.created_at ?? now())
     const hash = hashToken(row.token)
     if (!tokenExists.get(hash)) {
-      insertToken.run(randomUUID(), row.id, 'legacy', hash, row.token, row.created_at ?? now())
+      // 安全基线:token_plain 不落明文(哈希即可鉴权;明文列仅为旧库形状兼容,恒 NULL)
+      insertToken.run(randomUUID(), row.id, 'legacy', hash, null, row.created_at ?? now())
     }
   }
 }
@@ -241,17 +242,21 @@ function toUser(row: Record<string, unknown>): User {
 export const userRepository = {
   list({ page, pageSize, keyword }: UserListQuery): Paginated<User> {
     const d = getDb()
-    const kw = keyword?.toLowerCase() ?? ''
+    // 分页边界钳制:超大/非法分页参数在 SQL 外收口(OFFSET 1e20 会打穿 sqlite 抛 500)
+    const safePage = Number.isSafeInteger(page) && page >= 1 ? page : 1
+    const safeSize = Number.isSafeInteger(pageSize) && pageSize >= 1 ? Math.min(pageSize, 200) : 20
+    // LIKE 通配符转义:用户关键词里的 %/_ 按字面匹配,不放大匹配面(ESCAPE 子句配套)
+    const kw = keyword?.toLowerCase() ? keyword.toLowerCase().replace(/[\\%_]/g, ch => `\\${ch}`) : ''
     const where = kw
-      ? `WHERE LOWER(name) LIKE ? OR LOWER(email) LIKE ?`
+      ? `WHERE LOWER(name) LIKE ? ESCAPE '\\' OR LOWER(email) LIKE ? ESCAPE '\\'`
       : ''
     const params = kw ? [`%${kw}%`, `%${kw}%`] : []
     const total = (d.prepare(`SELECT COUNT(*) AS n FROM users ${where}`).get(...params) as { n: number }).n
     const rows = d.prepare(
       `SELECT id, name, email, role, status, created_at AS createdAt FROM users ${where}
        ORDER BY created_at DESC LIMIT ? OFFSET ?`,
-    ).all(...params, pageSize, (page - 1) * pageSize) as Array<Record<string, unknown>>
-    return { items: rows.map(toUser), total, page, pageSize }
+    ).all(...params, safeSize, (safePage - 1) * safeSize) as Array<Record<string, unknown>>
+    return { items: rows.map(toUser), total, page: safePage, pageSize: safeSize }
   },
 
   /** 全量用户(不分页;管理面授权矩阵用,避免分页截断) */

package/server/services/user.service.ts

@@ -23,6 +23,12 @@ export function resolveUserByToken(token: string): UserProfile | null {
 }
 
 export const userService = {
+  /**
+   * 登录防爆破:同 IP+邮箱在 15 分钟窗口内累计失败 ≥5 次 → 锁到窗口结束(429)。
+   * 内存态,重启即清;多实例部署由反代层限流补齐。计数表封顶 5000 条防内存滥用。
+   */
+  _loginFails: new Map<string, { count: number, firstAt: number }>(),
+
   // ===== 管理面（与既有契约一致）=====
 
   list(input: UserListInput) {
@@ -104,9 +110,25 @@ export const userService = {
   },
 
   /** 登录：密码校验通过后签发新 token（每次登录生成一个可独立吊销的会话 token） */
-  login(input: UserLogin): AuthResult {
+  login(input: UserLogin, opts: { ip?: string } = {}): AuthResult {
+    const FAIL_WINDOW_MS = 15 * 60_000
+    const LOCK_THRESHOLD = 5
+    const lockKey = `${opts.ip ?? 'local'}|${input.email.toLowerCase()}`
+    const fails = this._loginFails
+    if (fails.size > 5000) {
+      const oldest = fails.keys().next().value
+      if (oldest) fails.delete(oldest)
+    }
+    const rec = fails.get(lockKey)
+    // 已达阈值且窗口未过 → 锁定;偶发失败(1-4 次)不锁,窗口滑过即重置
+    if (rec && rec.count >= LOCK_THRESHOLD && Date.now() - rec.firstAt < FAIL_WINDOW_MS) {
+      const waitMin = Math.ceil((FAIL_WINDOW_MS - (Date.now() - rec.firstAt)) / 60_000)
+      throw new AppError(429, 'LOGIN_LOCKED', `失败次数过多,账号已临时锁定,请约 ${waitMin} 分钟后再试`)
+    }
     const { id, hash } = userRepository.getPasswordHash(input.email) ?? {}
     if (!id || !hash || !verifyPassword(input.password, hash)) {
+      if (!rec || Date.now() - rec.firstAt >= FAIL_WINDOW_MS) fails.set(lockKey, { count: 1, firstAt: Date.now() })
+      else rec.count += 1
       throw new AppError(401, 'UNAUTHORIZED', '邮箱或密码错误')
     }
     const user = userRepository.findById(id)
@@ -116,6 +138,7 @@ export const userService = {
     if (user.status !== 'active') {
       throw new AppError(403, 'FORBIDDEN', '账号已禁用')
     }
+    fails.delete(lockKey)
     const { raw } = userRepository.createToken(id, `session-${Date.now()}`)
     return { user: this.publicProfile(user), token: raw }
   },

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

@@ -96,7 +96,7 @@ export async function dispatchHostTool(ctx: HostToolBridgeContext, req: HostTool
   }
 
   // 所有真实写入口在统一分发层再做一次服务端 fail-closed 守卫；工具目录隐藏不是安全边界。
-  if (['dcw_control', 'param_control', 'dcw_rollback', 'recipe_update', 'recipe_rollback'].includes(req.toolName)) {
+  if (['dcw_control', 'param_control', 'dcw_rollback', 'recipe_update', 'recipe_rollback', 'recipe_trial', 'recipe_apply'].includes(req.toolName)) {
     const profile = getChannelTwinProfile(identity.channelId)
     const guard = twinWriteGuard(identity.channelId, profile)
     if (!guard.allowed) return { text: `${guard.code}: ${guard.message}`, isError: true }

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

@@ -9,7 +9,7 @@
  * 该族**不依赖 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, toolRecipeLog, toolRecipeRollback, toolRecipeUpdate, toolRecipeVersions, toolOptimizationExplore, toolTwinProviderCatalog, toolTwinSceneDiscover, toolTwinSceneCompile, toolTwinSceneFreeze, toolTwinSceneRead, toolTwinPhysicsSpecDraft, toolTwinPhysicsSpecValidate, toolTwinPhysicsSpecCompile, toolTwinSnapshotCreate, toolTwinTrialRun, toolMpcOptimize, toolTwinGateEvaluate, toolTwinBayesOptimize, toolTwinCalibrationRequest } from '../../industrial'
+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'
 
 type IndustrialToolHandler = (agentId: string, args: Record<string, unknown>, channelId?: string) => Promise<HostToolResult>
 
@@ -59,7 +59,9 @@ 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_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])],
 ])
 
 /** 工业工具名集合(与 INDUSTRIAL_HANDLERS 同源;dispatch 据此在 workspace 门控前分流) */

package/server/services/workshop/agents/industrial/index.ts

@@ -17,7 +17,7 @@ export { toolMyIndustrialNodes, toolDcwControl, toolDcwRead } from './dcw-tools'
 export { toolParamControl, toolParamRead } from './param-tools'
 export { toolDaqQuery, toolDaqFrames } from './daq-tools'
 export { toolDcwJudge, toolDcwRollback, toolDcwJournal } from './dcw-judge-tools'
-export { toolOpsLog, toolRecipeLog, toolLineContext, toolRecipeVersions, toolRecipeUpdate, toolRecipeRollback } from './ops-tools'
+export { toolOpsLog, toolRecipeLog, toolLineContext, toolRecipeVersions, toolRecipeUpdate, toolRecipeRollback, toolRecipeTrial, toolRecipeApply } from './ops-tools'
 export { toolAmlNodeCatalog, toolAmlDatasetBuild, toolAmlDatasetStats } from './aml-dataset-tools'
 export { toolAmlJobSubmit, toolAmlJobStatus, toolAmlJobLogs, toolAmlJobCancel, toolAmlLeaderboard, toolAmlModelFind, toolAmlModelPromote, toolAmlModelReference, toolAmlTrainingPlanList, toolAmlTrainingPlanTrain, toolAmlTrainingPlanCreate } from './aml-job-tools'
 

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

@@ -17,10 +17,26 @@ import { fanoutQuery, windowOf } from './audit-query'
 // 运维日志 / Recipe 变更史查询(Agent 自查面:负责产线 scoped)
 // ================================================================
 
-/** Agent 负责范围 = 绑定节点的全集(节点 id 集 + 这些节点所属产线集);无绑定 = 无范围 */
-export function agentOpsScope(agentId: string): { lineIds: string[], nodeIds: Set<string> } | null {
+/** v18:频道绑定产线(只读扩权)——经全局 manager 读;manager 未装配/未绑定 = null */
+function channelBoundLineId(agentId: string): string | null {
+  try {
+    const g = globalThis as typeof globalThis & {
+      __workshopManager?: { channelLineBindingOf(id: string): string | null }
+    }
+    return g.__workshopManager?.channelLineBindingOf(agentId) ?? null
+  }
+  catch {
+    return null
+  }
+}
+
+/** Agent 负责范围 = 绑定节点的全集(节点 id 集 + 这些节点所属产线集;写权限依据)
+ *  ∪ 频道绑定产线(boundLineIds;v18 只读扩权:日志/配方史/上下文可读,写仍走节点授权)。 */
+export function agentOpsScope(agentId: string): { lineIds: string[], nodeIds: Set<string>, boundLineIds: string[] } | null {
   const bindings = getAgentNodeBindingRepo().byAgent(agentId)
-  if (bindings.length === 0) return null
+  const boundLine = channelBoundLineId(agentId)
+  const boundLineIds = boundLine ? [boundLine] : []
+  if (bindings.length === 0 && boundLineIds.length === 0) return null
   const lineIds = new Set<string>()
   const nodeIds = new Set<string>()
   for (const b of bindings) {
@@ -31,7 +47,17 @@ export function agentOpsScope(agentId: string): { lineIds: string[], nodeIds: Se
     }
     catch { /* 节点刚被删等情况忽略 */ }
   }
-  return { lineIds: [...lineIds], nodeIds }
+  return { lineIds: [...lineIds], nodeIds, boundLineIds }
+}
+
+/** 读工具的可见产线全集 = 节点授权线 ∪ 频道绑定线(去重) */
+function readableLineIds(scope: { lineIds: string[], boundLineIds: string[] }): string[] {
+  return [...new Set([...scope.lineIds, ...scope.boundLineIds])]
+}
+
+/** 产线展示标注:仅频道绑定(非节点授权)的线标注只读来源 */
+function lineTag(lid: string, scope: { lineIds: string[], boundLineIds: string[] }): string {
+  return scope.lineIds.includes(lid) ? '' : '(频道绑定,只读)'
 }
 
 /** 配方参数的节点失效态(数据一致性展示/Agent 提示共用):null=正常 */
@@ -63,19 +89,20 @@ export async function toolOpsLog(agentId: string, args: {
   const audit = getOps()?.audit
   if (!audit) return { text: '审计仓储未装配(服务未就绪),请稍后重试。', isError: true }
   const scope = agentOpsScope(agentId)
-  if (!scope) return { text: '你尚未绑定任何工业节点,无日志可查(日志权限跟随节点绑定)。', isError: true }
+  if (!scope) return { text: '你尚未绑定任何工业节点,所在频道也未绑定产线,无日志可查(日志权限跟随节点绑定或频道绑线)。', isError: true }
   const nodeId = String(args.node_id ?? '').trim()
   const lineId = String(args.line_id ?? '').trim()
+  const readable = readableLineIds(scope)
   if (nodeId && !scope.nodeIds.has(nodeId))
     return { text: `无权查询节点 ${nodeId} 的日志(仅可查自己绑定的节点;用 my_industrial_nodes 查看绑定)。`, isError: true }
-  if (lineId && !scope.lineIds.includes(lineId))
-    return { text: `无权查询产线 ${lineId} 的日志(你的负责产线:${scope.lineIds.join(', ') || '(绑定节点均未分配产线)'})。`, isError: true }
+  if (lineId && !readable.includes(lineId))
+    return { text: `无权查询产线 ${lineId} 的日志(你的可读产线:${readable.join(', ') || '(无)'})。`, isError: true }
   const kind = String(args.kind ?? '').trim() || undefined
   const actorKind = String(args.actor_kind ?? '').trim() || undefined
   const mine = args.mine === true || args.mine === 'true'
   const { minutes, limit, from } = windowOf(args)
 
-  const lines = lineId ? [lineId] : scope.lineIds
+  const lines = lineId ? [lineId] : readable
   let rows = fanoutQuery(audit, lines, lid => ({ lineId: lid, kind, actorKind, actor: mine ? agentId : undefined, from, limit }))
   if (nodeId) rows = rows.filter(r => r.targetId === nodeId)
   rows.sort((a, b) => String(b.at).localeCompare(String(a.at)))
@@ -86,7 +113,7 @@ export async function toolOpsLog(agentId: string, args: {
     const src = OPS_ACTOR_LABEL[String(r.actorKind)] ?? String(r.actorKind)
     return `- [${fmtAuditAt(String(r.at))}] 来源=${src} 操作者=${String(r.actorName) || String(r.actor)} | ${String(r.action)} | ${String(r.summary)}`
   })
-  const scopeNote = lineId ? `产线 ${lineId}` : `负责产线 ${scope.lineIds.length} 条`
+  const scopeNote = lineId ? `产线 ${lineId}` : `可读产线 ${readable.length} 条`
   return {
     text: `运维日志(${scopeNote},近 ${minutes} 分钟,${rows.length} 条,新→旧):\n${body.join('\n')}\n\n说明:来源=Agent 的操作者格式为「Channel名/成员名」;需要节点级参数值变更史用 dcw_journal,配方下发/回退专门视图用 recipe_log。`,
   }
@@ -103,14 +130,15 @@ export async function toolRecipeLog(agentId: string, args: {
   const audit = getOps()?.audit
   if (!audit) return { text: '审计仓储未装配(服务未就绪),请稍后重试。', isError: true }
   const scope = agentOpsScope(agentId)
-  if (!scope) return { text: '你尚未绑定任何工业节点,无 Recipe 历史可查(权限跟随节点绑定)。', isError: true }
+  if (!scope) return { text: '你尚未绑定任何工业节点,所在频道也未绑定产线,无 Recipe 历史可查(权限跟随节点绑定或频道绑线)。', isError: true }
   const lineId = String(args.line_id ?? '').trim()
-  if (lineId && !scope.lineIds.includes(lineId))
-    return { text: `无权查询产线 ${lineId} 的 Recipe 历史(你的负责产线:${scope.lineIds.join(', ') || '(无)'})。`, isError: true }
+  const readable = readableLineIds(scope)
+  if (lineId && !readable.includes(lineId))
+    return { text: `无权查询产线 ${lineId} 的 Recipe 历史(你的可读产线:${readable.join(', ') || '(无)'})。`, isError: true }
   const recipeId = String(args.recipe_id ?? '').trim() || undefined
   const { minutes, limit, from } = windowOf(args)
 
-  const lines = lineId ? [lineId] : scope.lineIds
+  const lines = lineId ? [lineId] : readable
   const rows = fanoutQuery(audit, lines, lid => [
     { lineId: lid, kind: 'recipe', recipeId, from, limit },
     { lineId: lid, kind: 'rollback', recipeId, from, limit },
@@ -131,9 +159,8 @@ export async function toolRecipeLog(agentId: string, args: {
             : action
     return `- [${fmtAuditAt(String(r.at))}] ${tag} 来源=${src} 操作者=${String(r.actorName) || String(r.actor)} | ${String(r.summary)}${r.recipeId ? `(配方 ${String(r.recipeId).slice(0, 8)})` : ''}`
   })
-  return {
-    text: `Recipe 变更史(${lineId ? `产线 ${lineId}` : `负责产线 ${scope.lineIds.length} 条`},近 ${minutes} 分钟,${rows.length} 条,新→旧):\n${body.join('\n')}\n\n说明:配方下发=整批参数写命令;优化开窗=单次设定变更(含 Agent 假设);回退执行=已恢复基线值。节点级参数值逐笔历史用 dcw_journal(node_id)。`,
-  }
+  const text = `Recipe 变更史(${lineId ? `产线 ${lineId}` : `可读产线 ${readable.length} 条`},近 ${minutes} 分钟,${rows.length} 条,新→旧):\n${body.join('\n')}\n\n说明:配方下发=整批参数写命令;优化开窗=单次设定变更(含 Agent 假设);回退执行=已恢复基线值。节点级参数值逐笔历史用 dcw_journal(node_id)。`
+  return { text }
 }
 
 // ================================================================
@@ -145,11 +172,12 @@ export async function toolRecipeLog(agentId: string, args: {
  *  配方目标 vs PLC 当前值对照、lastGood 批次。 */
 export async function toolLineContext(agentId: string, args: { line_id?: string } = {}): Promise<{ text: string, isError?: boolean }> {
   const scope = agentOpsScope(agentId)
-  if (!scope) return { text: '你尚未绑定任何工业节点,暂无产线上下文(请先在数字孪生界面绑定节点)。' }
+  if (!scope) return { text: '你尚未绑定任何工业节点,所在频道也未绑定产线,暂无产线上下文(可在频道设置绑定产线获得只读上下文,或在数字孪生界面绑定节点)。' }
   const wanted = String(args.line_id ?? '').trim()
-  const lineIds = wanted ? [wanted] : scope.lineIds
-  if (wanted && !scope.lineIds.includes(wanted)) {
-    return { text: `产线 ${wanted} 不在你的负责范围(你绑定节点覆盖的产线:${scope.lineIds.join(', ') || '无'})。`, isError: true }
+  const readable = readableLineIds(scope)
+  const lineIds = wanted ? [wanted] : readable
+  if (wanted && !readable.includes(wanted)) {
+    return { text: `产线 ${wanted} 不在你的可读范围(节点授权与频道绑定覆盖:${readable.join(', ') || '无'})。`, isError: true }
   }
   if (lineIds.length === 0) return { text: '你绑定的节点均未分配产线(未挂线的节点没有产线/产品/配方上下文)。' }
 
@@ -159,7 +187,7 @@ export async function toolLineContext(agentId: string, args: { line_id?: string
     const run = getActiveLineRun(lid)
     const recipe = run?.recipeId ? getDcwController().listRecipes().find(r => r.id === run.recipeId) : undefined
     const parts: string[] = []
-    parts.push(`■ 产线 ${line?.name ?? lid}(${lid})· 状态:${run ? '运行中' : '待机/停线'}`)
+    parts.push(`■ 产线 ${line?.name ?? lid}(${lid})${lineTag(lid, scope)} · 状态:${run ? '运行中' : '待机/停线'}`)
     if (run) {
       parts.push(`  活动批次 ${run.runId.slice(0, 8)} · 产品「${run.productName}」(${run.productId}) · 开跑 ${run.startedAt.slice(11, 19)} · 已打标 ${run.taggedSamples} 样本`)
     }
@@ -210,7 +238,7 @@ export async function toolLineContext(agentId: string, args: { line_id?: string
     sections.push(parts.join('\n'))
   }
   return {
-    text: `你控制的产线全景(${sections.length} 条):\n\n${sections.join('\n\n')}\n\n说明:配方目标=开跑批次冻结的工艺窗口;PLC 当前值=实时读数。把验证过的最佳参数固化到配方用 recipe_update;回退配方到稳定版本用 recipe_rollback;逐节点参数变更史用 dcw_journal;配方版本史用 recipe_versions。`,
+    text: `你控制的产线全景(${sections.length} 条):\n\n${sections.join('\n\n')}\n\n说明:配方目标=开跑批次冻结的工艺窗口;PLC 当前值=实时读数;(频道绑定,只读)= 该线来自频道绑定的只读授权,可看日志/配方/状态,参数下发仍需节点授权。把验证过的最佳参数固化到配方用 recipe_update;回退配方到稳定版本用 recipe_rollback;逐节点参数变更史用 dcw_journal;配方版本史用 recipe_versions。`,
   }
 }
 
@@ -221,9 +249,11 @@ export async function toolRecipeVersions(agentId: string, args: { recipe_id?: st
   if (!recipeId) return { text: 'recipe_id 必填(line_context 可看到当前配方的 id)。', isError: true }
   const recipe = getDcwController().listRecipes().find(r => r.id === recipeId)
   if (!recipe) return { text: `配方 ${recipeId} 不存在。`, isError: true }
+  // 只读面:节点授权线 ∪ 频道绑定线均可看版本史(回退走 toolRecipeRollback 的写门)
   const scope = agentOpsScope(agentId)
-  if (!scope || !recipe.lineId || !scope.lineIds.includes(recipe.lineId)) {
-    return { text: `无权查看配方 ${recipeId} 的版本史(该配方不在你负责的产线上)。`, isError: true }
+  const readable = scope ? readableLineIds(scope) : []
+  if (!recipe.lineId || !readable.includes(recipe.lineId)) {
+    return { text: `无权查看配方 ${recipeId} 的版本史(该配方不在你可读的产线上)。`, isError: true }
   }
   const rows = getDcwController().recipeVersions(recipeId)
   const limit = Math.min(Number(args.limit) || 20, 50)
@@ -327,16 +357,19 @@ export async function toolRecipeUpdate(agentId: string, args: {
 }
 
 /** 工具:recipe_rollback —— 回退配方参数到稳定版本(指定历史版本或已知良好批次快照)。
- *  生成新版本(非破坏,历史保留);不改运行中 PLC 当前值。 */
+ *  生成新版本(非破坏,历史保留);不改运行中 PLC 当前值。
+ *  v19 dispatch=true = **统一回退**:定义回退 + 该版本参数整批重下发到 PLC(批次级恢复)。 */
 export async function toolRecipeRollback(agentId: string, args: {
   recipe_id?: string
   version?: number | string
   to_last_good?: boolean | string
+  dispatch?: boolean | string
   reason?: string
 }): Promise<{ text: string, isError?: boolean }> {
   const recipeId = String(args.recipe_id ?? '').trim()
   const reason = String(args.reason ?? '').trim()
   const toLastGood = args.to_last_good === true || args.to_last_good === 'true'
+  const dispatch = args.dispatch === true || args.dispatch === 'true'
   const version = Number(args.version)
   if (!recipeId) return { text: 'recipe_id 必填。', isError: true }
   if (!reason) return { text: 'reason 必填:回退必须说明原因(如优化翻车/越限),便于版本史追溯。', isError: true }
@@ -351,6 +384,20 @@ export async function toolRecipeRollback(agentId: string, args: {
     return { text: `不能回退到 v${version}(当前已是 v${recipe.version ?? 1};回退目标是更早的版本)。`, isError: true }
   }
   try {
+    if (dispatch) {
+      const { recipe: updated, run } = await getDcwController().rollbackRecipeAndDispatch(recipeId, {
+        version: toLastGood ? undefined : version,
+        toLastGood,
+        by: 'agent',
+        actorName: agentBadgeLabel(agentId),
+        actor: agentId,
+        description: reason,
+      })
+      const okN = run.results.filter(r => r.ok).length
+      return {
+        text: `统一回退完成:配方「${updated.name}」已生成 v${updated.version ?? 1},参数恢复为目标版本(${toLastGood ? '已知良好批次冻结' : `v${version}`}),并已整批重下发到 PLC(${okN}/${run.results.length} 参数成功);原因:${reason}。\n用 daq_query 复测确认恢复效果;版本史用 recipe_versions 复核。`,
+      }
+    }
     const updated = getDcwController().revertRecipe(recipeId, {
       version: toLastGood ? undefined : version,
       toLastGood,
@@ -361,10 +408,105 @@ export async function toolRecipeRollback(agentId: string, args: {
       description: reason,
     })
     return {
-      text: `回退完成:配方「${updated.name}」已生成 v${updated.version ?? 1},参数恢复为目标版本(${toLastGood ? '已知良好批次冻结' : `v${version}`});原因:${reason}。\n运行中批次不受影响(仍按开跑冻结参数);新参数下次开跑生效。版本史用 recipe_versions 复核。`,
+      text: `回退完成:配方「${updated.name}」已生成 v${updated.version ?? 1},参数恢复为目标版本(${toLastGood ? '已知良好批次冻结' : `v${version}`});原因:${reason}。\n注意:仅回退了配方定义,运行中 PLC 未变动;要把恢复参数写入产线(统一回退),用 recipe_rollback 并带 dispatch=true。版本史用 recipe_versions 复核。`,
     }
   }
   catch (err) {
     return { text: `回退失败:${err instanceof Error ? err.message : String(err)}`, isError: true }
   }
 }
+
+/** 工具:recipe_trial —— 多参数候选整批试验下发(v19 配方链路核心)。
+ *  候选值只覆盖列出节点(**必须是自己绑定的数控节点**);整批一次落产线,**不写配方版本** ——
+ *  复测判读:有进步/达标 → recipe_update 固化(同 id 版本+1);劣化 → recipe_rollback(dispatch=true) 统一回退。
+ *  受同线试验节拍卡控(默认 ≥5 分钟,防连发震荡);四层限界(量程∩参数∩产品)照常拦截。 */
+export async function toolRecipeTrial(agentId: string, args: {
+  recipe_id?: string
+  params?: Array<{ node_id?: string, value?: number | string }>
+  hypothesis?: string
+}): Promise<{ text: string, isError?: boolean }> {
+  const recipeId = String(args.recipe_id ?? '').trim()
+  const hypothesis = String(args.hypothesis ?? '').trim()
+  if (!recipeId) return { text: 'recipe_id 必填(line_context 可看到当前配方 id)。', isError: true }
+  if (!hypothesis) return { text: 'hypothesis 必填:试验必须声明依据(知识库条目/数据分析结论),便于审计追溯。', isError: true }
+  const list = (args.params ?? []).filter(p => p && String(p.node_id ?? '').trim() && Number.isFinite(Number(p.value)))
+    .map(p => ({ nodeId: String(p.node_id).trim(), value: Number(p.value) }))
+  if (list.length === 0) return { text: 'params 至少提供一条 {node_id, value}(value 必须为数字);试验的意义就是多参数一次整批改动。', isError: true }
+  const recipe = getDcwController().listRecipes().find(r => r.id === recipeId)
+  if (!recipe) return { text: `配方 ${recipeId} 不存在。`, isError: true }
+  const repo = getAgentNodeBindingRepo()
+  for (const p of list) {
+    const node = getDcwController().byId(p.nodeId)
+    if (!node) return { text: `节点 ${p.nodeId} 已删除,不能纳入试验。`, isError: true }
+    if (node.lineId !== recipe.lineId) return { text: `节点「${node.name}」不在配方「${recipe.name}」所在产线,不可混入试验。`, isError: true }
+    if (!node.enabled) return { text: `节点「${node.name}」已停用,试验被拒。`, isError: true }
+    if (!repo.find(agentId, p.nodeId, 'dcw')) {
+      return { text: `无权试验节点「${node.name}」(仅可改自己绑定的数控节点;缺授权找 lead 用 team_grant_nodes 授予)。`, isError: true }
+    }
+  }
+  try {
+    const run = await getDcwController().applyRecipe(recipeId, { overrides: list, trial: true })
+    const okN = run.results.filter(r => r.ok).length
+    // 批次级留痕:试验动作入审计(逐参数写已有 write-audit;这里是"一次试验"粒度)
+    try {
+      const { recordOps } = await import('../../ops/ops')
+      recordOps({
+        actor: agentId, actorName: agentBadgeLabel(agentId), actorKind: 'agent',
+        action: 'recipe.trial', kind: 'recipe', targetKind: 'recipe', targetId: recipeId, recipeId, lineId: recipe.lineId,
+        summary: `配方试验整批下发(${okN}/${run.results.length} 成功,批次 ${run.id.slice(0, 8)}):${list.map(p => `${p.nodeId.slice(0, 8)}→${p.value}`).join(';')} | 假设:${hypothesis}`,
+      })
+    }
+    catch { /* 审计失败不影响试验结果 */ }
+    const changed = run.results.map((r) => {
+      const node = r.nodeId ? getDcwController().byId(r.nodeId) : undefined
+      const reason = r.ok ? '' : `(${String(r.message).slice(0, 60)})`
+      return `${node?.name ?? r.templateRef}→${r.value}${node?.unit ?? ''}${r.ok ? '' : ` 被拒${reason}`}`
+    }).join(';')
+    return {
+      text: `试验已整批下发(${okN}/${run.results.length} 成功,批次 ${run.id.slice(0, 8)}):${changed}。假设:${hypothesis}。注意:本次试验**未写入配方版本** —— 等待工艺惯性后 daq_query 复测判读:有进步/达标 → recipe_update 把候选值固化进配方(同 id 版本+1);无进步/劣化 → recipe_rollback(recipe_id, dispatch=true, reason=…) 统一回退(定义回退+PLC 整批恢复)。`,
+    }
+  }
+  catch (err) {
+    return { text: `试验下发失败:${err instanceof Error ? err.message : String(err)}`, isError: true }
+  }
+}
+
+/** 工具:recipe_apply —— 把配方当前已固化参数整批下发到产线(改配方(recipe_update)之后用)。
+ *  与 recipe_trial 的区别:apply 下发的是**已固化版本**(无候选覆盖),用于"改配方 → 配方下发"链路的正式下发。 */
+export async function toolRecipeApply(agentId: string, args: {
+  recipe_id?: string
+  reason?: string
+}): Promise<{ text: string, isError?: boolean }> {
+  const recipeId = String(args.recipe_id ?? '').trim()
+  if (!recipeId) return { text: 'recipe_id 必填(line_context 可看到当前配方 id)。', isError: true }
+  const recipe = getDcwController().listRecipes().find(r => r.id === recipeId)
+  if (!recipe) return { text: `配方 ${recipeId} 不存在。`, isError: true }
+  const scope = agentOpsScope(agentId)
+  if (!scope || !recipe.lineId || !scope.lineIds.includes(recipe.lineId)) {
+    return { text: `无权下发配方 ${recipeId}(该配方不在你负责的产线上)。`, isError: true }
+  }
+  const boundInRecipe = getAgentNodeBindingRepo().byAgent(agentId)
+    .some(b => b.kind === 'dcw' && recipe.params.some(p => p.nodeId === b.nodeId))
+  if (!boundInRecipe) {
+    return { text: `无权下发配方 ${recipeId}(需持有该配方至少一个数控节点的授权;找 lead 用 team_grant_nodes 授予)。`, isError: true }
+  }
+  try {
+    const run = await getDcwController().applyRecipe(recipeId)
+    const okN = run.results.filter(r => r.ok).length
+    try {
+      const { recordOps } = await import('../../ops/ops')
+      recordOps({
+        actor: agentId, actorName: agentBadgeLabel(agentId), actorKind: 'agent',
+        action: 'recipe.apply', kind: 'recipe', targetKind: 'recipe', targetId: recipeId, recipeId, lineId: recipe.lineId,
+        summary: `Agent 整批下发配方 v${recipe.version ?? 1}(${okN}/${run.results.length} 参数成功,批次 ${run.id.slice(0, 8)})${args.reason ? ` | 原因:${String(args.reason).trim()}` : ''}`,
+      })
+    }
+    catch { /* 审计失败不影响下发结果 */ }
+    return {
+      text: `配方「${recipe.name}」v${recipe.version ?? 1} 已整批下发(${okN}/${run.results.length} 参数成功,批次 ${run.id.slice(0, 8)})。用 daq_query 复测确认工艺响应。`,
+    }
+  }
+  catch (err) {
+    return { text: `配方下发失败:${err instanceof Error ? err.message : String(err)}`, isError: true }
+  }
+}

package/server/services/workshop/agents/tool-classes.ts

@@ -27,4 +27,6 @@ export const HYBRID_TWIN_DIRECT_WRITE_TOOL_NAMES = new Set([
   'dcw_rollback',
   'recipe_update',
   'recipe_rollback',
+  'recipe_trial',
+  'recipe_apply',
 ])

package/server/services/workshop/aml/dataset-builder.ts

@@ -194,7 +194,9 @@ export async function buildDataset(spec: AmlDatasetSpec, by: { id: string, kind:
       continue
     }
 
-    // 公共网格:[max(t0), min(t1)];逐节点最近邻对齐,网格点缺失计 NaN
+    // 公共网格:[max(t0), min(t1)];逐节点最近邻对齐,网格点缺失计 NaN。
+    // 全节点查空(如该 run 采样缺失/时序库丢数)时 g0/g1 保持 ±Infinity,
+    // 必须按丢弃处理 —— 否则 steps=Infinity 会把网格循环推到 RangeError(500)。
     let g0 = -Infinity
     let g1 = Infinity
     for (const n of order) {
@@ -206,7 +208,7 @@ export async function buildDataset(spec: AmlDatasetSpec, by: { id: string, kind:
       g0 = Math.max(g0, first.at)
       g1 = Math.min(g1, last.at)
     }
-    const steps = g1 > g0 ? Math.floor((g1 - g0) / beat) + 1 : 0
+    const steps = Number.isFinite(g0) && Number.isFinite(g1) && g1 > g0 ? Math.floor((g1 - g0) / beat) + 1 : 0
     if (steps < spec.window.historySteps + spec.window.horizonSteps + 2) {
       runsDropped.push({ runId: run.id, reason: `有效网格 ${steps} 步不足一个窗口` })
       continue

package/server/services/workshop/aml/job-orchestrator/process.ts

@@ -96,5 +96,6 @@ export function handleProtocolLine(run: RunningJob, rawLine: string): void {
   }
   else if (evt.type === 'error' && evt.message) {
     pushLog(run, `[error] ${evt.message}`)
+    run.lastProtocolError = String(evt.message).slice(0, 300) // 结题失败原因优先用它(见 start-job 评估段)
   }
 }

package/server/services/workshop/aml/job-orchestrator/shared.ts

@@ -31,6 +31,8 @@ export interface RunningJob {
   logLines: string[]
   protocolBadLines: number
   killed: boolean
+  /** 最近一条 ##AML error 协议消息(评估器的人读失败原因走 stdout;stderr 尾常为空) */
+  lastProtocolError?: string
 }
 
 export interface OrchestratorState {

package/server/services/workshop/aml/job-orchestrator/start-job.ts

@@ -140,8 +140,11 @@ export async function startJob(row: AmlJobRow): Promise<void> {
     const exit2 = await runPython(run, vpy, [evalScript, '--job', join(jobDir, 'job.json')], jobDir)
     if (run.killed) return
     if (exit2.code !== 0) {
-      rt.repo.job.fail(row.id, 'failed', `评估失败:${lastErrLine(exit2.errTail)}(永久错误不重试)`, new Date().toISOString())
-      experimentFail(run, `评估失败:${lastErrLine(exit2.errTail)}`)
+      // 失败原因优先取评估器的 ##AML error 协议消息(如「test 切分为空…」,人读可操作);
+      // stderr 尾兜底 —— 评估器把错误走 stdout 协议行时 errTail 常为空,只给 "exit" 无从排查。
+      const reason = run.lastProtocolError || lastErrLine(exit2.errTail)
+      rt.repo.job.fail(row.id, 'failed', `评估失败:${reason}(永久错误不重试)`, new Date().toISOString())
+      experimentFail(run, `评估失败:${reason}`)
       finishRun(run)
       return
     }