agentworkshop 0.8.8 → 0.9.0

package/server/services/workshop/process-model/experiment-runner.ts

@@ -0,0 +1,393 @@
+/**
+ * 参数试验计划执行器(科学探索计划 P4,docs/plans/2026-11-02-scientific-exploration-plan.md):
+ * 把 process_model_experiments 从"仅仿真线可建"升级为**治理分档**:
+ *  - simulated=true → tier=sim_auto:建计划即可执行(既有行为不变);
+ *  - 真实线 → tier=real_hitl:建计划落 awaiting_approval,须单卡 HITL 批准(卡上带成本核算)
+ *    后转 planned 才能执行。
+ * 执行语义(正交化由机制保证,不靠 Agent 自觉):
+ *  - 步序 = repeats × levels,默认 seeded 随机化(randomizedOrder=false 时按原序);
+ *  - 每步:写控制(走 DcwController.write 咽喉,source=agent → 步长/60s 间隔/保持窗照常生效)
+ *    → 等 settleMs → 等 observeMs → 下一步;
+ *  - 预算:步数上限 + 总时长上限,超限即 FAILED 并写明原因(不静默续跑);
+ *  - abortOnAlarm:每步前查告警,命中即 FAILED(剩余步不执行);
+ *  - 台账:写咽喉已自动落 intervention_events(hypothesis 前缀 [pexp:<id>] 建立关联),
+ *    计划结束时按台账汇总 verdict 分布进计划状态。
+ * 副作用全部经注入(测试可替换),默认实现走真实控制器/数采/告警仓储。
+ */
+import { createHash } from 'node:crypto'
+import { AppError } from '../../../utils/errors'
+import { getDcwLineRepo } from '../dcw/dcw-line.repo'
+import { getDcwController } from '../dcw/dcw-controller'
+import { getRecipeRollBackManager } from '../dcw/recipe-rollback-manager'
+import { getDaqController } from '../daq/daq-controller'
+import { getAmlRuntime } from '../aml/runtime'
+import { getExperimentPlan, updateExperimentStatus, type ExperimentPlanRow } from './experiment'
+import { assessIdentifiability, dominantPeriod } from '../aml/identifiability'
+import { attachAssessment, listInterventions, verdictCodeOf, verdictDetailOf } from '../aml/intervention-ledger'
+import { backfillInterventionEvidence } from '../aml/ontology-learning'
+
+export interface ExperimentPlanBody {
+  version: 1
+  lineId: string
+  simSceneId: string | null
+  specId: string | null
+  levels: Record<string, number[]>
+  repeats: number
+  settleMs: number
+  observeMs: number
+  randomizedOrder: boolean
+  abortOnAlarm: boolean
+  design: string
+  tier?: 'sim_auto' | 'real_hitl'
+  /** 主控制量 → 观测目标节点(执行时读回);缺省取 spec 或首个控制量,无目标则跳过判读 */
+  targets?: Record<string, string>
+  /** 创建时核算的成本(人读 + 机读) */
+  cost?: ExperimentCost
+  /** 真实线批准凭据(approveExperimentPlan 写入) */
+  approvalId?: string
+  approvedBy?: string
+  approvedAt?: string
+  note?: string
+}
+
+export interface ExperimentCost {
+  /** 各控制量中最大的水平数(展示用) */
+  levelsPerControl: number
+  /** 全部控制量水平数之和(步数基数) */
+  levelsTotal: number
+  controls: number
+  repeats: number
+  steps: number
+  perStepMs: number
+  totalDurationMs: number
+  /** 建议的单步响应窗(ms):已知主导周期时为 3×周期,否则 = settleMs */
+  suggestedWindowMs: number | null
+  dominantPeriodMs: number | null
+  summary: string
+}
+
+export interface ExperimentStep {
+  index: number
+  controlId: string
+  level: number
+  repeat: number
+}
+
+/** 真/仿真产线分档(不 throw:调用方按 tier 决定是否挂 HITL) */
+export function resolveExperimentTier(lineId: string): { lineId: string, lineName: string, simulated: boolean, tier: 'sim_auto' | 'real_hitl', simSceneId?: string } {
+  const line = getDcwLineRepo().byId(lineId)
+  if (!line) throw new AppError(404, 'LINE_NOT_FOUND', `产线 ${lineId} 不存在`)
+  const simulated = line.simulated === true
+  return { lineId: line.id, lineName: line.name, simulated, tier: simulated ? 'sim_auto' : 'real_hitl', simSceneId: line.simSceneId }
+}
+
+/** 真实线下 60s 节点最小间隔(与 write() 的在线写联锁同口径) */
+const REAL_MIN_STEP_MS = 60_000
+
+/**
+ * 成本核算(创建时就算给用户看):步数 × 每步驻留。真实线每步至少 60s(写间隔联锁),
+ * 仿真线不受此限。已知主导周期时,建议窗 = 3×周期,单步驻留取 max(settle, 建议窗, 60s)。
+ */
+export function estimateExperimentCost(plan: Pick<ExperimentPlanBody, 'levels' | 'repeats' | 'settleMs' | 'observeMs' | 'tier'>, opts: { dominantPeriodMs?: number | null } = {}): ExperimentCost {
+  const controls = Object.keys(plan.levels).length
+  const levelsPerControl = Math.max(0, ...Object.values(plan.levels).map(v => v.length))
+  // 步数 = 各控制量水平数之和 × 轮数(不是 max×控制量数 —— 控制量水平数可以不同)
+  const levelsTotal = Object.values(plan.levels).reduce((a, v) => a + v.length, 0)
+  const repeats = plan.repeats
+  const steps = levelsTotal * repeats
+  const period = opts.dominantPeriodMs ?? null
+  const suggestedWindowMs = period != null && period > 0 ? Math.round(3 * period) : null
+  const minStep = plan.tier === 'real_hitl' ? REAL_MIN_STEP_MS : 0
+  const holdMs = Math.max(plan.settleMs, suggestedWindowMs ?? 0, minStep)
+  const perStepMs = holdMs + plan.observeMs
+  const totalDurationMs = steps * perStepMs
+  const summary = `${controls} 个控制量共 ${levelsTotal} 个水平 × ${repeats} 轮 = ${steps} 步;每步 ${Math.round(perStepMs / 1000)}s(驻留 ${Math.round(holdMs / 1000)}s${
+    suggestedWindowMs != null ? `,含 3×主导周期 ${(suggestedWindowMs / 1000).toFixed(1)}s` : ''
+  }${minStep ? ',真实线 60s 写间隔下限' : ''} + 观测 ${Math.round(plan.observeMs / 1000)}s);预计总时长 ≈ ${(totalDurationMs / 3600_000).toFixed(2)} 小时`
+  return { levelsPerControl, levelsTotal, controls, repeats, steps, perStepMs, totalDurationMs, suggestedWindowMs, dominantPeriodMs: period, summary }
+}
+
+function seededShuffle<T>(items: T[], seed: number): T[] {
+  let a = seed >>> 0
+  const rnd = () => {
+    a |= 0
+    a = (a + 0x6D2B79F5) | 0
+    let t = Math.imul(a ^ (a >>> 15), 1 | a)
+    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296
+  }
+  const out = [...items]
+  for (let i = out.length - 1; i > 0; i--) {
+    const j = Math.floor(rnd() * (i + 1))
+    const tmp = out[i]!
+    out[i] = out[j]!
+    out[j] = tmp
+  }
+  return out
+}
+
+/**
+ * 生成执行步序:按 repeats × (control,level) 展开,randomizedOrder 时用计划 id 派生种子洗牌
+ * (同一计划可复现;跨控制量也打散,避免"先把一个 MV 走完再走另一个"带来的时间混杂)。
+ */
+export function buildExperimentSteps(plan: ExperimentPlanBody, planId: string): ExperimentStep[] {
+  const base: Array<{ controlId: string, level: number, repeat: number }> = []
+  for (let r = 0; r < plan.repeats; r++) {
+    for (const [controlId, levels] of Object.entries(plan.levels)) {
+      for (const level of levels) base.push({ controlId, level, repeat: r })
+    }
+  }
+  const seed = createHash('sha256').update(planId).digest().readUInt32BE(0)
+  const ordered = plan.randomizedOrder ? seededShuffle(base, seed) : base
+  return ordered.map((s, index) => ({ index, ...s }))
+}
+
+export function parsePlan(row: ExperimentPlanRow): ExperimentPlanBody {
+  return JSON.parse(row.planJson) as ExperimentPlanBody
+}
+
+/** 真实线批准:awaiting_approval → planned(记录批准凭据;幂等) */
+export function approveExperimentPlan(id: string, approvalId: string, approvedBy: string): ExperimentPlanRow {
+  const row = getExperimentPlan(id)
+  if (!row) throw new AppError(404, 'EXPERIMENT_PLAN_NOT_FOUND', `试验计划 ${id} 不存在`)
+  const plan = parsePlan(row)
+  if (row.status === 'planned' && plan.approvalId) return row
+  if (row.status !== 'awaiting_approval') {
+    throw new AppError(409, 'EXPERIMENT_STATUS_INVALID', `计划 ${id} 当前状态 ${row.status},只有 awaiting_approval 可批准`)
+  }
+  const next: ExperimentPlanBody = { ...plan, approvalId, approvedBy, approvedAt: new Date().toISOString() }
+  const db = getAmlRuntime().db
+  db.prepare('UPDATE process_model_experiments SET plan_json = ?, status = \'planned\', updated_at = ? WHERE id = ?')
+    .run(JSON.stringify(next), new Date().toISOString(), id)
+  return getExperimentPlan(id)!
+}
+
+// ---------- 执行 ----------
+
+export interface ExperimentRunnerDeps {
+  /** 写控制(默认走 DcwController.write 咽喉;测试注入) */
+  write?: (controlId: string, level: number, meta: { hypothesis: string, planId: string, stepIndex: number }) => Promise<{ ok: boolean, message?: string, recordId?: string }>
+  /** 关闭单步调控记录(默认 judge=rollback 关闭不执行回退;测试注入) */
+  closeRecord?: (recordId: string, reason: string) => void
+  /** 读目标窗均值(默认 daq samples;测试注入) */
+  readTargetMean?: (targetNodeId: string, fromMs: number, toMs: number) => Promise<number | null>
+  /** 读目标窗序列(默认 daq samples;判定用;缺省跳过引擎判读) */
+  readTargetSeries?: (targetNodeId: string, fromMs: number, toMs: number) => Promise<number[]>
+  /** 告警检查(默认查 audit_log 最近一条 level=error 的 alarm 行;测试注入) */
+  alarmActive?: (lineId: string, sinceMs: number) => Promise<boolean>
+  sleep?: (ms: number) => Promise<void>
+  /** 时钟(测试可推进) */
+  now?: () => number
+}
+
+export interface ExperimentRunResult {
+  planId: string
+  status: 'done' | 'failed' | 'cancelled'
+  executedSteps: number
+  totalSteps: number
+  failedReason?: string
+  verdicts: Record<string, number>
+  startedAt: string
+  finishedAt: string
+}
+
+function defaultWrite(): NonNullable<ExperimentRunnerDeps['write']> {
+  return async (controlId, level, meta) => {
+    try {
+      const outcome = await getDcwController().write(controlId, level, null, {
+        source: 'agent',
+        actor: `plan:${meta.planId}`,
+        actorName: `试验计划 ${meta.planId}`,
+        hypothesis: meta.hypothesis,
+      })
+      return { ok: outcome.ok !== false, message: outcome.message, recordId: outcome.recordId }
+    }
+    catch (err) {
+      return { ok: false, message: err instanceof Error ? err.message : String(err) }
+    }
+  }
+}
+
+/**
+ * 关闭单步的调控闭环记录(默认实现):不关闭会让下一步被"单一开放记录"守卫拒绝
+ * (beforeWrite: 正在优化试验中)。judge('rollback') 按设计只落判定、记录仍 open,
+ * 因此用 keep + takeover:关闭记录但**跳过好锚晋升**(试验步是探索,不是产能优化,
+ * 不应污染 keep 锚点链)。
+ */
+function defaultCloseRecord(): NonNullable<ExperimentRunnerDeps['closeRecord']> {
+  return (recordId, reason) => {
+    try {
+      getRecipeRollBackManager().judge(recordId, 'keep', reason, 'system', 'experiment-plan', { takeover: true })
+    }
+    catch { /* 已关闭/记录不存在:不影响执行 */ }
+  }
+}
+
+const sleepReal = (ms: number) => new Promise<void>(r => setTimeout(r, ms))
+
+export async function runExperimentPlan(id: string, deps: ExperimentRunnerDeps = {}): Promise<ExperimentRunResult> {
+  const row = getExperimentPlan(id)
+  if (!row) throw new AppError(404, 'EXPERIMENT_PLAN_NOT_FOUND', `试验计划 ${id} 不存在`)
+  const plan = parsePlan(row)
+  const tier = plan.tier ?? (resolveExperimentTier(plan.lineId).tier)
+  if (row.status === 'running') throw new AppError(409, 'EXPERIMENT_ALREADY_RUNNING', `计划 ${id} 正在执行`)
+  if (row.status !== 'planned') {
+    throw new AppError(409, 'EXPERIMENT_STATUS_INVALID', `计划 ${id} 当前状态 ${row.status},只有 planned 可执行${tier === 'real_hitl' ? '(真实线须先 HITL 批准)' : ''}`)
+  }
+  // 真实线执行前复核批准凭据(防"建完直接跑"绕过 HITL)
+  if (tier === 'real_hitl' && !plan.approvalId) {
+    throw new AppError(409, 'EXPERIMENT_APPROVAL_REQUIRED', `计划 ${id} 为真实产线计划,缺少 HITL 批准凭据,拒绝执行`)
+  }
+  const budget = JSON.parse(row.budgetJson) as { maxRuns?: number, maxDurationMs?: number }
+  const steps = buildExperimentSteps(plan, id)
+  if (budget.maxRuns && steps.length > budget.maxRuns) {
+    updateExperimentStatus(id, 'failed')
+    return {
+      planId: id, status: 'failed', executedSteps: 0, totalSteps: steps.length,
+      failedReason: `步数 ${steps.length} 超预算 maxRuns=${budget.maxRuns}(创建即拒绝执行)`,
+      verdicts: {}, startedAt: new Date().toISOString(), finishedAt: new Date().toISOString(),
+    }
+  }
+
+  const write = deps.write ?? defaultWrite()
+  const closeRecord = deps.closeRecord ?? defaultCloseRecord()
+  const readTarget = deps.readTargetMean ?? (async (nodeId, fromMs, toMs) => {
+    try {
+      const pts = await getDaqController().samples(nodeId, { fromMs, toMs, bucketMs: 1000, limit: 600 }) as Array<{ value?: number, avg?: number }>
+      const vals = pts.map(p => Number(p.value ?? p.avg)).filter(Number.isFinite)
+      return vals.length ? vals.reduce((a, b) => a + b, 0) / vals.length : null
+    }
+    catch {
+      return null
+    }
+  })
+  const alarmActive = deps.alarmActive ?? (async (lineId, sinceMs) => {
+    try {
+      const hit = getAmlRuntime().db.prepare(`SELECT id FROM audit_log WHERE line_id = ? AND level = 'error' AND created_at >= ? LIMIT 1`)
+        .get(lineId, new Date(sinceMs).toISOString()) as { id?: string } | undefined
+      return !!hit
+    }
+    catch {
+      return false
+    }
+  })
+  const readSeries = deps.readTargetSeries ?? (async (nodeId, fromMs, toMs) => {
+    try {
+      const pts = await getDaqController().samples(nodeId, { fromMs, toMs, bucketMs: 1000, limit: Math.max(60, Math.ceil((toMs - fromMs) / 1000) + 10) }) as Array<{ value?: number, avg?: number }>
+      return pts.map(p => Number(p.value ?? p.avg)).filter(Number.isFinite)
+    }
+    catch {
+      return []
+    }
+  })
+  const sleep = deps.sleep ?? sleepReal
+  const now = deps.now ?? (() => Date.now())
+
+  updateExperimentStatus(id, 'running')
+  const startedAt = new Date(now()).toISOString()
+  const started = now()
+  // 计划级主导周期估计:用一段长历史(≥30min 与 6×settle 的较大者)估一次,
+  // 逐步判定统一使用 —— 短窗局部自相关会把局部纹波当周期(事故形态)。
+  let expectedPeriodMs: number | undefined
+  const firstTarget = plan.targets ? Object.values(plan.targets)[0] : undefined
+  if (firstTarget) {
+    try {
+      const longMs = Math.max(30 * 60_000, plan.settleMs * 6)
+      const longSeries = await readSeries(firstTarget, now() - longMs, now())
+      if (longSeries.length >= 64) {
+        const p = dominantPeriod(longSeries)
+        // 长历史必须覆盖 ≥3 个周期才采信该估计
+        if (p.lagBeats != null && longSeries.length / p.lagBeats >= 3) expectedPeriodMs = p.lagBeats * 1000
+      }
+    }
+    catch { /* 估计失败退回逐步检测 */ }
+  }
+  let executed = 0
+  let failedReason: string | undefined
+
+  for (const step of steps) {
+    // 预算:总时长超限即停(不静默续跑)
+    if (budget.maxDurationMs && now() - started > budget.maxDurationMs) {
+      failedReason = `超出预算 maxDurationMs=${budget.maxDurationMs}ms(已执行 ${executed}/${steps.length} 步)`
+      break
+    }
+    if (plan.abortOnAlarm && await alarmActive(plan.lineId, started)) {
+      failedReason = `告警中止(abortOnAlarm):第 ${executed + 1} 步前检测到产线告警,剩余 ${steps.length - executed} 步未执行`
+      break
+    }
+    const hypothesis = `[pexp:${id}] 试验步 ${step.index + 1}/${steps.length}:${step.controlId}=${step.level}(第 ${step.repeat + 1} 轮)`
+    const res = await write(step.controlId, step.level, { hypothesis, planId: id, stepIndex: step.index })
+    if (!res.ok) {
+      failedReason = `第 ${step.index + 1} 步写入被拒:${res.message ?? '未知原因'}`
+      break
+    }
+    executed++
+    const writeAt = now()
+    await sleep(plan.settleMs)
+    // 观测窗 + 引擎判读:有目标映射时,写前窗/写后窗各取一次序列交给可辨识性引擎,
+    // 判定回填本步干预台账(与 optimization_explore 同口径);无目标则只驻留。
+    const target = plan.targets?.[step.controlId]
+    if (target) {
+      const pre = await readSeries(target, writeAt - plan.settleMs, writeAt)
+      await sleep(plan.observeMs)
+      const post = await readSeries(target, writeAt, now())
+      await readTarget(target, writeAt, now())
+      if (pre.length >= 8 && post.length >= 8) {
+        try {
+          const v = assessIdentifiability({ pre, post, beatMs: 1000, ...(expectedPeriodMs != null ? { expectedPeriodMs } : {}) })
+          // 写咽喉落行时若无 targetNodeId 会标 unassessed(尚无判定)—— 两者都视为"待判定"
+          const row = listInterventions({ nodeId: step.controlId, limit: 50 })
+            .find(r => r.hypothesis.startsWith(`[pexp:${id}]`) && (r.verdict === 'pending' || r.verdict === 'unassessed'))
+          if (row) {
+            attachAssessment(row.id, {
+              verdict: verdictCodeOf(v),
+              effect: v.effect,
+              ciLow: v.ciLow,
+              ciHigh: v.ciHigh,
+              mde: v.mde,
+              targetNodeId: target,
+              detail: verdictDetailOf(v),
+            })
+            // P6:判定回灌本体证据(有已发布本体才落;幂等)
+            const updated = listInterventions({ nodeId: step.controlId, limit: 1 })[0]
+            if (updated) {
+              try {
+                backfillInterventionEvidence(updated)
+              }
+              catch { /* 证据登记失败不影响执行 */ }
+            }
+          }
+        }
+        catch { /* 判读失败按未判定处理 */ }
+      }
+    }
+    else {
+      await sleep(plan.observeMs)
+    }
+    // 关闭本步调控记录(否则下一步会被"单一开放记录"守卫拒绝)
+    if (res.recordId) closeRecord(res.recordId, `试验计划 ${id} 第 ${step.index + 1} 步执行完成,由计划执行器关闭(关闭记录不晋升锚点)`)
+  }
+
+  // 台账汇总:按 hypothesis 前缀 [pexp:<id>] 找本次计划的干预行
+  const verdicts: Record<string, number> = {}
+  try {
+    const involved = new Set(Object.keys(plan.levels))
+    const rows = listInterventions({ lineId: plan.lineId, limit: 200 })
+      .filter(r => involved.has(r.nodeId) && r.hypothesis.startsWith(`[pexp:${id}]`))
+    for (const r of rows) verdicts[r.verdict] = (verdicts[r.verdict] ?? 0) + 1
+  }
+  catch { /* 台账不可读不影响执行结果 */ }
+
+  const status: ExperimentRunResult['status'] = failedReason ? 'failed' : 'done'
+  updateExperimentStatus(id, status)
+  return {
+    planId: id,
+    status,
+    executedSteps: executed,
+    totalSteps: steps.length,
+    ...(failedReason ? { failedReason } : {}),
+    verdicts,
+    startedAt,
+    finishedAt: new Date(now()).toISOString(),
+  }
+}

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

@@ -1,13 +1,16 @@
 /**
- * 模拟参数试验计划(G2.11 / C9 / A9):
- *  - 只有 simulated=true 的产线可发起;真实线 → SIM_ONLY_VIOLATION;
- *  - 计划只落 process_model_experiments;动作明细仍走既有 optimization_explorations/DCW 记录
+ * 参数试验计划(G2.11 / C9 / A9;P4 治理分档 2026-11-02):
+ *  - simulated=true → tier=sim_auto,建计划即可执行(既有行为不变);
+ *  - 真实线 → tier=real_hitl,创建后落 awaiting_approval,须 approveExperimentPlan
+ *    单卡 HITL 批准(卡上带成本核算)后才能由 runExperimentPlan 执行;
+ *  - 计划只落 process_model_experiments;动作明细仍走既有 DCW 写咽喉/台账
  *    (不制造第二套写设备账本)。
  */
 import type { DatabaseSync } from 'node:sqlite'
 import { AppError } from '../../../utils/errors'
 import { getAmlRuntime } from '../aml/runtime'
 import { getDcwLineRepo } from '../dcw/dcw-line.repo'
+import { estimateExperimentCost, resolveExperimentTier, type ExperimentPlanBody, type ExperimentCost } from './experiment-runner'
 
 export interface ExperimentPlanInput {
   lineId: string
@@ -21,6 +24,10 @@ export interface ExperimentPlanInput {
   abortOnAlarm?: boolean
   budget?: { maxRuns?: number, maxDurationMs?: number }
   createdBy?: string
+  /** MV → 观测目标节点(执行时读回;缺省不读) */
+  targets?: Record<string, string>
+  /** 已知主导扰动周期(ms;来自可辨识性引擎):成本核算按 3×周期给建议窗 */
+  dominantPeriodMs?: number
 }
 
 export interface ExperimentPlanRow {
@@ -44,7 +51,7 @@ export function assertSimulatedLine(lineId: string): { id: string, simSceneId?:
 }
 
 export function createExperimentPlan(input: ExperimentPlanInput): ExperimentPlanRow {
-  const line = assertSimulatedLine(input.lineId)
+  const tierInfo = resolveExperimentTier(input.lineId)
   if (!Object.keys(input.levels).length) throw new AppError(422, 'EXPERIMENT_PLAN_INVALID', '至少需要 1 个 MV 的水平序列')
   for (const [id, levels] of Object.entries(input.levels)) {
     if (!Array.isArray(levels) || levels.length < 2) throw new AppError(422, 'EXPERIMENT_PLAN_INVALID', `MV ${id} 至少需要 2 个水平(阶跃/多水平)`)
@@ -57,10 +64,15 @@ export function createExperimentPlan(input: ExperimentPlanInput): ExperimentPlan
   const db = getAmlRuntime().db
   const id = `pexp-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`
   const now = new Date().toISOString()
-  const plan = {
+  // P4 成本前置:创建时就核算(真实线含 60s 写间隔下限;已知主导周期时按 3×周期建议窗)
+  const cost: ExperimentCost = estimateExperimentCost(
+    { levels: input.levels, repeats, settleMs, observeMs, tier: tierInfo.tier },
+    { dominantPeriodMs: input.dominantPeriodMs ?? null },
+  )
+  const plan: ExperimentPlanBody = {
     version: 1,
     lineId: input.lineId,
-    simSceneId: line.simSceneId ?? null,
+    simSceneId: tierInfo.simSceneId ?? null,
     specId: input.specId ?? null,
     levels: input.levels,
     repeats,
@@ -69,12 +81,15 @@ export function createExperimentPlan(input: ExperimentPlanInput): ExperimentPlan
     randomizedOrder: input.randomizedOrder !== false,
     abortOnAlarm: input.abortOnAlarm !== false,
     design: 'stepped_multi_level',
-    note: '动作明细写入既有 optimization_explorations/DCW 账本;本台账只保存计划与状态',
+    tier: tierInfo.tier,
+    ...(input.targets ? { targets: input.targets } : {}),
+    cost,
+    note: '动作明细经 DCW 写咽喉落 intervention_events([pexp:<id>] 前缀关联);本台账只保存计划与状态',
   }
-  const budget = { maxRuns: input.budget?.maxRuns ?? 20, maxDurationMs: input.budget?.maxDurationMs ?? 4 * 3600_000 }
+  const budget = { maxRuns: input.budget?.maxRuns ?? Math.max(20, cost.steps), maxDurationMs: input.budget?.maxDurationMs ?? 4 * 3600_000 }
   db.prepare(`INSERT INTO process_model_experiments (id, line_id, plan_json, status, budget_json, created_by, created_at, updated_at)
-    VALUES (?, ?, ?, 'planned', ?, ?, ?, ?)`)
-    .run(id, input.lineId, JSON.stringify(plan), JSON.stringify(budget), input.createdBy ?? '', now, now)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)`)
+    .run(id, input.lineId, JSON.stringify(plan), tierInfo.tier === 'real_hitl' ? 'awaiting_approval' : 'planned', JSON.stringify(budget), input.createdBy ?? '', now, now)
   return this_get(db, id)!
 }
 

package/server/services/workshop/runtime/agent-runtime/lifecycle.ts

@@ -42,19 +42,42 @@ export abstract class AgentRuntimeLifecycle extends AgentRuntimeState {
     this.deps.mailbox.close()
     // 状态广播:前端经 WS agent.status 实时反映 stopped
     this.deps.bus.notifyAgent({ agentId: this.agentId, state: 'stopped', ...this.queueContext() })
-    // 宽限等待消费循环退出,但**不无限等**:impl 若不响应 abort(如长 sleep 的
-    // mock/外部进程卡死),HTTP stop 请求会无限悬挂(实测 30s×8 全超时)。
-    // 超过宽限即放行 —— loop 自身的 finally 稍后自行收尾,dispose 照常执行。
-    await Promise.race([
-      this.loopPromise?.catch(() => { }),
-      new Promise(r => setTimeout(r, 10_000)),
-    ])
-    // 清理 impl 持有的资源(omp 子进程等);容错:impl.dispose 可能不存在
+    // R-1(2026-11-01):dispose 从 stop() 的同步链路下放后台。
+    // 旧行为:await 宽限(≤10s)+ await impl.dispose(omp client 内含 ≤3s SIGKILL
+    // 等待)——调用方(HTTP 管理动作/D1 兜底/实例删除)在卸载窗口内被同步占住;
+    // 该窗口叠加事件循环繁忙时,健康探针连续 3 次失联 → 守护判僵死 SIGKILL 整个
+    // 服务进程(实测:"卸载一个 agent"演化为"全站活性风险")。
+    // 新语义:墓碑已立(索引已摘/信箱已关/广播已发),剩余收尾(宽限循环退出 +
+    // 子进程终止)不阻塞任何调用方;收尾全程容错并在完成后二次广播 stopped。
+    // stop() 的 await 语义保留给**同步可完成的部分**;后台收尾失败仅记日志,
+    // 不影响系统活性 —— 卸载与全站活性从此解耦。
+    void this.disposeInBackground()
+  }
+
+  /** R-1:后台收尾(宽限消费循环退出 → dispose impl)。失败只记日志,不反压调用方。 */
+  private async disposeInBackground(): Promise<void> {
     try {
-      await this.impl.dispose?.()
+      // 宽限等待消费循环退出,但**不无限等**:impl 若不响应 abort(如长 sleep 的
+      // mock/外部进程卡死),超过宽限即放行 —— loop 自身的 finally 稍后自行收尾。
+      await Promise.race([
+        this.loopPromise?.catch(() => { }),
+        new Promise(r => setTimeout(r, 10_000)),
+      ])
+      // 清理 impl 持有的资源(omp 子进程等);容错:impl.dispose 可能不存在
+      try {
+        await this.impl.dispose?.()
+      }
+      catch (err) {
+        log.error(`[AgentRuntime:${this.agentId}] dispose 失败:`, err)
+      }
     }
-    catch (err) {
-      log.error(`[AgentRuntime:${this.agentId}] dispose 失败:`, err)
+    finally {
+      // 收尾完成(或放行)后补一次状态广播:消费循环若在宽限后才退出,
+      // 其 finally 内的状态广播可能晚于本条;此处保证 stopped 是最后一条。
+      try {
+        this.deps.bus.notifyAgent({ agentId: this.agentId, state: 'stopped', ...this.queueContext() })
+      }
+      catch { /* 广播失败不影响收尾 */ }
     }
   }
 

package/server/services/workshop/runtime/agent-runtime/state.ts

@@ -4,6 +4,7 @@
  */
 import { AgentRuntimeContracts } from './contracts'
 import type { A2AMessage } from '../../types/a2a'
+import { isHumanChatDelivery } from '../../types/a2a'
 import type { AgentEvent, AgentInfo, AgentInterface, AgentWorkspace } from '../../agents/agent-interface'
 import type { AgentMemory } from '../memory'
 import type { AgentStatusView, AgentTaskQueueView, HarnessContinuityView, SupervisionAttemptView } from '../../types/task'
@@ -370,7 +371,11 @@ export abstract class AgentRuntimeState extends AgentRuntimeContracts {
     try {
       const deadline = Date.now() + Math.max(0, waitMs)
       for (;;) {
-        const msgs = await this.deps.mailbox.peek(limit)
+        // 人类群聊投递不交给 poll 认领:必须留给消息回合收尾的 platformReply 回写群聊。
+        // (poll 取走后文本只留在 Agent 会话里,用户永远收不到答复——实测故障。)
+        const msgs = (await this.deps.mailbox.peek(Math.max(limit, 10)))
+          .filter(m => !isHumanChatDelivery(m))
+          .slice(0, limit)
         if (msgs.length > 0 || Date.now() >= deadline) return msgs
         const { promise, resolve } = Promise.withResolvers<unknown>()
         const off = this.deps.mailbox.onArrival(() => resolve(undefined))

package/server/services/workshop/settings.ts

@@ -332,7 +332,7 @@ export interface AmlSettings {
   job: { timeoutMs: number, maxConcurrent: number, diskQuotaMb: number, stallMs: number, logTailLines: number }
   dataset: { maxRows: number, retentionDays: number, allowCrossRecipe: boolean }
   model: { retiredKeepDays: number }
-  gates: { nrmse: number, rolloutNrmse: number, valTestGap: number, minRows: number, minRuns: number }
+  gates: { nrmse: number, rolloutNrmse: number, valTestGap: number, minRows: number, minRuns: number, minControlLevels: number, maxCollinearity: number }
 }
 /** AML 自动建模平台运行语义(live 键热生效;logTailLines 非描述符键,固定缺省) */
 export function amlSettings(): AmlSettings {
@@ -363,6 +363,9 @@ export function amlSettings(): AmlSettings {
       valTestGap: Number(get('gates.valTestGap', 0.20)),
       minRows: Number(get('gates.minRows', 500)),
       minRuns: Number(get('gates.minRuns', 3)),
+      // P3/G6 动作覆盖门:控制量至少 3 个水平(可区分线性/二次),与时间序号 |r| ≤ 0.9
+      minControlLevels: Number(get('gates.minControlLevels', 3)),
+      maxCollinearity: Number(get('gates.maxCollinearity', 0.9)),
     },
   }
 }

package/server/services/workshop/types/a2a.ts

@@ -39,11 +39,26 @@ export interface ChannelMail {
   parts: Part[]
   metadata: Record<string, unknown>
   /** 投递状态:pending=未消费 / consuming=消费中 / consumed=已消费 */
-  state: 'pending' | 'consuming' | 'consumed'
+  state: 'pending' | 'consuming' | 'consumed' | 'dead'
   createdAt: string
   consumedAt: string | null
 }
 
+/**
+ * 人类群聊投递消息(平台盖章 x-aw-source-chat-message-id;非 Agent 间协作)。
+ *
+ * 这类消息必须走消息回合(processMessage)收尾的 platformReply 才能把答复回写群聊;
+ * poll_messages 的「读即取」一旦认领,poll 轮次内的文本不会触发 platformReply,
+ * 用户就永远收不到回答(实测:15:15 提问被 lead 的 poll 取走,15:50 群聊仍无回复)。
+ */
+export function isHumanChatDelivery(m: { metadata?: Record<string, unknown> }): boolean {
+  const meta = m.metadata ?? {}
+  const from = meta['x-aw-from-agent']
+  if (typeof from === 'string' && from.length > 0) return false
+  const sourceChatId = meta['x-aw-source-chat-message-id']
+  return typeof sourceChatId === 'string' && sourceChatId.length > 0
+}
+
 /** A2A 成果:任务作业产出的内容集合 */
 export interface A2AArtifact {
   artifactId: string

package/shared/config/schema.json

@@ -159,6 +159,8 @@
     { "key": "aml.gates.valTestGap", "type": "number", "group": "aml", "label": "门禁:泛化差", "labelKey": "settings.runtime.aml.gateValTestGap", "description": "门禁 G3:|test-val|/val 相对差上限(防过拟合验证集)", "applies": "live", "default": 0.2, "min": 0.01, "max": 2 },
     { "key": "aml.gates.minRows", "type": "number", "group": "aml", "label": "门禁:最少样本行", "labelKey": "settings.runtime.aml.gateMinRows", "description": "门禁 G4a:数据集滑窗样本行数下限", "applies": "live", "default": 500, "min": 50, "max": 1000000 },
     { "key": "aml.gates.minRuns", "type": "number", "group": "aml", "label": "门禁:最少批次数", "labelKey": "settings.runtime.aml.gateMinRuns", "description": "门禁 G4b:数据集覆盖的批次(run)数下限", "applies": "live", "default": 3, "min": 1, "max": 1000 },
+    { "key": "aml.gates.minControlLevels", "type": "number", "group": "aml", "label": "门禁 G6:控制量最少水平数", "labelKey": "settings.runtime.aml.gateMinControlLevels", "description": "动作覆盖门 G6:每个 role=control 节点至少出现的历史水平数(<3 无法区分线性/二次,模型学不到动作维度)", "applies": "live", "default": 3, "min": 2, "max": 20 },
+    { "key": "aml.gates.maxCollinearity", "type": "number", "group": "aml", "label": "门禁 G6:控制量与时间最大共线", "labelKey": "settings.runtime.aml.gateMaxCollinearity", "description": "动作覆盖门 G6:控制量序列与时间序号 |pearson| 上限(纯阶梯/单调斜坡无论档数多少都与时间不可分;2 水平的 |r| 理论上限仅 0.866)", "applies": "live", "default": 0.9, "min": 0.5, "max": 1 },
     { "key": "aml.uq.freshDays", "type": "number", "group": "aml", "label": "UQ 证据保鲜天数", "labelKey": "settings.runtime.aml.uqFreshDays", "description": "工件 UQ 校准时间(calibratedAt)超过该天数后建议降级 unverified(需重训刷新证据)", "applies": "live", "default": 7, "min": 1, "max": 365 },
 
     { "key": "mcp.enabled", "type": "boolean", "group": "mcp", "label": "启动 MCP 集成", "labelKey": "settings.runtime.mcp.enabled", "description": "允许 aw 工业 MCP(mcp/aw-mcp-server.mjs)连接并操作本实例;停用后 MCP 工具调用将被拒绝(平台 REST 与频道内 agent 不受影响)。也可用环境变量 AW_MCP_ENABLED 覆盖。", "applies": "live", "default": false, "aliases": ["AW_MCP_ENABLED"] },

package/shared/dcw-protocol/closed-loop.ts

@@ -23,6 +23,8 @@ export interface DcwWriteMeta {
   hypothesis?: string
   /** 精确关联触发本次 Agent 写入的人工审批记录 */
   approvalId?: string
+  /** 触发写入的 Channel(v34 干预台账归因;manual/recipe 等无频道路径缺省为空) */
+  channelId?: string
   /** 写入发生时频道的生效执行模式(observe/manual/auto;2026-10-28 三模式台账口径,事后审计用) */
   executionMode?: 'observe' | 'manual' | 'auto'
   /** D8 基准消融臂(仅 AW_BENCH_MODE=1 时被 write() 识别;生产模式恒忽略) */

package/.output/public/_nuxt/builds/meta/1231252d-2864-43c0-83b2-4e70d3b86dea.json

@@ -1 +0,0 @@
-{"id":"1231252d-2864-43c0-83b2-4e70d3b86dea","timestamp":1793420326476,"prerendered":[]}