agentworkshop 0.2.1

package/scripts/test-memory-dynamic.ts

@@ -0,0 +1,99 @@
+/**
+ * 动态记忆感知测试:按需抓取(recallRows scope 过滤/原文还原/touch)、
+ * 主动沉淀(save 私有/共享分流 + 共享域 dedupKey 命名空间)、
+ * 记忆引子(小预算 primer + 工具提示行)。
+ * 运行: npx tsx scripts/test-memory-dynamic.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 } from '../server/services/workshop/runtime/memory'
+
+let failures = 0
+function check(name: string, ok: boolean, detail = ''): void {
+  console.log(`  ${ok ? 'PASS' : 'FAIL'}  ${name}${detail ? ` — ${detail}` : ''}`)
+  if (!ok) failures += 1
+}
+
+const db: DatabaseSync = openWorkshopDb(':memory:')
+const repo = createMemoryRepo(db)
+const seg = (s: string): string => s.replace(/([\u4e00-\u9fff])/g, ' $1 ')
+
+// 播种:a1 私有 × 2、a2 私有 × 1、team 公共 × 1、他 channel 的 team 行 × 1(隔离守卫)
+repo.upsert({ channelId: 'ch1', agentId: 'a1', kind: 'episodic-task', title: '网关限流方案', titleFts: seg('网关限流方案'), content: seg('最终采用令牌桶算法限流,阈值100qps'), importance: 0.8, taskId: 't1', dedupKey: 'task:t1' })
+repo.upsert({ channelId: 'ch1', agentId: 'a1', kind: 'episodic-task', title: '部署脚本草稿', titleFts: seg('部署脚本草稿'), content: seg('deploy.sh 需要先source env'), importance: 0.4, taskId: 't2', dedupKey: 'task:t2' })
+repo.upsert({ channelId: 'ch1', agentId: 'a2', kind: 'episodic-task', title: '他人限流笔记', titleFts: seg('他人限流笔记'), content: seg('a2自己的限流杂记'), importance: 0.8, taskId: 't3', dedupKey: 'task:t3' })
+repo.upsert({ channelId: 'ch1', agentId: TEAM_AGENT_ID, kind: 'semantic', title: 'channel 限流约定', titleFts: seg('channel 限流约定'), content: seg('全channel统一用令牌桶,禁用计数器'), importance: 0.9, taskId: null, dedupKey: 'conv:ratelimit' })
+repo.upsert({ channelId: 'ch2', agentId: TEAM_AGENT_ID, kind: 'semantic', title: '他channel限流约定', titleFts: seg('他channel限流约定'), content: seg('ch2专属公共记忆不应被ch1看到'), importance: 0.9, taskId: null, dedupKey: 'conv:other' })
+
+const memA1 = new AgentMemory(repo, { channelId: 'ch1', agentId: 'a1' })
+
+console.log('--- 按需抓取 recallRows ---')
+{
+  const auto = await memA1.recallRows('限流 令牌桶')
+  check('auto 域命中本人 + 公共记忆', auto.some(s => s.title === '网关限流方案') && auto.some(s => s.title === 'channel 限流约定'), JSON.stringify(auto.map(s => s.title)))
+  check('auto 域不含他人私有记忆', auto.every(s => s.title !== '他人限流笔记'))
+  check('auto 域不含他 channel 公共记忆', auto.every(s => s.title !== '他channel限流约定'))
+  check('source 标注 private/shared', auto.some(s => s.source === 'private') && auto.some(s => s.source === 'shared'))
+  const own = auto.find(s => s.title === '网关限流方案')
+  check('content 还原为未切分原文', own !== undefined && !/\s/.test(own.content.slice(0, 4)) && own.content.includes('令牌桶'), own?.content.slice(0, 20))
+  check('返回综合分 score', auto.every(s => typeof s.score === 'number' && s.score > 0))
+
+  const sharedOnly = await memA1.recallRows('限流', { scope: 'shared' })
+  check('shared 域仅公共记忆', sharedOnly.length > 0 && sharedOnly.every(s => s.source === 'shared'), JSON.stringify(sharedOnly.map(s => s.title)))
+  check('shared 域严格本 channel', sharedOnly.every(s => s.title !== '他channel限流约定'))
+
+  const privOnly = await memA1.recallRows('限流', { scope: 'private' })
+  check('private 域仅本人记忆', privOnly.length > 0 && privOnly.every(s => s.source === 'private'), JSON.stringify(privOnly.map(s => s.title)))
+
+  const before = repo.listByAgent('a1', 10).find(r => r.title === '网关限流方案')!.accessCount
+  await memA1.recallRows('网关 限流')
+  const after = repo.listByAgent('a1', 10).find(r => r.title === '网关限流方案')!.accessCount
+  check('recallRows 触发 touch(强化后续排序)', after === before + 1, `before=${before} after=${after}`)
+
+  // scope 域内完全无记忆才真正返回空(全新 channel;有记忆时弱命中/时近兜底会返回行,by design)
+  const none = await new AgentMemory(repo, { channelId: 'ch-empty', agentId: 'nobody' }).recallRows('完全不存在的关键词xyzq')
+  check('无命中返回空数组(无记忆 agent)', Array.isArray(none) && none.length === 0)
+  const fallback = await memA1.recallRows('完全不存在的关键词xyzq')
+  check('FTS 无命中走时近兜底(有记忆 agent 返回最近行)', fallback.length > 0, JSON.stringify(fallback.map(s => s.title)))
+}
+
+console.log('\n--- 主动沉淀 save(私有/共享分流)---')
+{
+  const priv = await memA1.save({ title: 'SQLite 并发写坑', content: '并发写会 SQLITE_BUSY,须串行化写入', scope: 'private', dedupKey: 'note:sqlite' })
+  check('私有沉淀落入本人域', repo.findByAgentDedup('ch1', 'a1', 'note:sqlite') !== null && priv.scope === 'private')
+
+  const shared = await memA1.save({ title: '限流阈值结论', content: '全队统一令牌桶阈值100qps', scope: 'shared', dedupKey: 'conv:threshold' })
+  const teamRow = repo.findByAgentDedup('ch1', TEAM_AGENT_ID, `agent:a1:conv:threshold`)
+  check('共享沉淀落入 team 公共域(来源命名空间 dedupKey)', teamRow !== null && shared.dedupKey === 'agent:a1:conv:threshold')
+
+  // 同 raw key 不同 agent:命名空间隔离互不覆盖
+  const memA2 = new AgentMemory(repo, { channelId: 'ch1', agentId: 'a2' })
+  await memA2.save({ title: 'a2 的阈值结论', content: 'a2认为阈值应按服务分级', scope: 'shared', dedupKey: 'conv:threshold' })
+  const teamRows = repo.listByAgentChannel('ch1', TEAM_AGENT_ID, 100).filter(r => r.content.includes('阈值') || r.title.includes('阈值'))
+  check('多 agent 同 raw key 共享沉淀互不覆盖', repo.findByAgentDedup('ch1', TEAM_AGENT_ID, 'agent:a1:conv:threshold') !== null && repo.findByAgentDedup('ch1', TEAM_AGENT_ID, 'agent:a2:conv:threshold') !== null, `rows=${teamRows.length}`)
+
+  // 共享沉淀即时对全员可检索
+  const a2sees = await memA2.recallRows('阈值 令牌桶', { scope: 'shared' })
+  check('共享沉淀对其他 agent 即时可检索', a2sees.some(s => s.title === '限流阈值结论'), JSON.stringify(a2sees.map(s => s.title)))
+
+  // 稳定 dedupKey 幂等刷新不重复
+  await memA1.save({ title: '限流阈值结论', content: '修订:阈值升到200qps', scope: 'shared', dedupKey: 'conv:threshold' })
+  const count = repo.listByAgentChannel('ch1', TEAM_AGENT_ID, 100).filter(r => r.dedupKey === undefined && r.title === '限流阈值结论').length
+  const refreshed = repo.listByAgentChannel('ch1', TEAM_AGENT_ID, 100).some(r => r.title === '限流阈值结论')
+  check('稳定 dedupKey 幂等刷新', refreshed && count <= 1)
+}
+
+console.log('\n--- 记忆引子 primer(小预算注入)---')
+{
+  const block = await memA1.recall('限流 令牌桶 部署', { touch: false })
+  check('primer 返回记忆块', block !== null)
+  check('primer 含按需抓取工具提示', block !== null && block.includes('search_memory'), block?.slice(-80))
+  check('primer 小预算(默认300 tokens,行数受限)', block !== null && block.split('\n').length < 10, `lines=${block?.split('\n').length}`)
+
+  const memTiny = new AgentMemory(repo, { channelId: 'ch1', agentId: 'a1', budgetTokens: 5 })
+  check('极小预算 primer 无行则 null', (await memTiny.recall('限流')) === null)
+}
+
+console.log(failures === 0 ? '\nALL PASS' : `\n${failures} FAILED`)
+process.exit(failures === 0 ? 0 : 1)

package/scripts/test-memory-maintenance.ts

@@ -0,0 +1,117 @@
+/**
+ * 记忆衰减清理测试:episodic 过期删除 / semantic+team 豁免 / 容量淘汰(高分保留)/
+ * FTS 联动清理 / 幂等 + Task 9 review 必修回归(UNIQUE 含 channel_id 的跨通道团队去重)。
+ * 运行: npx tsx scripts/test-memory-maintenance.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 { runMemoryMaintenance, segmentCJK } from '../server/services/workshop/runtime/memory'
+import { createChannelRepo } from '../server/services/workshop/db/channel.repo'
+import { createAgentRepo } from '../server/services/workshop/db/agent.repo'
+import { createTeamRepo } from '../server/services/workshop/db/team.repo'
+import { createTeamMemberRepo } from '../server/services/workshop/db/team-member.repo'
+import { createChannelAgentRepo } from '../server/services/workshop/db/channel-agent.repo'
+import { createMessageRepo } from '../server/services/workshop/db/message.repo'
+import { createTaskRepo } from '../server/services/workshop/db/task.repo'
+import { createSubscriptionRepo } from '../server/services/workshop/db/subscription.repo'
+import { createAgentChannelManager } from '../server/services/workshop/runtime/manager'
+
+let failures = 0
+function check(name: string, ok: boolean, detail = ''): void {
+  console.log(`  ${ok ? 'PASS' : 'FAIL'}  ${name}${detail ? ` (${detail})` : ''}`)
+  if (!ok) failures++
+}
+
+const db: DatabaseSync = openWorkshopDb(':memory:')
+const repo = createMemoryRepo(db)
+const seg = (s: string): string => segmentCJK(s)
+
+/** 伪造行龄:created_at/last_accessed_at 一并回拨 days 天 */
+const age = (days: number, id: string): void => {
+  const iso = new Date(Date.now() - days * 86_400_000).toISOString()
+  db.prepare('UPDATE agent_memories SET created_at = ?, last_accessed_at = ? WHERE id = ?').run(iso, iso, id)
+}
+const rowId = (title: string): string => repo.listByAgent('aged', 100).find(r => r.title === title)!.id
+
+// ═══════════ 过期删除(仅 episodic;semantic / team 豁免)═══════════
+console.log('\n--- 过期删除(episodic-only)---')
+repo.upsert({ channelId: 'ch1', agentId: 'aged', kind: 'episodic-task', title: '古老任务', titleFts: seg('古老任务'), content: seg('ghosttoken 古老的登录实现'), importance: 0.8, taskId: 'old-1', dedupKey: 'task:old-1' })
+repo.upsert({ channelId: 'ch1', agentId: 'aged', kind: 'semantic', title: '古老规范', titleFts: seg('古老规范'), content: seg('人工策展永不衰减'), importance: 0.9, taskId: null, dedupKey: 'manual:old-sem' })
+repo.upsert({ channelId: 'ch1', agentId: TEAM_AGENT_ID, kind: 'semantic', title: '古老团队守则', titleFts: seg('古老团队守则'), content: seg('团队行永不衰减'), importance: 0.9, taskId: null, dedupKey: 'team:old' })
+age(200, rowId('古老任务'))
+age(200, rowId('古老规范'))
+age(200, repo.listByAgent(TEAM_AGENT_ID, 100).find(r => r.title === '古老团队守则')!.id)
+
+// ═══════════ 容量淘汰(600 → 500,保留 effectiveScore 高者)═══════════
+console.log('\n--- 容量淘汰(仅 episodic)---')
+for (let i = 0; i < 600; i++) {
+  repo.upsert({
+    channelId: 'ch1', agentId: 'bulk', kind: i % 2 ? 'episodic-task' : 'episodic-peer',
+    title: `批量${i}`, titleFts: seg(`批量${i}`), content: seg(`批量记忆${i}`),
+    importance: i < 50 ? 0.9 : 0.3, taskId: `bulk-${i}`, dedupKey: `task:bulk-${i}`,
+  })
+}
+repo.upsert({ channelId: 'ch1', agentId: 'bulk', kind: 'semantic', title: 'bulk 策展行', titleFts: seg('bulk 策展行'), content: seg('策展行不参与淘汰'), importance: 0.5, taskId: null, dedupKey: 'manual:bulk-sem' })
+
+const res1 = runMemoryMaintenance(repo, { expireDays: 180, cap: 500 })
+check('过期 episodic 被删除(deletedExpired=1)', res1.deletedExpired === 1, JSON.stringify(res1))
+check('semantic 200 天豁免保留', repo.listByAgent('aged', 100).some(r => r.title === '古老规范'))
+check('team 200 天豁免保留', repo.listByAgent(TEAM_AGENT_ID, 100).some(r => r.title === '古老团队守则'))
+check('删除后 FTS 不再命中', repo.search('aged', 'ghosttoken', 5).length === 0)
+check('容量淘汰至 cap(evicted=100)', res1.evicted === 100, JSON.stringify(res1))
+const bulkRows = repo.listByAgent('bulk', 1000)
+check('bulk 恰好剩 500 episodic + 1 semantic', bulkRows.length === 501 && bulkRows.filter(r => r.kind.startsWith('episodic')).length === 500, `len=${bulkRows.length}`)
+check('高分(importance=0.9)全部保留', bulkRows.filter(r => r.importance === 0.9).length === 50)
+check('孤儿 vec 清理未启用 vec 时为 0', res1.cleanedVec === 0)
+
+const res2 = runMemoryMaintenance(repo, { expireDays: 180, cap: 500 })
+check('维护幂等(第二遍 deletedExpired=0 / evicted=0)', res2.deletedExpired === 0 && res2.evicted === 0, JSON.stringify(res2))
+
+// ═══════════ Task 9 必修回归:UNIQUE(agent_id, dedup_key, channel_id)═══════════
+console.log('\n--- 跨通道团队去重(Part A)---')
+const stubImpl = (): never => {
+  throw new Error('impl unused')
+}
+const tmRepos = {
+  channels: createChannelRepo(db),
+  agents: createAgentRepo(db),
+  teams: createTeamRepo(db),
+  teamMembers: createTeamMemberRepo(db),
+  channelAgents: createChannelAgentRepo(db),
+  messages: createMessageRepo(db),
+  subscriptions: createSubscriptionRepo(db),
+  tasks: createTaskRepo(db),
+  memories: repo,
+}
+const teamManager = createAgentChannelManager({ repos: tmRepos, implFactory: stubImpl, db })
+const chA = tmRepos.channels.create({ name: 'ch-a' })
+const chB = tmRepos.channels.create({ name: 'ch-b' })
+const leadA = tmRepos.channelAgents.create({ channelId: chA.id, templateId: null, name: 'lead-a', harness: 'mock', role: 'lead' })
+const leadB = tmRepos.channelAgents.create({ channelId: chB.id, templateId: null, name: 'lead-b', harness: 'mock', role: 'lead' })
+
+teamManager.addTeamMemory(chA.id, leadA.id, { title: '规范甲', content: '通道甲的部署约定', dedupKey: 'shared:policy' })
+teamManager.addTeamMemory(chB.id, leadB.id, { title: '规范乙', content: '通道乙的部署约定', dedupKey: 'shared:policy' })
+const teamShared = repo.listByAgentChannel(chA.id, TEAM_AGENT_ID, 10)
+const teamAll = repo.listByAgent(TEAM_AGENT_ID, 100)
+check('跨通道同 dedupKey 团队写各留一行(不互相覆盖)', teamAll.filter(r => r.title === '规范甲' || r.title === '规范乙').length === 2)
+check('listByAgentChannel 只含本通道行', teamShared.length === 1 && teamShared[0].title === '规范甲')
+check('listTeamMemories 只返回本通道行', teamManager.listTeamMemories(chA.id).every(r => r.channelId === chA.id && r.title === '规范甲'))
+const dedupA = repo.findByAgentDedup(chA.id, TEAM_AGENT_ID, 'shared:policy')
+const dedupB = repo.findByAgentDedup(chB.id, TEAM_AGENT_ID, 'shared:policy')
+check('findByAgentDedup 按通道作用域(两行不同)', dedupA !== null && dedupB !== null && dedupA.rowid !== dedupB.rowid)
+check('findByAgentDedup 无匹配通道返回 null', repo.findByAgentDedup('ch-none', TEAM_AGENT_ID, 'shared:policy') === null)
+
+// 同通道同 dedupKey 仍幂等刷新(不新增行)
+teamManager.addTeamMemory(chA.id, leadA.id, { title: '规范甲', content: '通道甲的部署约定v2', dedupKey: 'shared:policy' })
+check('同通道同 dedupKey 仍幂等刷新', repo.listByAgentChannel(chA.id, TEAM_AGENT_ID, 10).length === 1)
+
+// limit 在本通道内生效(chA 3 行 / chB 2 行,dedupKey 部分重叠)
+teamManager.addTeamMemory(chA.id, leadA.id, { title: '守则1', content: 'x1', dedupKey: 'r:1' })
+teamManager.addTeamMemory(chA.id, leadA.id, { title: '守则2', content: 'x2', dedupKey: 'r:2' })
+teamManager.addTeamMemory(chB.id, leadB.id, { title: '守则1', content: 'y1', dedupKey: 'r:1' })
+check('listTeamMemories limit 作用域为本通道行', teamManager.listTeamMemories(chA.id, 2).length === 2
+&& teamManager.listTeamMemories(chA.id, 2).every(r => r.channelId === chA.id))
+
+console.log(`\n${failures === 0 ? 'ALL PASS' : `${failures} FAILURE(S)`}`)
+process.exit(failures === 0 ? 0 : 1)

package/scripts/test-memory-vector.ts

@@ -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)