agentworkshop 0.7.70 → 0.7.71

package/server/services/workshop/process-model/artifact-validation.ts

@@ -0,0 +1,19 @@
+import { AppError } from '../../../utils/errors'
+
+/** 旧 ARX 零延迟工件把当拍输入放进 D,会丢失下一拍反馈;只拒绝该已知布局。 */
+export function assertArxArtifactCurrent(artifact: unknown, modelId: string): void {
+  if (!artifact || typeof artifact !== 'object') return
+  const arx = artifact as Record<string, unknown>
+  if (arx.kind !== 'linear_state_space@1'
+    || !Number.isInteger(arx.arOrder) || Number(arx.arOrder) < 1
+    || !Number.isInteger(arx.inputOrder) || Number(arx.inputOrder) < 1
+    || !arx.layout || typeof arx.layout !== 'object') return
+  if (!Array.isArray(arx.mvOrder) || !Array.isArray(arx.D) || !arx.delaysSteps || typeof arx.delaysSteps !== 'object') return
+  const delays = arx.delaysSteps as Record<string, unknown>
+  for (const [m, mv] of arx.mvOrder.entries()) {
+    if (typeof mv !== 'string' || delays[mv] !== 0) continue
+    if (arx.D.some(row => Array.isArray(row) && typeof row[m] === 'number' && row[m] !== 0)) {
+      throw new AppError(409, 'MODEL_RETRAIN_REQUIRED', `模型 ${modelId} 使用旧版零延迟 ARX 工件(${mv} 的 D 非零);请使用修复后的训练器重新训练并发布新模型`)
+    }
+  }
+}

package/server/services/workshop/process-model/conditions.ts

@@ -0,0 +1,43 @@
+/**
+ * 运行时工况/配方版本重校验(plan §3.1 / A13):
+ *  - 当前配方版本与 spec 冻结版本不一致 → 计划失效;
+ *  - 批次谱系段版本不一致(运行中切换)→ 失效;
+ *  - 声明身份必须命中工况,且命中集合两两不重叠。
+ *
+ * stage 子句在首版视为**运行时未知维度**(产线批次没有结构化 stage 来源):
+ * 发布与运行都用同一"忽略 stage 静态匹配 + 两两不重叠"口径,避免 stage 型工况永远不命中。
+ */
+import type { ProcessModelSpec } from './contracts'
+import type { ContextSnapshot } from './context'
+import { conditionsOverlap } from './spec'
+import { getContextSegmentRepo } from './context-segments.repo'
+import { getDcwRecipeRepo } from '../dcw/dcw-recipe.repo'
+
+export async function isRuntimeConditionChanged(spec: ProcessModelSpec, context: ContextSnapshot): Promise<boolean> {
+  const recipe = getDcwRecipeRepo().byId(spec.recipeId)
+  if (recipe?.version != null && spec.recipeVersion !== 0 && recipe.version !== spec.recipeVersion) return true
+  const segment = getContextSegmentRepo().at(spec.lineId, context.eventAsOf)
+  if (segment && segment.confirmed === 1) {
+    // 运行中切换到不同配方(recipeId 变化)或同配方升版 → 旧计划失效
+    if (segment.recipeId !== spec.recipeId) return true
+    if (segment.recipeVersion !== 0 && segment.recipeVersion !== spec.recipeVersion) return true
+  }
+  const actual: Record<string, unknown> = {
+    lineId: spec.lineId, productId: spec.productId, recipeId: spec.recipeId, recipeVersion: spec.recipeVersion,
+  }
+  const matching = spec.conditions.filter(condition => condition.match.every((clause) => {
+    if (clause.field === 'stage') return true
+    const value = actual[clause.field]
+    if (clause.op === 'eq') return String(value ?? '') === String(clause.value)
+    if (typeof value !== 'number') return false
+    const [lo, hi] = clause.value as [number, number]
+    return value >= lo && value <= hi
+  }))
+  if (matching.length === 0) return true
+  for (let i = 0; i < matching.length; i++) {
+    for (let j = i + 1; j < matching.length; j++) {
+      if (conditionsOverlap(matching[i]!, matching[j]!)) return true
+    }
+  }
+  return false
+}

package/server/services/workshop/process-model/context-segments.repo.ts

@@ -0,0 +1,100 @@
+/* eslint-disable @stylistic/max-statements-per-line */
+/**
+ * 配方版本/工况谱系(process_context_segments)。
+ *
+ * 半开区间 [from_ts, to_ts);运行中切换拆段,训练窗口不得跨版本;
+ * 只有仓库编辑事件(无"产线已应用"事件)时不拆段,只触发重校验。
+ */
+import type { DatabaseSync } from 'node:sqlite'
+import { canonicalJson, sha256 } from '../aml/twin/contracts'
+import { getAmlRuntime } from '../aml/runtime'
+
+export interface ContextSegmentRow {
+  id: string
+  lineId: string
+  runId: string
+  fromTs: number
+  toTs: number | null
+  recipeId: string
+  recipeVersion: number
+  recipeContentHash: string
+  conditionId: string
+  source: 'line_run' | 'recipe_edit' | 'manual'
+  confirmed: number
+  createdAt: string
+}
+
+const COLS = `id, line_id AS lineId, run_id AS runId, from_ts AS fromTs, to_ts AS toTs,
+  recipe_id AS recipeId, recipe_version AS recipeVersion, recipe_content_hash AS recipeContentHash,
+  condition_id AS conditionId, source, confirmed, created_at AS createdAt`
+
+/**
+ * 配方内容 hash(C8 显式定义):
+ *   paramsSnapshot + daqWindows + access + recipe.version + recipe.id
+ * 稳定序列化后 sha256。不得声称等同于"整份配方定义"(不含 description/name 等展示字段)。
+ */
+export function recipeContentHash(recipe: {
+  id: string
+  version?: number
+  params?: unknown
+  daqWindows?: unknown
+  access?: unknown
+}, paramsSnapshot?: unknown): string {
+  return sha256(canonicalJson({
+    recipeId: recipe.id,
+    version: recipe.version ?? 0,
+    params: paramsSnapshot ?? recipe.params ?? [],
+    daqWindows: recipe.daqWindows ?? [],
+    access: recipe.access ?? null,
+  }))
+}
+
+export function createContextSegmentRepo(db: DatabaseSync) {
+  return {
+    insert(input: Omit<ContextSegmentRow, 'id' | 'createdAt' | 'confirmed' | 'source'> & { source?: ContextSegmentRow['source'], confirmed?: boolean }): ContextSegmentRow {
+      const id = `pcs-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 7)}`
+      const now = new Date().toISOString()
+      const source = input.source ?? 'line_run'
+      const confirmed = input.confirmed ? 1 : 0
+      db.prepare(`INSERT INTO process_context_segments
+        (id, line_id, run_id, from_ts, to_ts, recipe_id, recipe_version, recipe_content_hash, condition_id, source, confirmed, created_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(run_id, from_ts) DO NOTHING`)
+        .run(id, input.lineId, input.runId, input.fromTs, input.toTs, input.recipeId, input.recipeVersion, input.recipeContentHash, input.conditionId, source, confirmed, now)
+      return this.getByRunFrom(input.runId, input.fromTs)!
+    },
+
+    getByRunFrom(runId: string, fromTs: number): ContextSegmentRow | undefined {
+      return db.prepare(`SELECT ${COLS} FROM process_context_segments WHERE run_id = ? AND from_ts = ?`).get(runId, fromTs) as unknown as ContextSegmentRow | undefined
+    },
+
+    /** 关段:取该 run 未闭合的最新段 */
+    close(runId: string, toTs: number): void {
+      db.prepare(`UPDATE process_context_segments SET to_ts = ? WHERE run_id = ? AND to_ts IS NULL`).run(toTs, runId)
+    },
+
+    listByLine(lineId: string, fromTs?: number, toTs?: number): ContextSegmentRow[] {
+      const where = ['line_id = ?']
+      const args: Array<string | number> = [lineId]
+      if (toTs != null) { where.push('from_ts < ?'); args.push(toTs) }
+      if (fromTs != null) { where.push('(to_ts IS NULL OR to_ts > ?)'); args.push(fromTs) }
+      return db.prepare(`SELECT ${COLS} FROM process_context_segments WHERE ${where.join(' AND ')} ORDER BY from_ts ASC`)
+        .all(...(args as never[])) as unknown as ContextSegmentRow[]
+    },
+
+    /** 时间点归属段(半开区间)。 */
+    at(lineId: string, tsMs: number): ContextSegmentRow | undefined {
+      return db.prepare(`SELECT ${COLS} FROM process_context_segments WHERE line_id = ? AND from_ts <= ? AND (to_ts IS NULL OR to_ts > ?) ORDER BY from_ts DESC LIMIT 1`)
+        .get(lineId, tsMs, tsMs) as unknown as ContextSegmentRow | undefined
+    },
+  }
+}
+
+export type ContextSegmentRepo = ReturnType<typeof createContextSegmentRepo>
+
+const g = globalThis as typeof globalThis & { __processContextSegmentRepo?: ContextSegmentRepo }
+
+export function getContextSegmentRepo(): ContextSegmentRepo {
+  g.__processContextSegmentRepo ??= createContextSegmentRepo(getAmlRuntime().db)
+  return g.__processContextSegmentRepo
+}

package/server/services/workshop/process-model/context.ts

@@ -0,0 +1,202 @@
+/**
+ * Runtime Context(plan §3.2 / G2.6):
+ *   getRuntimeContext(spec, asOf) → 真实 history + timestamps + dt + qualityMask
+ *   + 当前实际输入 + 状态估计 + availabilityWatermark。
+ *
+ * 铁律:历史不足明确拒绝;不复制单快照伪造历史(旧 model-backed-provider 的缺陷);
+ * watermark = max(ingested_at),全部为 NULL 时 = unknown(不得用于严格在线回放)。
+ */
+import { AppError } from '../../../utils/errors'
+import { toModel as sharedToModel } from '@/shared/units'
+import { getTsdb } from '../daq/storage'
+import type { TsdbPoint } from '../daq/storage/tsdb-port'
+import { getDcwRecipeRepo } from '../dcw/dcw-recipe.repo'
+import type { VariableMap, ProcessModelSpec } from './contracts'
+import { matchCondition } from './contracts'
+import { fetchNodeSeries } from '../aml/dataset-builder'
+import { getContextSegmentRepo, recipeContentHash } from './context-segments.repo'
+
+export interface ContextSnapshot {
+  lineId: string
+  productId: string
+  recipeId: string
+  recipeVersion: number
+  conditionId: string
+  capturedAt: string
+  /** 历史末点的事件时间(允许使用的最后观测) */
+  eventAsOf: number
+  /** 平台入库水位(= max(ingested_at));null = unknown */
+  availabilityWatermark: number | null
+  dtMs: number
+  variables: VariableMap[]
+  /** [H][F],按 spec.variables 顺序,已换算到模型单位 */
+  history: number[][]
+  timestamps: number[]
+  /** [H][F],state=ok 且值有限 */
+  qualityMask: boolean[][]
+  /** 当前 MV 实际值(模型单位) */
+  currentInputs: Record<string, number>
+  /** 最近一次 CV 观测(模型单位) */
+  currentOutputs: Record<string, number>
+  /** 数据来源(由资格作用域决定;缺省 unassessed) */
+  evidenceSource: 'simulation' | 'real' | 'unassessed'
+}
+
+function toModel(value: number, variable: VariableMap): number {
+  // D23 唯一换算边界:spec parse 已强制 scale/offset 有限(scale≠0);此处缺失/非法 = 契约破坏,fail-closed
+  return sharedToModel(value, { scale: variable.scale as number, offset: variable.offset as number }, `变量 ${variable.id}`)
+}
+
+/** 从点列取最后一个 ≤ t 的值;过期/非 ok 一律视为缺失(不拿坏点当历史)。 */
+function valueAt(points: TsdbPoint[], t: number, maxAgeMs: number): { value: number, state: string } | null {
+  let best: TsdbPoint | null = null
+  for (const p of points) {
+    if (p.at <= t && (!best || p.at > best.at)) best = p
+  }
+  if (!best || best.value === undefined || !Number.isFinite(best.value)) return null
+  if (t - best.at > maxAgeMs) return null
+  return { value: best.value, state: best.state ?? 'unknown' }
+}
+
+export async function getRuntimeContext(spec: ProcessModelSpec, asOfMs?: number): Promise<ContextSnapshot> {
+  const asOf = asOfMs ?? Date.now()
+  const beat = spec.timing.beatMs
+  const H = spec.timing.historySteps
+  const maxDelay = Math.max(0, ...spec.variables.filter(v => v.role === 'mv').map(v => v.delayMs ?? 0))
+  const fromMs = asOf - (H * beat + maxDelay + beat * 5)
+  const tsdb = getTsdb()
+  const pointsByVariable = new Map<string, TsdbPoint[]>()
+  for (const variable of spec.variables) {
+    const points = await fetchNodeSeries(tsdb, variable.nodeId, {
+      lineId: spec.lineId, productId: spec.productId, recipeId: spec.recipeId,
+      fromMs, toMs: asOf,
+    })
+    if (!points.length) {
+      throw new AppError(422, 'CONTEXT_INSUFFICIENT', `变量 ${variable.id}(节点 ${variable.nodeId})在 ${new Date(fromMs).toISOString()} ~ ${new Date(asOf).toISOString()} 无样本`)
+    }
+    pointsByVariable.set(variable.id, points)
+  }
+
+  const history: number[][] = []
+  const timestamps: number[] = []
+  const qualityMask: boolean[][] = []
+  const watermarks: number[] = []
+  let anyIngest = false
+  for (let i = H - 1; i >= 0; i--) {
+    const t = asOf - i * beat
+    const row: number[] = []
+    const mask: boolean[] = []
+    for (const variable of spec.variables) {
+      const points = pointsByVariable.get(variable.id) ?? []
+      const hit = valueAt(points, t, beat * 1.5)
+      if (hit && hit.state === 'ok') {
+        row.push(toModel(hit.value, variable))
+        mask.push(true)
+        const ingested = points.filter(p => p.at === t && p.ingestedAt != null).map(p => p.ingestedAt as number)
+        if (ingested.length) {
+          anyIngest = true
+          watermarks.push(Math.max(...ingested))
+        }
+      }
+      else {
+        // 坏点/过期点不进入历史(否则常量持值会伪装成观测)
+        row.push(Number.NaN)
+        mask.push(false)
+      }
+    }
+    history.push(row)
+    timestamps.push(t)
+    qualityMask.push(mask)
+  }
+
+  // 历史末行必须全部可观测(MV/CV 都不允许 NaN);否则明确拒绝,不用持值/复制伪造
+  const lastRow = history[history.length - 1] ?? []
+  const missing = spec.variables.filter((v, idx) => !Number.isFinite(lastRow[idx]))
+  if (missing.length) {
+    throw new AppError(422, 'CONTEXT_INSUFFICIENT', `历史末点缺少可观测变量:${missing.map(v => v.id).join(', ')}`)
+  }
+
+  const conditionId = requireCondition(spec, asOf)
+  const currentInputs: Record<string, number> = {}
+  const currentOutputs: Record<string, number> = {}
+  for (let idx = 0; idx < spec.variables.length; idx++) {
+    const variable = spec.variables[idx]!
+    const value = lastRow[idx]!
+    if (variable.role === 'mv') {
+      const domain = spec.effectiveDomain.mv[variable.id]
+      if (domain && (value < domain.min - 1e-9 || value > domain.max + 1e-9)) {
+        throw new AppError(422, 'CONTEXT_OOD', `当前 MV ${variable.id}=${value} 超出模型有效域[${domain.min}, ${domain.max}];拒绝用域外状态求解`)
+      }
+      currentInputs[variable.id] = value
+    }
+    if (variable.role === 'cv') {
+      const domain = spec.effectiveDomain.cv?.[variable.id]
+      if (domain && (value < domain.min - 1e-9 || value > domain.max + 1e-9)) {
+        throw new AppError(422, 'CONTEXT_OOD', `当前 CV ${variable.id}=${value} 超出模型有效域[${domain.min}, ${domain.max}]`)
+      }
+      currentOutputs[variable.id] = value
+    }
+  }
+
+  return {
+    lineId: spec.lineId,
+    productId: spec.productId,
+    recipeId: spec.recipeId,
+    recipeVersion: spec.recipeVersion,
+    conditionId,
+    capturedAt: new Date().toISOString(),
+    eventAsOf: asOf,
+    availabilityWatermark: anyIngest ? Math.max(...watermarks) : null,
+    dtMs: beat,
+    variables: spec.variables,
+    history,
+    timestamps,
+    qualityMask,
+    currentInputs,
+    currentOutputs,
+    evidenceSource: 'unassessed',
+  }
+}
+
+function requireCondition(spec: ProcessModelSpec, _asOf: number): string {
+  // 运行时用声明身份 exactly-one 命中(exactly-one 由 matchCondition 强制);
+  // 批次谱系段版本不一致 → 旧计划失效。
+  const segment = getContextSegmentRepo().at(spec.lineId, _asOf)
+  if (segment && segment.confirmed === 1) {
+    if (segment.recipeId !== spec.recipeId) {
+      throw new AppError(409, 'CONDITION_MISMATCH', `运行批次已切换到配方 ${segment.recipeId},与模型规格 ${spec.recipeId} 不一致;旧计划失效`)
+    }
+    if (segment.recipeVersion !== 0 && segment.recipeVersion !== spec.recipeVersion) {
+      throw new AppError(409, 'CONDITION_MISMATCH', `运行批次配方版本 v${segment.recipeVersion} 与模型规格 v${spec.recipeVersion} 不一致;旧计划失效`)
+    }
+  }
+  return matchCondition(spec.conditions, {
+    lineId: spec.lineId, productId: spec.productId, recipeId: spec.recipeId, recipeVersion: spec.recipeVersion,
+  })
+}
+
+/** 运行批次开段(线开跑时调用):冻结配方内容 hash 与版本。 */
+export function openContextSegment(run: { id: string, lineId: string, recipeId: string, startedAt: string, recipeVersion?: number, paramsSnapshot?: unknown }): void {
+  const recipe = getDcwRecipeRepo().byId(run.recipeId)
+  const version = run.recipeVersion ?? recipe?.version ?? 0
+  const hash = recipe
+    ? recipeContentHash(recipe, run.paramsSnapshot)
+    : recipeContentHash({ id: run.recipeId, version })
+  getContextSegmentRepo().insert({
+    lineId: run.lineId,
+    runId: run.id,
+    fromTs: Date.parse(run.startedAt),
+    toTs: null,
+    recipeId: run.recipeId,
+    recipeVersion: version,
+    recipeContentHash: hash,
+    conditionId: '',
+    source: 'line_run',
+    confirmed: true,
+  })
+}
+
+/** 运行批次关段(线停止时调用)。 */
+export function closeContextSegment(runId: string, atMs?: number): void {
+  getContextSegmentRepo().close(runId, atMs ?? Date.now())
+}