agentworkshop 0.7.37 → 0.7.39

package/scripts/.mimosa/hook-state/sess_aeaecb58-8833-4b83-b93c-050467d21e03.mtxwtxme-61028-1f4519fbc4.baseline/b3849943c3aff102d1af815631fc843a2a52c17646a4b04696ece323e483bbec.source

@@ -0,0 +1,332 @@
+/**
+ * 记忆系统端到端验证 — 真实 AgentChannelManager(:memory: db)+ echo harness 全链:
+ * ① channel + lead/2worker 装配,runtimes started
+ * ② 任务完成 → lead/worker 各自记忆落库
+ * ③ lead addTeamMemory('团队统一用 pnpm')
+ * ④ 相关任务下发 → echo 捕获 worker request.memory 含任务1记忆 + 团队行
+ * ⑤ worker 间 peer 消息(require_reply)→ 双方 peer 记忆落库
+ * ⑥ REST(h3 toWebHandler 挂真实路由 handler):GET memories / POST team(lead)/ POST agent / DELETE 全 2xx;非 lead 写 team → 403
+ * ⑦ runMemoryMaintenanceNow() → 回拨老数据被清(团队行豁免)
+ * ⑧ await manager.shutdown() → 干净退出
+ * 向量链(hash embedder)已由 test-memory-vector.ts 覆盖;本 E2E 走纯 FTS 路径。
+ */
+import { randomUUID } from 'node:crypto'
+import { createChannelEventRepo } from '../server/services/workshop/db/channel-event.repo'
+import { mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { createApp, createRouter, toWebHandler } from 'h3'
+import { openWorkshopDb } from '../server/services/workshop/db/database'
+import type { MemoryRow } from '../server/services/workshop/db/database'
+import { createChannelRepo } from '../server/services/workshop/db/channel.repo'
+import { createAgentRepo } from '../server/services/workshop/db/agent.repo'
+import { createChannelAgentRepo } from '../server/services/workshop/db/channel-agent.repo'
+import { createTaskRepo } from '../server/services/workshop/db/task.repo'
+import { createMemoryRepo, TEAM_AGENT_ID } from '../server/services/workshop/db/memory.repo'
+import { createTeamRepo } from '../server/services/workshop/db/team.repo'
+import { createTeamMemberRepo } from '../server/services/workshop/db/team-member.repo'
+import { createMessageRepo } from '../server/services/workshop/db/message.repo'
+import { createSubscriptionRepo } from '../server/services/workshop/db/subscription.repo'
+import { createAgentChannelManager } from '../server/services/workshop/runtime/manager'
+
+import type { AgentInfo, AgentInterface, AgentRunContext, AgentRunRequest, AgentEvent } from '../server/services/workshop/agents/agent-interface'
+import type { A2AArtifact, Part } from '../server/services/workshop/types/a2a'
+// 真实 REST 路由 handler(生产同源;经 globalThis.__workshopManager 接测试 manager)
+import teamMemGet from '../server/api/workshop/channels/[id]/memories/index.get'
+import teamMemPost from '../server/api/workshop/channels/[id]/memories/index.post'
+import teamMemDelete from '../server/api/workshop/channels/[id]/memories/[memoryId].delete'
+import agentMemPost from '../server/api/workshop/channels/[id]/agents/[agentId]/memories/index.post'
+import agentMemDelete from '../server/api/workshop/channels/[id]/agents/[agentId]/memories/[memoryId].delete'
+
+let failures = 0
+function check(name: string, ok: boolean, detail = ''): void {
+  console.log(`${ok ? 'PASS' : 'FAIL'}  ${name}${detail ? ` — ${detail}` : ''}`)
+  if (!ok) failures += 1
+}
+
+const sleep = (ms: number) => new Promise<void>(r => setTimeout(r, ms))
+
+async function waitUntil(cond: () => boolean | Promise<boolean>, timeoutMs: number): Promise<boolean> {
+  const deadline = Date.now() + timeoutMs
+  while (Date.now() < deadline) {
+    if (await cond()) return true
+    await sleep(50)
+  }
+  return false
+}
+
+function partsText(parts: Part[]): string {
+  return parts.map(p => ('text' in p ? p.text : '')).filter(Boolean).join('\n')
+}
+
+// ═══════════ echo harness:捕获 request.memory + 驱动任务/peer 剧本 ═══════════
+
+/** worker echo:assign → 产 deliverable + completeTask;peer(require-reply)→ 回执(message 事件 + sendMessage) */
+class EchoWorkerImpl implements AgentInterface {
+  readonly captured: AgentRunRequest[] = []
+
+  async* run(request: AgentRunRequest, ctx: AgentRunContext): AsyncGenerator<AgentEvent, void, unknown> {
+    this.captured.push(request)
+    const kind = request.message.metadata?.['x-aw-task-kind']
+    if (kind === 'assign' && request.taskId) {
+      yield { kind: 'status', status: { state: 'WORKING', timestamp: new Date().toISOString() } }
+      const artifact: A2AArtifact = {
+        artifactId: randomUUID(),
+        name: 'deliverable',
+        parts: [{ text: `echo 完成(${ctx.agentId}):${partsText(request.message.parts).slice(0, 80)}` }],
+      }
+      yield { kind: 'artifact', artifact, lastChunk: true, totalChunks: 1 }
+      await ctx.workspace.completeTask(request.taskId, [artifact])
+      yield { kind: 'done', final: { taskId: request.taskId } }
+      return
+    }
+    const fromId = request.fromAgentId
+    if (!kind && fromId) {
+      if (request.message.metadata?.['x-aw-require-reply'] === 'true') {
+        const text = partsText(request.message.parts)
+        const reply = `echo 回复(${ctx.agentId}):已处理「${text.slice(0, 60)}」。执行结果:完成。本回复不需要再响应。`
+        yield { kind: 'message', message: { messageId: randomUUID(), contextId: ctx.channelId, role: 'ROLE_AGENT', parts: [{ text: reply }] } }
+        await ctx.workspace.sendMessage({
+          toAgentId: fromId,
+          parts: [{ text: reply }],
+          metadata: { 'x-aw-in-reply-to': request.message.messageId, 'x-aw-require-reply': 'false' },
+        })
+      }
+      yield { kind: 'done' }
+    }
+  }
+}
+
+/** lead echo:child-completed → 汇总 summary + completeTask 父任务(终态后 runtime 自动沉淀 lead 记忆);调度走规则引擎兜底 */
+class EchoLeadImpl implements AgentInterface {
+  readonly captured: AgentRunRequest[] = []
+
+  async* run(request: AgentRunRequest, ctx: AgentRunContext): AsyncGenerator<AgentEvent, void, unknown> {
+    this.captured.push(request)
+    if (request.message.metadata?.['x-aw-task-kind'] === 'child-completed' && request.taskId) {
+      // 规则引擎兜底可能已先收口父任务(调度轮与 child-completed 投递并发)→ 幂等:仅非终态时汇总收口
+      const parent = await ctx.workspace.getTask(request.taskId)
+      if (parent && parent.state !== 'COMPLETED' && parent.state !== 'FAILED' && parent.state !== 'CANCELED') {
+        const summary: A2AArtifact = {
+          artifactId: randomUUID(),
+          name: 'summary',
+          parts: [{ text: `汇总:子任务完成(${partsText(request.message.parts).slice(0, 80)})` }],
+        }
+        await ctx.workspace.completeTask(request.taskId, [summary])
+      }
+      yield { kind: 'done' }
+    }
+  }
+}
+
+// ═══════════ 装配 ═══════════
+
+const db = openWorkshopDb(':memory:')
+const repos = {
+  channels: createChannelRepo(db),
+  agents: createAgentRepo(db),
+  channelAgents: createChannelAgentRepo(db),
+  messages: createMessageRepo(db),
+  subscriptions: createSubscriptionRepo(db),
+  tasks: createTaskRepo(db),
+  memories: createMemoryRepo(db),
+
+  channelEvents: createChannelEventRepo(db),
+  teams: createTeamRepo(db),
+  teamMembers: createTeamMemberRepo(db),
+}
+
+const echoByAgent = new Map<string, EchoWorkerImpl | EchoLeadImpl>()
+const implFactory = (agent: AgentInfo): AgentInterface => {
+  const impl = agent.role === 'lead' ? new EchoLeadImpl() : new EchoWorkerImpl()
+  echoByAgent.set(agent.id, impl)
+  return impl
+}
+// C1:env 向量 provider 接线验证(127.0.0.1:1 立即拒连 → 熔断 → 全链 FTS 降级不崩)
+const savedEmbedBase = process.env.AW_MEMORY_EMBED_BASE_URL
+const savedEmbedModel = process.env.AW_MEMORY_EMBED_MODEL
+process.env.AW_MEMORY_EMBED_BASE_URL = 'http://127.0.0.1:1'
+process.env.AW_MEMORY_EMBED_MODEL = 'e2e-unreachable'
+const manager = createAgentChannelManager({ repos, implFactory, db })
+// REST 路由 handler 经 getWorkshopManager() 读进程级单例 → 指向测试 manager
+globalThis.__workshopManager = manager
+
+const tmpWorkspace = mkdtempSync(join(tmpdir(), 'aw-e2e-memory-'))
+
+async function main(): Promise<void> {
+  // ── ① channel + lead + 2 worker 装配,runtimes started ──
+  console.log('\n=== ① channel + agents 装配 ===')
+  const ch = await manager.createChannel({ name: 'memory-e2e', workspace: tmpWorkspace })
+  const channelId = ch.channelId
+  const leadTpl = await manager.createAgent({ name: 'lead', harness: 'echo' })
+  const lead = await manager.addAgentToChannel({ channelId, agentId: leadTpl.id, role: 'lead' })
+  const mkWorker = async (name: string) => {
+    const tpl = await manager.createAgent({ name, harness: 'echo' })
+    return manager.addAgentToChannel({ channelId, agentId: tpl.id, role: 'worker' })
+  }
+  const w1 = await mkWorker('w1')
+  const w2 = await mkWorker('w2')
+
+  manager.ensureChannelActive(channelId, { tickMs: 50 })
+  const status1 = manager.runtimeStatus()
+  check('channel 装配 3 实例', (await manager.listChannelAgents(channelId)).length === 3)
+  check('lead runtime started(activeChannels + wired)', status1.activeChannels.includes(channelId) && status1.wiredAgents.includes(lead.id))
+
+  // ── ② 登录任务完成 → lead/worker 各自记忆落库 ──
+  console.log('\n=== ② 任务完成记忆落库(lead/worker) ===')
+  const submit = (title: string, description: string) => manager.submitChannelTask({ channelId, title, description })
+  const waitDone = (title: string) => waitUntil(async () =>
+    (await manager.listTasks(channelId, lead.id)).some(t => t.title === title && t.state === 'COMPLETED'), 10_000)
+  const rowsOf = (agentId: string): MemoryRow[] => repos.memories.listByAgent(agentId, 50)
+
+  await submit('实现登录页面', '为管理后台实现登录页面,含表单校验与错误提示')
+  check('任务1(登录)闭环 COMPLETED', await waitDone('实现登录页面'))
+
+  // 两个登录族任务保证两个 worker 各自有可召回的任务记忆(分发由规则引擎按负载/空闲决定)
+  await submit('实现登录页面表单校验', '补充登录页面表单校验规则')
+  check('任务1b(登录族)闭环 COMPLETED', await waitDone('实现登录页面表单校验'))
+
+  const leadRows = await waitUntil(() => rowsOf(lead.id).some(r => r.kind === 'episodic-task' && r.title === '实现登录页面'), 3000)
+    ? rowsOf(lead.id)
+    : []
+  const leadRow = leadRows.find(r => r.kind === 'episodic-task' && r.title === '实现登录页面')
+  // 汇总 summary 与规则引擎兜底收口并发(谁先收口均可)→ 断言落库本身,不强求 content 来源
+  check('lead 记忆落库(父任务终态 harvest)', leadRow !== undefined && leadRow.importance === 0.8, leadRow?.title ?? '-')
+  const w1Row = rowsOf(w1.id).find(r => r.kind === 'episodic-task' && r.title.includes('登录页面'))
+  const w2Row = rowsOf(w2.id).find(r => r.kind === 'episodic-task' && r.title.includes('登录页面'))
+  check('worker 各自记忆落库(两 worker 均有登录族任务记忆)', w1Row !== undefined && w2Row !== undefined,
+    `w1=${w1Row?.title ?? '-'} w2=${w2Row?.title ?? '-'}`)
+
+  // ── ③ lead 策展团队共享记忆 ──
+  console.log('\n=== ③ lead addTeamMemory ===')
+  const teamList = manager.addTeamMemory(channelId, lead.id, {
+    title: '团队工程规范',
+    content: '团队统一用 pnpm 管理依赖,禁止 npm/yarn',
+    dedupKey: 'team:pnpm',
+  })
+  check('团队记忆入列(__team__ 域)', teamList.length === 1 && teamList[0].agentId === TEAM_AGENT_ID && teamList[0].channelId === channelId)
+
+  // ── ④ 相关任务 → worker request.memory 含任务1记忆 + 团队行 ──
+  console.log('\n=== ④ 相关任务召回注入 ===')
+  await submit('统一登录交互规范', '把统一用 pnpm 的工程规范落实到登录页面交互')
+  check('任务2(相关)闭环 COMPLETED', await waitDone('统一登录交互规范'))
+  const executorReq = [w1, w2]
+    .flatMap(w => (echoByAgent.get(w.id) as EchoWorkerImpl).captured)
+    .reverse()
+    .find(r => partsText(r.message.parts).includes('统一登录交互规范') && r.memory !== undefined)
+  check('worker request.memory 含任务1记忆 + 团队行',
+    executorReq !== undefined && executorReq.memory!.includes('登录页面') && executorReq.memory!.includes('pnpm'),
+    executorReq?.memory?.slice(0, 100))
+
+  // ── ④b env provider 接线:embed 全失败(拒连)→ 熔断 → FTS 降级不裸奔 ──
+  console.log('\n=== ④b env provider 接线降级(C1)===')
+  await submit('登录错误提示规范', '登录错误提示统一红字展示并联动表单校验')
+  check('embedder 不可达不阻任务闭环', await waitDone('登录错误提示规范'))
+  const degradedReq = [w1, w2]
+    .flatMap(w => (echoByAgent.get(w.id) as EchoWorkerImpl).captured)
+    .reverse()
+    .find(r => partsText(r.message.parts).includes('登录错误提示规范') && r.memory !== undefined)
+  check('熔断后召回仍注入记忆(纯 FTS 降级)', degradedReq !== undefined && degradedReq.memory!.includes('登录'),
+    degradedReq?.memory?.slice(0, 80))
+
+  // ── ⑤ worker 间 peer 消息(require_reply)→ 双方 peer 记忆落库 ──
+  console.log('\n=== ⑤ peer 消息双向记忆 ===')
+  await manager.sendA2A(channelId, w1.id, {
+    toAgentId: w2.id,
+    parts: [{ text: '登录页面的错误提示请统一文案,处理完回我' }],
+    metadata: { 'x-aw-require-reply': 'true' },
+  })
+  const peerDone = await waitUntil(() =>
+    rowsOf(w1.id).some(r => r.kind === 'episodic-peer') && rowsOf(w2.id).some(r => r.kind === 'episodic-peer'), 5000)
+  const w1Peer = rowsOf(w1.id).find(r => r.kind === 'episodic-peer')
+  const w2Peer = rowsOf(w2.id).find(r => r.kind === 'episodic-peer')
+  check('双方 peer 记忆落库', peerDone && w1Peer !== undefined && w2Peer !== undefined,
+    `w1=${w1Peer?.title ?? '-'} w2=${w2Peer?.title ?? '-'}`)
+  check('peer 记忆含问答内容(回执文本进 content;存储侧已 CJK 切分,断言用未切分片段)',
+    w2Peer !== undefined && w2Peer.content.includes('echo') && w2Peer.content.includes('答'),
+    w2Peer?.content.slice(0, 60))
+
+  // ── ⑥ REST 端点(h3 toWebHandler + 生产路由 handler) ──
+  console.log('\n=== ⑥ REST 记忆端点 ===')
+  const router = createRouter()
+  router.get('/api/workshop/channels/:id/memories', teamMemGet)
+  router.post('/api/workshop/channels/:id/memories', teamMemPost)
+  router.delete('/api/workshop/channels/:id/memories/:memoryId', teamMemDelete)
+  router.post('/api/workshop/channels/:id/agents/:agentId/memories', agentMemPost)
+  router.delete('/api/workshop/channels/:id/agents/:agentId/memories/:memoryId', agentMemDelete)
+  const app = createApp()
+  app.use(router)
+  const webHandler = toWebHandler(app)
+  const rest = async (method: string, path: string, token: string | null, body?: unknown): Promise<{ status: number, code: number | string }> => {
+    const res = await webHandler(new Request(`http://localhost/api/workshop${path}`, {
+      method,
+      headers: token ? { authorization: `Bearer ${token}` } : {},
+      body: body === undefined ? undefined : JSON.stringify(body),
+    }))
+    const json = await res.json().catch(() => ({ code: -1 })) as { code: number | string }
+    return { status: res.status, code: json.code }
+  }
+
+  const leadToken = lead.token!
+  const w1Token = w1.token!
+  check('REST token 有效(findByToken)', manager.findByToken(leadToken)?.id === lead.id && manager.findByToken(w1Token)?.id === w1.id)
+
+  const get1 = await rest('GET', `/channels/${channelId}/memories`, w1Token)
+  check('GET team memories(worker token)→ 200 + code 0', get1.status === 200 && get1.code === 0, `status=${get1.status} code=${get1.code}`)
+  const postTeam = await rest('POST', `/channels/${channelId}/memories`, leadToken,
+    { title: 'REST 策展行', content: 'REST 写入的团队记忆', dedupKey: 'team:rest' })
+  check('POST team memory(lead token)→ 200', postTeam.status === 200 && postTeam.code === 0, `status=${postTeam.status}`)
+  const postTeamDenied = await rest('POST', `/channels/${channelId}/memories`, w1Token, { title: 'x', content: 'y' })
+  check('POST team memory(非 lead)→ 403 SCOPE_VIOLATION', postTeamDenied.status === 403 && postTeamDenied.code === 'SCOPE_VIOLATION',
+    `status=${postTeamDenied.status} code=${postTeamDenied.code}`)
+  const postAgent = await rest('POST', `/channels/${channelId}/agents/${w1.id}/memories`, leadToken,
+    { title: 'REST 代写规范', content: '提交信息用中文', dedupKey: 'agent:rest' })
+  check('POST agent memory(lead 代写)→ 200', postAgent.status === 200 && postAgent.code === 0, `status=${postAgent.status}`)
+  const restTeamRow = manager.listTeamMemories(channelId, 50).find(r => r.title === 'REST 策展行')
+  const delTeam = await rest('DELETE', `/channels/${channelId}/memories/${restTeamRow!.id}`, leadToken)
+  check('DELETE team memory(lead)→ 200', delTeam.status === 200 && manager.listTeamMemories(channelId, 50).every(r => r.id !== restTeamRow!.id),
+    `status=${delTeam.status}`)
+  const restAgentRow = rowsOf(w1.id).find(r => r.title === 'REST 代写规范')!
+  const delAgent = await rest('DELETE', `/channels/${channelId}/agents/${w1.id}/memories/${restAgentRow.id}`, leadToken)
+  check('DELETE agent memory(lead)→ 200', delAgent.status === 200 && !rowsOf(w1.id).some(r => r.id === restAgentRow.id), `status=${delAgent.status}`)
+
+  // ── ⑦ 维护:回拨老数据 → runMemoryMaintenanceNow 清理(团队行豁免) ──
+  console.log('\n=== ⑦ 记忆维护清理 ===')
+  const oldIso = new Date(Date.now() - 400 * 86_400_000).toISOString()
+  const agedLeadRow = rowsOf(lead.id).find(r => r.kind === 'episodic-task')!
+  db.prepare(`UPDATE agent_memories SET created_at = ?, last_accessed_at = ? WHERE id = ?`).run(oldIso, oldIso, agedLeadRow.id)
+  const before = manager.listTeamMemories(channelId, 50)
+  const maint = manager.runMemoryMaintenanceNow()
+  check('老数据(400 天前)被过期清理', maint.deletedExpired >= 1 && !rowsOf(lead.id).some(r => r.id === agedLeadRow.id),
+    `deletedExpired=${maint.deletedExpired} evicted=${maint.evicted}`)
+  check('团队行(策展)豁免清理', before.length > 0 && manager.listTeamMemories(channelId, 50).length === before.length)
+
+  // ── ⑧ shutdown 干净退出 ──
+  console.log('\n=== ⑧ shutdown ===')
+  await manager.shutdown()
+  const status8 = manager.runtimeStatus()
+  check('shutdown 后 runtime 全卸载', status8.wiredAgents.length === 0 && status8.activeChannels.length === 0)
+  globalThis.__workshopManager = undefined // 还原 REST 单例,不泄漏测试 manager
+  const restoreEmbedEnv = (name: string, value: string | undefined): void => {
+    if (value === undefined) Reflect.deleteProperty(process.env, name)
+    else process.env[name] = value
+  }
+  restoreEmbedEnv('AW_MEMORY_EMBED_BASE_URL', savedEmbedBase)
+  restoreEmbedEnv('AW_MEMORY_EMBED_MODEL', savedEmbedModel)
+
+  rmSync(tmpWorkspace, { recursive: true, force: true })
+  db.close()
+  console.log(`\n${failures === 0 ? 'ALL PASS' : `${failures} FAILED`}`)
+  process.exit(failures === 0 ? 0 : 1)
+}
+
+main().catch(async (e) => {
+  console.error('E2E 异常:', e)
+  try {
+    await manager.shutdown()
+  }
+  catch { /* 尽力清理 */
+  }
+  rmSync(tmpWorkspace, { recursive: true, force: true })
+  process.exit(1)
+})

package/scripts/.mimosa/hook-state/sess_aeaecb58-8833-4b83-b93c-050467d21e03.mtxwtxme-61028-1f4519fbc4.baseline/bac735a3803a6650b7f1eb8f587e6dc5c68ea055000c3c99a11789438b78e837.source

@@ -0,0 +1,43 @@
+/**
+ * 审计实验 4 —— DCW 落盘放大成本(只读:仅读真实 data/*.json,写入 scripts/_audit/.tmp)。
+ *
+ * 运行:node --experimental-transform-types scripts/_audit/run.mjs scripts/_audit/dcw-flush-cost.ts
+ */
+import { mkdirSync, readFileSync, statSync } from 'node:fs'
+import { saveJsonFileAtomic } from '../../server/services/workshop/json-store.mjs'
+
+const TMP = new URL('./.tmp/', import.meta.url).pathname.replace(/^\//, '')
+mkdirSync(TMP, { recursive: true })
+
+const rows = (f: string): unknown => JSON.parse(readFileSync(`server/data/${f}`, 'utf-8'))
+
+const nodes = rows('dcws.json') as Array<Record<string, unknown>>
+const writes = rows('dcw-writes.json') as Array<Record<string, unknown>>
+
+function bench(label: string, data: unknown, target: string, iters: number): void {
+  const t0 = performance.now()
+  for (let i = 0; i < iters; i++) saveJsonFileAtomic(target, data)
+  const dt = performance.now() - t0
+  const size = statSync(target).size
+  // JSON.stringify 单独计量(纯 CPU,事件循环阻塞部分)
+  const t1 = performance.now()
+  for (let i = 0; i < iters; i++) JSON.stringify(data, null, 2)
+  const ds = performance.now() - t1
+  console.log(
+    `  ${label}: flushNow 全量落盘 per-op=${(dt / iters).toFixed(1)}ms`
+    + ` (其中 JSON.stringify(pretty) ${(ds / iters).toFixed(1)}ms), 文件=${(size / 1024).toFixed(1)}KB,`
+    + ` iters=${iters}`,
+  )
+  console.log(`    记录数=${Array.isArray(data) ? data.length : Object.keys(data as object).length}`)
+}
+
+console.log('=== 真实数据规模下的落盘成本(与生产 server/data/*.json 同形) ===')
+bench('dcws.json(节点快照;每次写值/读值后防抖落盘 dcw-controller.ts:179,235)', nodes, `${TMP}/dcws.json`, 20)
+bench('dcw-writes.json(写历史;每次下发后防抖落盘 dcw-controller.ts:193)', writes, `${TMP}/dcw-writes.json`, 20)
+
+const readInt = nodes.map(n => Number(n.readIntervalMs)).filter(v => Number.isFinite(v) && v > 0)
+const perSec = readInt.reduce((a, v) => a + (1000 / v), 0)
+console.log('\n=== 生产规模推算 ===')
+console.log(`  配置了周期读的节点=${readInt.length},合计周期读频率=${perSec.toFixed(1)} 次/秒`)
+console.log(`  每次周期读 executeRead 尾部调用 repo.flushDebounced()(dcw-controller.ts:235)`)
+console.log(`  防抖窗 1.5s(dcw-node.repo.ts:60-66)→ 稳态下 dcws.json 全量重写≈每 1.5s 一次`)

package/scripts/.mimosa/hook-state/sess_aeaecb58-8833-4b83-b93c-050467d21e03.mtxwtxme-61028-1f4519fbc4.baseline/d32c24d61eb8b33c73e5a8fc7e4dc7ef437aed238ee4371c2b00617e6104090a.source

@@ -0,0 +1,154 @@
+/**
+ * 向量记忆管线测试:repo vec 方法(vec0 分区隔离/BigInt 绑定/刷新语义)+ embedding provider。
+ * 用确定性 hash provider(零网络);真实 provider 由 env 配置,e2e 可选验证。
+ * AgentMemory 混合召回融合断言由后续 task 追加(embedder 注入 AgentMemory 后)。
+ * 运行: npx tsx scripts/test-memory-vector.ts
+ */
+import type { DatabaseSync } from 'node:sqlite'
+import { openWorkshopDb } from '../server/services/workshop/db/database'
+import { createMemoryRepo, TEAM_AGENT_ID } from '../server/services/workshop/db/memory.repo'
+import { AgentMemory, segmentCJK, vectorizeMemory } from '../server/services/workshop/runtime/memory'
+import {
+  createEnvEmbeddingProvider,
+  createHashEmbeddingProvider,
+} from '../server/services/workshop/runtime/embedding-provider'
+
+let failures = 0
+function check(name: string, ok: boolean, detail = ''): void {
+  console.log(`  ${ok ? 'PASS' : 'FAIL'}  ${name}${detail ? ` — ${detail}` : ''}`)
+  if (!ok) failures += 1
+}
+
+const DIMS = 64 // hash 词袋维度:过小(如 8)会哈希碰撞扰乱 top-1 语义
+const db: DatabaseSync = openWorkshopDb(':memory:')
+const repo = createMemoryRepo(db)
+const embedder = createHashEmbeddingProvider(DIMS)
+const embed = async (text: string): Promise<Float32Array> => (await embedder.embed([text]))[0]!
+
+// ---- embedding provider:确定性 hash 词袋 ----
+console.log('--- hash provider ---')
+check('dims 返回构造维度', embedder.dims() === DIMS)
+const [va, vb] = await embedder.embed(['登录 鉴权', '登录 鉴权'])
+check('相同词集向量一致(确定性)', va!.every((x, i) => x === vb![i]))
+const norm = Math.sqrt(va!.reduce((s, x) => s + x * x, 0))
+check('向量归一化(L2=1)', Math.abs(norm - 1) < 1e-5, `norm=${norm.toFixed(5)}`)
+
+// ---- embedding provider:env 驱动 + 熔断 ----
+console.log('--- env provider ---')
+const savedBase = process.env.AW_MEMORY_EMBED_BASE_URL
+const savedModel = process.env.AW_MEMORY_EMBED_MODEL
+const savedKey = process.env.AW_MEMORY_EMBED_API_KEY
+delete process.env.AW_MEMORY_EMBED_BASE_URL
+delete process.env.AW_MEMORY_EMBED_MODEL
+delete process.env.AW_MEMORY_EMBED_API_KEY
+check('env 未配置返回 null(纯 FTS 降级)', createEnvEmbeddingProvider() === null)
+process.env.AW_MEMORY_EMBED_BASE_URL = 'http://127.0.0.1:1' // 立即拒绝,零等待
+process.env.AW_MEMORY_EMBED_MODEL = 'test-model'
+const breaker = createEnvEmbeddingProvider()!
+for (let i = 0; i < 3; i++) await breaker.embed(['x']).catch(() => {})
+const cooled = await breaker.embed(['x']).then(() => false, (e: Error) => e.message.includes('冷却'))
+check('连续 3 次失败进入冷却熔断', cooled)
+const restoreEnv = (name: string, value: string | undefined): void => {
+  if (value === undefined) Reflect.deleteProperty(process.env, name)
+  else process.env[name] = value
+}
+restoreEnv('AW_MEMORY_EMBED_BASE_URL', savedBase)
+restoreEnv('AW_MEMORY_EMBED_MODEL', savedModel)
+restoreEnv('AW_MEMORY_EMBED_API_KEY', savedKey)
+
+// ---- repo:vec 延迟建表(首次 embed 维度)----
+console.log('--- repo vec 方法 ---')
+check('vecInit 首次建表', repo.vecInit(DIMS) === true)
+check('vecInit 幂等(同维度)', repo.vecInit(DIMS) === true)
+check('vecInit 维度不符拒绝(不重建)', repo.vecInit(4) === false)
+check('vecReady 状态只读', repo.vecReady === true)
+
+// rowid → agentId 映射(kNN 分区隔离断言用)
+const rowAgent = new Map<number, string>()
+const seed = async (agentId: string, title: string, content: string, key: string): Promise<void> => {
+  repo.upsert({ channelId: 'ch1', agentId, kind: 'episodic-task', title, titleFts: segmentCJK(title), content: segmentCJK(content), importance: 0.8, taskId: key, dedupKey: `task:${key}` })
+  const at = repo.findByAgentDedup('ch1', agentId, `task:${key}`)!
+  rowAgent.set(at.rowid, agentId)
+  repo.vecSet(at.rowid, agentId, await embed(segmentCJK(content)))
+}
+await seed('a1', '登录鉴权', '用OAuth2做了登录鉴权组件', 't1')
+await seed('a1', '数据库调研', '选择SQLite作为存储', 't2')
+await seed('a2', '他人登录杂事', '别的agent的登录内容', 't3')
+await seed(TEAM_AGENT_ID, '团队规范', '本团队代码必须写测试', 'g1')
+
+// ---- 域隔离 kNN(agent_id 分区;本人/team 各自命中,不串他人)----
+const a1hits = repo.vecSearch('a1', await embed(segmentCJK('登录鉴权')), 5)
+check('a1 向量命中本人记忆', a1hits.length >= 1 && a1hits.every(h => rowAgent.get(h.memRowid) === 'a1'), `hits=${JSON.stringify(a1hits)}`)
+check('a1 top1 为登录鉴权记忆', a1hits[0]?.memRowid === repo.findByAgentDedup('ch1', 'a1', 'task:t1')?.rowid)
+check('kNN 距离非负', a1hits.every(h => h.distance >= 0))
+const teamHits = repo.vecSearch(TEAM_AGENT_ID, await embed(segmentCJK('团队规范') + ' 测试'), 5)
+check('team 向量域命中(恒不串私有域)', teamHits.length >= 1 && teamHits.every(h => rowAgent.get(h.memRowid) === TEAM_AGENT_ID))
+
+// ---- 刷新语义:重写 t1 内容后 vecSet 覆盖旧向量 ----
+repo.upsert({ channelId: 'ch1', agentId: 'a1', kind: 'episodic-task', title: '登录鉴权', titleFts: segmentCJK('登录鉴权'), content: segmentCJK('重写为JWT方案'), importance: 0.8, taskId: 't1', dedupKey: 'task:t1' })
+const t1at = repo.findByAgentDedup('ch1', 'a1', 'task:t1')!
+repo.vecSet(t1at.rowid, 'a1', await embed(segmentCJK('重写为JWT方案')))
+const refreshed = repo.vecSearch('a1', await embed(segmentCJK('JWT方案')), 5)
+check('vecSet 刷新后新向量命中', refreshed.length >= 1 && refreshed[0]!.memRowid === t1at.rowid && refreshed[0]!.distance < 1.0, `top=${JSON.stringify(refreshed[0])}`)
+const oldQ = repo.vecSearch('a1', await embed(segmentCJK('OAuth2登录鉴权组件')), 5)
+check('旧向量不再零距命中(已替换)', oldQ.every(h => h.distance > 0.5), `hits=${JSON.stringify(oldQ)}`)
+
+// ---- vecDelete(删除记忆联动;不炸未向量化的 rowid)----
+const t2at = repo.findByAgentDedup('ch1', 'a1', 'task:t2')!
+repo.vecDelete(t2at.rowid)
+check('vecDelete 后不命中', repo.vecSearch('a1', await embed(segmentCJK('SQLite存储')), 5).every(h => h.memRowid !== t2at.rowid))
+repo.vecDelete(999_999) // 不存在的 rowid:静默
+check('vecDelete 不存在的 rowid 静默', true)
+
+// ---- AgentMemory 混合召回融合 + 写入自动向量化(T8)----
+console.log('--- AgentMemory 混合召回 ---')
+const mem = new AgentMemory(repo, { channelId: 'ch1', agentId: 'a1', embedder })
+
+// 融合语义:FTS 词面 miss(英文词不进 CJK 切分索引)但向量补足
+repo.upsert({ channelId: 'ch1', agentId: 'a1', kind: 'episodic-task', title: '登陆', titleFts: segmentCJK('登陆'), content: segmentCJK('用户登陆入口跳转处理'), importance: 0.8, taskId: 'tf1', dedupKey: 'task:tf1' })
+const fusedAt = repo.findByAgentDedup('ch1', 'a1', 'task:tf1')!
+repo.vecSet(fusedAt.rowid, 'a1', (await embedder.embed(['用户登陆入口跳转处理']))[0])
+const fused = await mem.recall('entry login 用户')
+check('向量兜底语义召回(FTS 弱命中时 vector 补足)', fused !== null && fused.includes('登陆'))
+
+// 写入向量化:recordTaskOutcome 后向量自动就位(fakeTask 按 WorkspaceTask 全字段)
+const fakeTask: WorkspaceTask = {
+  id: 'tv1', channelId: 'ch1', assigneeId: 'a1', creatorId: 'lead',
+  title: '向量写入验证', state: 'COMPLETED', progress: 100, retryCount: 0,
+  artifacts: [{ artifactId: 'x', name: 'deliverable', parts: [{ text: '记忆写入后应自动向量化' }] }],
+  history: [],
+  createdAt: new Date().toISOString(), updatedAt: new Date().toISOString(),
+}
+await mem.recordTaskOutcome(fakeTask)
+const vat = repo.findByAgentDedup('ch1', 'a1', 'task:tv1')!
+const vhit = repo.vecSearch('a1', (await embedder.embed(['记忆写入后应自动向量化']))[0], 3)
+check('recordTaskOutcome 自动向量化', vhit.some(h => h.memRowid === vat.rowid))
+
+// ---- M2:模块级 vectorizeMemory(策展行向量化;manager addTeamMemory/addAgentMemory 直调)----
+console.log('--- vectorizeMemory 模块导出(M2)---')
+repo.upsert({ channelId: 'ch1', agentId: TEAM_AGENT_ID, kind: 'semantic', title: '策展团队规范', titleFts: segmentCJK('策展团队规范'), content: segmentCJK('团队统一使用pnpm管理依赖'), importance: 0.9, taskId: null, dedupKey: 'team:vec1' })
+await vectorizeMemory(repo, embedder, 'ch1', TEAM_AGENT_ID, 'team:vec1', '团队统一使用pnpm管理依赖')
+const curatedAt = repo.findByAgentDedup('ch1', TEAM_AGENT_ID, 'team:vec1')
+const curatedHits = curatedAt ? repo.vecSearch(TEAM_AGENT_ID, await embed('团队统一使用pnpm管理依赖'), 5) : []
+check('vectorizeMemory 为策展行建向量(vecSearch 命中)', curatedAt !== null && curatedHits.some(h => h.memRowid === curatedAt.rowid),
+  `hits=${JSON.stringify(curatedHits)}`)
+await vectorizeMemory(repo, null, 'ch1', TEAM_AGENT_ID, 'team:vec1', 'x')
+check('vectorizeMemory null embedder 静默 no-op(不抛)', true)
+
+// ---- I1:向量融合所有权守卫(a1 分区混入他人 rowid → 反查主表后必须过滤)----
+console.log('--- 融合所有权守卫(I1)---')
+const ownPlain = '所有权守卫独占水印内容'
+repo.upsert({ channelId: 'ch1', agentId: 'a1', kind: 'episodic-task', title: '本人守卫行', titleFts: segmentCJK('本人守卫行'), content: segmentCJK(ownPlain), importance: 0.8, taskId: 'own1', dedupKey: 'task:own1' })
+const ownAt = repo.findByAgentDedup('ch1', 'a1', 'task:own1')!
+repo.vecSet(ownAt.rowid, 'a1', await embed(ownPlain))
+repo.upsert({ channelId: 'ch1', agentId: 'intruder', kind: 'episodic-task', title: '入侵者守卫行', titleFts: segmentCJK('入侵者守卫行'), content: segmentCJK(ownPlain), importance: 0.8, taskId: 'intr1', dedupKey: 'task:intr1' })
+const intrAt = repo.findByAgentDedup('ch1', 'intruder', 'task:intr1')!
+repo.vecSet(intrAt.rowid, 'a1', await embed(ownPlain)) // 脏数据:他人 rowid 被写进 a1 向量分区
+const dirtyHits = repo.vecSearch('a1', await embed(ownPlain), 10)
+check('前置:a1 向量域确有脏 rowid(无守卫则泄漏)', dirtyHits.some(h => h.memRowid === intrAt.rowid), `hits=${JSON.stringify(dirtyHits)}`)
+const guardBlock = await new AgentMemory(repo, { channelId: 'ch1', agentId: 'a1', embedder }).recall(ownPlain)
+check('recall 融合过滤他人行(只见本人行)', guardBlock !== null && guardBlock.includes('本人守卫行') && !guardBlock.includes('入侵者守卫行'),
+  guardBlock?.slice(0, 100))
+
+console.log(`\n${failures === 0 ? 'ALL PASS' : `${failures} FAILURE(S)`}`)
+process.exit(failures === 0 ? 0 : 1)