agentworkshop 0.7.27 → 0.7.34

package/server/services/workshop/aml/model-registry.ts

@@ -0,0 +1,169 @@
+/**
+ * AML 模型注册表:实验/模型登记 + 阶段流转(candidate → shadow → production → retired)。
+ *
+ * 治理:
+ *  - 门禁全过的作业自动成为 candidate 实验并登记 candidate 模型(工件拷贝至 models/<id>/,不可变);
+ *  - shadow/production 晋升必须经 HITL(调用方负责发审批;此处只做 SQL 层条件流转兜底并发);
+ *  - 每 (product, recipe, purpose) 至多一个 production:晋升事务里同组旧 production 顺次 retired;
+ *  - 候选/退役工件 GC 由 retention 扫描处理(注册表行永留,artifacts_pruned 标记缺文件)。
+ */
+import { cpSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { AppError } from '../../../utils/errors'
+import { recordOps } from '../ops/ops'
+import { broadcastSceneEvent } from '../scene-events'
+import { getAmlRuntime } from './runtime'
+import type { AmlModelRow, AmlModelStage } from './aml.repo'
+import type { GateReport } from './gates'
+
+export type { AmlModelRow, AmlModelStage }
+
+/** 作业终态时登记:门禁过 → candidate 模型;未过 → 仅实验行(gates_failed) */
+export function registerModelFromJob(jobId: string, gates: GateReport, metricsJson: string): { experimentId: string, modelId?: string } {
+  const rt = getAmlRuntime()
+  const job = rt.repo.job.get(jobId)
+  if (!job) throw new AppError(404, 'AML_JOB_MISSING', `作业 ${jobId} 不存在`)
+  const dataset = rt.repo.dataset.get(job.datasetId)
+  if (!dataset) throw new AppError(404, 'AML_DATASET_MISSING', `数据集 ${job.datasetId} 不存在`)
+
+  const now = new Date().toISOString()
+  const budget = job.budget as {
+    seed?: number
+    params?: Record<string, unknown>
+    changeNote?: string
+    parentExperimentId?: string | null
+  }
+  const expId = `exp-${jobId.slice(4)}`
+  const existing = rt.repo.experiment.get(expId)
+  if (!existing) {
+    rt.repo.experiment.insert({
+      id: expId,
+      jobId,
+      datasetId: job.datasetId,
+      parentExperimentId: budget.parentExperimentId ?? null,
+      changeNote: budget.changeNote ?? '',
+      configJson: JSON.stringify({ purpose: job.purpose, params: budget.params ?? {}, agentId: job.agentId }),
+      seed: budget.seed ?? null,
+      createdAt: now,
+    })
+  }
+  rt.repo.experiment.setResult(
+    expId,
+    metricsJson,
+    JSON.stringify(gates),
+    gates.passed ? 'gates_passed' : 'gates_failed',
+  )
+  if (!gates.passed) return { experimentId: expId }
+
+  // 工件快照:artifacts → models/<modelId>/(不可变;注册表行指向这里)
+  const modelId = `mdl-${jobId.slice(4)}`
+  const modelDir = join(rt.modelsDir, modelId)
+  if (!existsSync(modelDir)) {
+    mkdirSync(modelDir, { recursive: true })
+    cpSync(join(job.artifactsPath ?? join(rt.jobsDir, jobId, 'artifacts')), modelDir, { recursive: true })
+    // io_spec 快照(预测服务的输入契约;norm 来自数据集 manifest,评估器已嵌入 metrics)
+    writeFileSync(join(modelDir, 'REGISTERED'), now)
+  }
+  const ioSpec = buildIoSpec(dataset.path, job.purpose)
+  rt.repo.model.insert({
+    id: modelId,
+    experimentId: expId,
+    datasetId: job.datasetId,
+    productId: dataset.productId,
+    recipeId: dataset.recipeId,
+    purpose: job.purpose,
+    ioSpecJson: JSON.stringify(ioSpec),
+    metricsJson,
+    path: modelDir,
+    createdBy: job.agentId || 'aml',
+    note: gatesSummary(gates),
+    createdAt: now,
+  })
+  recordOps({
+    actor: job.agentId || 'aml', actorName: job.agentId || 'AML', actorKind: job.agentId ? 'agent' : 'system',
+    action: 'aml.model.register', kind: 'system', summary: `候选模型 ${modelId} 登记(门禁通过)`,
+    targetKind: 'aml_model', targetId: modelId,
+    lineId: dataset.lineId, productId: dataset.productId, recipeId: dataset.recipeId,
+  })
+  return { experimentId: expId, modelId }
+}
+
+function gatesSummary(gates: GateReport): string {
+  return gates.checks.map(c => `${c.id}:${c.pass ? '✓' : '✗'}${c.value != null ? `(${typeof c.value === 'number' ? c.value.toFixed(3) : c.value})` : ''}`).join(' ')
+}
+
+/** io_spec:从数据集 manifest 提取(预测服务的装配契约) */
+function buildIoSpec(datasetPath: string, purpose: string): Record<string, unknown> {
+  const manifest = JSON.parse(readFileSync(join(datasetPath, 'manifest.json'), 'utf8')) as {
+    allNodes: string[]
+    controlNodes: string[]
+    targetNodes: string[]
+    shapes: { x: [number, number, number], u: [number, number, number], y: [number, number, number] }
+    norm: Record<string, { mean: number[], std: number[] }>
+    beatMs: number
+  }
+  return {
+    version: 1,
+    purpose,
+    modelInterface: 'one_step', // history[H,nAll](归一化) → y_next[nTgt](归一化)
+    historySteps: manifest.shapes.x[1],
+    horizonSteps: manifest.shapes.u[1],
+    allNodes: manifest.allNodes,
+    controlNodes: manifest.controlNodes,
+    targetNodes: manifest.targetNodes,
+    norm: manifest.norm,
+    beatMs: manifest.beatMs,
+    assumptions: 'rollout: control 取未来 U,feature 持最后观测(persistence),target 回填预测',
+  }
+}
+
+export function parseIoSpec(model: AmlModelRow): ReturnType<typeof buildIoSpec> {
+  return JSON.parse(model.ioSpecJson) as ReturnType<typeof buildIoSpec>
+}
+
+/**
+ * 阶段流转(HITL 批准后调用):
+ *  - candidate→shadow / shadow→production;production 晋升时同组旧 production 自动 retired。
+ *  - 返回流转结果;SQL 条件更新兜底并发(他人已流转则失败)。
+ */
+export function transitionModel(modelId: string, toStage: Exclude<AmlModelStage, 'candidate'>, by: string, byKind: 'user' | 'agent' = 'user'): { ok: boolean, from?: AmlModelStage, retiredId?: string } {
+  const rt = getAmlRuntime()
+  const model = rt.repo.model.get(modelId)
+  if (!model) throw new AppError(404, 'AML_MODEL_MISSING', `模型 ${modelId} 不存在`)
+  const now = new Date().toISOString()
+  const allowed: Record<string, AmlModelStage[]> = {
+    shadow: ['candidate'],
+    production: ['candidate', 'shadow'],
+    retired: ['candidate', 'shadow', 'production'],
+  }
+  const from = allowed[toStage]
+  if (!from?.includes(model.stage)) {
+    throw new AppError(409, 'AML_STAGE_ILLEGAL', `不允许 ${model.stage} → ${toStage}`)
+  }
+  if (!rt.repo.model.transition(modelId, model.stage, toStage, by, now)) {
+    throw new AppError(409, 'AML_STAGE_RACE', `模型已被并发流转(${model.stage} → ${toStage} 失败),请刷新后重试`)
+  }
+  let retiredId: string | undefined
+  if (toStage === 'production') {
+    // 同组旧 production 退役(新生产已生效,顺次让位;查询已排除本模型)
+    for (const old of rt.repo.model.list({ stage: 'production', productId: model.productId, recipeId: model.recipeId, limit: 50 })) {
+      if (old.id !== modelId && old.purpose === model.purpose) {
+        rt.repo.model.transition(old.id, 'production', 'retired', by, now)
+        retiredId = old.id
+      }
+    }
+  }
+  const dataset = rt.repo.dataset.get(model.datasetId)
+  recordOps({
+    actor: by, actorName: by, actorKind: byKind, action: 'aml.model.promote', kind: 'write',
+    summary: `模型 ${modelId}: ${model.stage} → ${toStage}${retiredId ? `(旧生产 ${retiredId} 退役)` : ''}`,
+    targetKind: 'aml_model', targetId: modelId,
+    lineId: dataset?.lineId, productId: model.productId, recipeId: model.recipeId,
+  })
+  // WS:阶段流转实时帧(带 lineId 享逐 peer 过滤)
+  broadcastSceneEvent('aml.model', {
+    op: 'promoted', modelId, stage: toStage, from: model.stage,
+    productId: model.productId, recipeId: model.recipeId, lineId: dataset?.lineId,
+  })
+  return { ok: true, from: model.stage, retiredId }
+}

package/server/services/workshop/aml/predictor.ts

@@ -0,0 +1,262 @@
+/**
+ * AML 预测服务:onnxruntime-node 懒加载(createRequire,optionalDependencies 缺失时
+ * 结构化报错)+ session LRU 缓存(上限 4)+ one-step/闭环滚动推理(与 aml_eval.py 同口径)。
+ */
+import { existsSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { createRequire } from 'node:module'
+import { AppError } from '../../../utils/errors'
+import { createLogger } from '../logger'
+import { getAmlRuntime } from './runtime'
+import { parseIoSpec } from './model-registry'
+
+const log = createLogger('aml.predict')
+
+/** onnxruntime InferenceSession.run 返回按输出名键控的对象(非数组) */
+interface OrtSession {
+  run(feeds: Record<string, unknown>): Promise<Record<string, unknown>>
+  inputNames: string[]
+  outputNames: string[]
+}
+interface OrtModule {
+  InferenceSession: {
+    create(path: string, opts?: { providers?: string[] }): Promise<{ run: (feeds: Record<string, unknown>) => Promise<Record<string, unknown>>, inputNames: string[], outputNames: string[] }>
+  }
+  Tensor: new (type: string, data: Float32Array, dims: number[]) => unknown
+}
+
+const g = globalThis as typeof globalThis & {
+  __amlOrt?: OrtModule | null
+  __amlSessions?: Map<string, { session: OrtSession, at: number }>
+}
+
+function loadOrt(): OrtModule | null {
+  if (g.__amlOrt !== undefined) return g.__amlOrt
+  try {
+    const require = createRequire(import.meta.url)
+    g.__amlOrt = require('onnxruntime-node') as OrtModule
+  }
+  catch (err) {
+    g.__amlOrt = null
+    log.warn(`[aml-predict] onnxruntime-node 不可用:${err instanceof Error ? err.message : String(err)}`)
+  }
+  return g.__amlOrt ?? null
+}
+
+export function predictorAvailable(): boolean {
+  return loadOrt() != null
+}
+
+async function sessionFor(modelPath: string, modelId: string): Promise<OrtSession> {
+  if (!g.__amlSessions) g.__amlSessions = new Map()
+  const cached = g.__amlSessions.get(modelId)
+  if (cached) {
+    cached.at = Date.now()
+    return cached.session
+  }
+  const ort = loadOrt()
+  if (!ort) {
+    throw new AppError(503, 'AML_PREDICTOR_UNAVAILABLE', '预测服务依赖 onnxruntime-node 未安装:执行 pnpm install(可选依赖)后重启')
+  }
+  const created = await ort.InferenceSession.create(modelPath, { providers: ['CPUExecutionProvider'] })
+  // LRU 上限 4:超出驱逐最旧
+  if (g.__amlSessions.size >= 4) {
+    const oldest = [...g.__amlSessions.entries()].sort((a, b) => a[1].at - b[1].at)[0]
+    if (oldest) g.__amlSessions.delete(oldest[0])
+  }
+  g.__amlSessions.set(modelId, { session: created as unknown as OrtSession, at: Date.now() })
+  return created as unknown as OrtSession
+}
+
+export interface IoSpec {
+  version: number
+  purpose: string
+  modelInterface: string
+  historySteps: number
+  horizonSteps: number
+  allNodes: string[]
+  controlNodes: string[]
+  targetNodes: string[]
+  norm: { x: { mean: number[], std: number[] }, u: { mean: number[], std: number[] }, y: { mean: number[], std: number[] } }
+  beatMs: number
+  assumptions: string
+}
+
+export interface PredictRequest {
+  /** 历史(原始物理量):[historySteps][nAllNodes],顺序 = io_spec.allNodes */
+  history: number[][]
+  /** 未来控制轨迹(原始物理量):[≤horizonSteps][nControlNodes];缺省 = 持最后观测 */
+  controls?: number[][]
+  /** 滚动步数(≤horizonSteps;缺省 = horizonSteps) */
+  steps?: number
+}
+
+export interface PredictResult {
+  modelId: string
+  stage: string
+  targetNodes: string[]
+  /** 原始物理量预测:[steps][nTargetNodes] */
+  forecast: number[][]
+  beatMs: number
+  assumptions: string
+}
+
+/** 单模型推理(内部):historyRaw [H][nAll] → 逐步滚动 steps 步 */
+export async function predictWithModel(
+  modelId: string,
+  req: PredictRequest,
+): Promise<PredictResult> {
+  const rt = getAmlRuntime()
+  const row = rt.repo.model.get(modelId)
+  if (!row) throw new AppError(404, 'AML_MODEL_MISSING', `模型 ${modelId} 不存在`)
+  if (existsSync(join(row.path, 'STUB'))) {
+    throw new AppError(409, 'AML_STUB_MODEL', '该模型为存根作业产物(AML_STUB),不含真实权重,不可用于预测')
+  }
+  if (row.artifactsPruned || !existsSync(join(row.path, 'model.onnx'))) {
+    throw new AppError(410, 'AML_ARTIFACT_MISSING', `模型 ${modelId} 工件已被 GC 清理(artifacts_pruned),请用同配方数据重训`)
+  }
+  const io = parseIoSpec(row) as unknown as IoSpec
+  if (io.modelInterface !== 'one_step') {
+    throw new AppError(500, 'AML_IO_UNSUPPORTED', `未知模型接口 ${io.modelInterface}`)
+  }
+  const H = io.historySteps
+  const nAll = io.allNodes.length
+  const nCtrl = io.controlNodes.length
+  const steps = Math.max(1, Math.min(req.steps ?? io.horizonSteps, io.horizonSteps))
+
+  if (!Array.isArray(req.history) || req.history.length !== H || req.history.some(r => !Array.isArray(r) || r.length !== nAll)) {
+    throw new AppError(422, 'AML_INPUT_SHAPE', `history 形状须为 [${H}][${nAll}](节点顺序 = allNodes):${io.allNodes.join(',')}`)
+  }
+
+  const sess = await sessionFor(join(row.path, 'model.onnx'), row.id)
+  const mx = io.norm.x.mean
+  const sx = io.norm.x.std
+  const my = io.norm.y.mean
+  const sy = io.norm.y.std
+
+  // 归一化历史(norm 统计来自 train 切分,列数与 allNodes 对齐;越界兜底恒等变换)
+  const hist: number[][] = req.history.map(r => r.map((v, j) => (v - (mx[j] ?? 0)) / (sx[j] ?? 1)))
+  const lastHist = hist[hist.length - 1] ?? []
+  // 控制轨迹(统一为归一化形态):显式提供 raw 值 → 用 u 统计归一化;
+  // 缺省 = 历史最后观测的 control 值持稳(取 hist 中的归一化值,勿再归一化)
+  const ctrlIndex = io.allNodes.map((n, j) => (io.controlNodes.includes(n) ? j : -1)).filter(j => j >= 0)
+  const lastCtrlNorm = ctrlIndex.map(j => lastHist[j] ?? 0)
+  const ctrlRows: number[][] = []
+  for (let k = 0; k < steps; k++) {
+    const provided = req.controls?.[k]
+    if (provided && provided.length === nCtrl) {
+      ctrlRows.push(provided.map((v, j) => (v - (io.norm.u.mean[j] ?? 0)) / (io.norm.u.std[j] ?? 1)))
+    }
+    else {
+      ctrlRows.push([...lastCtrlNorm])
+    }
+  }
+
+  const forecast: number[][] = []
+  for (let k = 0; k < steps; k++) {
+    const input = hist.slice(hist.length - H).map(r => Float32Array.from(r))
+    const flat = new Float32Array(H * nAll)
+    for (let i = 0; i < H; i++) {
+      input[i]?.forEach((v, j) => {
+        flat[i * nAll + j] = v
+      })
+    }
+    const ort = loadOrt()
+    if (!ort) throw new AppError(503, 'AML_PREDICTOR_UNAVAILABLE', '预测服务依赖 onnxruntime-node 未安装:执行 pnpm install(可选依赖)后重启')
+    const inpName = sess.inputNames[0]
+    if (!inpName) throw new AppError(503, 'AML_PREDICTOR_UNAVAILABLE', `模型 ${row.id} 的 ONNX session 无有效输入名`)
+    const outName = sess.outputNames[0] ?? inpName
+    const out = await sess.run({ [inpName]: new ort.Tensor('float32', flat, [1, H, nAll]) })
+    const yNext = Array.from((out[outName] as { data: ArrayLike<number> }).data) as number[] // [nTgt] 归一化
+    // 组装下一行
+    const rowNext = new Array<number>(nAll).fill(0)
+    // feature 持最后观测;persistence
+    for (let j = 0; j < nAll; j++) rowNext[j] = lastHist[j] ?? 0
+    ctrlIndex.forEach((j, c) => {
+      rowNext[j] = ctrlRows[k]?.[c] ?? (lastCtrlNorm[c] ?? 0)
+    })
+    io.targetNodes.forEach((_, t) => {
+      const tn = io.targetNodes[t]
+      if (tn !== undefined) rowNext[io.allNodes.indexOf(tn)] = yNext[t] ?? 0
+    })
+    hist.push(rowNext)
+    forecast.push(yNext.map((v, t) => v * (sy[t] ?? 1) + (my[t] ?? 0)))
+  }
+
+  return {
+    modelId: row.id,
+    stage: row.stage,
+    targetNodes: io.targetNodes,
+    forecast,
+    beatMs: io.beatMs,
+    assumptions: io.assumptions,
+  }
+}
+
+/** 便捷入口:找 production 模型(product/recipe/purpose)→ 预测 */
+export async function predictProduction(
+  productId: string,
+  recipeId: string,
+  purpose: string,
+  req: PredictRequest,
+): Promise<PredictResult> {
+  const rt = getAmlRuntime()
+  const m = rt.repo.model.productionOf(productId, recipeId, purpose)
+  if (!m) {
+    throw new AppError(404, 'AML_NO_PRODUCTION_MODEL', `配方 ${recipeId} 尚无 ${purpose} 生产模型:先训练并通过门禁,再经 HITL 晋升 production`)
+  }
+  return predictWithModel(m.id, req)
+}
+
+/** 注册时深检:ONNX 可加载 + 试推理形状正确(异步,REST 注册/晋升前调用) */
+export async function verifyModelArtifact(modelId: string): Promise<{ ok: boolean, detail: string }> {
+  const rt = getAmlRuntime()
+  const row = rt.repo.model.get(modelId)
+  if (!row) return { ok: false, detail: '模型不存在' }
+  if (!predictorAvailable()) return { ok: false, detail: 'onnxruntime-node 不可用' }
+  try {
+    const io = parseIoSpec(row) as unknown as IoSpec
+    const sess = await sessionFor(join(row.path, 'model.onnx'), row.id)
+    const H = io.historySteps
+    const nAll = io.allNodes.length
+    const flat = new Float32Array(H * nAll)
+    const ort = loadOrt()
+    if (!ort) throw new AppError(503, 'AML_PREDICTOR_UNAVAILABLE', '预测服务依赖 onnxruntime-node 未安装:执行 pnpm install(可选依赖)后重启')
+    const inpName = sess.inputNames[0]
+    if (!inpName) throw new AppError(503, 'AML_PREDICTOR_UNAVAILABLE', `模型 ${row.id} 的 ONNX session 无有效输入名`)
+    const outName = sess.outputNames[0] ?? inpName
+    const out = await sess.run({ [inpName]: new ort.Tensor('float32', flat, [1, H, nAll]) })
+    const y = (out[outName] as { data: ArrayLike<number> }).data
+    const expect = io.targetNodes.length
+    if (Array.from(y).length !== expect) {
+      return { ok: false, detail: `输出维度 ${Array.from(y).length} ≠ target 数 ${expect}` }
+    }
+    return { ok: true, detail: '试推理通过' }
+  }
+  catch (err) {
+    return { ok: false, detail: `加载/推理失败:${err instanceof Error ? err.message : String(err)}` }
+  }
+}
+
+/** 供工具层:最近窗口组装(history 取自传入原始行,不做 DAQ 查询 —— 查询在工具层完成) */
+export function readIoSpecFor(modelId: string): IoSpec {
+  const rt = getAmlRuntime()
+  const row = rt.repo.model.get(modelId)
+  if (!row) throw new AppError(404, 'AML_MODEL_MISSING', `模型 ${modelId} 不存在`)
+  return parseIoSpec(row) as unknown as IoSpec
+}
+
+export function metricsOf(modelId: string): Record<string, unknown> {
+  const rt = getAmlRuntime()
+  const row = rt.repo.model.get(modelId)
+  if (!row) throw new AppError(404, 'AML_MODEL_MISSING', `模型 ${modelId} 不存在`)
+  try {
+    return JSON.parse(row.metricsJson)
+  }
+  catch { return {} }
+}
+
+export function artifactReadmeOf(modelPath: string): string | null {
+  const p = join(modelPath, 'REGISTERED')
+  return existsSync(p) ? readFileSync(p, 'utf8') : null
+}

package/server/services/workshop/aml/python/aml_eval.py

@@ -0,0 +1,171 @@
+# -*- coding: utf-8 -*-
+"""
+AML 权威评估器(平台代码,独立于训练进程):
+  加载数据集 + artifacts/model.onnx → one-step(val/test)+ horizon 闭环滚动(test)
+  → 反归一化计算 NRMSE/RMSE/MAE → 合并写 metrics.json → 协议行输出。
+
+权威指标在这里统一计算,不采信 Agent 训练代码的自报(平台信任边界)。
+训练进程(workspace/train.py)先行独立运行;本评估器是流水线第二拍。
+
+用法: aml_eval.py --job <job.json>
+退出码: 0 成功(metrics.json 权威段就绪);1 失败(含 test 切分为空/模型不可加载)。
+"""
+import argparse
+import json
+import os
+import sys
+import traceback
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))  # amlkit 与本文件同目录
+
+JOB_DIR = Path(os.environ.get("AML_JOB_DIR", "")).resolve()
+ARTIFACTS = JOB_DIR / "artifacts"
+
+
+def emit(obj):
+    sys.stdout.write("##AML " + json.dumps(obj, ensure_ascii=False) + "\n")
+    sys.stdout.flush()
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--job", required=True)
+    args = ap.parse_args()
+    job = json.loads(Path(args.job).read_text(encoding="utf-8"))
+
+    import numpy as np
+    import amlkit
+
+    emit({"type": "stage", "stage": "evaluating"})
+    bundle = amlkit.load_bundle(job["datasetPath"])
+    manifest = bundle.manifest
+    n_all = manifest["shapes"]["x"][2]
+    n_tgt = manifest["shapes"]["y"][2]
+    h_steps = manifest["shapes"]["x"][1]
+    horizon = manifest["shapes"]["u"][1]
+
+    model_path = ARTIFACTS / "model.onnx"
+    if not model_path.is_file():
+        emit({"type": "error", "message": "训练完成但未产出 artifacts/model.onnx(须调用 amlkit.export_torch_onnx 或自行按契约导出)"})
+        return 1
+
+    import onnxruntime as ort
+
+    sess = ort.InferenceSession(str(model_path), providers=["CPUExecutionProvider"])
+    inp_name = sess.get_inputs()[0].name
+
+    def predict_next(hist_norm):
+        out = sess.run(None, {inp_name: hist_norm.astype(np.float32)[None, ...]})[0]
+        return np.asarray(out[0], dtype=np.float64)  # [n_tgt] 归一化
+
+    def denorm_targets(y_norm):
+        mean = np.array(manifest["norm"]["y"]["mean"], dtype=np.float64)
+        std = np.array(manifest["norm"]["y"]["std"], dtype=np.float64)
+        return y_norm * std + mean
+
+    def eval_one_step(split_name, max_windows=2000):
+        x = bundle.get("x", split_name)
+        y = bundle.get("y", split_name)
+        if x.shape[0] == 0:
+            return None
+        idx = np.linspace(0, x.shape[0] - 1, min(max_windows, x.shape[0])).astype(int)
+        preds = []
+        truths = []
+        for i in idx:
+            preds.append(predict_next(x[i]))
+            truths.append(y[i][0])
+        preds = np.array(preds)
+        truths = np.array(truths)
+        p_raw = denorm_targets(preds)
+        t_raw = denorm_targets(truths)
+        per_target = []
+        # NRMSE 分母 = train 切分的目标 std(manifest 归一化统计,固定口径):
+        # 用 test 切分局部 std 会在"整批 settle 后近常量"的切片上把指标放大数十倍,
+        # 且同一模型跨切分不可比。与 rollout 指标同口径。
+        train_y_std = np.array(manifest["norm"]["y"]["std"], dtype=np.float64)
+        for j in range(n_tgt):
+            rmse = float(np.sqrt(np.mean((p_raw[:, j] - t_raw[:, j]) ** 2)))
+            std = float(train_y_std[j]) or 1e-9
+            per_target.append({
+                "rmse": rmse,
+                "mae": float(np.mean(np.abs(p_raw[:, j] - t_raw[:, j]))),
+                "nrmse": rmse / std,
+            })
+        return {
+            "windows": int(idx.size),
+            "nrmse": float(np.mean([d["nrmse"] for d in per_target])),
+            "perTarget": per_target,
+        }
+
+    # 闭环滚动:预测回填 target 列;control 列取未来 U;feature 列持最后观测(persistence)
+    ctrl_positions = [manifest["allNodes"].index(cid) for cid in manifest["controlNodes"]]
+    tgt_positions = [manifest["allNodes"].index(tid) for tid in manifest["targetNodes"]]
+    feat_positions = [p for p in range(n_all) if p not in ctrl_positions and p not in tgt_positions]
+
+    def eval_rollout(max_windows=500):
+        x = bundle.get("x", "test")
+        u = bundle.get("u", "test")
+        y = bundle.get("y", "test")
+        if x.shape[0] == 0:
+            return None
+        idx = np.linspace(0, x.shape[0] - 1, min(max_windows, x.shape[0])).astype(int)
+        errs = np.zeros(n_tgt)
+        count = 0
+        for i in idx:
+            hist = x[i].copy()  # [H, n_all] 归一化
+            for k in range(horizon):
+                nxt = predict_next(hist[-h_steps:])
+                row = np.zeros(n_all, dtype=np.float64)
+                row[feat_positions] = hist[-1][feat_positions]
+                for cp, uv in zip(ctrl_positions, u[i][k]):
+                    row[cp] = uv
+                for tp, yv in zip(tgt_positions, nxt):
+                    row[tp] = yv
+                hist = np.vstack([hist, row[None, :]])
+                truth_k = y[i][k]
+                errs += (nxt - truth_k) ** 2
+                count += 1
+        # 逐 (窗口, 步) 平方误差均值 → 逐步 RMSE(与预测服务逐拍输出同口径)
+        rmse_norm = np.sqrt(errs / max(1, count))
+        std = np.array(manifest["norm"]["y"]["std"], dtype=np.float64)
+        nrmse = float(np.mean(rmse_norm / std))
+        return {"windows": int(idx.size), "horizon": horizon, "nrmse": nrmse}
+
+    ev_val = eval_one_step("val")
+    ev_test = eval_one_step("test")
+    ev_roll = eval_rollout()
+    if ev_test is None:
+        emit({"type": "error", "message": "test 切分为空(byRun 切分后无测试批次),无法评估"})
+        return 1
+
+    platform_metrics = {"platform": {
+        "oneStepVal": ev_val,
+        "oneStepTest": ev_test,
+        "rolloutTest": ev_roll,
+        "ioSpec": {
+            "historySteps": h_steps,
+            "horizonSteps": horizon,
+            "allNodes": manifest["allNodes"],
+            "controlNodes": manifest["controlNodes"],
+            "targetNodes": manifest["targetNodes"],
+            "norm": manifest["norm"],
+            "assumptions": "rollout: control 取未来 U,feature 持最后观测(persistence),target 回填预测",
+        },
+    }}
+    merged = amlkit.save_metrics(platform_metrics)
+    emit({"type": "metrics", "metrics": {"platform": platform_metrics["platform"], "agent": {
+        k: v for k, v in merged.items() if k != "platform"}}})
+    emit({"type": "done"})
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main())
+    except SystemExit:
+        raise
+    except Exception as e:  # noqa: BLE001 - 评估器顶层兜底:失败必须带回信息而非裸崩
+        emit({"type": "error", "message": "评估器异常:%s" % e})
+        traceback.print_exc()
+        sys.exit(1)