agentworkshop 0.5.5 → 0.5.7

package/scripts/test-context-governor.ts

@@ -0,0 +1,176 @@
+/**
+ * 上下文治理环测试(假 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-memory-brief-chronicle.ts

@@ -0,0 +1,180 @@
+/**
+ * 记忆持久化面测试:L0 会话简报 / 压缩摘要入库 / 团队编年史 / 维护豁免与淘汰 /
+ * manager 任务终态事件 → 团队域沉淀总线接线。
+ * 运行: npx tsx --tsconfig .nuxt/tsconfig.server.json scripts/test-memory-brief-chronicle.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, runMemoryMaintenance, unsegmentCJK } from '../server/services/workshop/runtime/memory'
+import type { AgentInterface } from '../server/services/workshop/agents/agent-interface'
+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 += 1
+}
+const sleep = (ms: number): Promise<void> => new Promise(r => setTimeout(r, ms))
+
+const db: DatabaseSync = openWorkshopDb(':memory:')
+const repo = createMemoryRepo(db)
+const seg = (s: string): string => s.replace(/([\u4e00-\u9fff])/g, ' $1 ')
+
+// ===== L0 会话简报:recordTaskOutcome / save(shared) 自动刷新,幂等单行 =====
+console.log('\n--- L0 会话简报(brief)---')
+{
+  const mem = new AgentMemory(repo, { channelId: 'ch1', agentId: 'w1' })
+  check('无完成记录时不产简报', repo.findByAgentDedup('ch1', 'w1', 'brief:w1') === null)
+  await mem.recordTaskOutcome({
+    id: 'tk1', channelId: 'ch1', assigneeId: 'w1', creatorId: 'lead', title: '网关配置任务',
+    state: 'COMPLETED', progress: 100, retryCount: 0,
+    artifacts: [{ artifactId: 'a1', name: 'deliverable', parts: [{ text: '网关路由表已生效' }] }],
+    history: [], createdAt: new Date().toISOString(), updatedAt: new Date().toISOString(),
+  } as Parameters<AgentMemory['recordTaskOutcome']>[0])
+  let brief = repo.findByAgentDedup('ch1', 'w1', 'brief:w1')
+  check('任务终态后简报生成', brief !== null)
+  check('简报含最近完成条目', brief !== null && unsegmentCJK(repo.getById(brief.id)!.content).includes('网关配置任务'))
+  check('简报为单行幂等(brief kind)', repo.listByAgentChannel('ch1', 'w1', 100).filter(r => r.kind === 'brief').length === 1)
+
+  await mem.save({ title: '限流约定', content: '全队统一令牌桶', scope: 'shared', dedupKey: 'conv:rl' })
+  brief = repo.findByAgentDedup('ch1', 'w1', 'brief:w1')
+  check('共享沉淀后简报含团队约定', brief !== null && unsegmentCJK(repo.getById(brief.id)!.content).includes('限流约定'))
+
+  // recall L0 置顶
+  const block = await mem.recall('任意查询')
+  check('recall 注入块含会话简报', block !== null && block.includes('会话简报'))
+}
+
+// ===== 压缩摘要入库:episodic-session,序号 dedupKey,可检索 =====
+console.log('\n--- 压缩摘要(episodic-session)---')
+{
+  const mem = new AgentMemory(repo, { channelId: 'ch1', agentId: 'w1' })
+  const s1 = await mem.recordSessionCompaction({ summary: '完成网关配置;待办:验证路由', tokensBefore: 90000, tokensAfter: 30000, reason: 'threshold' })
+  const s2 = await mem.recordSessionCompaction({ summary: '第二次压缩摘要', tokensBefore: 88000 })
+  check('dedupKey 序号递增不互踩', s1.dedupKey !== s2.dedupKey && repo.findByAgentDedup('ch1', 'w1', s1.dedupKey) !== null && repo.findByAgentDedup('ch1', 'w1', s2.dedupKey) !== null)
+  const found = await mem.recallRows('网关配置 验证路由')
+  check('压缩摘要可被 search_memory 检索', found.some(s => s.kind === 'episodic-session'), JSON.stringify(found.map(s => s.kind)))
+  const row = repo.listByAgentChannel('ch1', 'w1', 100).find(r => r.kind === 'episodic-session')
+  check('importance=0.75 元信息入库', row !== null && row.importance === 0.75)
+}
+
+// ===== 团队编年史:滚动重写幂等单行 =====
+console.log('\n--- 团队编年史(chronicle)---')
+{
+  const mem = new AgentMemory(repo, { channelId: 'ch1', agentId: TEAM_AGENT_ID })
+  mem.upsertChronicle(['09-02 10:00 [完成] 任务A — w1(交付 x)', '09-02 11:00 [失败] 任务B — w2'].join('\n'))
+  mem.upsertChronicle(['09-02 12:00 [完成] 任务C — w3'].join('\n'))
+  const rows = repo.listByAgentChannel('ch1', TEAM_AGENT_ID, 100).filter(r => r.kind === 'chronicle')
+  check('编年史幂等单行(重写不新增)', rows.length === 1)
+  const chron = rows[0] !== undefined ? unsegmentCJK(rows[0]!.content) : ''
+  check('编年史内容为最新滚动', chron.includes('w3') && !chron.includes('任务 A'), chron)
+}
+
+// ===== 维护:session 14d 过期 / 策展层豁免 / team-task 淘汰 =====
+console.log('\n--- 维护规则 v2 ---')
+{
+  const old = new Date(Date.now() - 20 * 86_400_000).toISOString()
+  repo.upsert({ channelId: 'ch1', agentId: 'w1', kind: 'episodic-session', title: '旧压缩摘要', titleFts: seg('旧压缩摘要'), content: seg('过期内容'), importance: 0.75, taskId: null, dedupKey: 'session:w1:c99' })
+  db.prepare('UPDATE agent_memories SET created_at = ? WHERE dedup_key = ?').run(old, 'session:w1:c99')
+
+  const res = runMemoryMaintenance(repo, { expireDays: 180, cap: 500 })
+  check('episodic-session 14d 过期删除', res.deletedExpired >= 1 && repo.findByAgentDedup('ch1', 'w1', 'session:w1:c99') === null, JSON.stringify(res))
+  check('brief 豁免保留', repo.findByAgentDedup('ch1', 'w1', 'brief:w1') !== null)
+  check('chronicle 豁免保留', repo.listByAgentChannel('ch1', TEAM_AGENT_ID, 100).some(r => r.kind === 'chronicle'))
+
+  // team-task 容量淘汰(cap=2 时仅保留 2 行)
+  for (let i = 0; i < 4; i++) {
+    repo.upsert({ channelId: 'ch1', agentId: TEAM_AGENT_ID, kind: 'episodic-team-task', title: `团队任务${i}`, titleFts: seg(`团队任务${i}`), content: seg('成果'), importance: i < 2 ? 0.9 : 0.5, taskId: `tt-${i}`, dedupKey: `team-task:tt-${i}` })
+  }
+  runMemoryMaintenance(repo, { expireDays: 180, cap: 2 })
+  const remaining = repo.listByAgentChannel('ch1', TEAM_AGENT_ID, 100).filter(r => r.kind === 'episodic-team-task')
+  check('team episodic 纳入容量淘汰(高分保留)', remaining.length === 2 && remaining.every(r => r.importance === 0.9), `left=${remaining.length}`)
+}
+
+// ===== manager 总线接线:任务终态 → team-task 行 + 编年史(单点不双写)=====
+console.log('\n--- manager 任务终态团队沉淀 ---')
+{
+  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,
+  }
+  // 空转 impl:run 即返回(lead 自派任务的回合立即落定,不产错误)
+  const stubImpl = (): AgentInterface => ({ async* run() {} })
+  const manager = createAgentChannelManager({ repos: tmRepos, implFactory: stubImpl, db })
+  const ch = tmRepos.channels.create({ name: 'ch-harvest' })
+  const lead = tmRepos.channelAgents.create({ channelId: ch.id, templateId: null, name: 'lead-h', harness: 'mock', role: 'lead' })
+  // 激活 channel runtime(创建 bus + 注册团队沉淀监听)
+  manager.subscribeTaskEvents(ch.id, () => {})
+
+  const task = await manager.dispatchTask(ch.id, lead.id, { assigneeId: lead.id, title: '数据迁移执行', description: '迁移并验证' })
+  await sleep(30)
+  await manager.completeTask(ch.id, lead.id, {
+    taskId: task.id,
+    artifacts: [{ artifactId: 'd1', name: 'deliverable', parts: [{ text: '迁移完成,校验和一致' }] }],
+  })
+  await sleep(30)
+
+  const teamRow = repo.findByAgentDedup(ch.id, TEAM_AGENT_ID, `team-task:${task.id}`)
+  check('任务完成 → team-task 共享行入库', teamRow !== null)
+  const teamRows = repo.listByAgentChannel(ch.id, TEAM_AGENT_ID, 100).filter(r => r.kind === 'episodic-team-task')
+  check('团队域单点写入(无双写)', teamRows.length === 1, `rows=${teamRows.length}`)
+  check('交付物进入共享行内容', teamRow !== null && unsegmentCJK(repo.getById(teamRow.id)!.content).includes('校验和一致'))
+  const chronicle = repo.listByAgentChannel(ch.id, TEAM_AGENT_ID, 100).find(r => r.kind === 'chronicle')
+  check('编年史随任务终态滚动更新', chronicle !== undefined && unsegmentCJK(repo.getById(chronicle.id)!.content).includes('数据迁移执行'))
+  await manager.shutdown()
+}
+
+// ===== 空闲反思:当月 episodic-task ≥ 阈值 → reflection 行聚合(月度幂等)=====
+console.log('\n--- 空闲反思(reflection)---')
+{
+  const month = new Date().toISOString().slice(0, 7)
+  for (let i = 0; i < 8; i++) {
+    repo.upsert({ channelId: 'ch1', agentId: 'rx', kind: 'episodic-task', title: `反思任务${i}`, titleFts: seg(`反思任务${i}`), content: seg('结论性内容'), importance: 0.8, taskId: `rx-${i}`, dedupKey: `task:rx-${i}` })
+  }
+  const stubImpl = (): AgentInterface => ({ async* run() {} })
+  const m2 = createAgentChannelManager({
+    repos: {
+      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,
+    },
+    implFactory: stubImpl,
+    db,
+  })
+  ;(m2 as unknown as Record<string, () => void>).reflectIdleMemories()
+  const reflRef = repo.findByAgentDedup('ch1', 'rx', `reflection:rx:${month}`)
+  const refl = reflRef ? repo.getById(reflRef.id) : null
+  check('反思行入库(月度 dedupKey)', refl !== null)
+  check('反思行聚合任务结论', refl !== null && unsegmentCJK(refl.content).includes('反思任务'))
+
+  // 再跑一轮:无新增任务 → 不重复聚合(内容不变,幂等)
+  ;(m2 as unknown as Record<string, () => void>).reflectIdleMemories()
+  const reflCount = repo.listByAgentChannel('ch1', 'rx', 100).filter(r => r.kind === 'reflection').length
+  check('反思月度幂等(无增量不再重写)', reflCount === 1)
+  await m2.shutdown()
+}
+
+console.log(failures === 0 ? '\nALL PASS' : `\n${failures} FAILED`)
+process.exit(failures === 0 ? 0 : 1)

package/scripts/test-memory-dynamic.ts

@@ -89,7 +89,9 @@ 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}`)
+  // v2 三层注入:L0 简报(save(shared) 后自动存在)+ L1 引子 + 提示,同在 300 tok 引子预算 + 500 tok 总预算内
+  check('primer 含 L0 会话简报', block !== null && block.includes('会话简报'))
+  check('primer 小预算(行数受限)', block !== null && block.split('\n').length < 16, `lines=${block?.split('\n').length}`)
 
   const memTiny = new AgentMemory(repo, { channelId: 'ch1', agentId: 'a1', budgetTokens: 5 })
   check('极小预算 primer 无行则 null', (await memTiny.recall('限流')) === null)

package/scripts/test-memory-rrf-mmr.ts

@@ -0,0 +1,114 @@
+/**
+ * 记忆检索 v2 算法测试:RRF 融合 / MMR 多样性 / kind 感知半衰期 / 任务关联加权 / 策展层排除。
+ * 运行: npx tsx --tsconfig .nuxt/tsconfig.server.json scripts/test-memory-rrf-mmr.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, buildMatchQuery, estimateTokens } 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 ')
+
+// ===== buildMatchQuery:CJK 词项扩容 + 去重 =====
+console.log('\n--- buildMatchQuery(CJK 词项扩容)---')
+{
+  const q = buildMatchQuery('网关限流方案讨论,部署脚本与令牌桶阈值约定')
+  const termCount = q ? q.split(' OR ').length : 0
+  check('CJK 单字词项上限提升(>12)', termCount > 12, `terms=${termCount}`)
+  const deduped = buildMatchQuery('限流 限流 限流')
+  check('词项去重', deduped !== null && deduped.split(' OR ').length === 2, `terms=${deduped}`) // 限/流
+  check('token 估算为正', estimateTokens('abc 中文') > 0)
+}
+
+// ===== RRF 融合:FTS+向量双榜融合(词袋 embedder)=====
+console.log('\n--- RRF 融合(混合检索)---')
+{
+  // hash 词袋 provider:同词集 → 相近向量(零网络)
+  const { createHashEmbeddingProvider } = await import('../server/services/workshop/runtime/embedding-provider')
+  const embedder = createHashEmbeddingProvider(64)
+
+  const rows = [
+    { dedup: 'task:a', title: 'Redis 缓存穿透方案', content: '布隆过滤器前置拦截,空值缓存五分钟' },
+    { dedup: 'task:b', title: 'Redis 雪崩预案', content: '过期时间加随机抖动,多级缓存兜底' },
+    { dedup: 'task:c', title: '部署脚本清单', content: 'docker compose 拉镜像,健康检查后切流量' },
+  ]
+  for (const r of rows) {
+    repo.upsert({ channelId: 'ch1', agentId: 'a1', kind: 'episodic-task', title: r.title, titleFts: seg(r.title), content: seg(r.content), importance: 0.8, taskId: r.dedup, dedupKey: `task:${r.dedup}` })
+  }
+  const mem = new AgentMemory(repo, { channelId: 'ch1', agentId: 'a1', embedder })
+  // 向量可命中(词袋相似)但 FTS 无词面匹配的查询:RRF 仍能通过向量榜给出结果
+  const hits = await mem.recallRows('cache 穿透 拦截')
+  check('向量榜独有命中可达(RRF 不丢向量结果)', hits.some(s => s.title === 'Redis 缓存穿透方案'), JSON.stringify(hits.map(s => s.title)))
+
+  // 双榜同时命中:融合排序应把两榜都命中的排前
+  const both = await mem.recallRows('Redis 雪崩')
+  check('双榜命中排序靠前', both.length > 0 && both[0]!.title === 'Redis 雪崩预案', JSON.stringify(both.map(s => `${s.title}:${s.score}`)))
+}
+
+// ===== kind 感知半衰期:semantic 不衰减,episodic-task 14d =====
+console.log('\n--- kind 感知半衰期 ---')
+{
+  const old = new Date(Date.now() - 60 * 86_400_000).toISOString()
+  repo.upsert({ channelId: 'ch1', agentId: 'old1', kind: 'semantic', title: '六十天前的架构决策', titleFts: seg('六十天前的架构决策'), content: seg('内核结论:单写多读'), importance: 0.9, taskId: null, dedupKey: 'manual:old-sem' })
+  repo.upsert({ channelId: 'ch1', agentId: 'old1', kind: 'episodic-task', title: '六十天前的任务', titleFts: seg('六十天前的任务'), content: seg('过程性记录,内容已过时'), importance: 0.9, taskId: 't-old', dedupKey: 'task:t-old' })
+  // 直接改 created_at 模拟老化(upsert ON CONFLICT 会刷新,故用参数化 UPDATE)
+  db.prepare('UPDATE agent_memories SET created_at = ? WHERE agent_id = ?').run(old, 'old1')
+
+  const mem = new AgentMemory(repo, { channelId: 'ch1', agentId: 'old1' })
+  const hits = await mem.recallRows('六十天前')
+  const sem = hits.find(s => s.title === '六十天前的架构决策')
+  const epi = hits.find(s => s.title === '六十天前的任务')
+  check('semantic 知识不随时近衰减(分高于 episodic)', sem !== undefined && epi !== undefined && sem.score > epi.score, `sem=${sem?.score} epi=${epi?.score}`)
+}
+
+// ===== 任务关联加权:兄弟/父任务记忆置顶 =====
+console.log('\n--- 任务关联加权(related-task boost)---')
+{
+  repo.upsert({ channelId: 'ch1', agentId: 'rel', kind: 'episodic-task', title: '无关旧任务', titleFts: seg('无关旧任务'), content: seg('数据库迁移完成,版本升到 v14'), importance: 0.8, taskId: 't-other', dedupKey: 'task:t-other' })
+  repo.upsert({ channelId: 'ch1', agentId: 'rel', kind: 'episodic-task', title: '兄弟任务结论', titleFts: seg('兄弟任务结论'), content: seg('API 网关路由表已生成'), importance: 0.55, taskId: 't-sib1', dedupKey: 'task:t-sib1' })
+  const mem = new AgentMemory(repo, { channelId: 'ch1', agentId: 'rel' })
+  // 查询词面同时弱命中两行;兄弟任务 id 加权后必须反超高重要度旧行
+  const hits = await mem.recallRows('任务 结论 数据库 网关', { relatedTaskIds: ['t-sib1', 't-parent'] })
+  check('兄弟任务记忆加权反超(置顶)', hits[0]?.title === '兄弟任务结论', JSON.stringify(hits.map(s => `${s.title}:${s.score}`)))
+  const hitsNoRel = await mem.recallRows('任务 结论 数据库 网关', { touch: false })
+  check('无关联集时高重要度旧行居前(对照)', hitsNoRel[0]?.title === '无关旧任务', JSON.stringify(hitsNoRel.map(s => `${s.title}:${s.score}`)))
+}
+
+// ===== 策展层:brief 走 L0 置顶,L1 引子不重复;chronicle 不进 L1 但 L2 可检索 =====
+console.log('\n--- 策展层(L0/L1/L2 分层)---')
+{
+  const mem = new AgentMemory(repo, { channelId: 'ch1', agentId: 'cur' })
+  await mem.save({ title: '普通结论', content: '普通检索应该能命中', scope: 'private', dedupKey: 'note:normal' })
+  mem.repo.upsert({ channelId: 'ch1', agentId: 'cur', kind: 'brief', title: '会话简报', titleFts: seg('会话简报'), content: seg('最近完成:普通结论'), importance: 0.6, taskId: null, dedupKey: 'brief:cur' })
+  mem.repo.upsert({ channelId: 'ch1', agentId: 'cur', kind: 'chronicle', title: '团队编年史', titleFts: seg('团队编年史'), content: seg('完成 普通结论'), importance: 0.9, taskId: null, dedupKey: 'chronicle:ch1' })
+
+  // L1(recall):brief 经 L0 路径恰好注入一次(去重靠 excludeCurated);chronicle 不进 L1
+  const primer = await mem.recall('普通')
+  const briefHits = (primer?.match(/会话简报/g) ?? []).length
+  check('brief 恰好注入一次(L0 路径)', briefHits === 1, `hits=${briefHits}`)
+  check('L1 引子不含 chronicle(防双份注入)', primer !== null && !primer.includes('编年史'))
+
+  // L2(search_memory/recallRows):策展层可被检索(特性)
+  const found = await mem.recallRows('编年史')
+  check('L2 search_memory 可命中 chronicle', found.some(s => s.title === '团队编年史'), JSON.stringify(found.map(s => s.title)))
+}
+
+// ===== team 域可见性:episodic-team-task 对全员 shared 可检索 =====
+console.log('\n--- team-task 共享域 ---')
+{
+  repo.upsert({ channelId: 'ch1', agentId: TEAM_AGENT_ID, kind: 'episodic-team-task', title: '团队任务成果', titleFts: seg('团队任务成果'), content: seg('数据迁移已全部完成并验证'), importance: 0.8, taskId: 't-team', dedupKey: 'team-task:t-team' })
+  const memB = new AgentMemory(repo, { channelId: 'ch1', agentId: 'member-b' })
+  const seen = await memB.recallRows('数据迁移', { scope: 'shared' })
+  check('其他成员 shared 域可命中 team-task 行', seen.some(s => s.title === '团队任务成果'), JSON.stringify(seen.map(s => s.title)))
+}
+
+console.log(failures === 0 ? '\nALL PASS' : `\n${failures} FAILED`)
+process.exit(failures === 0 ? 0 : 1)

package/server/api/workshop/agent-tools/invoke.post.ts

@@ -6,6 +6,7 @@
 import { readBody } from 'h3'
 import { resolveUser } from '@/server/api/workshop/caller'
 import { defineApiHandler } from '@/server/utils/response'
+import { getWorkshopManager } from '@/server/plugins/workshop'
 import {
   toolDaqQuery,
   toolDcwControl,
@@ -15,6 +16,9 @@ import {
   toolMyIndustrialNodes,
 } from '@/server/services/workshop/agents/industrial-tools'
 
+/** 协作工具族:经 manager 工具桥落到 agent workspace(跨团队可见性/跨 Channel 通信) */
+const COLLAB_TOOLS = new Set(['list_other_teams', 'search_other_teams_memory', 'send_cross_channel_message'])
+
 export default defineApiHandler(async (event) => {
   resolveUser(event)
   const body = await readBody<{ agentId?: string, tool?: string, args?: Record<string, unknown> }>(event) ?? {}
@@ -23,7 +27,10 @@ export default defineApiHandler(async (event) => {
   const args = body.args ?? {}
   if (!agentId) throw createError({ statusCode: 400, statusMessage: 'agentId required' })
   let result: { text: string, isError?: boolean }
-  if (tool === 'my_industrial_nodes') result = await toolMyIndustrialNodes(agentId)
+  if (COLLAB_TOOLS.has(tool)) {
+    result = getWorkshopManager().invokeAgentWorkspaceTool(agentId, tool, args)
+  }
+  else if (tool === 'my_industrial_nodes') result = await toolMyIndustrialNodes(agentId)
   else if (tool === 'dcw_control') result = await toolDcwControl(agentId, args as { node_id?: string, value?: number, hypothesis?: string, task_id?: string })
   else if (tool === 'daq_query') result = await toolDaqQuery(agentId, args as Parameters<typeof toolDaqQuery>[1])
   else if (tool === 'dcw_judge') result = await toolDcwJudge(agentId, args as { record_id?: string, verdict?: string, reason?: string })

package/server/api/workshop/channels/[id]/messages/index.post.ts

@@ -15,7 +15,7 @@ import { defineApiHandler } from '../../../../../utils/response'
 import { getWorkshopManager } from '../../../../../plugins/workshop'
 
 const sendMessageSchema = z.object({
-  toAgentId: z.string().min(1, 'toAgentId 必填'),
+  toAgentId: z.string().min(1, 'toAgentId 必填').optional(),
   text: z.string().min(1, 'text 必填'),
   fromAgentId: z.string().optional(),
   /** 人类发送者显示名(时间线 a2a.message 的发送者归属 → x-aw-from-label) */
@@ -23,6 +23,11 @@ const sendMessageSchema = z.object({
   priority: z.enum(['immediate', 'task']).default('task'),
   /** 触发器:要求接收方回执(执行结果 + 所需内容,in_reply_to 关联) */
   requireReply: z.boolean().optional(),
+  /**
+   * 跨 Channel 通信(仅 lead):指定目标 channel(id 或名字)→ 消息直投其 lead mailbox。
+   * 与 toAgentId 二选一;fromAgentId 必填且必须是本 channel 的 lead(worker 拒绝)。
+   */
+  toChannelId: z.string().optional(),
 })
 
 export default defineApiHandler(async (event) => {
@@ -33,6 +38,26 @@ export default defineApiHandler(async (event) => {
   const channel = manager.getChannelForUser(channelId, user.id)
   manager.requireOwned(channel.ownerUserId, user.id, 'channel')
 
+  // 跨 Channel 分支:lead 专属;目标解析(id/名字)与投递在 manager 内完成
+  if (body.toChannelId) {
+    if (body.toAgentId) {
+      throw new AppError(400, 'BAD_REQUEST', 'toChannelId 与 toAgentId 二选一,不可同时指定')
+    }
+    if (!body.fromAgentId) {
+      throw new AppError(403, 'ROLE_FORBIDDEN', '跨 Channel 通信必须以本 channel Leader 身份发送(fromAgentId 必填)')
+    }
+    const fromAgentId = manager.resolveChannelMember(channelId, body.fromAgentId).id
+    return manager.sendCrossChannelMessage(channelId, fromAgentId, {
+      toChannelId: body.toChannelId,
+      parts: [{ text: body.text }],
+      requireReply: body.requireReply,
+    })
+  }
+
+  if (!body.toAgentId) {
+    throw new AppError(400, 'BAD_REQUEST', 'toAgentId 必填(跨 Channel 请改用 toChannelId)')
+  }
+
   // 目标寻址(容错:精确实例 id / 模板 id / 名字 / 唯一名字前缀)
   const target = manager.resolveChannelMember(channelId, body.toAgentId)
   // 发送方身份校验:显式 fromAgentId 必须可解析到本 channel 成员 ——

package/server/api/workshop/ws.ts

@@ -379,6 +379,7 @@ function bindStreamSubscriptions(manager: AgentChannelManager, stream: ChannelSt
     currentTaskProgress: e.currentTaskProgress ?? null,
     queued: e.queuedCount ?? 0,
     completed: e.completedCount ?? 0,
+    context: e.context ?? null,
   }, { agentId: e.agentId })))
   // harness 事件流(message/artifact/status.message/error)
   stream.unsubs.push(manager.subscribeChannelEvents(channelId, (event, source) => mapAgentEvent(manager, stream, event, source)))