agentworkshop 0.7.34 → 0.7.38

package/scripts/test-context-governor.ts

@@ -1,176 +0,0 @@
-/**
- * 上下文治理环测试(假 RPC 客户端,零真实子进程):
- * 70% 门控 / get_state 复查 / compact→compaction_end 等待 / legacy 降级 /
- * 压缩事件分支 harvest / 被动 usage 透出 / 总开关与最小间隔。
- * 运行: npx tsx --tsconfig .nuxt/tsconfig.server.json scripts/test-context-governor.ts
- */
-import { OmpRpcAgentImpl } from '../server/services/workshop/agents/omp-agent'
-
-let failures = 0
-function check(name: string, ok: boolean, detail = ''): void {
-  console.log(`  ${ok ? 'PASS' : 'FAIL'}  ${name}${detail ? ` — ${detail}` : ''}`)
-  if (!ok) failures += 1
-}
-
-type Frame = Record<string, unknown>
-
-/** 假 omp RPC 客户端:协议面仿真(命令应答/事件订阅/被动 usage) */
-class FakeOmpClient {
-  alive = true
-  streaming = false
-  statsOk = true
-  compactOk = true
-  usageTokens = 0
-  contextWindow = 1000
-  autoCompact: boolean | null = null
-  sent: Array<Record<string, unknown>> = []
-  private listeners = new Set<(e: Frame) => void>()
-
-  onEvent(fn: (e: Frame) => void): () => void {
-    this.listeners.add(fn)
-    return () => this.listeners.delete(fn)
-  }
-
-  emit(e: Frame): void {
-    for (const fn of this.listeners) fn(e)
-  }
-
-  async send(cmd: Record<string, unknown>): Promise<{ success: boolean, data?: unknown }> {
-    this.sent.push(cmd)
-    const type = cmd.type as string
-    if (type === 'get_session_stats') {
-      if (!this.statsOk) throw new Error('omp RPC 命令失败: get_session_stats 未知命令')
-      return { success: true, data: { contextUsage: { tokens: this.usageTokens, contextWindow: this.contextWindow, percent: this.usageTokens / this.contextWindow } } }
-    }
-    if (type === 'get_state') {
-      return { success: true, data: { isStreaming: this.streaming, isCompacting: false, sessionId: 'sess-1', model: { contextWindow: this.contextWindow } } }
-    }
-    if (type === 'compact') {
-      if (!this.compactOk) throw new Error('omp RPC 命令失败: compact 未知命令')
-      const summary = '压缩摘要:完成任务A;未竟:验证B'
-      setTimeout(() => {
-        this.emit({ type: 'compaction_end', result: { summary, tokensBefore: this.usageTokens, tokensAfter: 30000 }, reason: 'manual' })
-      }, 10)
-      return { success: true, data: {} }
-    }
-    if (type === 'set_auto_compaction') {
-      this.autoCompact = cmd.enabled as boolean
-      return { success: true }
-    }
-    return { success: true }
-  }
-
-  getContextUsage(): { tokens: number, contextWindow: number, percent: number } {
-    return { tokens: this.usageTokens, contextWindow: this.contextWindow, percent: this.usageTokens / this.contextWindow }
-  }
-
-  setContextWindow(n: number): void {
-    this.contextWindow = n
-  }
-
-  onHostToolCall(_fn: unknown): void {}
-}
-
-/** 装配:真实 OmpRpcAgentImpl + 注入假客户端/假 workspace */
-function assemble(): { impl: OmpRpcAgentImpl, client: FakeOmpClient, harvested: Array<Record<string, unknown>> } {
-  const impl = new OmpRpcAgentImpl({ agentId: 'a1', name: 'A', role: 'worker', channelId: 'ch1' })
-  const client = new FakeOmpClient()
-  const harvested: Array<Record<string, unknown>> = []
-  const box = impl as unknown as Record<string, unknown>
-  box.client = client
-  box.workspace = {
-    recordSessionMemory: async (i: Record<string, unknown>) => {
-      harvested.push(i)
-    },
-  }
-  return { impl, client, harvested }
-}
-
-const gate = (impl: OmpRpcAgentImpl, reason = 'test'): Promise<void> =>
-  (impl as unknown as Record<string, unknown>).contextGate(reason) as Promise<void>
-
-process.env.AW_OMP_COMPACT_THRESHOLD = '0.7'
-process.env.AW_OMP_COMPACT_MIN_INTERVAL_MS = '300000'
-process.env.AW_OMP_COMPACT_WAIT_MS = '5000'
-
-console.log('\n--- 门控基础路径 ---')
-{
-  process.env.AW_OMP_COMPACT_ENABLED = '1'
-  const { impl, client, harvested } = assemble()
-  client.usageTokens = 500 // 50% < 70%
-  await gate(impl)
-  check('低于阈值不触发 compact', !client.sent.some(c => c.type === 'compact'), `sent=${client.sent.map(c => c.type)}`)
-
-  client.usageTokens = 850 // 85% ≥ 70%
-  await gate(impl)
-  check('达阈值发起 compact', client.sent.some(c => c.type === 'compact'))
-  check('compact 前先复查 get_state', client.sent.indexOf('get_state') !== -1 || client.sent.some(c => c.type === 'get_state'))
-  await new Promise(r => setTimeout(r, 50))
-  check('compaction_end 摘要 harvest 入库', harvested.length === 1 && harvested[0]!.summary === '压缩摘要:完成任务A;未竟:验证B', JSON.stringify(harvested))
-  check('harvest 携带 token 元信息', harvested[0]!.tokensBefore === 850 && harvested[0]!.tokensAfter === 30000)
-
-  // 最小间隔:压缩后立即再 gate 不应二次 compact
-  client.usageTokens = 950
-  await gate(impl)
-  check('最小间隔防振荡(不再 compact)', client.sent.filter(c => c.type === 'compact').length === 1)
-}
-
-console.log('\n--- 安全防线 ---')
-{
-  // get_state 复查:流式中绝不压缩
-  const { impl, client } = assemble()
-  client.usageTokens = 900
-  client.streaming = true
-  await gate(impl)
-  check('isStreaming=true 时不发起 compact', !client.sent.some(c => c.type === 'compact'))
-
-  // 总开关
-  process.env.AW_OMP_COMPACT_ENABLED = '0'
-  const g2 = assemble()
-  g2.client.usageTokens = 900
-  await gate(g2.impl)
-  check('总开关关闭不压缩', !g2.client.sent.some(c => c.type === 'compact'))
-  process.env.AW_OMP_COMPACT_ENABLED = '1'
-
-  // legacy 降级:compact 未知命令 → 标记后不再尝试
-  const g3 = assemble()
-  g3.client.usageTokens = 900
-  g3.client.compactOk = false
-  await gate(g3.impl)
-  const box3 = g3.impl as unknown as Record<string, unknown>
-  check('未知命令 → legacy 标记', box3.compactLegacy === true)
-  g3.client.usageTokens = 980
-  await gate(g3.impl)
-  check('legacy 后续回合不再发 compact', g3.client.sent.filter(c => c.type === 'compact').length === 1)
-}
-
-console.log('\n--- 事件分支与状态透出 ---')
-{
-  const { impl, client, harvested } = assemble()
-  // 回合中途原生压缩(compaction_start/end 事件):不污染事件流 + harvest
-  const map = (impl as unknown as Record<string, (e: Frame) => Frame[]>).mapOmpEvent.bind(impl)
-  const startOut = map({ type: 'compaction_start' }, undefined)
-  const endOut = map({ type: 'compaction_end', result: { summary: '原生阈值压缩摘要', tokensBefore: 900 }, reason: 'threshold' }, undefined)
-  const settledOut = map({ type: 'agent_settled' }, undefined)
-  check('压缩事件映射为空(不污染 AgentEvent 流)', startOut.length === 0 && endOut.length === 0 && settledOut.length === 0)
-  await new Promise(r => setTimeout(r, 20))
-  check('原生压缩摘要同样 harvest', harvested.some(h => h.summary === '原生阈值压缩摘要'))
-
-  // 被动 usage 透出 getContextStats
-  client.usageTokens = 420
-  const stats = (impl as unknown as Record<string, () => unknown>).getContextStats()
-  check('getContextStats 透出用量与占比', JSON.stringify(stats) === JSON.stringify({ usedTokens: 420, contextWindow: 1000, percent: 0.42, compacting: false }), JSON.stringify(stats))
-
-  // 双路去重:同摘要 60s 内只入库一次
-  map({ type: 'compaction_end', result: { summary: '原生阈值压缩摘要' }, reason: 'threshold' }, undefined)
-  await new Promise(r => setTimeout(r, 20))
-  check('同摘要双达去重(60s 窗口)', harvested.filter(h => h.summary === '原生阈值压缩摘要').length === 1)
-
-  // onTurnSettled 复用 gate(自守卫不抛错)
-  client.usageTokens = 100
-  await impl.onTurnSettled()
-  check('onTurnSettled 低用量安全返回', true)
-}
-
-console.log(failures === 0 ? '\nALL PASS' : `\n${failures} FAILED`)
-process.exit(failures === 0 ? 0 : 1)

package/scripts/test-daq-frames.ts

@@ -1,180 +0,0 @@
-/**
- * DAQ 多形态帧管线单元测试:v2 帧信封 / mock 三形态驱动 / sink 处理器 /
- * 磁盘对象存储 / SQLite 帧适配 / runtime 帧路径 / 打标与预览。
- * 运行: npx tsx --tsconfig .nuxt/tsconfig.server.json scripts/test-daq-frames.ts
- */
-import type { DatabaseSync } from 'node:sqlite'
-import { openWorkshopDb } from '../server/services/workshop/db/database'
-import { encodePng, resizeGray } from '../server/services/workshop/daq/png-enc'
-import { runSinkPipeline, registerFrameProcessor, type DaqFrameWorking } from '../server/services/workshop/daq/frames'
-import { mockDaqDriver } from '../server/services/workshop/daq/drivers'
-import { DiskObjectAdapter } from '../server/services/workshop/daq/objectstore/disk.adapter'
-import { daqObjectKey } from '../server/services/workshop/daq/objectstore/objectstore-port'
-import { DaqNode } from '../server/services/workshop/daq/daq-node'
-import { DaqNodeRuntime, type DaqRuntimeHost } from '../server/services/workshop/daq/daq-runtime'
-import type { DaqFrameRow, DaqSampleRow } from '../server/services/workshop/daq/storage/tsdb-port'
-
-let failures = 0
-function check(name: string, ok: boolean, detail = ''): void {
-  console.log(`  ${ok ? 'PASS' : 'FAIL'}  ${name}${detail ? ` — ${detail}` : ''}`)
-  if (!ok) failures += 1
-}
-
-// ===== PNG 编码/解码闭环 + 缩放 =====
-console.log('\n--- PNG 编码器(png-enc)---')
-{
-  const w = 64
-  const h = 48
-  const px = new Uint8Array(w * h)
-  for (let i = 0; i < px.length; i++) px[i] = (i * 7) % 256
-  const blob = encodePng(w, h, px)
-  check('PNG 魔数与 IEND', blob.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])) && blob.subarray(blob.length - 8, blob.length - 4).toString('ascii') === 'IEND')
-  const small = resizeGray(px, w, h, 32, 24)
-  check('最近邻缩放尺寸', small.length === 32 * 24)
-  check('缩放取点保真(角点)', small[0] === px[0] && small[23 * 32 + 31] === px[Math.min(h - 1, Math.floor((23 * h) / 24)) * w + Math.min(w - 1, Math.floor((31 * w) / 32))])
-}
-
-// ===== mock 三形态驱动 =====
-console.log('\n--- mock 驱动三形态 ---')
-{
-  const base = { ctx: { nodeId: 'dn-t1', now: Date.now(), ageMs: 5000 }, config: { base: 0.52, amp: 0.018, min: 0.4, max: 0.65 }, driverConfig: {} }
-  const scalar = await mockDaqDriver.sample({ ...base })
-  check('scalar 形态返回数值(既有契约)', typeof scalar === 'number' && Number.isFinite(scalar))
-
-  const vec = await mockDaqDriver.sample({ ...base, signalKind: 'vector', vector: { points: 64, min: 0.4, max: 0.65 } })
-  check('vector 形态返回帧信封', vec != null && typeof vec === 'object' && 'frame' in vec && vec.frame.kind === 'vector')
-  if (vec != null && typeof vec === 'object' && 'frame' in vec && vec.frame.kind === 'vector') {
-    check('vector 64 点且在量程内', vec.frame.points.length === 64 && vec.frame.points.every(p => p >= 0.4 && p <= 0.65))
-  }
-
-  const img = await mockDaqDriver.sample({ ...base, signalKind: 'image' })
-  check('image 形态返回 PNG blob', img != null && typeof img === 'object' && 'frame' in img && img.frame.kind === 'image')
-  if (img != null && typeof img === 'object' && 'frame' in img && img.frame.kind === 'image') {
-    check('image 尺寸与 mime', img.frame.width === 320 && img.frame.height === 240 && img.frame.mime === 'image/png')
-    check('image blob 可解码出像素(经 thumbnail 处理器间接验证)', img.frame.blob.length > 1000)
-  }
-}
-
-// ===== sink 处理器管线 =====
-console.log('\n--- sink 处理器管线 ---')
-{
-  const points = Array.from({ length: 100 }, (_, i) => 0.5 + Math.sin(i / 10) * 0.05)
-  let wf: DaqFrameWorking = { kind: 'vector', points, metrics: {} }
-  wf = runSinkPipeline(wf, [
-    { name: 'resample', args: { n: 32 } },
-    { name: 'derive-metric', args: { name: 'avg', op: 'avg' } },
-    { name: 'derive-metric', args: { name: 'max', op: 'max' } },
-    { name: 'zones', args: { n: 4 } },
-  ], 'dn-t')
-  check('resample 降采样到 32 点', wf.points?.length === 32, `len=${wf.points?.length}`)
-  check('derive-metric avg/max 入 metrics', Number.isFinite(wf.metrics?.avg) && Number.isFinite(wf.metrics?.max))
-  check('max ≥ avg(轮廓统计自洽)', (wf.metrics?.max ?? 0) >= (wf.metrics?.avg ?? 0))
-  check('zones 分区指标(zone1_avg/zone4_max)', wf.metrics?.zone1_avg != null && wf.metrics?.zone4_max != null)
-  check('未知处理器跳过不抛', (runSinkPipeline(wf, [{ name: 'no-such-proc' }], 'dn-t')).points?.length === 32)
-
-  // image 管线:thumbnail + quality-gate
-  const w = 320
-  const h = 240
-  const px = new Uint8Array(w * h).fill(120)
-  const blob = encodePng(w, h, px)
-  let imf: DaqFrameWorking = { kind: 'image', blob, mime: 'image/png', width: w, height: h, metrics: {} }
-  imf = runSinkPipeline(imf, [{ name: 'thumbnail', args: { width: 64 } }, { name: 'quality-gate' }], 'dn-t')
-  check('thumbnail 生成缩略 blob(平坦图高压缩,仅验存在)', imf.thumbBlob != null && imf.thumbBlob.length > 0)
-  check('quality-gate 亮度/对比度指标', imf.metrics?.brightness != null && Math.abs((imf.metrics?.brightness ?? 0) - 120) < 12, `brightness=${imf.metrics?.brightness}`)
-
-  // 插件处理器注册(同名覆盖 + 自定义)
-  registerFrameProcessor({ name: 'test-double', applies: 'vector', process: f => ({ ...f, metrics: { ...f.metrics, doubled: (f.metrics?.avg ?? 0) * 2 } }) })
-  const out = runSinkPipeline({ kind: 'vector', points: [1, 2, 3], metrics: { avg: 2 } }, [{ name: 'test-double' }], 'dn-t')
-  check('插件处理器注册生效', out.metrics?.doubled === 4)
-}
-
-// ===== 磁盘对象存储 =====
-console.log('\n--- 磁盘对象存储(disk adapter)---')
-{
-  const os = new DiskObjectAdapter()
-  await os.init()
-  const key = daqObjectKey('dn-t1', Date.now(), '.png')
-  const payload = Buffer.from([1, 2, 3, 4, 5])
-  await os.put(key, payload, 'image/png')
-  const back = await os.get(key)
-  check('put/get 闭环', back.equals(payload), `key=${key}`)
-  check('daqObjectKey 目录结构', /^daq\/dn-t1\/\d{4}\/\d{2}\/\d{2}\/\d+\.png$/.test(key))
-  let rejected = false
-  try {
-    await os.put('../evil', payload, 'image/png')
-  }
-  catch {
-    rejected = true
-  }
-  check('路径逃逸键拒绝', rejected)
-  await os.remove(key)
-  check('remove 后 404 化', await os.get(key).then(() => false, () => true))
-}
-
-// ===== SQLite 帧适配(降级环境全链路)=====
-console.log('\n--- SQLite 帧适配 ---')
-{
-  const db: DatabaseSync = openWorkshopDb(':memory:')
-  // SqliteTimeSeriesAdapter 自持连接(文件路径),此处直接验证 SQL 形态:
-  // 用与 adapter 相同 DDL 在内存库上跑一遍查询语义
-  db.exec(`
-    CREATE TABLE daq_frames (
-      node_id TEXT NOT NULL, ts_ms INTEGER NOT NULL, kind TEXT NOT NULL,
-      template_key TEXT, device_binding_id TEXT,
-      line_id TEXT, product_id TEXT, recipe_id TEXT, run_id TEXT,
-      points INTEGER NOT NULL DEFAULT 0, meta TEXT NOT NULL DEFAULT '{}', metrics TEXT NOT NULL DEFAULT '{}',
-      PRIMARY KEY (node_id, ts_ms)
-    );
-  `)
-  const rows: DaqFrameRow[] = [
-    { nodeId: 'dn-v', tsMs: 1000, kind: 'vector', templateKey: 'thickness-scan', deviceBindingId: 'dev-1', lineId: 'line-1', productId: 'p1', recipeId: 'r1', runId: 'run-1', points: 32, meta: { points: [0.5, 0.51] }, metrics: { avg: 0.505, max: 0.51 } },
-    { nodeId: 'dn-i', tsMs: 2000, kind: 'image', templateKey: 'ccd-image', points: 0, meta: { objectKey: 'daq/x/1.png', thumbKey: 'daq/x/1.thumb.png', mime: 'image/png', width: 320, height: 240 }, metrics: { brightness: 120 } },
-  ]
-  const ins = db.prepare('INSERT INTO daq_frames (node_id, ts_ms, kind, template_key, device_binding_id, line_id, product_id, recipe_id, run_id, points, meta, metrics) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
-  for (const r of rows) ins.run(r.nodeId, r.tsMs, r.kind, r.templateKey ?? null, r.deviceBindingId ?? null, r.lineId ?? null, r.productId ?? null, r.recipeId ?? null, r.runId ?? null, r.points, JSON.stringify(r.meta), JSON.stringify(r.metrics))
-  const vecRow = db.prepare(`SELECT * FROM daq_frames WHERE node_id = 'dn-v'`).get() as { meta: string, metrics: string }
-  check('向量行 meta.points 还原', JSON.parse(vecRow.meta).points.length === 2)
-  check('打标列逐条携带', db.prepare(`SELECT line_id FROM daq_frames WHERE node_id='dn-v'`).get().line_id === 'line-1')
-  check('图像行对象键在 meta', JSON.parse((db.prepare(`SELECT meta FROM daq_frames WHERE node_id='dn-i'`).get() as { meta: string }).meta).objectKey === 'daq/x/1.png')
-}
-
-// ===== runtime 帧路径(fake host:tick 采样→入队→onSample 消费)=====
-console.log('\n--- runtime 帧路径 ---')
-{
-  const node = new DaqNode({
-    id: 'dn-frame', templateRef: 'thickness-scan', name: '测厚扫描 01', driver: 'mock',
-    intervalMs: 120, publishIntervalMs: 0, min: 0.4, max: 0.65, lineId: '',
-  })
-  const published: Array<Record<string, unknown>> = []
-  const ingested: Array<{ env: Record<string, unknown>, allowPublish: boolean }> = []
-  const sampleRows: DaqSampleRow[] = []
-  const frameRows: DaqFrameRow[] = []
-  const host: DaqRuntimeHost = {
-    defaults: () => ({ intervalMs: 1000, publishIntervalMs: 0 }),
-    sample: (n, now) => mockDaqDriver.sample({
-      ctx: { nodeId: n.id, now, ageMs: 10_000 },
-      config: { base: 0.52, amp: 0.018, min: 0.4, max: 0.65 },
-      driverConfig: {},
-      signalKind: 'vector',
-      vector: { points: 64, min: 0.4, max: 0.65 },
-    }),
-    publishSample: env => published.push(env as Record<string, unknown>),
-    ingest: (n, env, allowPublish) => ingested.push({ env: env as Record<string, unknown>, allowPublish }),
-    broadcastError: () => {},
-  }
-  const rt = new DaqNodeRuntime(node, host)
-  await rt.tick(Date.now())
-  check('tick 产出帧信封(vector)', published.length === 1 && (published[0]!.frame as { kind: string }).kind === 'vector')
-  const env = published[0] as unknown as { nodeId: string, at: string, frame: { kind: 'vector', points: number[] }, value: number }
-  check('信封值语义 = avg 指标回填', Number.isFinite(env.value))
-  const v1 = rt.onSample(env as never)
-  check('onSample 帧路径消费 ok', v1 === 'ok' && ingested.length === 1 && ingested[0]!.allowPublish === true)
-  check('节点触活(lastAt 更新,state=ok)', node.state === 'ok' && node.lastAt != null && node.value != null)
-  check('帧路径不产标量样本行(mock vector 无 value 写库)', sampleRows.length === 0 && frameRows.length === 0)
-  // 迟到帧丢弃
-  const late = rt.onSample({ ...env, at: new Date(Date.parse(env.at) - 5000).toISOString() } as never)
-  check('乱序帧丢弃(late)', late === 'late')
-}
-
-console.log(failures === 0 ? '\nALL PASS' : `\n${failures} FAILED`)
-process.exit(failures === 0 ? 0 : 1)

package/scripts/test-daq-minio.ts

@@ -1,77 +0,0 @@
-/**
- * 补充验证:minio 适配器真容器 roundtrip + 工厂装配/降级路径。
- * 运行: npx tsx --tsconfig .nuxt/tsconfig.server.json scripts/test-daq-minio.ts
- * 凭据从 config.yml daq.objectstore 读取(单一事实源,不在源码硬编码);
- * 需 daq-minio 容器在 127.0.0.1:9000。
- */
-import { readFileSync } from 'node:fs'
-import { MinioObjectAdapter } from '../server/services/workshop/daq/objectstore/minio.adapter'
-import { rebuildObjectStore, getObjectStore } from '../server/services/workshop/daq/objectstore'
-
-let failures = 0
-const check = (name: string, ok: boolean, detail = ''): void => {
-  console.log(`  ${ok ? 'PASS' : 'FAIL'}  ${name}${detail ? ` — ${detail}` : ''}`)
-  if (!ok) failures += 1
-}
-
-/** 从 config.yml 读 daq.objectstore 段(键值对缩进解析,够用即可) */
-function osConfigFromYml(): { endPoint: string, port: number, accessKey: string, secretKey: string, bucket: string } | null {
-  const yml = readFileSync('config.yml', 'utf-8')
-  const m = yml.match(/^ {2}objectstore:\r?\n((?: {4}.*\r?\n?)+)/m)
-  if (!m) return null
-  const kv = (key: string, dflt: string): string => (m[1]!.match(new RegExp(`${key}:\\s*(\\S+)`))?.[1] ?? dflt)
-  return {
-    endPoint: kv('host', '127.0.0.1'),
-    port: Number(kv('port', '9000')),
-    accessKey: kv('accessKey', 'awshop'),
-    secretKey: kv('secretKey', ''),
-    bucket: 'daq-e2e-probe',
-  }
-}
-
-console.log('\n--- MinIO 适配器(真容器)---')
-{
-  const cfg = osConfigFromYml()
-  check('config.yml objectstore 段可读', cfg != null)
-  if (cfg) {
-    const adapter = new MinioObjectAdapter(cfg)
-    let ok = true
-    for (let i = 0; i < 3; i++) {
-      try {
-        await adapter.init()
-        break
-      }
-      catch (err) {
-        if (i === 2) {
-          ok = false
-          console.log('  init 失败:', (err as Error).message)
-        }
-        await new Promise(r => setTimeout(r, 2000))
-      }
-    }
-    check('init(建连 + 建桶)', ok)
-    if (ok) {
-      const key = 'probe/test-object.png'
-      const payload = Buffer.from([0x89, 0x50, 1, 2, 3, 4])
-      await adapter.put(key, payload, 'image/png')
-      const back = await adapter.get(key)
-      check('put/get 闭环', back.equals(payload))
-      await adapter.remove(key)
-      check('remove', (await adapter.get(key).then(() => false, () => true)))
-      await adapter.close()
-    }
-
-    // 工厂装配路径:rebuildObjectStore(online, url) → backend=minio
-    const url = `http://${encodeURIComponent(cfg.accessKey)}:${encodeURIComponent(cfg.secretKey)}@${cfg.endPoint}:${cfg.port}/${cfg.bucket}`
-    await rebuildObjectStore(true, url)
-    check('rebuildObjectStore 装配 minio', getObjectStore().backend === 'minio')
-    await getObjectStore().put('probe/factory.txt', Buffer.from('aw'), 'text/plain')
-    check('工厂 get 可用(真桶)', (await getObjectStore().get('probe/factory.txt')).toString() === 'aw')
-    // 降级路径
-    await rebuildObjectStore(false, null)
-    check('离线判定 → disk 降级', getObjectStore().backend === 'disk')
-  }
-}
-
-console.log(failures === 0 ? '\nALL PASS' : `\n${failures} FAILED`)
-process.exit(failures === 0 ? 0 : 1)

package/scripts/test-dedup-logic.ts

@@ -1,132 +0,0 @@
-/**
- * 事件消费去重回归(逻辑级):
- *  断言"每个 WS 事件恰好消费一次、绝不重复渲染"的三条防线:
- *  R1. delta 合并(ingest)× loadHistory 历史回填 → 同段文本只出现一次(consumed seq 集合)
- *  R2. 历史头部插入 × 聚类器增量推进 → 已聚类事件不成第二块(头部 seq 检测重建;真实 BlockClusterer)
- *  R3. 快照对齐/重放与过滤切换 → 聚类重建后仍无重复(真实 BlockClusterer)
- * 注:events store 的 ingest/loadHistory 含 $fetch,纯 Node 环境按实现等价复刻
- *     (与 stores/workshop/events.ts 保持同步);聚类器为真实导入。
- * 运行:pnpm exec tsx scripts/test-dedup-logic.ts
- */
-import { BlockClusterer } from '../app/composables/workshop/useEventBlocks'
-import type { AepEnvelope } from '../shared/workshop-protocol'
-
-const env = (seq: number, type: string, payload: Record<string, unknown>, agentId = 'w1'): AepEnvelope =>
-  ({ v: 1, type, seq, at: new Date().toISOString(), channelId: 'c1', agentId, payload }) as AepEnvelope
-
-let failures = 0
-const check = (name: string, ok: boolean, detail = ''): void => {
-  console.log(`  [${ok ? 'PASS' : 'FAIL'}] ${name}${detail ? ` — ${detail}` : ''}`)
-  if (!ok) failures += 1
-}
-
-// ===== events.ingest / loadHistory 等价复刻(与 stores/workshop/events.ts 同步) =====
-function makeRing() {
-  return { lastSeq: 0, items: [] as AepEnvelope[], consumed: new Set<number>() }
-}
-type Ring = ReturnType<typeof makeRing>
-function ingest(ring: Ring, e: AepEnvelope): void {
-  if (e.type === 'channel.snapshot') {
-    ring.lastSeq = e.seq
-    ring.items = []
-    ring.consumed = new Set([e.seq])
-    return
-  }
-  if (typeof e.seq === 'number' && e.seq > ring.lastSeq) {
-    ring.consumed.add(e.seq)
-    if (e.type === 'agent.delta') {
-      const last = ring.items[ring.items.length - 1]
-      if (last && last.type === 'agent.delta' && last.agentId === e.agentId && (last.taskId ?? null) === (e.taskId ?? null)) {
-        (last.payload as { delta: string }).delta += (e.payload as { delta: string }).delta
-        ring.lastSeq = e.seq
-        return
-      }
-    }
-    ring.items.push(e)
-    ring.lastSeq = e.seq
-  }
-}
-function loadHistoryInto(ring: Ring, frames: AepEnvelope[]): void {
-  for (const e of frames) {
-    if (typeof e.seq !== 'number' || e.seq > ring.lastSeq) continue
-    if (ring.consumed.has(e.seq)) continue
-    ring.items.push(e)
-    ring.consumed.add(e.seq)
-  }
-  ring.items.sort((a, b) => a.seq - b.seq)
-}
-
-// ===== R1:delta 合并 × loadHistory 历史回填 =====
-console.log('R1. delta 合并 × 历史回填(consumed seq 去重)')
-{
-  const ring = makeRing()
-  ingest(ring, env(100, 'channel.snapshot', {}))
-  ingest(ring, env(101, 'agent.delta', { delta: '你好' }))
-  ingest(ring, env(102, 'agent.delta', { delta: '，worker' })) // 合并进 seq=101
-  const history = [env(101, 'agent.delta', { delta: '你好' }), env(102, 'agent.delta', { delta: '，worker' }), env(99, 'task.status', { state: 'WORKING' })]
-  loadHistoryInto(ring, history)
-  const texts = ring.items.filter(i => i.type === 'agent.delta').map(i => (i.payload as { delta: string }).delta)
-  const dupCount = texts.join('\n').split('，worker').length - 1
-  check('合并过的 delta 不被历史回填重复插入', dupCount === 1, `delta frames=${JSON.stringify(texts)}`)
-  check('未被消费的历史帧正常补入(可见)', ring.items.some(i => i.seq === 99 && i.type === 'task.status'))
-  check('items 按 seq 升序', ring.items.every((it, i, a) => i === 0 || a[i - 1]!.seq <= it.seq))
-}
-
-// ===== R2:历史头部插入 × 聚类器增量推进(真实 BlockClusterer) =====
-console.log('R2. 历史头部插入 × 聚类器增量(头部 seq 检测重建)')
-{
-  const clusterer = new BlockClusterer()
-  const live = [
-    env(101, 'agent.delta', { delta: '流式输出A' }),
-    env(102, 'task.status', { state: 'WORKING' }),
-    env(103, 'agent.delta', { delta: '流式输出B' }),
-    env(104, 'agent.delta', { delta: '续' }), // 与 103 同源连续 → 聚类器层再合并进同块
-  ]
-  clusterer.sync(live)
-  const before = clusterer.blocks.length
-
-  // 历史回填:seq ≤ 快照游标(100)的 100 帧(与 live 101+ 无重叠;
-  // 与 live 重叠的场景由 store 的 consumed 闸门拦截,见 R1)
-  const history = Array.from({ length: 100 }, (_, i) => env(i + 1, 'task.status', { state: 'SUBMITTED' }))
-  const merged = [...history, ...live].sort((a, b) => a.seq - b.seq)
-  clusterer.sync(merged)
-
-  const blocksWith = (text: string) => clusterer.blocks.filter(b => b.events.some(e => (e.payload as { delta?: string }).delta === text)).length
-  check('已聚类流事件不成第二块(A)', blocksWith('流式输出A') === 1, `A块数=${blocksWith('流式输出A')}`)
-  check('已聚类流事件不成第二块(B)', blocksWith('流式输出B') === 1, `B块数=${blocksWith('流式输出B')}`)
-  check('历史事件被全量重建聚类(可见)', clusterer.blocks.length >= before, `blocks=${clusterer.blocks.length}`)
-  // 全序列无任何事件被消费两次:逐块 events 展开后 seq 无重复
-  const allSeqs = clusterer.blocks.flatMap(b => b.events.map(e => e.seq))
-  check('全部块内事件 seq 无重复(每事件恰好消费一次)', new Set(allSeqs).size === allSeqs.length, `events=${allSeqs.length}`)
-}
-
-// ===== R3:重放对齐 + 过滤切换重建 =====
-console.log('R3. 重放对齐 / 过滤切换(每事件恰好一次)')
-{
-  // 快照对齐:同批事件二次投递(重连重放)→ ingest seq 闸门丢弃
-  const ring = makeRing()
-  ingest(ring, env(100, 'channel.snapshot', {}))
-  const batch = [env(101, 'agent.delta', { delta: 'x' }), env(102, 'task.status', { state: 'WORKING' })]
-  for (const e of batch) ingest(ring, e)
-  for (const e of batch) ingest(ring, e) // 重放
-  check('重放帧被 seq 闸门丢弃', ring.items.length === 2, `items=${ring.items.length}`)
-
-  // 过滤切换:聚类器对不同子序列切换后仍无重复消费
-  const c = new BlockClusterer()
-  const events = [
-    env(1, 'agent.delta', { delta: 's1' }, 'w1'),
-    env(2, 'task.status', { state: 'WORKING' }),
-    env(3, 'agent.delta', { delta: 's2' }, 'w1'),
-    env(4, 'agent.delta', { delta: 's3' }, 'w2'),
-  ]
-  c.sync(events) // 全量
-  c.sync(events.filter(e => e.agentId === 'w1')) // 切换到过滤视图
-  c.sync(events) // 切回全量
-  const allSeqs = c.blocks.flatMap(b => b.events.map(e => e.seq))
-  const w1StreamBlocks = c.blocks.filter(b => b.events.some(e => (e.payload as { delta?: string }).delta === 's1')).length
-  check('过滤来回切换后事件仍只消费一次', new Set(allSeqs).size === allSeqs.length && allSeqs.length === 4, `events=${allSeqs.length}`)
-  check('过滤来回切换后流块不重复', w1StreamBlocks === 1, `s1块数=${w1StreamBlocks}`)
-}
-
-console.log(failures === 0 ? '\n★ 全部通过:每事件恰好消费一次,无重复渲染' : `\n${failures} 项失败 ❌`)
-process.exit(failures === 0 ? 0 : 1)