agentworkshop 0.7.70 → 0.8.0

package/server/services/workshop/optimization/manager.ts

@@ -0,0 +1,315 @@
+/* eslint-disable @stylistic/max-statements-per-line */
+/**
+ * Optimizer Manager(G3 编排):resolve → build → solve → verify → persist → recommend。
+ *
+ * 边界:
+ *  - Worker 不读生产数据库、不持设备凭据;只接受已注册模型的 ProblemIR;
+ *  - Solver 成功仍独立复算约束与有效域(A4);代价以同一 ProblemIR 重算;
+ *  - 首版只产生建议(recommendation),不打开设备写权限。
+ */
+import { existsSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { AppError } from '../../../utils/errors'
+import { getAmlRuntime } from '../aml/runtime'
+import { getProcessModelSpecRepo } from '../process-model/spec.repo'
+import { parseProcessModelSpec } from '../process-model/spec'
+import { assertArxArtifactCurrent } from '../process-model/artifact-validation'
+import { getRuntimeContext, type ContextSnapshot } from '../process-model/context'
+import { getEligibilityRepo } from '../process-model/eligibility'
+import { getDcwLineRepo } from '../dcw/dcw-line.repo'
+import type { ProcessModelSpec } from '../process-model/contracts'
+import { buildProblemIR, constraintReport, evaluateCandidateCost, type LinearStateSpaceLike, type ModelArtifact, type StaticResponseLike } from './problem-builder'
+import type { Recommendation, SolveCandidate, SolveResult, SolveStatus } from './contracts'
+import { getProfileRepo, parseProfileRow } from './profile.repo'
+import { resolveBinding, type ResolvedBinding } from './binding.service'
+import { getRunRepo } from './run.repo'
+import { getSolverWorkerPool } from './worker-client'
+import { assertRecommendationUsable, createRecommendation } from './recommendation.service'
+import { inputDistance, isUqFresh, type ArtifactUq, type RecommendationUqEvidence } from './uq-evidence'
+import { deriveDualState } from './crosscheck.service'
+import { isRuntimeConditionChanged } from '../process-model/conditions'
+
+export interface SolveRequest {
+  bindingId?: string
+  /** 请求级超时(默认取配置) */
+  timeoutMs?: number
+}
+
+export interface SolveOutcome {
+  runId: string
+  bindingId: string
+  profileVersion: string
+  result: SolveResult
+  recommendation: Recommendation | null
+  context: Pick<ContextSnapshot, 'capturedAt' | 'eventAsOf' | 'availabilityWatermark' | 'conditionId'>
+}
+
+interface WorkerSolvePayload {
+  status: SolveStatus
+  controls?: number[][]
+  predicted?: number[][]
+  cost?: number
+  iterations?: number
+  backend?: string
+  solverVersion?: string
+  message?: string
+}
+
+function db() { return getAmlRuntime().db }
+
+function loadSpec(ref: string): ProcessModelSpec {
+  const [id, versionText] = ref.split('@')
+  if (!id) throw new AppError(422, 'PROFILE_SPEC_MISSING', 'Profile 未引用 ProcessModelSpec(processSpecRef 为空)')
+  const row = getProcessModelSpecRepo().get(id, versionText ? Number(versionText) : undefined)
+  if (!row) throw new AppError(404, 'SPEC_NOT_FOUND', `ProcessModelSpec ${ref} 不存在`)
+  return parseProcessModelSpec(JSON.parse(row.specJson))
+}
+
+function loadArtifact(modelId: string, expectedHash: string): { artifact: ModelArtifact, artifactHash: string } {
+  const row = db().prepare('SELECT path, artifact_kind AS kind, artifact_hash AS hash, artifacts_pruned AS pruned, stage, dataset_id AS datasetId FROM aml_models WHERE id = ?').get(modelId) as { path: string, kind: string, hash: string, pruned: number, stage: string, datasetId?: string | null } | undefined
+  if (!row) throw new AppError(404, 'MODEL_NOT_FOUND', `模型 ${modelId} 不存在`)
+  if (row.pruned) throw new AppError(410, 'MODEL_ARTIFACT_PRUNED', `模型 ${modelId} 工件已被保留策略清理;重新训练后再求解`)
+  // D18 谱系门:训练数据 lineage_verified=0(旧/未核验/无 confirmed segment)→ 禁止数值求解。
+  // Twin/shadow 不受限;重新走 builder 建 confirmed segment 数据集并重训即可解除。
+  if (row.datasetId) {
+    const lineage = db().prepare('SELECT lineage_verified AS v FROM aml_datasets WHERE id = ?').get(row.datasetId) as { v: number } | undefined
+    if (lineage && lineage.v !== 1) {
+      throw new AppError(422, 'LEGACY_MODEL_REQUIRES_RETRAIN',
+        `模型 ${modelId} 的训练数据集 ${row.datasetId} 谱系未核验(lineage_verified=0);请基于已确认工况段重建数据集并重训`)
+    }
+  }
+  const kind = row.kind || ''
+  if (kind !== 'linear_state_space@1' && kind !== 'static_response@1') {
+    throw new AppError(422, 'UNSUPPORTED_ARTIFACT', `模型 ${modelId} 工件类型 ${kind || 'legacy'} 不能用于数值求解(需要 linear_state_space@1 / static_response@1)`)
+  }
+  const path = join(row.path, 'model.json')
+  if (!existsSync(path)) throw new AppError(410, 'MODEL_ARTIFACT_MISSING', `模型工件 ${path} 缺失`)
+  const artifact = JSON.parse(readFileSync(path, 'utf8')) as ModelArtifact
+  if (artifact.kind !== kind) throw new AppError(409, 'MODEL_ARTIFACT_MISMATCH', `工件 kind=${artifact.kind} 与注册类型 ${kind} 不一致`)
+  assertArxArtifactCurrent(artifact, modelId)
+  if (expectedHash && row.hash && expectedHash !== row.hash) {
+    throw new AppError(409, 'BINDING_STALE', `Profile 冻结的工件 hash 与当前模型不一致(模型已替换);请重新发布 Profile`)
+  }
+  return { artifact, artifactHash: row.hash }
+}
+
+export async function solve(agentId: string, req: SolveRequest = {}): Promise<SolveOutcome> {
+  const resolved: ResolvedBinding = resolveBinding(agentId, req.bindingId)
+  try {
+    const profileRow = getProfileRepo().get(resolved.profileId, resolved.profileVersion)
+    if (!profileRow) throw new AppError(404, 'PROFILE_NOT_FOUND', `Profile ${resolved.profileId}@${resolved.profileVersion} 不存在`)
+    if (profileRow.status === 'retired') throw new AppError(409, 'PROFILE_RETIRED', `Profile ${profileRow.id}@${profileRow.version} 已退役`)
+    const profile = parseProfileRow(profileRow)
+    const spec = loadSpec(profile.processSpecRef)
+    const { artifact, artifactHash } = loadArtifact(profile.modelRef.modelId, profile.modelRef.artifactHash)
+
+    // 资格:必须存在通过的 optimizationEligible(A2/A3)。
+    // D20 精确谱系:资格按"模型的训练数据集"查询;模型无数据集谱系(已被 D18 门拦截,双保险)才回退 latest。
+    // 作用域必须与产线性质一致:模拟资格不能授权真实线,反之亦然。
+    const modelDatasetId = (db().prepare('SELECT dataset_id AS d FROM aml_models WHERE id = ?').get(profile.modelRef.modelId) as { d?: string | null } | undefined)?.d ?? ''
+    const eligibility = modelDatasetId
+      ? (getEligibilityRepo().latestForDataset(spec.id, modelDatasetId) ?? getEligibilityRepo().latest(spec.id))
+      : getEligibilityRepo().latest(spec.id)
+    const line = getDcwLineRepo().byId(spec.lineId)
+    if (!line) throw new AppError(404, 'LINE_NOT_FOUND', `产线 ${spec.lineId} 不存在`)
+    if (eligibility?.scope === 'simulation' && line.simulated !== true) {
+      throw new AppError(422, 'ELIGIBILITY_SCOPE_MISMATCH', '该资格报告来自模拟作用域,不能用于真实产线求解')
+    }
+    if (line.simulated !== true && eligibility && eligibility.scope !== 'real') {
+      throw new AppError(422, 'ELIGIBILITY_SCOPE_MISMATCH', '真实产线求解需要 real 作用域资格报告')
+    }
+    if (line.simulated === true && eligibility && eligibility.scope !== 'simulation') {
+      throw new AppError(422, 'ELIGIBILITY_SCOPE_MISMATCH', '模拟产线求解只接受 simulation 作用域资格报告')
+    }
+    if (!eligibility || !eligibility.optimizationEligible) {
+      const gaps = eligibility?.gaps.map(g => `${g.code}:${g.message}`).join('; ') ?? '尚无资格报告'
+      throw new AppError(422, 'OPTIMIZATION_NOT_ELIGIBLE', `不具备优化资格:${gaps}`)
+    }
+    if (profile.conditionIds.length && eligibility && !profile.conditionIds.includes(eligibility.conditionId)) {
+      throw new AppError(422, 'CONDITION_NOT_ALLOWED', `Profile 不允许工况 ${eligibility.conditionId}`)
+    }
+
+    const context = await getRuntimeContext(spec)
+    context.evidenceSource = eligibility?.scope ?? 'unassessed'
+    if (await isRuntimeConditionChanged(spec, context)) {
+      getRunRepo().expireWhere({ bindingId: resolved.binding.id })
+      throw new AppError(409, 'CONDITION_CHANGED', '运行工况/配方版本已变化;旧 Profile 计划失效,请重新装配')
+    }
+    const ir = buildProblemIR({ profile, spec, artifact: artifact as LinearStateSpaceLike | StaticResponseLike, context, runId: '' })
+    if (profile.problemIrHash && profile.problemIrHash !== ir.hash) {
+      throw new AppError(409, 'PROBLEM_IR_CHANGED', `问题结构 hash 与发布时冻结值不一致(profile=${profile.problemIrHash.slice(0, 12)}, now=${ir.hash.slice(0, 12)})`)
+    }
+
+    const runId = `orun-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 7)}`
+    const startedAt = new Date().toISOString()
+    getRunRepo().insertRun({
+      id: runId, bindingId: resolved.binding.id, bindingRevision: resolved.binding.revision,
+      profileId: profile.id, profileVersion: profile.version, ir, context, startedAt,
+    })
+
+    const pool = getSolverWorkerPool()
+    let payload: WorkerSolvePayload
+    let elapsedMs = 0
+    let workerPid: number | undefined
+    try {
+      // 用 runId 作 Worker 请求 ID,取消才能命中(worker-client 按 reqId 匹配)
+      const solved = await pool.solve(ir, { timeoutMs: req.timeoutMs, requestId: runId })
+      payload = solved.result as WorkerSolvePayload
+      elapsedMs = solved.elapsedMs
+      workerPid = solved.workerPid
+    }
+    catch (err) {
+      const code = err instanceof AppError ? err.code : ''
+      const message = err instanceof Error ? err.message : String(err)
+      const status: SolveStatus = code === 'SOLVE_TIMEOUT' ? 'timeout' : code === 'WORKER_INTERRUPTED' ? 'numerical_error' : code === 'ENV_MISSING_DEP' ? 'unsupported' : 'numerical_error'
+      const failed: SolveResult = {
+        runId, status, candidates: [], firstMove: null, independentCost: null,
+        diagnostics: { backend: 'worker', solverVersion: 'unknown', elapsedMs, problemIrHash: ir.hash, message, workerPid },
+        createdAt: new Date().toISOString(),
+      }
+      getRunRepo().finishRun(runId, failed)
+      return { runId, bindingId: resolved.binding.id, profileVersion: resolved.binding.profileVersion, result: failed, recommendation: null, context: pick(context) }
+    }
+
+    const candidates: SolveCandidate[] = []
+    if (payload.controls && payload.predicted) {
+      const candidate: SolveCandidate = {
+        seq: 0,
+        controls: payload.controls,
+        predicted: payload.predicted,
+        cost: Number(payload.cost ?? 0),
+        constraints: [],
+        feasible: true,
+      }
+      candidate.constraints = constraintReport(ir, candidate)
+      candidate.feasible = candidate.constraints.every(c => c.satisfied)
+      // 独立代价重算(A4):Solver 自报代价与平台重算必须一致
+      candidate.cost = evaluateCandidateCost(ir, candidate)
+      candidates.push(candidate)
+    }
+    const independentCost = candidates[0]?.cost ?? null
+    const solverCost = Number(payload.cost ?? Number.NaN)
+    const costMismatch = Number.isFinite(solverCost) && independentCost != null && Math.abs(solverCost - independentCost) > 1e-6 * Math.max(1, Math.abs(independentCost))
+    // 取消/超时竞争:终态已由 cancel() 落定 → 丢弃迟到结果,不写候选/建议。
+    const liveRun = getRunRepo().getRun(runId)
+    if (!liveRun || liveRun.status !== 'running') {
+      const cancelled: SolveResult = {
+        runId, status: 'cancelled', candidates: [], firstMove: null, independentCost: null,
+        diagnostics: { backend: 'worker', solverVersion: 'unknown', elapsedMs, problemIrHash: ir.hash, message: '运行已取消或终态已落定;迟到结果丢弃', workerPid },
+        createdAt: new Date().toISOString(),
+      }
+      return { runId, bindingId: resolved.binding.id, profileVersion: resolved.binding.profileVersion, result: cancelled, recommendation: null, context: pick(context) }
+    }
+    // 绑定 revision 在求解期间被撤销/变更 → 结果失效
+    const freshBinding = db().prepare('SELECT revision FROM optimizer_bindings WHERE id = ?').get(resolved.binding.id) as { revision: number } | undefined
+    if (!freshBinding || freshBinding.revision !== resolved.binding.revision) {
+      const stale: SolveResult = {
+        runId, status: 'cancelled', candidates: [], firstMove: null, independentCost: null,
+        diagnostics: { backend: 'worker', solverVersion: 'unknown', elapsedMs, problemIrHash: ir.hash, message: 'BINDING_STALE: 绑定在求解期间被撤销或 revision 变化', workerPid },
+        createdAt: new Date().toISOString(),
+      }
+      getRunRepo().finishRun(runId, stale)
+      getRunRepo().expireWhere({ bindingId: resolved.binding.id })
+      return { runId, bindingId: resolved.binding.id, profileVersion: resolved.binding.profileVersion, result: stale, recommendation: null, context: pick(context) }
+    }
+    const firstMove = candidates[0] ? Object.fromEntries(ir.problem.mvOrder.map((id, m) => [id, candidates[0]!.controls[0]?.[m] ?? 0])) : null
+    const result: SolveResult = {
+      runId,
+      status: costMismatch ? 'numerical_error' : payload.status,
+      candidates,
+      firstMove,
+      independentCost,
+      diagnostics: {
+        backend: payload.backend ?? 'worker', solverVersion: payload.solverVersion ?? 'unknown',
+        iterations: payload.iterations, elapsedMs, problemIrHash: ir.hash,
+        message: costMismatch ? `代价不一致:solver=${solverCost} independent=${independentCost}` : payload.message,
+        workerPid,
+      },
+      createdAt: new Date().toISOString(),
+    }
+    getRunRepo().finishRun(runId, result)
+
+    let recommendation: Recommendation | null = null
+    if (result.status === 'optimal' || result.status === 'feasible') {
+      const candidateIds = getRunRepo().insertCandidates(runId, candidates, profile.modelRef.modelId)
+      // D5 证据单源:唯一来源 = 工件 uq 字段(注册前已算入 artifactHash);快照含 artifactHash 锚
+      const uqSnapshot = buildUqEvidence(artifact as { uq?: ArtifactUq, norm?: { u: { mean: number[], std: number[] }, y: { mean: number[], std: number[] } }, mvOrder?: string[], cvOrder?: string[] }, artifactHash, context)
+      recommendation = createRecommendation({
+        runId,
+        candidate: candidates[0]!,
+        candidateId: candidateIds[0]!,
+        problemIrHash: ir.hash,
+        modelArtifactHash: artifactHash,
+        evidenceSource: context.evidenceSource,
+        uqEvidence: uqSnapshot,
+      })
+    }
+    return { runId, bindingId: resolved.binding.id, profileVersion: resolved.binding.profileVersion, result, recommendation, context: pick(context) }
+  }
+  finally {
+    resolved.lease.release()
+  }
+}
+
+function pick(context: ContextSnapshot): SolveOutcome['context'] {
+  return {
+    capturedAt: context.capturedAt, eventAsOf: context.eventAsOf,
+    availabilityWatermark: context.availabilityWatermark, conditionId: context.conditionId,
+  }
+}
+
+/**
+ * 工件 UQ → 建议证据快照(D2/D4/D5):
+ * 无 uq 字段(旧 ONNX/样本不足)→ null(维持 unverified,不伪造);
+ * inputDistance 由本次上下文现算(MV+CV 双偏移;σ 缺失/列序不符 → null 不乐观)。
+ */
+function buildUqEvidence(
+  artifact: { uq?: ArtifactUq, norm?: { u: { mean: number[], std: number[] }, y: { mean: number[], std: number[] } }, mvOrder?: string[], cvOrder?: string[] },
+  artifactHash: string,
+  context: ContextSnapshot,
+): RecommendationUqEvidence | null {
+  const uq = artifact.uq
+  if (!uq) return null
+  const currentU = (artifact.mvOrder ?? []).map(id => context.currentInputs[id])
+  const currentY = (artifact.cvOrder ?? []).map(id => context.currentOutputs[id])
+  const distance = artifact.norm
+    ? inputDistance({ currentU, currentY, normU: artifact.norm.u, normY: artifact.norm.y })
+    : null
+  return {
+    ...uq,
+    artifactHash,
+    calibrationFresh: isUqFresh(uq),
+    inputDistance: distance,
+  }
+}
+
+export function getRunStatus(agentId: string, runId: string): { run: ReturnType<ReturnType<typeof getRunRepo>['getRun']>, recommendation: Recommendation | null, candidates: unknown[], crosscheck?: ReturnType<typeof deriveDualState> } {
+  const run = getRunRepo().getRun(runId)
+  if (!run) throw new AppError(404, 'RUN_NOT_FOUND', `运行 ${runId} 不存在`)
+  const binding = db().prepare('SELECT channel_agent_id AS agentId FROM optimizer_bindings WHERE id = ?').get(run.bindingId) as { agentId: string } | undefined
+  if (!binding || binding.agentId !== agentId) throw new AppError(403, 'BINDING_NOT_OWNED', `运行 ${runId} 不属于当前 Agent`)
+  const recommendation = getRunRepo().latestRecommendationForRun(runId)
+  return {
+    run,
+    recommendation: recommendation ? assertRecommendationUsable(recommendation) : null,
+    candidates: getRunRepo().listCandidates(runId),
+    // D6 计算态:互校一致由最新 crosscheck 行派生(不改建议 status)
+    ...(recommendation ? { crosscheck: deriveDualState(recommendation.id) } : {}),
+  }
+}
+
+export async function cancel(agentId: string, runId: string): Promise<{ cancelled: boolean }> {
+  const run = getRunRepo().getRun(runId)
+  if (!run) throw new AppError(404, 'RUN_NOT_FOUND', `运行 ${runId} 不存在`)
+  const binding = db().prepare('SELECT channel_agent_id AS agentId FROM optimizer_bindings WHERE id = ?').get(run.bindingId) as { agentId: string } | undefined
+  if (!binding || binding.agentId !== agentId) throw new AppError(403, 'BINDING_NOT_OWNED', `运行 ${runId} 不属于当前 Agent`)
+  if (run.status !== 'running') return { cancelled: false }
+  await getSolverWorkerPool().cancel(runId)
+  const fake: SolveResult = {
+    runId, status: 'cancelled', candidates: [], firstMove: null, independentCost: null,
+    diagnostics: { backend: 'worker', solverVersion: 'unknown', elapsedMs: 0, problemIrHash: run.problemIrHash, message: 'cancelled by request' },
+    createdAt: new Date().toISOString(),
+  }
+  getRunRepo().finishRun(runId, fake)
+  return { cancelled: true }
+}

package/server/services/workshop/optimization/problem-builder.ts

@@ -0,0 +1,359 @@
+/**
+ * ProblemIR 编译(G3.4 / plan §4.1):
+ *   ContextSnapshot + 模型工件 + OptimizationProfile → 同一问题定义(带稳定 hash)。
+ *
+ * 编译期检查(不可 eval 用户公式):
+ *  - 工件类型与求解器兼容(ONNX 黑箱不能交给 OSQP);
+ *  - 维度/变量序/权重非负/边界一致;
+ *  - MV 有效域与 maxStep 必须来自 spec(不允许"看起来合理"的缺省)。
+ */
+import { AppError } from '../../../utils/errors'
+import type { ContextSnapshot } from '../process-model/context'
+import type { ProcessModelSpec } from '../process-model/contracts'
+import { assertSolverSupportsArtifact } from '../process-model/contracts'
+import type { OptimizationProfile, ProblemBounds, ProblemIR, ProblemScaling, SolveCandidate } from './contracts'
+import { computeProblemIrHash } from './contracts'
+
+export interface LinearStateSpaceLike {
+  kind: 'linear_state_space@1'
+  stateDim: number
+  arOrder: number
+  inputOrder: number
+  mvOrder: string[]
+  cvOrder: string[]
+  delaysSteps: Record<string, number>
+  K: number
+  A: number[][]
+  B: number[][]
+  C: number[][]
+  D: number[][]
+  bias: number[]
+  layout: { yOffset: number, uOffset: number, stateDim: number, K: number }
+}
+
+export interface StaticResponseLike {
+  kind: 'static_response@1'
+  mvOrder: string[]
+  cvOrder: string[]
+  featureOrder: string[]
+  coefficients: Record<string, number[]>
+  order: 1 | 2
+}
+
+export type ModelArtifact = LinearStateSpaceLike | StaticResponseLike
+
+function boundsFor(spec: ProcessModelSpec, variableId: string): ProblemBounds {
+  const domain = spec.effectiveDomain.mv[variableId]
+  if (!domain) throw new AppError(422, 'PROBLEM_DOMAIN_MISSING', `MV ${variableId} 缺少有效域;拒绝编译问题`)
+  return { min: domain.min, max: domain.max, maxStep: domain.maxStep }
+}
+
+function scalingOf(spec: ProcessModelSpec): ProblemScaling {
+  const mv: ProblemScaling['mv'] = {}
+  const cv: ProblemScaling['cv'] = {}
+  for (const variable of spec.variables) {
+    const entry = { scale: variable.scale, offset: variable.offset }
+    if (variable.role === 'mv') mv[variable.id] = entry
+    if (variable.role === 'cv') cv[variable.id] = entry
+  }
+  return { mv, cv }
+}
+
+export function buildProblemIR(input: {
+  profile: OptimizationProfile
+  spec: ProcessModelSpec
+  artifact: ModelArtifact
+  context: ContextSnapshot
+  runId: string
+}): ProblemIR {
+  const { profile, spec, artifact, context } = input
+  assertSolverSupportsArtifact(profile.solverRef, profile.modelRef.artifactKind)
+  const conditionId = context.conditionId || spec.conditions[0]?.id || ''
+  const base = {
+    irVersion: 1 as const,
+    profileRef: `${profile.id}@${profile.version}`,
+    modelRef: profile.modelRef,
+    solverRef: profile.solverRef,
+    conditions: {
+      conditionId, lineId: spec.lineId, productId: spec.productId, recipeId: spec.recipeId,
+      recipeVersion: spec.recipeVersion,
+    },
+    horizon: spec.timing.horizonSteps,
+    beatMs: spec.timing.beatMs,
+    scaling: scalingOf(spec),
+    context: {
+      capturedAt: context.capturedAt,
+      eventAsOf: context.eventAsOf,
+      availabilityWatermark: context.availabilityWatermark,
+      evidenceSource: context.evidenceSource,
+    },
+  }
+
+  if (profile.problemTemplateRef === 'linear_mpc_quadratic@1') {
+    if (artifact.kind !== 'linear_state_space@1') {
+      throw new AppError(422, 'PROBLEM_MODEL_MISMATCH', `linear_mpc_quadratic 需要 linear_state_space 工件,收到 ${artifact.kind}`)
+    }
+    const cfg = profile.problemConfig.linear_mpc_quadratic
+    if (!cfg) throw new AppError(422, 'PROBLEM_CONFIG_INVALID', '缺少 linear_mpc_quadratic 配置')
+    const mvOrder = artifact.mvOrder
+    const cvOrder = artifact.cvOrder
+    for (const id of mvOrder) if (!(id in cfg.duWeights)) throw new AppError(422, 'PROBLEM_CONFIG_INVALID', `duWeights 缺少 ${id}`)
+    for (const id of cvOrder) if (!(id in cfg.cvWeights)) throw new AppError(422, 'PROBLEM_CONFIG_INVALID', `cvWeights 缺少 ${id}`)
+    if (artifact.stateDim !== artifact.A.length || artifact.A.some(row => row.length !== artifact.stateDim)) {
+      throw new AppError(422, 'PROBLEM_DIMENSION_MISMATCH', '状态矩阵维度不一致')
+    }
+    if (artifact.B.length !== artifact.stateDim || artifact.B.some(row => row.length !== mvOrder.length)) {
+      throw new AppError(422, 'PROBLEM_DIMENSION_MISMATCH', '输入矩阵维度不一致')
+    }
+    if (artifact.C.length !== cvOrder.length || artifact.C.some(row => row.length !== artifact.stateDim)) {
+      throw new AppError(422, 'PROBLEM_DIMENSION_MISMATCH', '观测矩阵维度不一致')
+    }
+    const x0 = new Array<number>(artifact.stateDim).fill(0)
+    const { yOffset, uOffset, K } = artifact.layout
+    for (let j = 0; j < cvOrder.length; j++) {
+      const value = context.currentOutputs[cvOrder[j]!]
+      if (value === undefined) throw new AppError(422, 'PROBLEM_CONTEXT_MISSING', `上下文缺少 CV ${cvOrder[j]} 的当前观测`)
+      for (let i = 0; i < artifact.arOrder; i++) {
+        // 历史寄存器:history[H-1-i][cv]
+        const variableIndex = spec.variables.findIndex(v => v.id === cvOrder[j])
+        x0[yOffset + j * artifact.arOrder + i] = context.history.at(-1 - i)?.[variableIndex] ?? value
+      }
+    }
+    for (let m = 0; m < mvOrder.length; m++) {
+      const variableIndex = spec.variables.findIndex(v => v.id === mvOrder[m])
+      for (let q = 0; q < K; q++) x0[uOffset + m * K + q] = context.history.at(-1 - q)?.[variableIndex] ?? 0
+    }
+    const cvSetpoints = cvOrder.map((id) => {
+      const target = cfg.targets[id]
+      if (target == null || !Number.isFinite(target)) throw new AppError(422, 'PROBLEM_CONFIG_INVALID', `targets 缺少 ${id}(CV 设定值必填)`)
+      return target
+    })
+    const cvBounds = cvOrder.map((id) => {
+      const domain = spec.effectiveDomain.cv?.[id]
+      return domain ? { min: domain.min, max: domain.max } : {}
+    })
+    const uPrev = mvOrder.map((id) => {
+      const value = context.currentInputs[id]
+      if (value === undefined) throw new AppError(422, 'PROBLEM_CONTEXT_MISSING', `上下文缺少 MV ${id} 的当前值`)
+      return value
+    })
+    const cvWeights = Object.fromEntries(cvOrder.map(id => [id, cfg.cvWeights[id]!]))
+    const duWeights = Object.fromEntries(mvOrder.map(id => [id, cfg.duWeights[id]!]))
+    const ir: Omit<ProblemIR, 'hash'> = {
+      ...base,
+      weights: {
+        cv: cvWeights, du: duWeights, terminal: cfg.terminalWeight, economic: undefined, slack: cfg.slackPenalty,
+      },
+      problem: {
+        template: 'linear_mpc_quadratic@1',
+        dynamics: {
+          stateDim: artifact.stateDim,
+          A: artifact.A.flat(),
+          B: artifact.B.flat(),
+          C: artifact.C.flat(),
+          D: artifact.D.flat(),
+          bias: artifact.bias,
+          delays: artifact.delaysSteps,
+          x0,
+        },
+        cvSetpoints,
+        cvBounds,
+        mvOrder,
+        cvOrder,
+        mvBounds: mvOrder.map(id => boundsFor(spec, id)),
+        uPrev,
+      },
+    }
+    return { ...ir, hash: computeProblemIrHash(ir) }
+  }
+
+  if (profile.problemTemplateRef === 'steady_response@1') {
+    if (artifact.kind !== 'static_response@1') {
+      throw new AppError(422, 'PROBLEM_MODEL_MISMATCH', `steady_response 需要 static_response 工件,收到 ${artifact.kind}`)
+    }
+    const cfg = profile.problemConfig.steady_response
+    if (!cfg) throw new AppError(422, 'PROBLEM_CONFIG_INVALID', '缺少 steady_response 配置')
+    const mvOrder = artifact.mvOrder
+    const cvOrder = artifact.cvOrder
+    for (const id of cvOrder) {
+      if (!artifact.coefficients[id]) throw new AppError(422, 'PROBLEM_CONFIG_INVALID', `工件缺少 CV ${id} 的响应面系数`)
+      if (cfg.cvWeights[id] == null && cfg.economicWeights[id] == null) {
+        // 经济权重按 MV 给;CV 至少要有目标或权重
+        if (cfg.targets[id] == null) throw new AppError(422, 'PROBLEM_CONFIG_INVALID', `CV ${id} 缺少 targets/cvWeights`)
+      }
+    }
+    const cvTargets = cvOrder.map(id => Number(cfg.targets[id] ?? 0))
+    const uPrev = mvOrder.map((id) => {
+      const value = context.currentInputs[id]
+      if (value === undefined) throw new AppError(422, 'PROBLEM_CONTEXT_MISSING', `上下文缺少 MV ${id} 的当前值`)
+      return value
+    })
+    const ir: Omit<ProblemIR, 'hash'> = {
+      ...base,
+      weights: { cv: { ...cfg.cvWeights }, du: {}, terminal: 0, economic: { ...cfg.economicWeights } },
+      problem: {
+        template: 'steady_response@1',
+        mvOrder,
+        cvOrder,
+        coefficients: artifact.coefficients,
+        featureOrder: artifact.featureOrder,
+        cvTargets,
+        mvBounds: mvOrder.map(id => boundsFor(spec, id)),
+        cvBounds: cvOrder.map((id) => {
+          const domain = spec.effectiveDomain.cv?.[id]
+          return domain ? { min: domain.min, max: domain.max } : {}
+        }),
+        uPrev,
+      },
+    }
+    return { ...ir, hash: computeProblemIrHash(ir) }
+  }
+
+  throw new AppError(422, 'UNSUPPORTED_PROBLEM_TEMPLATE', `不支持的问题模板 ${profile.problemTemplateRef}`)
+}
+
+/**
+ * 独立代价重算(Solver/Twin/baseline 同口径):A4 要求三者相对差 ≤1e-6。
+ * 线性 MPC:全时域跟踪误差 + Δu + 终端 + 软约束;静态:经济代价 + CV 跟踪。
+ */
+export function evaluateCandidateCost(ir: ProblemIR, candidate: SolveCandidate): number {
+  const controls = candidate.controls
+  if (ir.problem.template === 'linear_mpc_quadratic@1') {
+    const p = ir.problem
+    const cvWeights = p.cvOrder.map(id => ir.weights.cv[id] ?? 1)
+    const duWeights = p.mvOrder.map(id => ir.weights.du[id] ?? 0)
+    let cost = 0
+    const predicted = simulateLinear(p.dynamics, p.mvOrder.length, p.cvOrder.length, p.uPrev, controls)
+    for (let t = 0; t < predicted.length; t++) {
+      for (let j = 0; j < p.cvOrder.length; j++) cost += cvWeights[j]! * (predicted[t]![j]! - p.cvSetpoints[j]!) ** 2
+    }
+    // 终端代价
+    const last = predicted[predicted.length - 1]
+    if (last) for (let j = 0; j < p.cvOrder.length; j++) cost += ir.weights.terminal * cvWeights[j]! * (last[j]! - p.cvSetpoints[j]!) ** 2
+    for (let t = 0; t < controls.length; t++) {
+      const prev = t === 0 ? p.uPrev : controls[t - 1]!
+      for (let m = 0; m < p.mvOrder.length; m++) cost += duWeights[m]! * (controls[t]![m]! - prev[m]!) ** 2
+    }
+    return cost
+  }
+  const p = ir.problem
+  const u = controls[0] ?? []
+  let cost = 0
+  for (const [id, weight] of Object.entries(ir.weights.economic ?? {})) {
+    const m = p.mvOrder.indexOf(id)
+    if (m >= 0 && u[m] != null) cost += weight * u[m]!
+  }
+  for (let j = 0; j < p.cvOrder.length; j++) {
+    const y = evaluateStatic(p.coefficients[p.cvOrder[j]!]!, p.featureOrder, p.mvOrder, u)
+    cost += (ir.weights.cv[p.cvOrder[j]!] ?? 0) * (y - (p.cvTargets[j] ?? 0)) ** 2
+  }
+  return cost
+}
+
+export function evaluateStatic(coefficients: number[], featureOrder: string[], mvOrder: string[], u: number[]): number {
+  let sum = 0
+  const byName = new Map<string, number>()
+  mvOrder.forEach((id, i) => byName.set(id, u[i] ?? 0))
+  for (let k = 0; k < featureOrder.length; k++) {
+    const name = featureOrder[k]!
+    let value: number
+    if (name === 'bias') value = 1
+    else if (name.endsWith('^2')) {
+      const id = name.slice(0, -2)
+      value = (byName.get(id) ?? 0) ** 2
+    }
+    else if (name.includes('*')) {
+      const [a, b] = name.split('*')
+      value = (byName.get(a!) ?? 0) * (byName.get(b!) ?? 0)
+    }
+    else value = byName.get(name) ?? 0
+    sum += (coefficients[k] ?? 0) * value
+  }
+  return sum
+}
+
+/** 线性状态空间 rollout(与 Solver/Python 相同的离散语义)。 */
+export function constraintReport(ir: ProblemIR, candidate: SolveCandidate): import('./contracts').ConstraintReport[] {
+  const reports: import('./contracts').ConstraintReport[] = []
+  if (ir.problem.template !== 'linear_mpc_quadratic@1') {
+    const p = ir.problem
+    for (let m = 0; m < p.mvOrder.length; m++) {
+      const value = candidate.controls[0]?.[m] ?? 0
+      const b = p.mvBounds[m] ?? {}
+      reports.push({ id: `mv.${p.mvOrder[m]}.bound`, kind: 'bound', satisfied: (b.min == null || value >= b.min - 1e-9) && (b.max == null || value <= b.max + 1e-9), residual: Math.max(0, (b.min ?? value) - value, value - (b.max ?? value)), tolerance: 1e-6 })
+      if (b.maxStep != null) {
+        const delta = Math.abs(value - p.uPrev[m]!)
+        reports.push({ id: `mv.${p.mvOrder[m]}.rate`, kind: 'rate', satisfied: delta <= b.maxStep + 1e-9, residual: Math.max(0, delta - b.maxStep), tolerance: 1e-6 })
+      }
+    }
+    // 静态路径:独立复核 CV 有效域(此前只查 MV)
+    for (let j = 0; j < p.cvOrder.length; j++) {
+      const y = candidate.predicted[0]?.[j] ?? Number.NaN
+      const b = p.cvBounds[j] ?? {}
+      const lo = b.min ?? Number.NEGATIVE_INFINITY
+      const hi = b.max ?? Number.POSITIVE_INFINITY
+      reports.push({ id: `cv.${p.cvOrder[j]}.bound`, kind: 'domain', satisfied: Number.isFinite(y) && y >= lo - 1e-9 && y <= hi + 1e-9, residual: Math.max(0, lo - y, y - hi), tolerance: 1e-6 })
+    }
+    return reports
+  }
+  const p = ir.problem
+  const mvCount = p.mvOrder.length
+  for (let t = 0; t < candidate.controls.length; t++) {
+    for (let m = 0; m < mvCount; m++) {
+      const value = candidate.controls[t]?.[m] ?? 0
+      const b = p.mvBounds[m] ?? {}
+      const lo = b.min ?? Number.NEGATIVE_INFINITY
+      const hi = b.max ?? Number.POSITIVE_INFINITY
+      reports.push({
+        id: `mv.${p.mvOrder[m]}.t${t}.bound`, kind: 'bound',
+        satisfied: value >= lo - 1e-9 && value <= hi + 1e-9,
+        residual: Math.max(0, lo - value, value - hi), tolerance: 1e-6,
+      })
+      if (b.maxStep != null) {
+        const prev = t === 0 ? p.uPrev[m] ?? value : candidate.controls[t - 1]?.[m] ?? value
+        const delta = Math.abs(value - prev)
+        reports.push({ id: `mv.${p.mvOrder[m]}.t${t}.rate`, kind: 'rate', satisfied: delta <= b.maxStep + 1e-9, residual: Math.max(0, delta - b.maxStep), tolerance: 1e-6 })
+      }
+    }
+  }
+  // 动态一致性:重算预测轨迹与 Solver 返回预测逐点对齐
+  const simulated = simulateLinear(p.dynamics, mvCount, p.cvOrder.length, p.uPrev, candidate.controls)
+  let maxDiff = 0
+  for (let t = 0; t < simulated.length; t++) {
+    for (let j = 0; j < p.cvOrder.length; j++) {
+      maxDiff = Math.max(maxDiff, Math.abs((simulated[t]?.[j] ?? 0) - (candidate.predicted[t]?.[j] ?? 0)))
+    }
+  }
+  reports.push({ id: 'dynamics.rollout', kind: 'dynamic', satisfied: maxDiff <= 1e-6, residual: maxDiff, tolerance: 1e-6 })
+  return reports
+}
+
+export function simulateLinear(
+  dynamics: { A: number[], B: number[], C: number[], D: number[], stateDim: number, x0: number[], bias?: number[] },
+  mvCount: number,
+  cvCount: number,
+  uPrev: number[],
+  controls: number[][],
+): number[][] {
+  const n = dynamics.stateDim
+  let x = [...dynamics.x0]
+  const out: number[][] = []
+  for (let t = 0; t < controls.length; t++) {
+    const u = controls[t] ?? uPrev
+    const next = new Array<number>(n).fill(0)
+    for (let r = 0; r < n; r++) {
+      let v = dynamics.bias?.[r] ?? 0
+      for (let c = 0; c < n; c++) v += (dynamics.A[r * n + c] ?? 0) * (x[c] ?? 0)
+      for (let m = 0; m < mvCount; m++) v += (dynamics.B[r * mvCount + m] ?? 0) * (u[m] ?? 0)
+      next[r] = v
+    }
+    x = next
+    const y = new Array<number>(cvCount).fill(0)
+    for (let j = 0; j < cvCount; j++) {
+      for (let c = 0; c < n; c++) y[j] = (y[j] ?? 0) + (dynamics.C[j * n + c] ?? 0) * (x[c] ?? 0)
+      for (let m = 0; m < mvCount; m++) y[j] = (y[j] ?? 0) + (dynamics.D[j * mvCount + m] ?? 0) * (u[m] ?? 0)
+    }
+    out.push(y)
+  }
+  return out
+}