agentworkshop 0.7.54 → 0.7.59

package/server/services/workshop/dcw/recipe-op-anchor.ts

@@ -0,0 +1,117 @@
+/**
+ * Recipe 下发操作间隔锚点(治理频控)。
+ *
+ * 语义(用户需求):每个 recipe 可配 opIntervalMs(缺省 60s);Agent 的下发族操作
+ * (trial/apply/propose/rollback-dispatch)两次**已批准**下发之间必须 ≥ 该间隔;
+ * 计时锚 = 上一次审批(HITL approve)时刻或该次下发执行成功时刻(封 auto 绑定连发);
+ * 提案未获批(挂起/拒绝/超时)不产生新锚、不计时。
+ *
+ * 键控:按 recipeId 全局共享(跨 Agent;防多 Agent 轮番绕频控)。
+ * 持久化:落盘 dcw-recipe-op-anchors.json(重启不清零,防"重启即绕频控");
+ *         写失败仅告警不反噬主流程(与审批历史 remember 同口径)。
+ * 豁免:人工 REST 下发与系统路径(产线开跑/基准恢复)不查不锚——它们不经
+ *       agentDispatch 标记;emergency 仅豁免本频控,不豁免审批/四层限界/试验节拍。
+ */
+import { join } from 'node:path'
+import { ensureDataDir } from '@/shared/config/home.mjs'
+import { loadJsonFile, saveJsonFileAtomic } from '../json-store.mjs'
+import { recipeOpIntervalMs } from './dcw-recipe.repo'
+import { AppError, ErrorCodes } from '../../../utils/errors'
+
+const ANCHORS_PATH = join(ensureDataDir(), 'dcw-recipe-op-anchors.json')
+const ANCHORS_CAP = 200
+const ANCHOR_TTL_MS = 24 * 3600_000
+
+export interface RecipeOpAnchor {
+  recipeId: string
+  /** epoch ms(锚定时刻:审批 decidedAt 或下发执行完成) */
+  at: number
+  /** 审批单 id;auto 绑定无审批执行时为 '' */
+  approvalId: string
+  agentId: string
+  op: 'trial' | 'apply' | 'propose' | 'rollback'
+  source: 'hitl-approved' | 'agent-executed'
+}
+
+type Store = { anchors: RecipeOpAnchor[] }
+const g = globalThis as unknown as { __recipeOpAnchors?: Store }
+function store(): Store {
+  if (!g.__recipeOpAnchors) g.__recipeOpAnchors = loadJson<Store>(ANCHORS_PATH, { anchors: [] })
+  return g.__recipeOpAnchors
+}
+function loadJson<T>(file: string, fallback: T): T {
+  return loadJsonFile(file, fallback) as T
+}
+
+function persist(): void {
+  const s = store()
+  // GC:超 TTL 的锚在写入时顺手清理(cap 双保险)
+  const now = Date.now()
+  s.anchors = s.anchors.filter(a => now - a.at < ANCHOR_TTL_MS).slice(-ANCHORS_CAP)
+  try {
+    saveJsonFileAtomic(ANCHORS_PATH, s)
+  }
+  catch (err) {
+    console.warn('[recipe-op-anchor] 落盘失败(仅告警,不影响主流程):', err instanceof Error ? err.message : err)
+  }
+}
+
+export function recordRecipeOpAnchor(a: RecipeOpAnchor): void {
+  const s = store()
+  s.anchors = s.anchors.filter(x => x.recipeId !== a.recipeId)
+  s.anchors.push(a)
+  persist()
+}
+
+export function getRecipeOpAnchor(recipeId: string): RecipeOpAnchor | null {
+  return store().anchors.find(a => a.recipeId === recipeId) ?? null
+}
+
+/** 仅供测试:清空全部锚(内存+落盘) */
+export function resetRecipeOpAnchors(): void {
+  g.__recipeOpAnchors = { anchors: [] }
+  persist()
+}
+
+/**
+ * 频控判定:距上一锚不足 opIntervalMs 即抛 429(提案早拒与执行兜底共用)。
+ * - emergency=true 豁免(审批不可豁免,由调用方保证照常挂卡)
+ * - approvalId 命中锚内 id = 自己刚获批的那次,放行(防审批竞态:后批者胜出,先批者滞后执行被弹回)
+ */
+export function assertRecipeOpInterval(
+  recipe: { id: string, name: string, opIntervalMs?: number },
+  opts: { approvalId?: string, emergency?: boolean } = {},
+): void {
+  if (opts.emergency) return
+  const interval = recipeOpIntervalMs(recipe)
+  if (interval <= 0) return
+  const anchor = getRecipeOpAnchor(recipe.id)
+  if (!anchor) return
+  if (opts.approvalId && anchor.approvalId && anchor.approvalId === opts.approvalId) return
+  const elapsed = Date.now() - anchor.at
+  if (elapsed >= interval) return
+  const remainSec = Math.max(1, Math.ceil((interval - elapsed) / 1000))
+  throw new AppError(429, ErrorCodes.RECIPE_OP_INTERVAL_NOT_ELAPSED,
+    `配方「${recipe.name}」下发操作间隔卡控生效:上一次已批准/已执行的下发距现在仅 ${Math.floor(elapsed / 1000)}s`
+    + `(审批 ${anchor.approvalId || '无单号'},操作者 ${anchor.agentId || 'auto'}),本配方要求 ≥${Math.round(interval / 1000)}s。`
+    + `请等待约 ${remainSec}s 后重新提交;等待期间可用 daq_query 复测上一批次的工艺响应。`
+    + `确属应急(如超限纠偏/安全恢复)可在调用时带 emergency=true 豁免频控——审批卡将标注【应急】并仍需人工批准,滥用会留审计痕迹。`)
+}
+
+/** 执行兜底用变体:存在更新的已批单抢先落锚时,文案区分"竞态拦截" */
+export function assertRecipeOpIntervalForExecution(
+  recipe: { id: string, name: string, opIntervalMs?: number },
+  opts: { approvalId?: string, emergency?: boolean } = {},
+): void {
+  try {
+    assertRecipeOpInterval(recipe, opts)
+  }
+  catch (err) {
+    const anchor = getRecipeOpAnchor(recipe.id)
+    if (anchor && opts.approvalId && anchor.approvalId && anchor.approvalId !== opts.approvalId && Date.now() - anchor.at < recipeOpIntervalMs(recipe)) {
+      throw new AppError(429, ErrorCodes.RECIPE_OP_INTERVAL_NOT_ELAPSED,
+        `配方「${recipe.name}」下发被间隔卡控拦截(执行时兜底):存在更新的已批准下发(审批 ${anchor.approvalId})已落锚,本方案审批(${opts.approvalId})未获执行。产线未做任何变更;请吸收最新已批方案意图后按指引重新提交。`)
+    }
+    throw err
+  }
+}

package/server/services/workshop/dcw/recipe-rollback.repo.ts

@@ -41,6 +41,21 @@ function loadDb(): RollbackDb {
   return db
 }
 
+/**
+ * 纯过滤:指定产线在 sinceMs(epoch ms,含边界)之后的锚,时间正序(只读,不改入参)。
+ * 导出为模块级函数便于单测覆盖(不必构造 repo 单例触碰真实数据文件)。
+ */
+export function anchorsSince(all: DcwJournalAnchor[], lineId: string, sinceMs: number, limit = 5000): DcwJournalAnchor[] {
+  const out: DcwJournalAnchor[] = []
+  for (const a of all) {
+    if (a.lineId !== lineId) continue
+    if (Date.parse(a.at) < sinceMs) continue
+    out.push(a)
+    if (out.length >= limit) break
+  }
+  return out
+}
+
 export class RecipeRollBackRepo {
   private db: RollbackDb = loadDb()
   private flushTimer: NodeJS.Timeout | null = null
@@ -208,6 +223,17 @@ export class RecipeRollBackRepo {
     return undefined
   }
 
+  /**
+   * 指定产线在 sinceMs(epoch ms)之后的锚(时间正序,只读)。
+   * 经验采集(Co-Pilot)的水位增量入口:锚 id 是 UUID 非单调、cap 头部淘汰会使
+   * index 型水位漂移,故按 at 过滤(边界含等号,同 ms 锚不漏;调用方再以
+   * watermark.seenAnchorIds 剔重 —— 双保险见 exp-collector)。
+   * 纯过滤逻辑在 anchorsSince,单测可脱离单例直接覆盖。
+   */
+  listAnchorsSince(lineId: string, sinceMs: number, limit = 5000): DcwJournalAnchor[] {
+    return anchorsSince(this.db.anchors, lineId, sinceMs, limit)
+  }
+
   // ---------- records(优化记录) ----------
 
   insertRecord(r: Omit<OptimizationRecord, 'id' | 'createdAt'> & { id?: string, createdAt?: string }): OptimizationRecord {

package/server/services/workshop/exp/exp-collector.ts

@@ -0,0 +1,275 @@
+/**
+ * exp-collector —— 经验采集器(产线 Co-Pilot P1;确定性,无 LLM)。
+ *
+ * collectEpisodes(lineId) 每轮两路(计划 §5.1):
+ *  1. 平台动作(必有证据):锚账本增量(listAnchorsSince:at 水位 + seenAnchorIds 双保险)
+ *     → episode 聚合(同 recipeRunId 归一个;无 runId 按 nodeId+±60s 时间簇)
+ *     → audit_log 交叉归因(targetId+时间窗;写审计新值字段是 `eng`,旧值 prevValue)
+ *     → approval_history 按 nodeId+时间窗拼人类意见 → status=pending 落 exp-state(哈希去重)。
+ *  2. 推断动作·主路:逐 dcw 节点 readNow 取当前 SET,与 exp-state 上轮快照 diff ——
+ *     SET 变化 且 ±60s 内该节点无锚记录 → 入待确认队列(铁律 9:人工确认后才转 episode)。
+ *     首轮无快照只建快照不推断。
+ *
+ * SP 序列增强路(计划 §5.1 增强项):本期留 TODO 结构 —— sp 语义位节点若存在同 key
+ * daq 节点则跳过快照 diff(将来由 tsdb raw 序列阶跃检测覆盖,避免双路重复归因)。
+ *
+ * 时间源统一 Date.now();单节点读取失败(离线等)跳过不阻塞整轮。
+ */
+import type { DcwJournalAnchor } from '../../../../shared/dcw-protocol'
+import type { ExpConfirmation, ExpEpisode, ExpNodeSnapshot, ExpWatermark } from './exp-state.repo'
+import { getDaqNodeRepo } from '../daq/daq-node.repo'
+import { getDcwController } from '../dcw/dcw-controller'
+import { getDcwNodeRepo } from '../dcw/dcw-node.repo'
+import { getRecipeRollBackRepo } from '../dcw/recipe-rollback.repo'
+import { getOps } from '../ops/ops'
+import { getExpStateRepo } from './exp-state.repo'
+
+/** 无 runId 锚的时间簇窗口(±60s;计划 §5.1) */
+export const CLUSTER_MS = 60_000
+/** 推断判定的"平台无写入"回看窗(±60s) */
+export const ANCHOR_WINDOW_MS = 60_000
+/** 审计/审批意见交叉窗的外扩缓冲 */
+const AUDIT_SLACK_MS = 60_000
+/** SET 变化判定阈值(节点值已按 decimals 取整,浮点噪声用 epsilon 吸收) */
+const SET_EPSILON = 1e-9
+
+/** episode 草稿(recordEpisodes 前的中间形态;untilAt 仅归因窗计算用,不入库) */
+export type ExpEpisodeDraft = Omit<ExpEpisode, 'id' | 'lineId' | 'status' | 'hash'> & { untilAt?: string }
+
+/** 锚写来源 → episode 来源归因(rollback 恢复归入配方/系统路径) */
+function srcOf(source: string): 'manual' | 'agent' | 'recipe' {
+  return source === 'manual' ? 'manual' : source === 'agent' ? 'agent' : 'recipe'
+}
+
+function actorKindOf(source: string): 'user' | 'agent' | 'system' {
+  return source === 'manual' ? 'user' : source === 'agent' ? 'agent' : 'system'
+}
+
+/**
+ * 水位过滤(纯):at 水位粗筛 + 已见锚 id 精剔。
+ * 锚 id 是 UUID 非单调、cap 头部淘汰会使 index 型水位漂移,故必须双字段(计划 §2.1)。
+ */
+export function unseenAnchorsSince(anchors: DcwJournalAnchor[], wm: ExpWatermark): DcwJournalAnchor[] {
+  const seen = new Set(wm.seenAnchorIds)
+  return anchors.filter((a) => {
+    if (seen.has(a.id)) return false
+    return Date.parse(a.at) >= wm.lastAnchorAt
+  })
+}
+
+/** 单组锚 → episode 草稿(组内已按时间正序;来源取簇内主导写来源) */
+function draftOf(lineId: string, group: DcwJournalAnchor[]): ExpEpisodeDraft {
+  const hasManual = group.some(a => a.source === 'manual')
+  const hasAgent = group.some(a => a.source === 'agent')
+  const source = hasManual ? 'manual' : hasAgent ? 'agent' : 'recipe'
+  const anchorForActor = group.find(a => srcOf(a.source) === source) ?? group[0]!
+  return {
+    nodeIds: [...new Set(group.map(a => a.nodeId))],
+    kind: 'platform',
+    source: srcOf(source),
+    actor: anchorForActor.actor,
+    actorKind: actorKindOf(source),
+    params: group.map(a => ({ nodeId: a.nodeId, from: a.prevValue, to: a.newValue })),
+    at: group[0]!.at,
+    untilAt: group[group.length - 1]!.at,
+    anchors: group.map(a => a.id),
+    auditIds: [],
+    comments: [],
+  }
+}
+
+/**
+ * 锚 → episode 草稿聚合(纯):
+ *  - 同 recipeRunId 的锚(跨节点/跨时刻)归一个 episode(一次配方下发是一笔动作);
+ *  - 无 runId 的锚按 nodeId 分组后 ±clusterMs 时间簇归并(一次手动连调是同一动作)。
+ */
+export function aggregateAnchorsToEpisodes(lineId: string, anchors: DcwJournalAnchor[], opts: { clusterMs?: number } = {}): ExpEpisodeDraft[] {
+  const clusterMs = opts.clusterMs ?? CLUSTER_MS
+  const sorted = [...anchors].sort((a, b) => a.at.localeCompare(b.at) || a.id.localeCompare(b.id))
+  const drafts: ExpEpisodeDraft[] = []
+  const byRun = new Map<string, DcwJournalAnchor[]>()
+  const byNode = new Map<string, DcwJournalAnchor[]>()
+  for (const a of sorted) {
+    if (a.recipeRunId) {
+      const arr = byRun.get(a.recipeRunId)
+      if (arr) arr.push(a)
+      else byRun.set(a.recipeRunId, [a])
+    }
+    else {
+      const arr = byNode.get(a.nodeId)
+      if (arr) arr.push(a)
+      else byNode.set(a.nodeId, [a])
+    }
+  }
+  for (const group of byRun.values()) drafts.push(draftOf(lineId, group))
+  for (const group of byNode.values()) {
+    let cur: DcwJournalAnchor[] = []
+    for (const a of group) {
+      if (cur.length > 0 && Date.parse(a.at) - Date.parse(cur[0]!.at) > clusterMs) {
+        drafts.push(draftOf(lineId, cur))
+        cur = []
+      }
+      cur.push(a)
+    }
+    if (cur.length > 0) drafts.push(draftOf(lineId, cur))
+  }
+  return drafts
+}
+
+/** SP 语义位冷启动推断:模板 key 含 '-sp'(如 `reactor-temp-sp`)视为设定值语义,其余 PV */
+export function inferSemantic(templateKey: string): 'sp' | 'pv' {
+  return templateKey.toLowerCase().includes('-sp') ? 'sp' : 'pv'
+}
+
+/**
+ * 快照 diff(纯):上轮 vs 本轮都读到的节点里,SET 变化(|Δ|>epsilon)且 ±窗内无锚
+ * → 推断"本地调整"候选(入待确认队列,由人工裁决)。
+ */
+export function diffSnapshot(
+  prev: Record<string, ExpNodeSnapshot>,
+  current: Record<string, ExpNodeSnapshot>,
+  anchoredNodeIds: Set<string>,
+  opts: { epsilon?: number } = {},
+): Array<{ nodeId: string, from: number, to: number }> {
+  const epsilon = opts.epsilon ?? SET_EPSILON
+  const out: Array<{ nodeId: string, from: number, to: number }> = []
+  for (const nodeId of Object.keys(prev).sort()) {
+    const p = prev[nodeId]
+    const c = current[nodeId]
+    if (!p || !c) continue
+    if (Math.abs(c.set - p.set) <= epsilon) continue
+    if (anchoredNodeIds.has(nodeId)) continue
+    out.push({ nodeId, from: p.set, to: c.set })
+  }
+  return out
+}
+
+/**
+ * 平台动作归因增强(就地改写草稿):
+ *  - audit_log 按 targetId+时间窗交叉:取写审计行 id(证据链)与 actor 归因
+ *    (写审计 detail_json 新值字段为 `eng`、旧值 prevValue —— 本处仅用行级
+ *    actor/actorKind,值以锚账本为准,锚有 prev/new 全量);
+ *  - approval_history 按 nodeId+时间窗拼人类裁决意见(为什么这样调的语境)。
+ * 审计/审批仓储未装配(getOps()=null,单测/降级)或查询异常时不阻塞采集。
+ */
+function enrichDraft(draft: ExpEpisodeDraft): void {
+  const ops = getOps()
+  if (!ops) return
+  const fromMs = Date.parse(draft.at)
+  const toMs = Date.parse(draft.untilAt ?? draft.at)
+  const auditFrom = new Date(fromMs - AUDIT_SLACK_MS).toISOString()
+  const auditTo = new Date(toMs + AUDIT_SLACK_MS).toISOString()
+  const auditIds: string[] = []
+  for (const nodeId of draft.nodeIds) {
+    try {
+      for (const r of ops.audit.query({ targetId: nodeId, from: auditFrom, to: auditTo, limit: 50 })) {
+        if (!String(r.action).startsWith('dcw.write.')) continue
+        auditIds.push(String(r.id))
+        // 归因以审计为准(携带 actorName 人话名;锚账本只有 actor id)
+        draft.actor = String(r.actor) || draft.actor
+        draft.actorKind = r.actorKind === 'agent' ? 'agent' : r.actorKind === 'system' ? 'system' : 'user'
+      }
+    }
+    catch { /* 单节点审计查询失败不阻塞 */ }
+  }
+  draft.auditIds = auditIds
+  try {
+    for (const h of ops.approvalHistory.list(200)) {
+      if (!draft.nodeIds.includes(h.nodeId)) continue
+      const t = Date.parse(h.createdAt)
+      if (!Number.isFinite(t) || t < fromMs - AUDIT_SLACK_MS || t > toMs + AUDIT_SLACK_MS) continue
+      if (h.comment) draft.comments.push(`${h.decidedName || h.decidedBy || '系统'}(${h.status}): ${h.comment}`)
+    }
+  }
+  catch { /* 审批史不可用不阻塞采集 */ }
+}
+
+/**
+ * 一轮经验采集(确定性;调用方=exp_collect 工具/学习 Channel 定时任务):
+ * 平台动作入 pending episode + 推断动作入待确认队列,返回本轮增量与待确认计数。
+ * 重复调用幂等:水位(at+已见 id)剔重,第二轮零新增(单测覆盖)。
+ */
+export async function collectEpisodes(lineId: string, opts: { nowMs?: number } = {}): Promise<{
+  episodes: ExpEpisode[]
+  confirmations: { added: number, pending: number }
+}> {
+  const state = getExpStateRepo()
+  const nowMs = opts.nowMs ?? Date.now()
+  const nowIso = new Date(nowMs).toISOString()
+  const wm = state.getWatermark(lineId)
+
+  // ---- 1. 平台动作:锚账本增量 → 聚合 → 归因 → pending 落账 → 水位推进
+  const fresh = unseenAnchorsSince(getRecipeRollBackRepo().listAnchorsSince(lineId, wm.lastAnchorAt), wm)
+  const drafts = aggregateAnchorsToEpisodes(lineId, fresh)
+  for (const d of drafts) enrichDraft(d)
+  const episodes = state.recordEpisodes(lineId, drafts)
+  if (fresh.length > 0) {
+    const seen = new Set(wm.seenAnchorIds)
+    let maxAt = wm.lastAnchorAt
+    let maxAuditId = wm.lastAuditId
+    for (const a of fresh) {
+      seen.add(a.id)
+      maxAt = Math.max(maxAt, Date.parse(a.at))
+    }
+    for (const e of episodes) {
+      for (const id of e.auditIds) {
+        const n = Number(id)
+        if (Number.isFinite(n)) maxAuditId = Math.max(maxAuditId, n)
+      }
+    }
+    state.setWatermark(lineId, { lastAnchorAt: maxAt, seenAnchorIds: [...seen], lastAuditId: maxAuditId })
+  }
+
+  // ---- 2. 推断动作·主路:dcw 读回快照 vs 上轮快照(diff;首轮只建快照)
+  const rollback = getRecipeRollBackRepo()
+  const anchoredNow = new Set(rollback.listAnchorsSince(lineId, nowMs - ANCHOR_WINDOW_MS).map(a => a.nodeId))
+  const daqKeys = new Set(getDaqNodeRepo().all().filter(d => d.lineId === lineId).map(d => d.templateKey))
+  const prev = state.getSnapshot(lineId)
+  const current: Record<string, ExpNodeSnapshot> = { ...(prev ?? {}) }
+  for (const node of getDcwNodeRepo().all()) {
+    if (node.lineId !== lineId || !node.enabled) continue
+    // 语义位冷启动(模板 key 推断;人工可后续改标)
+    const meta = state.paramMetaGet(lineId, node.id)
+    const semantic = meta?.semantic ?? inferSemantic(node.templateKey)
+    if (!meta) state.paramMetaSet(lineId, node.id, semantic)
+    // TODO(SP 序列增强路):sp 语义位且存在同 key daq 节点 → 本期跳过快照 diff,
+    // 将来由 tsdb raw 序列阶跃检测覆盖(主路已注释局限:改了又改回的瞬变盲区)
+    if (semantic === 'sp' && daqKeys.has(node.templateKey)) continue
+    try {
+      // readNow 与节点周期读共用在飞互斥,偶发 409/失败 —— 重试两次再放弃(快照缺样本=漏检阶跃)
+      let r: { ok: boolean, value: number | null, raw: number | null, message: string, at: string } | null = null
+      for (let attempt = 0; attempt < 3 && !r?.ok; attempt++) {
+        if (attempt > 0) await new Promise(res => setTimeout(res, 1500))
+        r = await getDcwController().readNow(node.id)
+      }
+      if (!r || !r.ok || r.value == null) continue
+      current[node.id] = { set: r.value, readAt: Date.parse(r.at) }
+    }
+    catch { /* 单节点失败(离线/驱动异常)跳过,不阻塞整轮 */ }
+  }
+  state.setSnapshot(lineId, current)
+  let confirmAdded = 0
+  if (prev) {
+    for (const cand of diffSnapshot(prev, current, anchoredNow)) {
+      const node = getDcwNodeRepo().byId(cand.nodeId)
+      const res = state.addConfirmation({
+        lineId,
+        nodeId: cand.nodeId,
+        nodeName: node?.name ?? cand.nodeId,
+        from: cand.from,
+        to: cand.to,
+        at: nowIso,
+        evidence: `SET 由 ${cand.from} 变为 ${cand.to}${node?.unit ? ` ${node.unit}` : ''},时间窗内平台无写入记录`,
+      })
+      if (res.added) confirmAdded++
+    }
+  }
+
+  return {
+    episodes,
+    confirmations: { added: confirmAdded, pending: state.listConfirmations({ lineId, status: 'pending' }).length },
+  }
+}
+
+/** 类型再导出(工具/测试面常用;避免各自深路径 import) */
+export type { ExpConfirmation, ExpEpisode, ExpNodeSnapshot, ExpWatermark }