agentworkshop 0.7.44 → 0.7.46

package/server/services/workshop/aml/python/train-hybrid-example.py

@@ -0,0 +1,87 @@
+# -*- coding: utf-8 -*-
+"""AML Hybrid Twin 参考训练器。
+
+物理优先：先用 physics.py/physics_parameters.json 给出主干预测，网络只学习有界残差。
+输入：AML bundle x [N,H,nAll]，y [N,F,nTgt]；物理主干输出可由 job workspace 注入。
+输出：artifacts/model.pt、model.onnx、physics_parameters.json、hybrid_metrics.json。
+
+生产提交前必须由平台门禁重新计算指标；本文件不授予任何 DCW 权限。
+"""
+import json
+import os
+from pathlib import Path
+
+import numpy as np
+import torch
+import torch.nn as nn
+
+import amlkit
+
+
+class BoundedResidual(nn.Module):
+    def __init__(self, n_in: int, n_out: int, hidden: int = 64, residual_scale: float = 0.25):
+        super().__init__()
+        self.residual_scale = float(residual_scale)
+        self.net = nn.Sequential(
+            nn.Flatten(),
+            nn.Linear(n_in, hidden),
+            nn.Tanh(),
+            nn.Linear(hidden, n_out),
+            nn.Tanh(),
+        )
+
+    def forward(self, x):
+        return self.residual_scale * self.net(x)
+
+
+def main():
+    job_dir = Path(os.environ["AML_JOB_DIR"]).resolve()
+    job = json.loads((job_dir / "job.json").read_text(encoding="utf-8"))
+    bundle = amlkit.load_bundle(job["datasetPath"])
+    manifest = bundle.manifest
+    params = job.get("params", {})
+    x = torch.tensor(bundle.get("x", "train"), dtype=torch.float32)
+    y = torch.tensor(bundle.get("y", "train")[:, 0, :], dtype=torch.float32)
+    if x.shape[0] == 0:
+        raise RuntimeError("HYBRID_EMPTY_TRAIN")
+
+    n_in = int(np.prod(x.shape[1:]))
+    n_out = int(y.shape[-1])
+    model = BoundedResidual(n_in, n_out, int(params.get("hidden", 64)), float(params.get("residual_scale", 0.25)))
+    optimizer = torch.optim.Adam(model.parameters(), lr=float(params.get("lr", 1e-3)))
+    epochs = int(params.get("epochs", 80))
+    loss_fn = nn.MSELoss()
+    for epoch in range(epochs):
+        model.train()
+        optimizer.zero_grad()
+        residual = model(x)
+        # 物理优先：此处默认 physics_next=0，真实场景由 provider 输出后写入 bundle/physics target。
+        loss_data = loss_fn(residual, y)
+        loss_bound = torch.mean(torch.relu(torch.abs(residual) - float(params.get("residual_scale", 0.25))) ** 2)
+        loss = loss_data + 0.1 * loss_bound
+        loss.backward()
+        optimizer.step()
+        if epoch % max(1, epochs // 20) == 0 or epoch == epochs - 1:
+            amlkit.report_progress(5 + int(85 * (epoch + 1) / epochs), f"hybrid epoch={epoch + 1}/{epochs} loss={float(loss):.6f}")
+
+    model.eval()
+    artifact_dir = Path(amlkit._artifacts_dir())
+    torch.save({"state_dict": model.state_dict(), "residual_scale": model.residual_scale}, artifact_dir / "model.pt")
+    amlkit.export_torch_onnx(model, manifest)
+    physics_params = job.get("physicsParameters", {})
+    (artifact_dir / "physics_parameters.json").write_text(json.dumps(physics_params, ensure_ascii=False, indent=2), encoding="utf-8")
+    metrics = {
+        "kind": "hybrid_physics_residual",
+        "backend": "pytorch",
+        "residualBound": model.residual_scale,
+        "epochs": epochs,
+        "trainRows": int(x.shape[0]),
+        "physicsFirst": True,
+    }
+    amlkit.save_metrics({"hybrid": metrics})
+    (artifact_dir / "hybrid_metrics.json").write_text(json.dumps(metrics, ensure_ascii=False, indent=2), encoding="utf-8")
+    amlkit.report_progress(99, "hybrid artifacts exported")
+
+
+if __name__ == "__main__":
+    main()

package/server/services/workshop/aml/twin/acceptance.ts

@@ -0,0 +1,68 @@
+import type { SceneContract, VirtualTrial } from './contracts'
+
+export interface TwinAcceptanceProfile {
+  model: { oneStepTestNrmseMax: number, rolloutTestNrmseMax: number, valTestGapMax: number, minRows: number, minRuns: number }
+  uncertainty: { coverageTarget: number, minCalibrationRows: number, falseSafeRateMax: number, minWriteEligibleCandidateCount: number, minTrialCount: number }
+  physics: { hardConstraintViolationRateMax: number, solverFailureRateMax: number }
+}
+
+export const DEFAULT_ACCEPTANCE_PROFILE: TwinAcceptanceProfile = {
+  model: { oneStepTestNrmseMax: 0.10, rolloutTestNrmseMax: 0.25, valTestGapMax: 0.20, minRows: 500, minRuns: 3 },
+  uncertainty: { coverageTarget: 0.90, minCalibrationRows: 300, falseSafeRateMax: 0, minWriteEligibleCandidateCount: 10, minTrialCount: 10 },
+  physics: { hardConstraintViolationRateMax: 0, solverFailureRateMax: 0 },
+}
+
+export interface HybridGateInput {
+  rows: number
+  runs: number
+  oneStepTestNrmse: number
+  rolloutTestNrmse: number
+  valTestGap: number
+  calibrationRows: number
+  calibrationCoverage: number
+  candidateTrials: VirtualTrial[]
+  physicsSolverFailureRate: number
+}
+
+export interface HybridGateResult {
+  passed: boolean
+  stage: 'candidate' | 'shadow' | 'recommendation_only' | 'write_eligible'
+  checks: Array<{ id: string, passed: boolean, value: number | string | boolean | null, detail: string }>
+  rejectCodes: string[]
+}
+
+export function evaluateHybridGates(input: HybridGateInput, profile = DEFAULT_ACCEPTANCE_PROFILE): HybridGateResult {
+  const checks: HybridGateResult['checks'] = []
+  const rejectCodes: string[] = []
+  const add = (id: string, passed: boolean, value: number | string | boolean | null, detail: string, code = id) => {
+    checks.push({ id, passed, value, detail })
+    if (!passed) rejectCodes.push(code)
+  }
+  add('G0_ROWS', input.rows >= profile.model.minRows, input.rows, `rows ${input.rows}/${profile.model.minRows}`)
+  add('G0_RUNS', input.runs >= profile.model.minRuns, input.runs, `runs ${input.runs}/${profile.model.minRuns}`)
+  add('G1_SINGLE_STEP', input.oneStepTestNrmse <= profile.model.oneStepTestNrmseMax, input.oneStepTestNrmse, `NRMSE ${input.oneStepTestNrmse}`)
+  add('G2_ROLLOUT', input.rolloutTestNrmse <= profile.model.rolloutTestNrmseMax, input.rolloutTestNrmse, `rollout ${input.rolloutTestNrmse}`)
+  add('G3_GENERALIZATION', input.valTestGap <= profile.model.valTestGapMax, input.valTestGap, `gap ${input.valTestGap}`)
+  add('G4_CALIBRATION_ROWS', input.calibrationRows >= profile.uncertainty.minCalibrationRows, input.calibrationRows, `calibration rows ${input.calibrationRows}`)
+  add('G4_COVERAGE', input.calibrationCoverage >= profile.uncertainty.coverageTarget, input.calibrationCoverage, `coverage ${input.calibrationCoverage}`)
+  add('G5_PHYSICS_FAILURE', input.physicsSolverFailureRate <= profile.physics.solverFailureRateMax, input.physicsSolverFailureRate, `solver failure ${input.physicsSolverFailureRate}`)
+  const candidateCount = input.candidateTrials.length
+  const hardViolations = input.candidateTrials.filter(t => t.constraintResults.some(c => !c.passed)).length
+  add('G6_CANDIDATE_COUNT', candidateCount >= profile.uncertainty.minWriteEligibleCandidateCount, candidateCount, `candidate trials ${candidateCount}`)
+  add('G6_TRIAL_COUNT', candidateCount >= profile.uncertainty.minTrialCount, candidateCount, `trial count ${candidateCount}`)
+  add('G6_HARD_VIOLATION', candidateCount > 0 && hardViolations === 0, hardViolations, `hard violating candidates ${hardViolations}`)
+  const uqSafe = candidateCount > 0 && input.candidateTrials.every(t => t.outOfDistribution.accepted && t.uncertainty.coverage >= profile.uncertainty.coverageTarget)
+  add('G7_UQ_OOD', uqSafe, uqSafe, 'all candidate trials must pass UQ/OOD')
+  const passed = checks.every(c => c.passed)
+  return { passed, stage: passed ? 'write_eligible' : 'candidate', checks, rejectCodes }
+}
+
+export function chooseTuningMode(gates: HybridGateResult): 'safe_small_step' | 'precise_search' {
+  return gates.passed ? 'precise_search' : 'safe_small_step'
+}
+
+export function validateSceneForMpc(scene: SceneContract): void {
+  if (!scene.controls.length) throw new Error('MPC_NO_CONTROLS')
+  if (!scene.observations.length) throw new Error('MPC_NO_TARGETS')
+  if (scene.writePolicy.minNodeIntervalSec < 60 || scene.writePolicy.minLineActionIntervalSec < 60) throw new Error('MPC_WRITE_INTERVAL_BELOW_60S')
+}

package/server/services/workshop/aml/twin/calibration-scheduler.ts

@@ -0,0 +1,48 @@
+import type { DatabaseSync } from 'node:sqlite'
+import { createId } from './contracts'
+
+export interface TwinCalibrationPolicy {
+  policyVersion: string
+  minNewRuns: number
+  minNewRows: number
+  cooldownSec: number
+  maxConcurrentRuns: number
+  shadowRequired: boolean
+  approvalRequired: boolean
+}
+
+export interface TwinCalibrationSignal {
+  sceneId: string
+  lineId: string
+  recipeId: string
+  newRuns: number
+  newRows: number
+  driftScore?: number
+  errorScore?: number
+  reason: string
+}
+
+export function shouldTriggerCalibration(signal: TwinCalibrationSignal, policy: TwinCalibrationPolicy): boolean {
+  return signal.newRuns >= policy.minNewRuns || signal.newRows >= policy.minNewRows || (signal.driftScore ?? 0) > 0.2 || (signal.errorScore ?? 0) > 0.15
+}
+
+export function requestCalibration(db: DatabaseSync, signal: TwinCalibrationSignal, policy: TwinCalibrationPolicy, createdBy: string): { accepted: boolean, reason: string, updateRunId?: string } {
+  if (!shouldTriggerCalibration(signal, policy)) return { accepted: false, reason: 'TRIGGER_THRESHOLD_NOT_REACHED' }
+  const dedupKey = `${signal.sceneId}:${signal.lineId}:${signal.recipeId}:${policy.policyVersion}`
+  const active = db.prepare(`SELECT id,state,cooldown_until AS cooldownUntil FROM twin_update_runs WHERE dedup_key=? AND state IN ('queued','running','cooldown') ORDER BY created_at DESC LIMIT 1`).get(dedupKey) as { id?: string, state?: string, cooldownUntil?: string } | undefined
+  if (active) return { accepted: false, reason: `ACTIVE_OR_COOLDOWN:${active.state}`, updateRunId: active.id }
+  const id = createId('twin-update')
+  const now = new Date().toISOString()
+  db.prepare(`INSERT INTO twin_update_runs(id,request_id,dedup_key,scene_id,line_id,recipe_id,state,cooldown_until,payload_json,error,created_at) VALUES(?,?,?,?,?,?,?,?,?,?,?)`).run(id, id, dedupKey, signal.sceneId, signal.lineId, signal.recipeId, 'queued', new Date(Date.now() + policy.cooldownSec * 1000).toISOString(), JSON.stringify({ signal, policy, createdBy }), '', now)
+  return { accepted: true, reason: 'QUEUED_FOR_AGENTTEAM_CALIBRATION', updateRunId: id }
+}
+
+export const DEFAULT_TWIN_CALIBRATION_POLICY: TwinCalibrationPolicy = {
+  policyVersion: 'twin-calibration-v1',
+  minNewRuns: 3,
+  minNewRows: 500,
+  cooldownSec: 3600,
+  maxConcurrentRuns: 1,
+  shadowRequired: true,
+  approvalRequired: true,
+}

package/server/services/workshop/aml/twin/channel-profile.ts

@@ -0,0 +1,43 @@
+import type { DatabaseSync } from 'node:sqlite'
+import { getAmlRuntime } from '../../aml/runtime'
+
+export interface HybridChannelProfile {
+  channelId: string
+  profile: 'legacy' | 'hybrid_twin'
+  capability: Record<string, unknown>
+  sceneId?: string
+  sceneVersion?: string
+  sceneContract?: Record<string, unknown>
+  objective?: Record<string, unknown>
+  controlPolicy: 'recommendation_only' | 'hitl_governed' | 'bounded_auto'
+}
+
+function repo(db: DatabaseSync) {
+  const upsert = db.prepare(`INSERT INTO aml_channel_profiles(channel_id,profile,capability_json,scene_id,scene_version,scene_contract_json,objective_json,control_policy,created_by,created_at,updated_at)
+    VALUES(?,?,?,?,?,?,?,?,?,?,?)
+    ON CONFLICT(channel_id) DO UPDATE SET profile=excluded.profile, capability_json=excluded.capability_json, scene_id=excluded.scene_id, scene_version=excluded.scene_version, scene_contract_json=excluded.scene_contract_json, objective_json=excluded.objective_json, control_policy=excluded.control_policy, updated_at=excluded.updated_at`)
+  const get = db.prepare(`SELECT channel_id AS channelId, profile, capability_json AS capabilityJson, scene_id AS sceneId, scene_version AS sceneVersion, scene_contract_json AS sceneContractJson, objective_json AS objectiveJson, control_policy AS controlPolicy FROM aml_channel_profiles WHERE channel_id=?`)
+  return { upsert, get }
+}
+
+export function setHybridChannelProfile(input: Omit<HybridChannelProfile, 'channelId'> & { channelId: string, createdBy?: string }): HybridChannelProfile {
+  const rt = getAmlRuntime()
+  const now = new Date().toISOString()
+  repo(rt.db).upsert.run(input.channelId, input.profile, JSON.stringify(input.capability ?? {}), input.sceneId ?? null, input.sceneVersion ?? null, JSON.stringify(input.sceneContract ?? {}), JSON.stringify(input.objective ?? {}), input.controlPolicy ?? 'recommendation_only', input.createdBy ?? 'system', now, now)
+  return input
+}
+
+export function getChannelTwinProfile(channelId: string): HybridChannelProfile {
+  try {
+    const row = repo(getAmlRuntime().db).get.get(channelId) as Record<string, unknown> | undefined
+    if (!row) return { channelId, profile: 'legacy', capability: {}, controlPolicy: 'recommendation_only' }
+    return { channelId, profile: String(row.profile) === 'hybrid_twin' ? 'hybrid_twin' : 'legacy', capability: JSON.parse(String(row.capabilityJson ?? '{}')), sceneId: row.sceneId ? String(row.sceneId) : undefined, sceneVersion: row.sceneVersion ? String(row.sceneVersion) : undefined, sceneContract: JSON.parse(String(row.sceneContractJson ?? '{}')), objective: JSON.parse(String(row.objectiveJson ?? '{}')), controlPolicy: (['recommendation_only', 'hitl_governed', 'bounded_auto'] as const).includes(row.controlPolicy as never) ? row.controlPolicy as HybridChannelProfile['controlPolicy'] : 'recommendation_only' }
+  }
+  catch {
+    return { channelId, profile: 'legacy', capability: {}, controlPolicy: 'recommendation_only' }
+  }
+}
+
+export function isHybridTwinChannel(channelId: string): boolean {
+  return getChannelTwinProfile(channelId).profile === 'hybrid_twin'
+}

package/server/services/workshop/aml/twin/contracts.ts

@@ -0,0 +1,215 @@
+import { createHash } from 'node:crypto'
+import { z } from 'zod'
+
+export type TwinRole = 'control' | 'state' | 'feature' | 'disturbance' | 'observation' | 'target' | 'guard'
+
+export interface SceneVariable {
+  id: string
+  nodeId?: string
+  role: TwinRole
+  physicalMeaning: string
+  unit: string
+  min?: number
+  max?: number
+  maxStep?: number
+  samplingPeriodMs?: number
+  phaseScope?: string[]
+}
+
+export interface SceneContract {
+  schemaVersion: number
+  createdAt: string
+  createdBy: string
+  sceneId: string
+  sceneVersion: string
+  lineId: string
+  productId?: string
+  recipeId?: string
+  phases: string[]
+  controls: SceneVariable[]
+  states: SceneVariable[]
+  disturbances: SceneVariable[]
+  observations: SceneVariable[]
+  guards: SceneVariable[]
+  constraints: Array<{ id: string, kind: 'hard_range' | 'max_delta' | 'rate' | 'custom', expression?: string, min?: number, max?: number }>
+  physicsProfileId: string
+  objectiveProfileIds: string[]
+  writePolicy: {
+    minNodeIntervalSec: number
+    minLineActionIntervalSec: number
+    maxActionsPerRun: number
+    maxDeltaPerAction: Record<string, number>
+  }
+}
+
+export interface NodeBindingSnapshot {
+  schemaVersion: number
+  createdAt: string
+  createdBy: string
+  snapshotId: string
+  channelId: string
+  bindingEpoch: string
+  sceneId: string
+  sceneVersion: string
+  bindings: Array<{
+    agentId: string
+    agentRole: string
+    nodeId: string
+    kind: 'daq' | 'dcw'
+    mode: 'auto' | 'manual'
+    controlPolicy: 'recommendation_only' | 'hitl_governed' | 'bounded_auto'
+    lineId: string
+    physicalMeaning: string
+    unit: string
+    min?: number
+    max?: number
+    samplePeriodMs?: number
+  }>
+  snapshotHash: string
+}
+
+export interface PhysicsModelManifest {
+  schemaVersion: number
+  createdAt: string
+  createdBy: string
+  physicsModelId: string
+  version: string
+  sceneId: string
+  backend: 'pytorch' | 'typescript'
+  stateVariables: string[]
+  controlVariables: string[]
+  disturbanceVariables: string[]
+  parameters: Record<string, { value: number, min?: number, max?: number, unit?: string }>
+  parameterPriors: Record<string, { min: number, max: number }>
+  sourceHash?: string
+  artifactHash?: string
+}
+
+export interface TwinSnapshot {
+  schemaVersion: number
+  createdAt: string
+  createdBy: string
+  snapshotId: string
+  sceneId: string
+  sceneVersion: string
+  lineId: string
+  productId?: string
+  recipeId?: string
+  phase: string
+  capturedAt: string
+  daqWatermark: number
+  sourceSequence?: string
+  controlValues: Record<string, number>
+  stateEstimate: Record<string, number>
+  disturbances: Record<string, number>
+  dataQuality: { fresh: boolean, completeness: number, staleNodeIds: string[], duplicateCount?: number }
+  estimatorVersion: string
+  bindingSnapshotHash?: string
+  physicsModelVersion?: string
+  residualModelVersion?: string
+  snapshotHash: string
+}
+
+export interface ObjectiveProfile {
+  schemaVersion: number
+  createdAt: string
+  createdBy: string
+  objectiveId: string
+  twinModelId?: string
+  targets: Record<string, number>
+  weights: Record<string, number>
+  controlCosts: Record<string, number>
+  horizonSteps: number
+  trustRegion: Record<string, { min?: number, max?: number, maxDelta?: number }>
+}
+
+export interface VirtualTrial {
+  schemaVersion: number
+  createdAt: string
+  createdBy: string
+  trialId: string
+  snapshotId: string
+  modelId: string
+  objectiveId: string
+  candidateControlTrajectory: Array<Record<string, number>>
+  predictedTrajectory: Array<Record<string, number>>
+  uncertainty: { maxStd: number, coverage: number, ensembleSize: number }
+  outOfDistribution: { distance: number, disagreement: number, accepted: boolean, rejectCode?: string }
+  constraintResults: Array<{ id: string, passed: boolean, detail: string, firstViolationStep?: number }>
+  baselineComparison: { baselineCost: number, candidateCost: number, improvement: number }
+  candidateExecuted: false
+  provenance: Record<string, string>
+}
+
+export interface RecommendationCertificate {
+  schemaVersion: number
+  createdAt: string
+  createdBy: string
+  recommendationId: string
+  trialId: string
+  snapshotHash: string
+  modelHash: string
+  objectiveHash: string
+  recipeHash?: string
+  candidateControlTrajectory: Array<Record<string, number>>
+  constraintDigest: string
+  uncertainty: VirtualTrial['uncertainty']
+  outOfDistribution: VirtualTrial['outOfDistribution']
+  candidateExecuted: false
+  status: 'ISSUED' | 'EXPIRED' | 'REVOKED'
+  certificateHash: string
+}
+
+export const sceneContractSchema = z.object({
+  schemaVersion: z.number().int().positive(),
+  createdAt: z.string().min(1),
+  createdBy: z.string().min(1),
+  sceneId: z.string().min(1),
+  sceneVersion: z.string().min(1),
+  lineId: z.string().min(1),
+  productId: z.string().optional(),
+  recipeId: z.string().optional(),
+  phases: z.array(z.string().min(1)).min(1),
+  controls: z.array(z.object({ id: z.string(), nodeId: z.string().optional(), role: z.literal('control'), physicalMeaning: z.string(), unit: z.string(), min: z.number().optional(), max: z.number().optional(), maxStep: z.number().positive().optional(), samplingPeriodMs: z.number().positive().optional(), phaseScope: z.array(z.string()).optional() })),
+  states: z.array(z.any()),
+  disturbances: z.array(z.any()),
+  observations: z.array(z.any()),
+  guards: z.array(z.any()),
+  constraints: z.array(z.any()),
+  physicsProfileId: z.string().min(1),
+  objectiveProfileIds: z.array(z.string()),
+  writePolicy: z.object({ minNodeIntervalSec: z.number().min(60), minLineActionIntervalSec: z.number().min(60), maxActionsPerRun: z.number().int().positive(), maxDeltaPerAction: z.record(z.number().positive()) }),
+})
+
+function stable(value: unknown): unknown {
+  if (Array.isArray(value)) return value.map(stable)
+  if (value && typeof value === 'object') {
+    return Object.fromEntries(Object.entries(value as Record<string, unknown>).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => [k, stable(v)]))
+  }
+  return value
+}
+
+export function canonicalJson(value: unknown): string {
+  return JSON.stringify(stable(value))
+}
+
+export function sha256(value: unknown): string {
+  return createHash('sha256').update(typeof value === 'string' ? value : canonicalJson(value)).digest('hex')
+}
+
+export function createId(prefix: string): string {
+  return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`
+}
+
+export function parseSceneContract(input: unknown): SceneContract {
+  return sceneContractSchema.parse(input) as SceneContract
+}
+
+export function hashWithout(value: Record<string, unknown>, keys: string[]): string {
+  const clone = Object.fromEntries(Object.entries(value).filter(([key]) => !keys.includes(key)))
+  return sha256(clone)
+}
+
+export function hashConstraintResults(results: unknown[]): string {
+  return sha256(results)
+}

package/server/services/workshop/aml/twin/physics-runtime.ts

@@ -0,0 +1,165 @@
+import { type PhysicsModelManifest, type SceneContract, sha256 } from './contracts'
+
+export interface PhysicsState { [key: string]: number }
+export interface PhysicsInput { state: PhysicsState, controls: Record<string, number>, disturbances?: Record<string, number>, dtSec?: number }
+export interface PhysicsStepResult { state: PhysicsState, observations: Record<string, number>, guards: Record<string, number> }
+export interface PhysicsTrajectory { steps: PhysicsStepResult[], failures: string[] }
+
+export interface PhysicsModelProvider {
+  readonly manifest: PhysicsModelManifest
+  initialize(snapshot: { stateEstimate: Record<string, number>, controlValues: Record<string, number> }): PhysicsState
+  step(input: PhysicsInput): PhysicsStepResult
+  simulate(initial: PhysicsState, controls: Array<Record<string, number>>, disturbances?: Record<string, number>): PhysicsTrajectory
+  evaluateConstraints(scene: SceneContract, trajectory: PhysicsTrajectory): Array<{ id: string, passed: boolean, detail: string, firstViolationStep?: number }>
+}
+
+/**
+ * 注塑第一版低阶灰箱模型：热状态/压力滞后/保压时间到质量指标。
+ * 这是安全的离线/VirtualTrial 模型，不拥有任何 DAQ/DCW 网络能力。
+ */
+export class InjectionGreyboxProvider implements PhysicsModelProvider {
+  readonly manifest: PhysicsModelManifest = {
+    schemaVersion: 1,
+    createdAt: new Date().toISOString(),
+    createdBy: 'aml-twin-runtime',
+    physicsModelId: 'injection-greybox-v1',
+    version: '1.0.0',
+    sceneId: 'injection-hold-control',
+    backend: 'typescript',
+    stateVariables: ['melt_temperature', 'cavity_pressure', 'fill_fraction'],
+    controlVariables: ['hold_pressure', 'hold_time', 'melt_temperature_setpoint'],
+    disturbanceVariables: ['ambient_temperature', 'material_batch_factor'],
+    parameters: {
+      pressureGain: { value: 0.10, min: 0.02, max: 0.30, unit: 'g/bar' },
+      pressureTauSec: { value: 5, min: 1, max: 30, unit: 's' },
+      thermalTauSec: { value: 25, min: 5, max: 120, unit: 's' },
+      weightBase: { value: 31.8, min: 20, max: 50, unit: 'g' },
+      weightTempGain: { value: 0.015, min: -0.1, max: 0.1, unit: 'g/degC' },
+    },
+    parameterPriors: {
+      pressureGain: { min: 0.02, max: 0.30 },
+      pressureTauSec: { min: 1, max: 30 },
+      thermalTauSec: { min: 5, max: 120 },
+      weightBase: { min: 20, max: 50 },
+      weightTempGain: { min: -0.1, max: 0.1 },
+    },
+  }
+
+  initialize(snapshot: { stateEstimate: Record<string, number>, controlValues: Record<string, number> }): PhysicsState {
+    return {
+      melt_temperature: snapshot.stateEstimate.melt_temperature ?? snapshot.controlValues.melt_temperature_setpoint ?? 247,
+      cavity_pressure: snapshot.stateEstimate.cavity_pressure ?? snapshot.controlValues.hold_pressure ?? 65,
+      fill_fraction: snapshot.stateEstimate.fill_fraction ?? 1,
+    }
+  }
+
+  step(input: PhysicsInput): PhysicsStepResult {
+    const dt = Math.max(0.1, input.dtSec ?? 1)
+    const u = input.controls
+    const d = input.disturbances ?? {}
+    const p = this.manifest.parameters
+    const cavityPressure = input.state.cavity_pressure ?? 60
+    const meltTemperature = input.state.melt_temperature ?? 247
+    const fillFraction = input.state.fill_fraction ?? 1
+    const pressureTauSec = p.pressureTauSec?.value ?? 5
+    const thermalTauSec = p.thermalTauSec?.value ?? 25
+    const weightBase = p.weightBase?.value ?? 31.8
+    const pressureGain = p.pressureGain?.value ?? 0.10
+    const weightTempGain = p.weightTempGain?.value ?? 0.015
+    const pressure = cavityPressure + (dt / pressureTauSec) * ((u.hold_pressure ?? cavityPressure) - cavityPressure)
+    const temp = meltTemperature + (dt / thermalTauSec) * ((u.melt_temperature_setpoint ?? meltTemperature) - meltTemperature) + (d.ambient_temperature ?? 23) * 0.0005
+    const fill = Math.min(1, Math.max(0, fillFraction + dt * 0.05))
+    const batch = d.material_batch_factor ?? 1
+    const weight = weightBase + pressureGain * (pressure - 60) + weightTempGain * (temp - 247) + (batch - 1) * 0.25
+    const flash = Math.max(0, (pressure - 78) * 0.12)
+    const sink = Math.max(0, (70 - pressure) * 0.035 + (temp - 250) * 0.02)
+    return {
+      state: { melt_temperature: temp, cavity_pressure: pressure, fill_fraction: fill },
+      observations: { weight, flash_rate: flash, sink_rate: sink, melt_temperature: temp, cavity_pressure: pressure },
+      guards: { pressure, temperature: temp, fill_fraction: fill },
+    }
+  }
+
+  simulate(initial: PhysicsState, controls: Array<Record<string, number>>, disturbances: Record<string, number> = {}): PhysicsTrajectory {
+    let state = { ...initial }
+    const steps: PhysicsStepResult[] = []
+    const failures: string[] = []
+    for (const control of controls) {
+      const result = this.step({ state, controls: control, disturbances, dtSec: 1 })
+      if (Object.values(result.observations).some(v => !Number.isFinite(v))) failures.push('PHYSICS_NON_FINITE')
+      state = result.state
+      steps.push(result)
+    }
+    return { steps, failures }
+  }
+
+  evaluateConstraints(scene: SceneContract, trajectory: PhysicsTrajectory): Array<{ id: string, passed: boolean, detail: string, firstViolationStep?: number }> {
+    return scene.constraints.map((constraint) => {
+      for (let i = 0; i < trajectory.steps.length; i++) {
+        const obs = trajectory.steps[i]?.observations ?? {}
+        const value = obs[constraint.id] ?? trajectory.steps[i]?.guards[constraint.id]
+        if (constraint.kind === 'hard_range' && value != null && ((constraint.min != null && value < constraint.min) || (constraint.max != null && value > constraint.max))) {
+          return { id: constraint.id, passed: false, detail: `${constraint.id}=${value} 越过 ${constraint.min ?? '-∞'}~${constraint.max ?? '∞'}`, firstViolationStep: i }
+        }
+      }
+      return { id: constraint.id, passed: true, detail: '全轨迹通过' }
+    })
+  }
+}
+
+export function defaultInjectionScene(createdBy = 'aml-twin-runtime'): SceneContract {
+  return {
+    schemaVersion: 1,
+    createdAt: new Date().toISOString(),
+    createdBy,
+    sceneId: 'injection-hold-control',
+    sceneVersion: '1.0.0',
+    lineId: 'line-injection-01',
+    productId: 'product-injection-a',
+    recipeId: 'recipe-injection-a',
+    phases: ['startup', 'filling', 'holding', 'cooling', 'completed'],
+    controls: [
+      { id: 'hold_pressure', role: 'control', physicalMeaning: '保压压力设定', unit: 'bar', min: 50, max: 90, maxStep: 2 },
+      { id: 'hold_time', role: 'control', physicalMeaning: '保压时间设定', unit: 's', min: 4, max: 14, maxStep: 0.5 },
+      { id: 'melt_temperature_setpoint', role: 'control', physicalMeaning: '熔体温度设定', unit: 'degC', min: 235, max: 260, maxStep: 2 },
+    ],
+    states: [
+      { id: 'melt_temperature', role: 'state', physicalMeaning: '熔体温度状态', unit: 'degC' },
+      { id: 'cavity_pressure', role: 'state', physicalMeaning: '模腔压力状态', unit: 'bar' },
+    ],
+    disturbances: [{ id: 'material_batch_factor', role: 'disturbance', physicalMeaning: '材料批次因子', unit: 'ratio' }],
+    observations: [
+      { id: 'weight', role: 'target', physicalMeaning: '制品重量', unit: 'g', min: 31, max: 34 },
+      { id: 'flash_rate', role: 'guard', physicalMeaning: '飞边率', unit: '%' },
+      { id: 'sink_rate', role: 'guard', physicalMeaning: '缩痕率', unit: '%' },
+    ],
+    guards: [],
+    constraints: [
+      { id: 'weight', kind: 'hard_range', min: 31, max: 34 },
+      { id: 'flash_rate', kind: 'hard_range', min: 0, max: 1.0 },
+      { id: 'sink_rate', kind: 'hard_range', min: 0, max: 1.0 },
+      { id: 'pressure', kind: 'hard_range', min: 50, max: 90 },
+      { id: 'temperature', kind: 'hard_range', min: 235, max: 260 },
+    ],
+    physicsProfileId: 'injection-greybox-v1',
+    objectiveProfileIds: ['weight-quality'],
+    writePolicy: { minNodeIntervalSec: 60, minLineActionIntervalSec: 60, maxActionsPerRun: 3, maxDeltaPerAction: { hold_pressure: 2, hold_time: 0.5, melt_temperature_setpoint: 2 } },
+  }
+}
+
+export function smallStepCandidates(scene: SceneContract, baseline: Record<string, number>): Array<Record<string, number>> {
+  const out = [{ ...baseline }]
+  for (const control of scene.controls) {
+    const current = baseline[control.id]
+    if (current == null || !Number.isFinite(current) || !control.maxStep) continue
+    for (const sign of [-1, 1]) {
+      const value = Math.min(control.max ?? Infinity, Math.max(control.min ?? -Infinity, current + sign * control.maxStep))
+      out.push({ ...baseline, [control.id]: value })
+    }
+  }
+  return out
+}
+
+export function providerFingerprint(provider: PhysicsModelProvider): string {
+  return sha256(provider.manifest)
+}

package/server/services/workshop/aml/twin/repo.ts

@@ -0,0 +1,26 @@
+import type { DatabaseSync } from 'node:sqlite'
+import { sha256, type RecommendationCertificate, type SceneContract, type TwinSnapshot, type VirtualTrial } from './contracts'
+
+export function createTwinRepo(db: DatabaseSync) {
+  const upsertSceneStmt = db.prepare(`INSERT INTO twin_scenes(scene_id,scene_version,schema_version,contract_json,contract_hash,line_id,product_id,recipe_id,status,created_by,created_at,updated_at)
+    VALUES(?,?,?,?,?,?,?,?,?,?,?,?)
+    ON CONFLICT(scene_id,scene_version) DO UPDATE SET contract_json=excluded.contract_json, contract_hash=excluded.contract_hash, updated_at=excluded.updated_at`)
+  const insertSnapshotStmt = db.prepare(`INSERT OR IGNORE INTO twin_snapshots(id,scene_id,scene_version,line_id,product_id,recipe_id,phase,snapshot_hash,watermark_ms,freshness_json,payload_json,created_by,created_at) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?)`)
+  const insertTrialStmt = db.prepare(`INSERT OR IGNORE INTO twin_trials(id,snapshot_id,twin_model_id,objective_id,candidate_executed,status,result_json,result_hash,created_by,created_at) VALUES(?,?,?,?,0,?,?,?,?,?)`)
+  const insertRecStmt = db.prepare(`INSERT OR IGNORE INTO twin_recommendations(id,trial_id,certificate_hash,status,certificate_json,expires_at,created_by,created_at) VALUES(?,?,?,?,?,?,?,?)`)
+  return {
+    upsertScene(scene: SceneContract, createdBy: string): void {
+      const now = new Date().toISOString()
+      upsertSceneStmt.run(scene.sceneId, scene.sceneVersion, scene.schemaVersion, JSON.stringify(scene), sha256(scene), scene.lineId, scene.productId ?? '', scene.recipeId ?? '', 'draft', createdBy, scene.createdAt || now, now)
+    },
+    insertSnapshot(snapshot: TwinSnapshot): void {
+      insertSnapshotStmt.run(snapshot.snapshotId, snapshot.sceneId, snapshot.sceneVersion, snapshot.lineId, snapshot.productId ?? '', snapshot.recipeId ?? '', snapshot.phase, snapshot.snapshotHash, snapshot.daqWatermark, JSON.stringify(snapshot.dataQuality), JSON.stringify(snapshot), snapshot.createdBy, snapshot.createdAt)
+    },
+    insertTrial(trial: VirtualTrial, twinModelId?: string): void {
+      insertTrialStmt.run(trial.trialId, trial.snapshotId, twinModelId ?? trial.modelId, trial.objectiveId, 'completed', JSON.stringify(trial), sha256(trial), trial.createdBy, trial.createdAt)
+    },
+    insertRecommendation(certificate: RecommendationCertificate, createdBy: string, expiresAt?: string): void {
+      insertRecStmt.run(certificate.recommendationId, certificate.trialId, certificate.certificateHash, certificate.status.toLowerCase(), JSON.stringify(certificate), expiresAt ?? null, createdBy, certificate.createdAt)
+    },
+  }
+}