agentworkshop 0.7.48 → 0.7.50

package/server/services/workshop/aml/twin/training-plans.ts

@@ -0,0 +1,260 @@
+/**
+ * AML 建模任务(Training Plans)—— 训练与优化解耦的编排核心(2026-09-26 计划 v3)。
+ *
+ * 职责:AML 管理界面/训练 Channel 创建「建模任务」(绑定 line/product/recipe + 数据集
+ * IO 契约 + 固化训练 spec);worker 检测新批次 → 重建数据集(历史+新批次=修正训练)
+ * → submitJob(平台参考训练器,实验谱系串联)→ concludeJob 钩子回写状态与模型 id。
+ * 模型入册后由 AML 界面绑定到工艺优化 Channel(绑定校验在 channel-profile.ts)。
+ */
+import { createId } from './contracts'
+import { getAmlRuntime } from '../runtime'
+import { parseDatasetSpec, type AmlDatasetSpec } from '../spec'
+import { buildDataset } from '../dataset-builder'
+import { submitJob } from '../job-orchestrator/submit'
+import { getDcwController } from '../../dcw/dcw-controller'
+
+export interface AmlTrainingPlanRow {
+  id: string
+  name: string
+  lineId: string
+  productId: string
+  recipeId: string
+  sceneId?: string
+  sceneVersion?: string
+  objectiveId?: string
+  purpose: string
+  strategy: 'auto' | 'manual'
+  datasetSpecJson: string
+  trainingSpecJson?: string
+  modelNamePrefix: string
+  paramsJson: string
+  seed?: number
+  minIntervalSec: number
+  lastRunCount: number
+  lastJobId?: string
+  lastDatasetId?: string
+  lastModelId?: string
+  lastStatus: 'idle' | 'training' | 'done' | 'failed'
+  lastError?: string
+  lastTrainedAt?: string
+  enabled: number
+  createdBy: string
+  createdAt: string
+  updatedAt: string
+}
+
+const COLS = 'id,name,line_id,product_id,recipe_id,scene_id,scene_version,objective_id,purpose,strategy,dataset_spec_json,training_spec_json,model_name_prefix,params_json,seed,min_interval_sec,last_run_count,last_job_id,last_dataset_id,last_model_id,last_status,last_error,last_trained_at,enabled,created_by,created_at,updated_at'
+
+function rowOf(r: Record<string, unknown>): AmlTrainingPlanRow {
+  return {
+    id: String(r.id), name: String(r.name), lineId: String(r.line_id), productId: String(r.product_id), recipeId: String(r.recipe_id),
+    sceneId: r.scene_id ? String(r.scene_id) : undefined, sceneVersion: r.scene_version ? String(r.scene_version) : undefined,
+    objectiveId: r.objective_id ? String(r.objective_id) : undefined,
+    purpose: String(r.purpose), strategy: r.strategy === 'manual' ? 'manual' : 'auto',
+    datasetSpecJson: String(r.dataset_spec_json ?? '{}'), trainingSpecJson: r.training_spec_json ? String(r.training_spec_json) : undefined,
+    modelNamePrefix: String(r.model_name_prefix ?? 'AML 自动训练模型'), paramsJson: String(r.params_json ?? '{}'),
+    seed: r.seed != null ? Number(r.seed) : undefined,
+    minIntervalSec: Number(r.min_interval_sec ?? 3600), lastRunCount: Number(r.last_run_count ?? 0),
+    lastJobId: r.last_job_id ? String(r.last_job_id) : undefined, lastDatasetId: r.last_dataset_id ? String(r.last_dataset_id) : undefined,
+    lastModelId: r.last_model_id ? String(r.last_model_id) : undefined,
+    lastStatus: (['idle', 'training', 'done', 'failed'].includes(String(r.last_status)) ? String(r.last_status) : 'idle') as AmlTrainingPlanRow['lastStatus'],
+    lastError: r.last_error ? String(r.last_error) : undefined, lastTrainedAt: r.last_trained_at ? String(r.last_trained_at) : undefined,
+    enabled: Number(r.enabled ?? 1), createdBy: String(r.created_by ?? ''), createdAt: String(r.created_at), updatedAt: String(r.updated_at),
+  }
+}
+
+function db() {
+  return getAmlRuntime().db
+}
+
+export function listTrainingPlans(): AmlTrainingPlanRow[] {
+  return (db().prepare(`SELECT ${COLS} FROM aml_training_plans ORDER BY created_at DESC`).all() as Array<Record<string, unknown>>).map(rowOf)
+}
+
+export function getTrainingPlan(id: string): AmlTrainingPlanRow | undefined {
+  const r = db().prepare(`SELECT ${COLS} FROM aml_training_plans WHERE id = ?`).get(id) as Record<string, unknown> | undefined
+  return r ? rowOf(r) : undefined
+}
+
+export function createTrainingPlan(input: {
+  name: string
+  lineId: string
+  productId: string
+  recipeId: string
+  sceneId?: string
+  sceneVersion?: string
+  objectiveId?: string | null
+  purpose?: string
+  strategy?: 'auto' | 'manual'
+  datasetSpec: AmlDatasetSpec
+  trainingSpec?: Record<string, unknown>
+  modelNamePrefix?: string
+  params?: Record<string, unknown>
+  seed?: number
+  minIntervalSec?: number
+  createdBy?: string
+}): AmlTrainingPlanRow {
+  const parsed = parseDatasetSpec(input.datasetSpec)
+  const id = createId('aml-plan')
+  const now = new Date().toISOString()
+  db().prepare(`INSERT INTO aml_training_plans(${COLS}) VALUES(${COLS.split(',').map(() => '?').join(',')})`)
+    .run(id, String(input.name ?? '').slice(0, 120) || `建模任务 ${id.slice(-6)}`, input.lineId, input.productId, input.recipeId,
+      input.sceneId ?? null, input.sceneVersion ?? null, input.objectiveId ?? null,
+      input.purpose === 'quality_predict' ? 'quality_predict' : 'mpc_surrogate',
+      input.strategy === 'manual' ? 'manual' : 'auto',
+      JSON.stringify(parsed), input.trainingSpec ? JSON.stringify(input.trainingSpec) : null,
+      String(input.modelNamePrefix ?? 'AML 自动训练模型').slice(0, 80), JSON.stringify(input.params ?? {}), input.seed ?? null,
+      Math.max(60, Number(input.minIntervalSec ?? 3600)), 0, null, null, null, 'idle', null, null,
+      input.strategy === 'manual' ? 0 : 1, input.createdBy ?? 'system', now, now)
+  return getTrainingPlan(id)!
+}
+
+export function updateTrainingPlan(id: string, patch: {
+  name?: string
+  strategy?: 'auto' | 'manual'
+  trainingSpec?: Record<string, unknown> | null
+  objectiveId?: string | null
+  minIntervalSec?: number
+  enabled?: boolean
+  lastModelId?: string
+}): AmlTrainingPlanRow {
+  const prev = getTrainingPlan(id)
+  if (!prev) throw new Error(`建模任务不存在:${id}`)
+  const sets: string[] = []
+  const vals: Array<string | number | null> = []
+  if (patch.name !== undefined) {
+    sets.push('name=?')
+    vals.push(String(patch.name).slice(0, 120))
+  }
+  if (patch.strategy !== undefined) {
+    sets.push('strategy=?')
+    vals.push(patch.strategy)
+  }
+  if (patch.trainingSpec !== undefined) {
+    sets.push('training_spec_json=?')
+    vals.push(patch.trainingSpec === null ? null : JSON.stringify(patch.trainingSpec))
+  }
+  if (patch.objectiveId !== undefined) {
+    sets.push('objective_id=?')
+    vals.push(patch.objectiveId ?? null)
+  }
+  if (patch.minIntervalSec !== undefined) {
+    sets.push('min_interval_sec=?')
+    vals.push(Math.max(60, Number(patch.minIntervalSec)))
+  }
+  if (patch.enabled !== undefined) {
+    sets.push('enabled=?')
+    vals.push(patch.enabled ? 1 : 0)
+  }
+  if (patch.lastModelId !== undefined) {
+    sets.push('last_model_id=?')
+    vals.push(patch.lastModelId ?? null)
+  }
+  if (sets.length === 0) return prev
+  sets.push('updated_at=?')
+  vals.push(new Date().toISOString())
+  vals.push(id)
+  db().prepare(`UPDATE aml_training_plans SET ${sets.join(', ')} WHERE id=?`).run(...vals)
+  return getTrainingPlan(id)!
+}
+
+export function deleteTrainingPlan(id: string): boolean {
+  return db().prepare('DELETE FROM aml_training_plans WHERE id=?').run(id).changes > 0
+}
+
+/** 该产线+配方的已完结批次数(新批次检测基数) */
+function completedRunCount(lineId: string, recipeId: string): number {
+  try {
+    return getDcwController().listRuns().filter(r => r.lineId === lineId && (!r.recipeId || r.recipeId === recipeId) && r.endedAt).length
+  }
+  catch {
+    try {
+      return getDcwController().listRuns().filter(r => r.lineId === lineId && r.recipeId === recipeId).length
+    }
+    catch {
+      return 0
+    }
+  }
+}
+
+/**
+ * 触发一次建模任务的修正训练:
+ * 数据集重建(不传 runIds → 全部已完结批次,自动纳入探索 Channel 产的新批次)
+ * → submitJob(hybrid_residual,固化 spec)→ plan 状态回写。spec 未固化的 plan 拒绝
+ * (须先由训练 Channel 的 draft 流程生成后 PATCH 到 plan)。
+ */
+export async function runPlanTraining(planId: string, by: { id: string, kind: 'user' | 'agent' }): Promise<{ jobId: string, datasetId: string, rowCount: number }> {
+  const plan = getTrainingPlan(planId)
+  if (!plan) throw new Error(`建模任务不存在:${planId}`)
+  if (!plan.trainingSpecJson) throw new Error('建模任务尚未固化训练 spec(先在训练 Channel 完成 draft 流程,或由界面导入);拒绝训练。')
+  const spec = parseDatasetSpec(JSON.parse(plan.datasetSpecJson))
+  const built = await buildDataset(spec, by)
+  const dataset = built.dataset
+  const trainingSpec = JSON.parse(plan.trainingSpecJson) as Record<string, unknown> & { modelId?: string }
+  const providerId = String(trainingSpec.modelId ?? '')
+  if (!providerId) throw new Error('训练 spec 缺少 modelId(providerId),拒绝提交。')
+  const params = (() => {
+    try {
+      return JSON.parse(plan.paramsJson || '{}') as Record<string, unknown>
+    }
+    catch {
+      return {}
+    }
+  })()
+  const job = submitJob({
+    datasetId: dataset.id,
+    purpose: plan.purpose === 'quality_predict' ? 'quality_predict' : 'mpc_surrogate',
+    changeNote: `建模任务 ${plan.name}:修正训练(批次基数 ${plan.lastRunCount}→${completedRunCount(plan.lineId, plan.recipeId)})`,
+    params,
+    seed: plan.seed ?? 7,
+    jobKind: 'hybrid_residual',
+    sceneId: plan.sceneId ?? undefined,
+    sceneVersion: plan.sceneVersion ?? undefined,
+    objectiveId: plan.objectiveId ?? undefined,
+    physicsSpec: trainingSpec,
+    providerId,
+    providerVersion: '1.0.0',
+    providerHash: `sha256:${JSON.stringify(trainingSpec).length}`,
+    modelName: `${plan.modelNamePrefix}`,
+    modelDescription: `建模任务 ${plan.id} 自动训练;产线 ${plan.lineId}/配方 ${plan.recipeId}${plan.objectiveId ? `;目标 ${plan.objectiveId}` : ''};数据集 ${dataset.id}(${dataset.rowCount} 行)`,
+    agent: by.kind === 'agent' ? { id: by.id } : undefined,
+  })
+  const now = new Date().toISOString()
+  db().prepare('UPDATE aml_training_plans SET last_job_id=?, last_dataset_id=?, last_status=?, last_run_count=?, last_trained_at=?, last_error=NULL, updated_at=? WHERE id=?')
+    .run(job.id, dataset.id, 'training', completedRunCount(plan.lineId, plan.recipeId), now, now, planId)
+  return { jobId: job.id, datasetId: dataset.id, rowCount: dataset.rowCount }
+}
+
+/** worker tick:检测新批次并自动触发(auto 策略 + 到达最短间隔 + 批次数增长) */
+export async function processTrainingPlans(): Promise<Array<{ planId: string, jobId: string }>> {
+  const triggered: Array<{ planId: string, jobId: string }> = []
+  for (const plan of listTrainingPlans()) {
+    try {
+      if (!plan.enabled || plan.strategy !== 'auto') continue
+      if (plan.lastStatus === 'training') continue
+      if (plan.lastTrainedAt && Date.parse(plan.lastTrainedAt) + plan.minIntervalSec * 1000 > Date.now()) continue
+      const runs = completedRunCount(plan.lineId, plan.recipeId)
+      if (runs <= plan.lastRunCount) continue
+      if (!plan.trainingSpecJson) continue
+      const r = await runPlanTraining(plan.id, { id: 'system:training-planner', kind: 'agent' })
+      triggered.push({ planId: plan.id, jobId: r.jobId })
+    }
+    catch (err) {
+      db().prepare('UPDATE aml_training_plans SET last_status=?, last_error=?, updated_at=? WHERE id=?')
+        .run('failed', err instanceof Error ? err.message.slice(0, 400) : String(err).slice(0, 400), new Date().toISOString(), plan.id)
+    }
+  }
+  return triggered
+}
+
+/** concludeJob 钩子:训练终态回写 plan(按 job 的 budget.planId 关联) */
+export function settleTrainingPlanByJob(jobId: string, status: 'done' | 'failed', modelId?: string, error?: string): void {
+  try {
+    const rows = db().prepare('SELECT id FROM aml_training_plans WHERE last_job_id = ?').all(jobId) as Array<{ id: string }>
+    for (const row of rows) {
+      db().prepare('UPDATE aml_training_plans SET last_status=?, last_model_id=COALESCE(?, last_model_id), last_error=?, updated_at=? WHERE id=?')
+        .run(status, modelId ?? null, status === 'failed' ? (error ?? 'training failed').slice(0, 400) : null, new Date().toISOString(), row.id)
+    }
+  }
+  catch { /* 单测/表未建:静默 */ }
+}

package/server/services/workshop/aml/twin/trial-service.ts

@@ -1,7 +1,40 @@
 import { createId, hashConstraintResults, sha256, type ObjectiveProfile, type RecommendationCertificate, type SceneContract, type TwinSnapshot, type VirtualTrial } from './contracts'
 import { assertFreshSnapshot } from './snapshot-service'
-import type { PhysicsModelProvider } from './physics-runtime'
+import type { PhysicsModelProvider, PhysicsState, PhysicsTrajectory } from './physics-runtime'
 import { evaluateEnsemble } from './uq-ood'
+import { resolveAcceptanceProfile } from './acceptance'
+
+/**
+ * rollout 协议:VirtualTrial/MPC 的模型面。物理-only provider 经 syncRolloutProvider
+ * 适配;训练注册的 hybrid 模型由 model-backed provider 提供残差修正 rollout。
+ */
+export interface RolloutProvider {
+  initialize(snapshot: { stateEstimate: Record<string, number>, controlValues: Record<string, number> }): PhysicsState
+  rollout(initial: PhysicsState, controls: Array<Record<string, number>>, disturbances: Record<string, number>): Promise<PhysicsTrajectory>
+  evaluateConstraints(scene: SceneContract, trajectory: PhysicsTrajectory): Array<{ id: string, passed: boolean, detail: string, firstViolationStep?: number }>
+}
+
+export function syncRolloutProvider(provider: PhysicsModelProvider): RolloutProvider {
+  return {
+    initialize: snapshot => provider.initialize(snapshot),
+    rollout: (initial, controls, disturbances) => Promise.resolve(provider.simulate(initial, controls, disturbances)),
+    evaluateConstraints: (scene, trajectory) => provider.evaluateConstraints(scene, trajectory),
+  }
+}
+
+type AnyRolloutProvider = RolloutProvider | PhysicsModelProvider
+
+function asRolloutProvider(provider: AnyRolloutProvider): RolloutProvider {
+  if (typeof (provider as RolloutProvider).rollout === 'function') return provider as RolloutProvider
+  return syncRolloutProvider(provider as PhysicsModelProvider)
+}
+
+export interface TrialUncertaintyInput {
+  predictions: Array<Record<string, number>>
+  coverage: number
+  inputDistance?: number
+  calibrationFresh?: boolean
+}
 
 export interface TrialRequest {
   scene: SceneContract
@@ -11,8 +44,9 @@ export interface TrialRequest {
   objective: ObjectiveProfile
   baselineControls: Record<string, number>
   candidateControls: Array<Record<string, number>>
-  provider: PhysicsModelProvider
-  uncertainty?: { predictions: Array<Record<string, number>>, coverage: number, inputDistance?: number, calibrationFresh?: boolean }
+  provider: RolloutProvider
+  /** 模型驱动时传 thunk:集成预测在 rollout 后才可读,runVirtualTrial 内部惰性解析 */
+  uncertainty?: TrialUncertaintyInput | (() => TrialUncertaintyInput)
   createdBy: string
   nowMs?: number
 }
@@ -27,21 +61,71 @@ function objectiveCost(objective: ObjectiveProfile, trajectory: Array<Record<str
   return cost
 }
 
-export function runVirtualTrial(request: TrialRequest): VirtualTrial {
+function validateControlTrajectory(scene: SceneContract, baseline: Record<string, number>, candidate: Array<Record<string, number>>, horizon: number): string | null {
+  if (!candidate.length) return 'MPC_EMPTY_CANDIDATE'
+  if (candidate.length > horizon) return 'MPC_HORIZON_EXCEEDED'
+  // A VirtualTrial horizon is simulated, not a sequence of PLC writes. maxActionsPerRun is enforced by the governed write gateway, not rollout length.
+  const controls = new Map(scene.controls.map(control => [control.id, control]))
+  let previous = baseline
+  for (const step of candidate) {
+    for (const [id, value] of Object.entries(step)) {
+      const control = controls.get(id)
+      if (!control) return `MPC_UNKNOWN_CONTROL:${id}`
+      if (!Number.isFinite(value)) return `MPC_CONTROL_NON_FINITE:${id}`
+      if ((control.min != null && value < control.min) || (control.max != null && value > control.max)) return `MPC_CONTROL_OUT_OF_RANGE:${id}`
+      const maxDelta = scene.writePolicy.maxDeltaPerAction[id] ?? control.maxStep
+      if (maxDelta != null && Number.isFinite(previous[id]) && Math.abs(value - Number(previous[id])) > maxDelta + 1e-9) return `MPC_CONTROL_DELTA_EXCEEDED:${id}`
+    }
+    previous = step
+  }
+  return null
+}
+
+export async function runVirtualTrial(request: TrialRequest): Promise<VirtualTrial> {
   assertFreshSnapshot(request.snapshot, request.nowMs ?? Date.now(), 60_000)
-  const initial = request.provider.initialize({ stateEstimate: request.snapshot.stateEstimate, controlValues: request.snapshot.controlValues })
-  const trajectory = request.provider.simulate(initial, request.candidateControls, request.snapshot.disturbances)
+  const controlFailure = validateControlTrajectory(request.scene, request.baselineControls, request.candidateControls, request.objective.horizonSteps)
+  if (controlFailure) {
+    const failedBase = {
+      schemaVersion: 1,
+      createdAt: new Date(request.nowMs ?? Date.now()).toISOString(),
+      createdBy: request.createdBy,
+      trialId: createId('trial'),
+      snapshotId: request.snapshot.snapshotId,
+      modelId: request.modelId,
+      objectiveId: request.objective.objectiveId,
+      candidateControlTrajectory: request.candidateControls,
+      predictedTrajectory: [],
+      uncertainty: { maxStd: Number.POSITIVE_INFINITY, coverage: 0, ensembleSize: 0 },
+      outOfDistribution: { distance: Number.POSITIVE_INFINITY, disagreement: Number.POSITIVE_INFINITY, accepted: false, rejectCode: 'CONTROL_SAFETY' },
+      constraintResults: [{ id: 'MPC_CONTROL_SAFETY', passed: false, detail: controlFailure }],
+      baselineComparison: { baselineCost: Number.POSITIVE_INFINITY, candidateCost: Number.POSITIVE_INFINITY, improvement: Number.NEGATIVE_INFINITY },
+      candidateExecuted: false as const,
+      provenance: { snapshotHash: request.snapshot.snapshotHash, modelHash: request.modelHash, objectiveHash: sha256(request.objective), constraintDigest: hashConstraintResults([{ id: 'MPC_CONTROL_SAFETY', passed: false, detail: controlFailure }]) },
+    }
+    return { ...failedBase, provenance: { ...failedBase.provenance, trialHash: sha256(failedBase) } }
+  }
+  const provider = asRolloutProvider(request.provider)
+  const initial = provider.initialize({ stateEstimate: request.snapshot.stateEstimate, controlValues: request.snapshot.controlValues })
+  const trajectory = await provider.rollout(initial, request.candidateControls, request.snapshot.disturbances)
+  if (trajectory.failures.length > 0) throw new Error(`PHYSICS_ROLLOUT_FAILED:${trajectory.failures.join(',')}`)
   const predicted = trajectory.steps.map(s => s.observations)
-  const constraintResults = request.provider.evaluateConstraints(request.scene, trajectory)
-  const predictions = request.uncertainty?.predictions ?? predicted.slice(0, 3)
-  const uq = evaluateEnsemble({ predictions, calibrationCoverage: request.uncertainty?.coverage ?? 1 }, {
-    coverageTarget: 0.90,
+  const constraintResults = provider.evaluateConstraints(request.scene, trajectory)
+  // 惰性解析:模型 rollout 完成后,集成预测(memberPredictions)才是本次 rollout 的
+  const resolvedUncertainty = typeof request.uncertainty === 'function' ? request.uncertainty() : request.uncertainty
+  const predictions = resolvedUncertainty?.predictions ?? predicted.slice(0, 3)
+  // UQ 策略与 Twin Gate 同源:coverage 下限取场景验收档(缺省 0.90;castfilm 等噪声主导
+  // 场景 0.85),并留一个有限样本容差 —— conformal 实现覆盖率是二项抽样,613 行校准集在
+  // 真目标 0.90 下实现值 ~N(0.90, 0.012),硬卡 0.900 会让合格模型按抛硬币被拒
+  // (实测:coverage 0.8989 全部 trial 被 UQ_COVERAGE_LOW 拒 → G7 恒挂)。
+  const coverageFloor = Math.max(0.5, resolveAcceptanceProfile(request.scene.sceneId).uncertainty.coverageTarget - 0.01)
+  const uq = evaluateEnsemble({ predictions, calibrationCoverage: resolvedUncertainty?.coverage ?? 1 }, {
+    coverageTarget: coverageFloor,
     distanceThreshold: 16,
     disagreementThreshold: 0.15,
-    calibrationFresh: request.uncertainty?.calibrationFresh ?? true,
-    inputDistance: request.uncertainty?.inputDistance ?? 0,
+    calibrationFresh: resolvedUncertainty?.calibrationFresh ?? true,
+    inputDistance: resolvedUncertainty?.inputDistance ?? 0,
   })
-  const baselineTrajectory = request.provider.simulate(initial, Array.from({ length: request.candidateControls.length }, () => request.baselineControls), request.snapshot.disturbances)
+  const baselineTrajectory = await provider.rollout(initial, Array.from({ length: request.candidateControls.length }, () => request.baselineControls), request.snapshot.disturbances)
   const baseline = objectiveCost(request.objective, baselineTrajectory.steps.map(s => s.observations))
   const candidate = objectiveCost(request.objective, predicted)
   const trialBase = {

package/server/services/workshop/aml/twin/write-guard.ts

@@ -0,0 +1,20 @@
+import { getAmlRuntime } from '../runtime'
+import { getChannelTwinProfile } from './channel-profile'
+import { twinWriteGuard } from './feature-flags'
+
+export function channelIdForAgent(agentId: string): string | undefined {
+  try {
+    const row = getAmlRuntime().db.prepare('SELECT channel_id AS channelId FROM channel_agents WHERE id = ?').get(agentId) as { channelId?: string } | undefined
+    return row?.channelId ? String(row.channelId) : undefined
+  }
+  catch {
+    return undefined
+  }
+}
+
+export function guardTwinWrite(agentId: string, channelId?: string): { allowed: true } | { allowed: false, code: string, message: string } {
+  const resolved = String(channelId ?? channelIdForAgent(agentId) ?? '').trim()
+  // 非 Channel 直接调用保留 legacy 工具兼容性；所有 HostTool/Agent runtime 调用都会带 channel_agents 记录。
+  if (!resolved) return { allowed: true }
+  return twinWriteGuard(resolved, getChannelTwinProfile(resolved))
+}

package/server/services/workshop/daq/daq-controller/state.ts

@@ -16,7 +16,6 @@ import { findDaqTemplate } from '../daq-templates'
 import { getDaqNodeRepo } from '../daq-node.repo'
 import { getDaqQueue } from '../bus'
 import { getObjectStore } from '../objectstore'
-import { getSystemConfigService } from '../../../system-config'
 import { log } from './helpers'
 import { normalizeSignalKind } from '../../../../../shared/daq-protocol'
 import { resolveDaqDriver } from '../drivers'
@@ -103,10 +102,14 @@ export abstract class DaqControllerState extends DaqControllerContracts {
   applyRuntimeSettings(): void {
     if (!this.settingsSynced) {
       this.settingsSynced = true
-      try {
-        this.settingsUnsub = getSystemConfigService().subscribe(() => this.applyRuntimeSettings())
-      }
-      catch { /* 设置系统不可用(单测) → 用字段默认值 */ }
+      // 惰性订阅:system-config 终点依赖 nitro 虚拟模块(#imports),静态导入会把
+      // 纯 node/tsx 回归上下文的可导入性一并绑架;订阅本就有"不可用→字段默认值"降级。
+      void import('../../../system-config')
+        .then(({ getSystemConfigService }) => {
+          this.settingsUnsub = getSystemConfigService().subscribe(() => this.applyRuntimeSettings())
+          this.applyRuntimeSettings()
+        })
+        .catch(() => { /* 设置系统不可用(单测/回归脚本) → 用字段默认值 */ })
     }
     const before = `${this.defaultIntervalMs}|${this.minIntervalMs}|${this.defaultPublishIntervalMs}|${this.minPublishIntervalMs}|${this.queryDisplayIntervalMs}|${this.minQueryDisplayIntervalMs}`
     try {