agentworkshop 0.7.66 → 0.7.71

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

@@ -23,12 +23,34 @@ export interface AmlDatasetRow {
   createdByKind: string // 'user' | 'agent'
   note: string
   createdAt: string
+  /** 由 ProcessModelSpec 构建时的规格引用(旧 AML 数据集为空 = 无工艺规格谱系) */
+  specRef?: string
+  specVersion?: number | null
+  /** 数据谱系核验(D18):0=未核验(旧/无 confirmed segment;模型禁优化资格);1=每 run 均有已确认 segment 且版本匹配 */
+  lineageVerified?: number
 }
 
 export type AmlJobStatus
   = | 'queued' | 'provisioning' | 'training' | 'evaluating'
     | 'done' | 'failed' | 'cancelled' | 'timeout' | 'interrupted'
 
+/** AML 作业状态机(C12):终态不可迁出;done 只能从 evaluating 进入。 */
+export const AML_JOB_TRANSITIONS: Record<AmlJobStatus, AmlJobStatus[]> = {
+  queued: ['provisioning', 'training', 'cancelled', 'failed', 'interrupted'],
+  provisioning: ['training', 'evaluating', 'failed', 'cancelled', 'timeout', 'interrupted'],
+  training: ['evaluating', 'failed', 'cancelled', 'timeout', 'interrupted'],
+  evaluating: ['done', 'failed', 'cancelled', 'timeout', 'interrupted'],
+  done: [],
+  failed: [],
+  cancelled: [],
+  timeout: [],
+  interrupted: [],
+}
+
+export function canTransitionJob(from: AmlJobStatus, to: AmlJobStatus): boolean {
+  return AML_JOB_TRANSITIONS[from]?.includes(to) ?? false
+}
+
 export interface AmlJobRow {
   id: string
   datasetId: string
@@ -40,6 +62,8 @@ export interface AmlJobRow {
   metricsJson: string | null
   gatesJson: string | null
   artifactsPath: string | null
+  /** 成功终态登记的模型 id(同一 UPDATE 写入;C11) */
+  modelId?: string | null
   error: string | null
   retryCount: number
   agentId: string
@@ -90,17 +114,26 @@ export interface AmlModelRow {
   lineId: string
   /** 优化目标区分(ObjectiveProfile id;legacy 作业为空串,用 purpose 表达) */
   objectiveId: string
+  /** 工件类型判别(G1.2):'' = 历史行,由 metrics 推断 */
+  artifactKind: string
+  schemaVersion: number
+  /** 模型接口(one_step / linear_state_space / static_response) */
+  modelInterface: string
+  artifactHash: string
+  /** 历史口径标记(如 twin_v1);新链为空串 */
+  legacy: string
   createdAt: string
 }
 
 const DS_COLS = `id, line_id AS lineId, product_id AS productId, recipe_id AS recipeId,
   run_ids_json AS runIdsJson, spec_json AS specJson, sha256, row_count AS rowCount,
   from_ms AS fromMs, to_ms AS toMs, path, created_by AS createdBy,
-  created_by_kind AS createdByKind, note, created_at AS createdAt`
+  created_by_kind AS createdByKind, note, created_at AS createdAt,
+  spec_ref AS specRef, spec_version AS specVersion, lineage_verified AS lineageVerified`
 
 const JOB_COLS = `id, dataset_id AS datasetId, purpose, status, stage, progress,
   budget_json AS budgetJson, metrics_json AS metricsJson, gates_json AS gatesJson,
-  artifacts_path AS artifactsPath, error, retry_count AS retryCount,
+  artifacts_path AS artifactsPath, model_id AS modelId, error, retry_count AS retryCount,
   agent_id AS agentId, channel_id AS channelId, task_id AS taskId,
   created_at AS createdAt, started_at AS startedAt, ended_at AS endedAt`
 
@@ -114,7 +147,9 @@ const MODEL_COLS = `id, experiment_id AS experimentId, dataset_id AS datasetId,
   io_spec_json AS ioSpecJson, metrics_json AS metricsJson, path,
   artifacts_pruned AS artifactsPruned, created_by AS createdBy,
   promoted_by AS promotedBy, promoted_at AS promotedAt, note,
-  label, description, line_id AS lineId, objective_id AS objectiveId, created_at AS createdAt`
+  label, description, line_id AS lineId, objective_id AS objectiveId,
+  artifact_kind AS artifactKind, schema_version AS schemaVersion, model_interface AS modelInterface,
+  artifact_hash AS artifactHash, legacy, created_at AS createdAt`
 
 function rowToDataset(r: Record<string, unknown>): AmlDatasetRow {
   return { ...(r as unknown as Omit<AmlDatasetRow, 'runIds'>), runIds: JSON.parse(String(r.runIdsJson || '[]')) }
@@ -135,8 +170,9 @@ function rowToModel(r: Record<string, unknown>): AmlModelRow {
 export function createAmlRepo(db: DatabaseSync) {
   const dsInsert = db.prepare(
     `INSERT INTO aml_datasets (id, line_id, product_id, recipe_id, run_ids_json, spec_json, sha256,
-       row_count, from_ms, to_ms, path, created_by, created_by_kind, note, created_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+       row_count, from_ms, to_ms, path, created_by, created_by_kind, note, created_at,
+       spec_ref, spec_version, lineage_verified)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
   )
   const jobInsert = db.prepare(
     `INSERT INTO aml_jobs (id, dataset_id, purpose, status, stage, progress, budget_json,
@@ -144,14 +180,14 @@ export function createAmlRepo(db: DatabaseSync) {
      VALUES (?, ?, ?, 'queued', '', 0, ?, ?, ?, ?, ?)`,
   )
   const jobState = db.prepare(
-    `UPDATE aml_jobs SET status = ?, stage = ?, progress = ? WHERE id = ?`,
+    `UPDATE aml_jobs SET status = ?, stage = ?, progress = ? WHERE id = ? AND status = ?`,
   )
   const jobFinish = db.prepare(
     `UPDATE aml_jobs SET status = ?, stage = 'done', progress = 100, metrics_json = ?, gates_json = ?,
-       artifacts_path = ?, error = ?, ended_at = ? WHERE id = ?`,
+       artifacts_path = ?, error = ?, ended_at = ?, model_id = ? WHERE id = ? AND status IN ('training','evaluating','provisioning')`,
   )
   const jobFail = db.prepare(
-    `UPDATE aml_jobs SET status = ?, error = ?, ended_at = ? WHERE id = ?`,
+    `UPDATE aml_jobs SET status = ?, error = ?, ended_at = ? WHERE id = ? AND status NOT IN ('done','failed','cancelled','timeout','interrupted')`,
   )
   const jobRetryBump = db.prepare(
     `UPDATE aml_jobs SET retry_count = retry_count + 1, status = 'queued', stage = '', progress = 0,
@@ -167,8 +203,9 @@ export function createAmlRepo(db: DatabaseSync) {
   )
   const modelInsert = db.prepare(
     `INSERT INTO aml_models (id, experiment_id, dataset_id, product_id, recipe_id, purpose, stage,
-       io_spec_json, metrics_json, path, created_by, note, label, description, line_id, objective_id, created_at)
-     VALUES (?, ?, ?, ?, ?, ?, 'candidate', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+       io_spec_json, metrics_json, path, created_by, note, label, description, line_id, objective_id,
+       artifact_kind, schema_version, model_interface, artifact_hash, legacy, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, 'candidate', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
   )
   /** 晋升/退役:SQL 层条件更新兜底并发竞态( WHERE stage 校验) */
   const modelStage = db.prepare(
@@ -183,6 +220,7 @@ export function createAmlRepo(db: DatabaseSync) {
         dsInsert.run(
           d.id, d.lineId, d.productId, d.recipeId, JSON.stringify(d.runIds), d.specJson, d.sha256,
           d.rowCount, d.fromMs, d.toMs, d.path, d.createdBy, d.createdByKind, d.note, d.createdAt,
+          d.specRef ?? '', d.specVersion ?? null, d.lineageVerified ?? 0,
         )
       },
       get(id: string): AmlDatasetRow | undefined {
@@ -265,18 +303,28 @@ export function createAmlRepo(db: DatabaseSync) {
         ).run(now)
         return Number(r.changes)
       },
-      setState(id: string, status: AmlJobStatus, stage: string, progress: number): void {
-        jobState.run(status, stage, progress, id)
+      /** 状态迁移(CAS):仅当当前状态允许迁移时生效;返回 false = 竞争失败/非法迁移 */
+      setState(id: string, status: AmlJobStatus, stage: string, progress: number): boolean {
+        const current = this.get(id)
+        if (!current) return false
+        if (!canTransitionJob(current.status, status)) return false
+        const r = jobState.run(status, stage, progress, id, current.status)
+        return Number(r.changes) > 0
       },
       markStarted(id: string, status: AmlJobStatus, stage: string, now: string): void {
-        db.prepare(`UPDATE aml_jobs SET status = ?, stage = ?, started_at = COALESCE(started_at, ?) WHERE id = ?`)
+        db.prepare(`UPDATE aml_jobs SET status = ?, stage = ?, started_at = COALESCE(started_at, ?)
+          WHERE id = ? AND status NOT IN ('done','failed','cancelled','timeout','interrupted')`)
           .run(status, stage, now, id)
       },
-      finish(id: string, status: AmlJobStatus, metricsJson: string, gatesJson: string, artifactsPath: string, now: string): void {
-        jobFinish.run(status, metricsJson, gatesJson, artifactsPath, null, now, id)
+      /** 成功终态:只有 evaluating/provisioning(无训练步骤的内置链)可进入 done;
+       *  modelId 与本行同一事务写入,杜绝"训练成功、模型不存在"的假成功(C11)。 */
+      finish(id: string, status: AmlJobStatus, metricsJson: string, gatesJson: string, artifactsPath: string, now: string, modelId?: string | null): boolean {
+        const r = jobFinish.run(status, metricsJson, gatesJson, artifactsPath, null, now, modelId ?? null, id)
+        return Number(r.changes) > 0
       },
-      fail(id: string, status: AmlJobStatus, error: string, now: string): void {
-        jobFail.run(status, error, now, id)
+      fail(id: string, status: AmlJobStatus, error: string, now: string): boolean {
+        const r = jobFail.run(status, error, now, id)
+        return Number(r.changes) > 0
       },
       requeue(id: string): void {
         jobRetryBump.run(id)
@@ -341,11 +389,18 @@ export function createAmlRepo(db: DatabaseSync) {
         description?: string
         lineId?: string
         objectiveId?: string
+        artifactKind?: string
+        schemaVersion?: number
+        modelInterface?: string
+        artifactHash?: string
+        legacy?: string
         createdAt: string
       }): void {
         modelInsert.run(m.id, m.experimentId, m.datasetId, m.productId, m.recipeId, m.purpose,
           m.ioSpecJson, m.metricsJson, m.path, m.createdBy, m.note,
-          m.label ?? '', m.description ?? '', m.lineId ?? '', m.objectiveId ?? '', m.createdAt)
+          m.label ?? '', m.description ?? '', m.lineId ?? '', m.objectiveId ?? '',
+          m.artifactKind ?? '', m.schemaVersion ?? 1, m.modelInterface ?? '', m.artifactHash ?? '', m.legacy ?? '',
+          m.createdAt)
       },
       get(id: string): AmlModelRow | undefined {
         const r = db.prepare(`SELECT ${MODEL_COLS} FROM aml_models WHERE id = ?`).get(id)

package/server/services/workshop/aml/dataset-builder.ts

@@ -6,24 +6,26 @@
  * 效率纪律:SQL 层不做降采样(需要 state 感知清洗,raw 点量 = 采样间隔×批长,可控);
  * 归一化统计只取 train 切分(防泄漏);快照 sha256 覆盖 spec+数据字节(防篡改)。
  */
+/* eslint-disable @stylistic/member-delimiter-style */
 import { createHash } from 'node:crypto'
 import { mkdirSync, readFileSync, writeFileSync, readdirSync, statSync } from 'node:fs'
 import { join } from 'node:path'
 import { AppError } from '../../../utils/errors'
 import { broadcastSceneEvent } from '../scene-events'
 import { getTsdb } from '../daq/storage'
+import type { TsdbPoint, TsdbPort } from '../daq/storage/tsdb-port'
 import { getDaqNodeRepo } from '../daq/daq-node.repo'
 import { findDaqTemplate } from '../daq/daq-templates'
 import { getDcwRecipeRepo } from '../dcw/dcw-recipe.repo'
 import { amlSettings } from '../settings'
 import type { AmlDatasetSpec } from './spec'
-import { cleanPoints, alignToGrid, type RawPoint } from './clean'
+import { cleanPoints, alignToGrid } from './clean'
 import { summarize, lagCrossCorr, type SeriesSummary, type LagEstimate, type RunProfile } from './stats'
 import { getAmlRuntime } from './runtime'
 import type { AmlDatasetRow } from './aml.repo'
 
 export interface AmlManifest {
-  version: 1
+  version: 1 | 2
   spec: AmlDatasetSpec
   /** 节点顺序(= spec.nodes 顺序;x 历史/归一化按此序) */
   allNodes: string[]
@@ -40,6 +42,17 @@ export interface AmlManifest {
     y: { mean: number[], std: number[] }
   }
   beatMs: number
+  // ===== manifest v2(新链路;v1 作业读不到这些字段) =====
+  dataKind?: 'dynamic' | 'static'
+  specHash?: string
+  specVersion?: number
+  recipeVersion?: number
+  variables?: ProcessDatasetExtras['variables']
+  artifacts?: { x: string, u: string, y: string, timestamps: string, mask: string, sidecar: string }
+  provenance?: {
+    lineId: string, productId: string, recipeId: string, recipeVersion: number, runIds: string[]
+    recipeContentHash: string, evidenceSource: string, availabilityWatermark: number | null, capturedAt: string
+  }
 }
 
 export interface AmlDatasetReport {
@@ -119,9 +132,66 @@ function meanStd(cols: number[][]): { mean: number[], std: number[] } {
   return { mean, std }
 }
 
+interface PageQuery {
+  lineId?: string
+  productId?: string
+  recipeId?: string
+  runId?: string
+  fromMs: number
+  toMs: number
+}
+
+/**
+ * 单节点取数(C7):优先逐节点分页接口(游标续读、无总量截断);
+ * 后端未实现时退化为单节点 queryTagged(旧语义在 nodeIds 单元素时等价)。
+ */
+export async function fetchNodeSeries(
+  tsdb: Pick<TsdbPort, 'queryTagged' | 'queryTaggedPage'>,
+  nodeId: string,
+  q: PageQuery,
+  pageLimit = 20_000,
+): Promise<TsdbPoint[]> {
+  if (typeof tsdb.queryTaggedPage === 'function') {
+    const out: TsdbPoint[] = []
+    let afterTs: number | undefined
+    for (;;) {
+      const page = await tsdb.queryTaggedPage(nodeId, {
+        afterTs, fromMs: q.fromMs, toMs: q.toMs, limit: pageLimit, withState: true,
+      })
+      out.push(...page.points)
+      if (page.done || page.nextCursor == null) break
+      afterTs = page.nextCursor
+    }
+    return out
+  }
+  const tagged = await tsdb.queryTagged({
+    lineId: q.lineId, productId: q.productId, recipeId: q.recipeId, runId: q.runId,
+    nodeIds: [nodeId], fromMs: q.fromMs, toMs: q.toMs, limit: 500_000,
+  })
+  return tagged.get(nodeId) ?? []
+}
+
 // ---------- 主流程 ----------
 
-export async function buildDataset(spec: AmlDatasetSpec, by: { id: string, kind: 'user' | 'agent' }): Promise<BuildDatasetResult> {
+export interface ProcessDatasetExtras {
+  specRef: string
+  specVersion: number
+  trainerRef: string
+  conditionId: string
+  recipeVersion: number
+  recipeContentHash: string
+  evidenceSource: 'simulation' | 'real' | 'unassessed'
+  variables: Array<{ id: string, nodeId: string, role: string, unit: string, modelUnit?: string, scale: number, offset: number, delayMs?: number }>
+  availabilityWatermark: number | null
+  /**
+   * 数据谱系核验结果(D18;由 dataset.ts 按 confirmed context segment 逐 run 判定):
+   * verified = 每 run 均有已确认且版本/内容 hash 匹配的段;unknown = 无段(不可证伪,保持 0)。
+   * 有任一 unknown 或全量非 verified → lineage_verified=0(模型禁优化资格)。
+   */
+  runLineage?: { verified: string[], unknown: string[], excluded: Array<{ runId: string, reason: string }> }
+}
+
+export async function buildDataset(spec: AmlDatasetSpec, by: { id: string, kind: 'user' | 'agent' }, extras?: ProcessDatasetExtras): Promise<BuildDatasetResult> {
   const rt = getAmlRuntime()
   const settings = amlSettings()
 
@@ -172,28 +242,29 @@ export async function buildDataset(spec: AmlDatasetSpec, by: { id: string, kind:
   const runMatrices = new Map<string, { at: number[], rows: Map<string, number[]> }>()
 
   for (const run of runs) {
-    const fromMs = Date.parse(run.startedAt)
-    const toMs = Date.parse(run.endedAt as string)
+    // C7/A1:spec 的 fromMs/toMs 真正生效(旧实现只取 run 窗口,规格里的时间窗被忽略)
+    const fromMs = Math.max(Date.parse(run.startedAt), spec.fromMs ?? Number.NEGATIVE_INFINITY)
+    const toMs = Math.min(Date.parse(run.endedAt as string), spec.toMs ?? Number.POSITIVE_INFINITY)
     let series: Map<string, { at: number, value: number }[]>
     try {
-      const tagged = await tsdb.queryTagged({
-        lineId: spec.lineId, productId: spec.productId, recipeId: spec.recipeId, runId: run.id,
-        nodeIds: order.map(n => n.nodeId), fromMs, toMs,
-        // 长跑批次数采可达数万行/节点:显式放大取数上限(适配器硬顶 100 万),
-        // 否则默认 2000 行把长批次截成稀疏点,滑窗为 0 → 数据集只剩短批次(实测缺陷 2026-10-05)
-        limit: 500_000,
-      })
       series = new Map()
-      for (const [nodeId, points] of tagged) {
-        const role = order.find(n => n.nodeId === nodeId)?.role ?? 'feature'
-        const cleaned = cleanPoints(points as RawPoint[], { range: ranges.get(nodeId), hampelK: spec.cleaning?.hampelK ?? 5 })
+      // 逐节点分页:queryTagged 的 limit 是 nodeIds 集合总量,多节点会被单点长序列截断;
+      // 这里对每个节点独立翻页(新增接口),后端不支持时退化为单节点 queryTagged。
+      for (const n of order) {
+        const points = await fetchNodeSeries(tsdb, n.nodeId, {
+          lineId: spec.lineId, productId: spec.productId, recipeId: spec.recipeId, runId: run.id,
+          fromMs, toMs,
+        })
+        const cleaned = cleanPoints(
+          points.map(p => ({ at: p.at, value: Number(p.value ?? Number.NaN), state: p.state })),
+          { range: ranges.get(n.nodeId), hampelK: spec.cleaning?.hampelK ?? 5 },
+        )
         const aligned = alignToGrid(cleaned.values, { beatMs: beat, maxInterpMs: maxInterp })
-        series.set(nodeId, aligned.grid)
-        cleaningReport[nodeId] = {
+        series.set(n.nodeId, aligned.grid)
+        cleaningReport[n.nodeId] = {
           ...cleaned.counts,
           missingRatio: 0,
         }
-        void role
       }
     }
     catch (err) {
@@ -271,7 +342,25 @@ export async function buildDataset(spec: AmlDatasetSpec, by: { id: string, kind:
   const nCtrl = Math.max(1, ctrlIds.length)
   const nTgt = tgtIds.length
 
-  interface Win { x: Float32Array, u: Float32Array, y: Float32Array }
+  interface Win { x: Float32Array, u: Float32Array, y: Float32Array, at: number[], mask: Float32Array }
+  // v2 链路:按变量声明把源单位换算到模型单位(训练/求解/有效域统一在模型单位上)。
+  // 无 extras(v1 旧链)时恒等变换,字节级行为不变。
+  // D23:v2 换算禁止兜底 —— extras 声明了变量但 scale/offset 缺失/非法 → fail-closed(防 train/serve skew)。
+  const transformOf = new Map<string, { scale: number, offset: number }>()
+  for (const variable of extras?.variables ?? []) {
+    const scale = Number(variable.scale)
+    const offset = Number(variable.offset)
+    if (!Number.isFinite(scale) || scale === 0 || !Number.isFinite(offset)) {
+      throw new AppError(422, 'UNIT_CONTRACT_INVALID',
+        `变量 ${variable.nodeId} 的单位换算非法(scale=${String(variable.scale)},offset=${String(variable.offset)});禁止按 1/0 兜底`)
+    }
+    transformOf.set(variable.nodeId, { scale, offset })
+  }
+  const toModel = (nodeId: string | undefined, value: number): number => {
+    if (!nodeId) return value
+    const t = transformOf.get(nodeId)
+    return t ? value * t.scale + t.offset : value
+  }
   const winsByRun = new Map<string, Win[]>()
   let winTotal = 0
   for (const [runId, m] of runMatrices) {
@@ -290,7 +379,7 @@ export async function buildDataset(spec: AmlDatasetSpec, by: { id: string, kind:
             bad = true
             break
           }
-          x[i * nAll + j] = v
+          x[i * nAll + j] = toModel(id, v)
         }
       }
       for (let i = 0; i < F && !bad; i++) {
@@ -307,7 +396,7 @@ export async function buildDataset(spec: AmlDatasetSpec, by: { id: string, kind:
             bad = true
             break
           }
-          u[i * nCtrl + j] = v
+          u[i * nCtrl + j] = toModel(cid, v)
         }
         for (let j = 0; j < nTgt; j++) {
           const tid = tgtIds[j]
@@ -316,10 +405,16 @@ export async function buildDataset(spec: AmlDatasetSpec, by: { id: string, kind:
             bad = true
             break
           }
-          y[i * nTgt + j] = v
+          y[i * nTgt + j] = toModel(tid, v)
         }
       }
-      if (!bad) out.push({ x, u, y })
+      if (!bad) {
+        // 窗口级时间戳/质量掩码(manifest v2):历史 H + 未来 F 拍;接受窗口的点均为
+        // 在 run 网格上有限的观测点(坏点已在 cleanPoints 阶段由 state/量程剔除)。
+        const mask = new Float32Array(H + F)
+        mask.fill(1)
+        out.push({ x, u, y, at: m.at.slice(t - H, t + F), mask })
+      }
     }
     if (out.length > 0) winsByRun.set(runId, out)
     winTotal += out.length
@@ -358,6 +453,17 @@ export async function buildDataset(spec: AmlDatasetSpec, by: { id: string, kind:
   split.train = bucketsPart.train.length
   split.val = bucketsPart.val.length
   split.test = bucketsPart.test.length
+  // 切分块契约(SW2.3/IO 冻结):当前口径 = 每 run 1 块(块界 = run 界,无内部 purge);
+  // 单长 run 时间块切分在该契约上扩展,消费方(dataset-reader/trainer/互校)只认 blocks 元数据
+  const blocksOf = (rids: string[], part: 'train' | 'val' | 'test') => rids.map(rid => ({
+    blockId: `${rid}#0`, runId: rid, split: part, purgeBeforeSteps: 0, purgeAfterSteps: 0,
+    uniqueSteps: winsByRun.get(rid)?.length ?? 0,
+  }))
+  ;(split as Record<string, unknown>).blocks = [
+    ...blocksOf(split.trainRunIds, 'train'),
+    ...blocksOf(split.valRunIds, 'val'),
+    ...blocksOf(split.testRunIds, 'test'),
+  ]
 
   // 5. 归一化统计(train only)→ 应用
   const statCols = (wins: Win[], pick: (w: Win, i: number, j: number) => number, dim: number): { mean: number[], std: number[] } => {
@@ -412,6 +518,55 @@ export async function buildDataset(spec: AmlDatasetSpec, by: { id: string, kind:
     beatMs: beat,
   }
   writeFileSync(join(dir, 'manifest.json'), JSON.stringify(manifest, null, 2))
+
+  // manifest v2(G2.9):仅新链路写;v1 保持原文件与 hash 算法不变。
+  if (extras) {
+    const all = [...bucketsPart.train, ...bucketsPart.val, ...bucketsPart.test]
+    const perWindow = H + F
+    const tsBuf = new Float64Array(all.length * perWindow)
+    const maskBuf = new Float32Array(all.length * perWindow)
+    all.forEach((w, idx) => {
+      const base = idx * perWindow
+      for (let i = 0; i < perWindow; i++) tsBuf[base + i] = w.at[i] ?? 0
+      maskBuf.set(w.mask, base)
+    })
+    writeFileSync(join(dir, 'arrays', 'timestamps.f64'), Buffer.from(tsBuf.buffer))
+    writeFileSync(join(dir, 'arrays', 'mask.f32'), f32Bytes(maskBuf))
+    const sidecar = {
+      delays: Object.fromEntries(extras.variables.map(v => [v.id, v.delayMs ?? 0])),
+      units: extras.variables.map(v => ({ id: v.id, unit: v.unit, modelUnit: v.modelUnit ?? v.unit, scale: v.scale, offset: v.offset })),
+      variableOrder: extras.variables.map(v => v.id),
+      trainerRef: extras.trainerRef,
+      conditionId: extras.conditionId,
+      recipeContentHash: extras.recipeContentHash,
+      evidenceSource: extras.evidenceSource,
+      availabilityWatermark: extras.availabilityWatermark,
+      splitRunIds: { train: split.trainRunIds, val: split.valRunIds, test: split.testRunIds },
+    }
+    writeFileSync(join(dir, 'arrays', 'sidecar.json'), JSON.stringify(sidecar, null, 2))
+    const v2 = {
+      ...manifest,
+      version: 2,
+      dataKind: extras.trainerRef === 'static_response@1' ? 'static' : 'dynamic',
+      specHash: extras.specRef,
+      specVersion: extras.specVersion,
+      recipeVersion: extras.recipeVersion,
+      variables: extras.variables,
+      artifacts: {
+        x: 'arrays/x.f32', u: 'arrays/u.f32', y: 'arrays/y.f32',
+        timestamps: 'arrays/timestamps.f64', mask: 'arrays/mask.f32', sidecar: 'arrays/sidecar.json',
+      },
+      provenance: {
+        lineId: spec.lineId, productId: spec.productId, recipeId: spec.recipeId,
+        recipeVersion: extras.recipeVersion, runIds: [...runMatrices.keys()],
+        recipeContentHash: extras.recipeContentHash, evidenceSource: extras.evidenceSource,
+        availabilityWatermark: extras.availabilityWatermark, capturedAt: new Date().toISOString(),
+        lineageVerified: extras.runLineage && extras.runLineage.unknown.length === 0 && extras.runLineage.excluded.length === 0 && extras.runLineage.verified.length > 0 ? 1 : 0,
+        runLineage: extras.runLineage,
+      },
+    }
+    writeFileSync(join(dir, 'manifest.json'), JSON.stringify(v2, null, 2))
+  }
   // spec.json:取数规格随实体落盘。元数据行里本来就有 spec_json,但那是**索引**;
   // 把规格同时写进实体目录,./aml 才是自描述、可整体拷贝的资产 ——
   // 拷到另一台机器(或 sqlite 丢了)时,仅凭 datasets/<id>/ 仍能还原"这份数据是怎么取的"。
@@ -476,6 +631,11 @@ export async function buildDataset(spec: AmlDatasetSpec, by: { id: string, kind:
     createdByKind: by.kind,
     note: spec.note ?? '',
     createdAt: now,
+    specRef: extras?.specRef ?? '',
+    specVersion: extras?.specVersion ?? null,
+    lineageVerified: extras?.runLineage
+      ? (extras.runLineage.unknown.length === 0 && extras.runLineage.excluded.length === 0 && extras.runLineage.verified.length > 0 ? 1 : 0)
+      : 0,
   }
   rt.repo.dataset.insert(row)
   // WS:数据集构建实时帧(带 lineId 享逐 peer 过滤)
@@ -491,11 +651,21 @@ export function loadManifest(dataset: AmlDatasetRow): AmlManifest {
   return JSON.parse(readFileSync(join(dataset.path, 'manifest.json'), 'utf8')) as AmlManifest
 }
 
-/** 数据集快照内容摘要:specJson + manifest + 三个数组逐字节流式哈希 */
+/** 数据集快照内容摘要:specJson + manifest + 三个数组逐字节流式哈希
+ *  v2:额外覆盖 timestamps/mask/sidecar(A12:篡改 sidecar 必须使 hash 失败);
+ *  v1 的文件清单与算法保持不变(旧 hash 兼容)。 */
 export function hashDatasetDir(dir: string, specJson: string): string {
   const hash = createHash('sha256')
   hash.update(specJson)
-  for (const f of ['manifest.json', 'arrays/x.f32', 'arrays/u.f32', 'arrays/y.f32']) {
+  const files = ['manifest.json', 'arrays/x.f32', 'arrays/u.f32', 'arrays/y.f32']
+  try {
+    const manifest = JSON.parse(readFileSync(join(dir, 'manifest.json'), 'utf8')) as { version?: number, artifacts?: Record<string, string> }
+    if (manifest.version === 2 && manifest.artifacts) {
+      for (const f of Object.values(manifest.artifacts)) if (!files.includes(f)) files.push(f)
+    }
+  }
+  catch { /* manifest 缺失/不合法:由后续 readFileSync 抛错 */ }
+  for (const f of files) {
     hash.update(f)
     const buf = readFileSync(join(dir, f))
     hash.update(buf)

package/server/services/workshop/aml/env-lease.ts

@@ -0,0 +1,148 @@
+/**
+ * AML 共享环境租约(G1.6 / B.9.4)。
+ *
+ * 规则:
+ *  - 训练/评估/Solver 运行期间持**读租约**(可多个并发);
+ *  - 安装/重建/`ensureVenv({force:true})` 持**独占锁**:先拒绝新租约,等待所有读者释放;
+ *    有读者时返回 ENV_BUSY(首版不强删占用目录,Windows 上 rmSync 会失败)。
+ *
+ * 进程内租约 + 跨进程文件锁:
+ *  - 进程内用计数器(本文件);
+ *  - 跨进程用 `<amlRoot>/runtime/env.lock` 文件锁(owner + heartbeat),仅用于阻止
+ *    另一个 aw 进程同时重建同一环境。崩溃遗留锁需人工确认旧进程已退出后清理。
+ */
+import { existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { randomUUID } from 'node:crypto'
+import { AppError } from '../../../utils/errors'
+
+export interface EnvReadLease {
+  holder: string
+  released: boolean
+  release(): void
+}
+
+export interface EnvLeaseStatus {
+  readers: number
+  holders: string[]
+  exclusive: string | null
+  fileLock: { path: string, owner: string, pid: number, heartbeatAt: number } | null
+}
+
+const g = globalThis as typeof globalThis & {
+  __amlEnvLease?: { readers: Map<string, number>, exclusive: string | null, lockPath: string | null }
+}
+
+function state() {
+  g.__amlEnvLease ??= { readers: new Map<string, number>(), exclusive: null, lockPath: null }
+  return g.__amlEnvLease
+}
+
+export function acquireEnvReadLease(holder: string): EnvReadLease {
+  const s = state()
+  if (s.exclusive) {
+    throw new AppError(409, 'ENV_BUSY', `AML 环境正在维护(${s.exclusive}),暂不接受新任务;请等待安装/重建完成`)
+  }
+  s.readers.set(holder, (s.readers.get(holder) ?? 0) + 1)
+  let released = false
+  return {
+    holder,
+    get released() { return released },
+    release() {
+      if (released) return
+      released = true
+      const count = (s.readers.get(holder) ?? 1) - 1
+      if (count <= 0) s.readers.delete(holder)
+      else s.readers.set(holder, count)
+    },
+  }
+}
+
+/** 重建前检查:有读者立即 ENV_BUSY(不阻塞等待,避免请求挂死)。 */
+export function assertEnvIdleForMaintenance(holder: string): void {
+  const s = state()
+  if (s.exclusive && s.exclusive !== holder) {
+    throw new AppError(409, 'ENV_BUSY', `AML 环境已被 ${s.exclusive} 独占,拒绝重复维护`)
+  }
+  if (s.readers.size > 0) {
+    const who = [...s.readers.keys()].join(', ')
+    throw new AppError(409, 'ENV_BUSY', `AML 环境仍有在途任务(${who}),拒绝重建/安装`)
+  }
+}
+
+/** 独占锁:进入时拒绝并发读者;退出时释放。 */
+export async function withEnvExclusiveLock<T>(holder: string, amlRoot: string, fn: () => Promise<T> | T): Promise<T> {
+  const s = state()
+  assertEnvIdleForMaintenance(holder)
+  s.exclusive = holder
+  let lockPath: string | undefined
+  let token: string | undefined
+  try {
+    lockPath = fileLockPath(amlRoot)
+    token = acquireFileLock(lockPath, holder)
+    return await fn()
+  }
+  finally {
+    s.exclusive = null
+    if (lockPath && token) releaseFileLock(lockPath, token)
+  }
+}
+
+export function envLeaseStatus(amlRoot?: string): EnvLeaseStatus {
+  const s = state()
+  const lockPath = amlRoot ? fileLockPath(amlRoot) : null
+  const lock = lockPath ? readFileLock(lockPath) : null
+  return {
+    readers: [...s.readers.values()].reduce((a, b) => a + b, 0),
+    holders: [...s.readers.keys()],
+    exclusive: s.exclusive,
+    fileLock: lock && lockPath ? { path: lockPath, ...lock } : null,
+  }
+}
+
+function fileLockPath(amlRoot: string): string {
+  const dir = join(amlRoot, 'runtime')
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true })
+  return join(dir, 'env.lock')
+}
+
+interface FileLock { owner: string, pid: number, heartbeatAt: number, token?: string }
+
+function readFileLock(path: string): FileLock | null {
+  try {
+    if (!existsSync(path)) return null
+    return JSON.parse(readFileSync(path, 'utf8')) as FileLock
+  }
+  catch {
+    return null
+  }
+}
+
+function acquireFileLock(path: string, holder: string): string {
+  const token = randomUUID()
+  try {
+    writeFileSync(path, JSON.stringify({ owner: holder, pid: process.pid, heartbeatAt: Date.now(), token }), { flag: 'wx' })
+  }
+  catch (err) {
+    if ((err as NodeJS.ErrnoException).code !== 'EEXIST') throw err
+    const existing = readFileLock(path)
+    // 不做 read-then-delete 过期回收:另一个进程可能已换入新锁。
+    throw new AppError(409, 'ENV_BUSY', `AML 环境被进程 ${existing?.pid ?? '?'}(${existing?.owner ?? '未知'})锁定;如确认其已退出,请清理 ${path}`)
+  }
+  return token
+}
+
+function releaseFileLock(path: string, token: string): void {
+  const existing = readFileLock(path)
+  if (existing?.pid === process.pid && existing.token === token) rmSync(path, { force: true })
+}
+
+/** 观察项:租约文件更新时间(排障用,不参与判定)。 */
+export function envLockMtime(amlRoot: string): number | null {
+  try {
+    return statSync(fileLockPath(amlRoot)).mtimeMs
+  }
+  catch {
+    return null
+  }
+}