agentworkshop 0.5.5 → 0.5.7

package/server/services/workshop/runtime/channel-runtime.ts

@@ -4,14 +4,14 @@
  * route 仅在本 channel 内路由消息;订阅关系经 subscriptionRepo。
  * 懒加载:agents map 不含目标时经 loader 回调按需装配(DB 行 → AgentRuntime);
  */
-import { createLogger } from '../logger'
+import { createLogger } from '../logger'
 import type { A2AMessage } from '../types/a2a'
 import type { SubscriptionRepo } from '../db/subscription.repo'
 import type { ChannelAgentRepo } from '../db/channel-agent.repo'
 import type { AgentRuntimeLike, TaskEngine } from './agent-runtime'
 
-const log = createLogger('workshop.channel')
-
+const log = createLogger('workshop.channel')
+
 /** 调度循环结构契约(实现方 T5 SchedulerLoop) */
 export interface SchedulerLoopLike {
   start(): void
@@ -85,10 +85,13 @@ export class ChannelRuntime {
   }
 
   /**
-   * 信箱守卫(垃圾信息拦截):三类消息放行,其余直接丢弃(不落库、不投递)——
+   * 信箱守卫(垃圾信息拦截):四类消息放行,其余直接丢弃(不落库、不投递)——
    *  ① 平台任务消息(task-kind + 真实存在的任务);
-   *  ② 声明发送人为本 channel 成员的消息(伪造/已移除成员 → 拒);
-   *  ③ 人类经 REST 注入的消息(x-aw-from-label 必须非空)。
+   *  ② 跨 Channel 消息(x-aw-cross-channel 标记 + 源 channel 注明)——
+   *    manager.sendCrossChannelMessage 发送时已校验「发送方=源 channel lead +
+   *    双方同主 + 目标 lead 在册」并盖服务端标记;REST/工具入参无法伪造;
+   *  ③ 声明发送人为本 channel 成员的消息(伪造/已移除成员 → 拒);
+   *  ④ 人类经 REST 注入的消息(x-aw-from-label 必须非空)。
    * 防脏信息注入:无主消息与未知发送人的消息没有回执对象,处理它们只会
    * 污染 Agent 上下文,因此拦截并删除。
    */
@@ -101,6 +104,11 @@ export class ChannelRuntime {
       log.warn(`[ChannelRuntime:${this.channelId.slice(0, 8)}] 拦截无效任务消息(kind=${String(taskKind)} task=${String(taskId)}),已丢弃`)
       return false
     }
+    if (meta['x-aw-cross-channel'] === 'true'
+      && typeof meta['x-aw-from-channel'] === 'string'
+      && meta['x-aw-from-channel'] !== this.channelId) {
+      return true
+    }
     const from = meta['x-aw-from-agent']
     if (typeof from === 'string' && from.length > 0) {
       const member = this.deps.channelAgents.findByChannelAgent(this.channelId, from)

package/server/services/workshop/runtime/manager.ts

@@ -9,7 +9,7 @@
  * - 每个实例在各自 channel 独立装配 AgentRuntime(独立 mailbox/impl 子进程/状态)
  * 权威契约见 docs/superpowers/plans/2026-08-13-agent-workshop-multi-agent.md 核心契约块 T3。
  */
-import { createLogger } from '../logger'
+import { createLogger } from '../logger'
 import { mkdirSync } from 'node:fs'
 import { resolve } from 'node:path'
 import { randomUUID } from 'node:crypto'
@@ -46,8 +46,8 @@ import type { UserRepo } from '../db/user.repo'
 import type { ChannelEventRepo } from '../db/channel-event.repo'
 import type { ChannelTemplateRepo, ChannelTemplateMember } from '../db/channel-template.repo'
 
-const log = createLogger('workshop.manager')
-
+const log = createLogger('workshop.manager')
+
 /** 全部仓储(依赖注入) */
 export interface AllRepos {
   users: UserRepo
@@ -304,6 +304,8 @@ export class AgentChannelManager {
   private memoryTimer: NodeJS.Timeout | null = null
   /** 全 manager 共享的 env 向量 provider(未配置 → null 纯 FTS;熔断/维度全体实例共享) */
   private readonly memoryEmbedder = createEnvEmbeddingProvider()
+  /** 反思游标:每 agent 上次聚合的当月任务数(月度幂等增量判定) */
+  private readonly reflectCounts = new Map<string, number>()
 
   constructor(private deps: ManagerDeps) {
     // 记忆衰减清理定时器(失败只记日志,绝不抛出;unref 不阻进程退出;非法/非正 env 回退默认)
@@ -314,6 +316,13 @@ export class AgentChannelManager {
       catch (err) {
         log.error('[memory] 维护任务异常', err)
       }
+      // 空闲反思(sleep-time compute):busy runtime 存在即整轮跳过,绝不与作业争抢
+      try {
+        this.reflectIdleMemories()
+      }
+      catch (err) {
+        log.error('[memory] 反思任务异常', err)
+      }
     }, envNum('AW_MEMORY_MAINTENANCE_MS', 6 * 3600_000))
     this.memoryTimer.unref?.()
   }
@@ -355,10 +364,110 @@ export class AgentChannelManager {
       cr.setLoader(id => this.ensureAgentRuntime(channelId, id))
       this.channels.set(channelId, cr)
       this.buses.set(channelId, this.buildBus(cr))
+      // 团队记忆沉淀(任务终态事件单点收口):team-task 共享行 + 编年史滚动重写。
+      // 事件总线保证每次状态迁移恰好一次通知——worker/lead 各自私有域 harvest 之外
+      // 的团队域写入不存在双写;失败仅记日志,绝不影响任务流。
+      this.buses.get(channelId)!.onTaskEvent(e => this.recordTeamTaskTerminal(channelId, e))
     }
     return cr
   }
 
+  /**
+   * 团队历史沉淀(任务终态):① team-task 共享行(成果/失败原因,全员可检索);
+   * ② 团队编年史滚动重写(最近 12 条终态任务轨迹)。
+   */
+  private recordTeamTaskTerminal(channelId: string, e: { taskId: string, state?: TaskState, task?: TaskEventTask }): void {
+    if (!e.state || !TERMINAL_TASK_STATES[e.state]) return
+    try {
+      const completed = e.state === 'COMPLETED'
+      const task = e.task
+      const title = task?.title ?? `任务 ${e.taskId.slice(0, 8)}`
+      // 成果提取与 AgentMemory.recordTaskOutcome 同口径(deliverable/summary 优先)
+      const artifacts = (task?.artifacts ?? []) as A2AArtifact[]
+      const preferred = artifacts.filter(a => a.name === 'deliverable' || a.name === 'summary')
+      const source = preferred.length > 0 ? preferred : artifacts
+      const deliverable = source
+        .flatMap(a => a.parts)
+        .map(p => ('text' in p ? p.text : ''))
+        .join(' ')
+        .trim()
+      const content = completed
+        ? (deliverable || title)
+        : `任务「${title}」${e.state === 'CANCELED' ? '已取消' : '未完成'}${deliverable ? `;已有进展: ${deliverable.slice(0, 200)}` : ''}`
+      const mem = new AgentMemory(this.deps.repos.memories, { channelId, agentId: TEAM_AGENT_ID, embedder: this.memoryEmbedder ?? undefined })
+      void mem.appendTeamTaskRecord({
+        taskId: e.taskId,
+        title,
+        content,
+        importance: completed ? 0.8 : 0.55,
+      }).catch((err) => { log.error('[memory] team-task 沉淀失败:', err) })
+      this.refreshChronicle(channelId)
+    }
+    catch (err) {
+      log.error('[memory] 团队任务沉淀异常:', err)
+    }
+  }
+
+  /** 团队编年史滚动重写(最近 12 条终态任务;chronicle:<channelId> 幂等单行;免向量化) */
+  private refreshChronicle(channelId: string): void {
+    try {
+      const terminal = this.getTaskEngine().list(channelId)
+        .filter(t => TERMINAL_TASK_STATES[t.state])
+        .sort((a, b) => (a.updatedAt < b.updatedAt ? 1 : -1))
+        .slice(0, 12)
+      if (terminal.length === 0) return
+      const entries = terminal.map((t) => {
+        const stamp = t.updatedAt.slice(5, 16).replace('T', ' ')
+        const deliverable = t.artifacts
+          .flatMap(a => a.parts)
+          .map(p => ('text' in p ? p.text : ''))
+          .join(' ')
+          .replace(/\s+/g, ' ')
+          .trim()
+          .slice(0, 60)
+        const state = t.state === 'COMPLETED' ? '完成' : t.state === 'FAILED' ? '失败' : '取消'
+        return `${stamp} [${state}] ${t.title} — ${t.assigneeId.slice(0, 8)}${deliverable ? `(${deliverable})` : ''}`
+      })
+      new AgentMemory(this.deps.repos.memories, { channelId, agentId: TEAM_AGENT_ID })
+        .upsertChronicle(entries.join('\n'))
+    }
+    catch (err) {
+      log.error('[memory] 编年史刷新失败:', err)
+    }
+  }
+
+  /**
+   * 空闲反思(sleep-time compute,零 LLM):当月 episodic-task 增量 ≥ 阈值时,
+   * 聚合标题+结论成 semantic 反思行(月度 dedupKey 幂等;FTS 可检索,免向量化)。
+   */
+  private reflectIdleMemories(): void {
+    for (const rt of this.agentIndex.values()) {
+      if (rt.getState() === 'busy') return
+    }
+    const trigger = envNum('AW_MEMORY_REFLECT_TRIGGER', 8)
+    const month = new Date().toISOString().slice(0, 7)
+    for (const agentId of this.deps.repos.memories.listMemoryAgentIds()) {
+      const rows = this.deps.repos.memories.listByAgentWithRowid(agentId, 1_000_000)
+        .filter(r => r.kind === 'episodic-task' && r.createdAt.slice(0, 7) === month)
+      const prev = this.reflectCounts.get(agentId) ?? 0
+      if (rows.length < trigger || rows.length <= prev) continue
+      // 行可能跨 channel(历史迁移):按 channel 分组,各组建反思
+      const byChannel = new Map<string, typeof rows>()
+      for (const r of rows) {
+        const list = byChannel.get(r.channelId) ?? []
+        list.push(r)
+        byChannel.set(r.channelId, list)
+      }
+      for (const [channelId, list] of byChannel) {
+        const lines = list.slice(0, 20).map(r => `- ${r.title}:${unsegmentCJK(r.content).slice(0, 60)}`)
+        new AgentMemory(this.deps.repos.memories, { channelId, agentId })
+          .upsertReflection({ month, content: [`当月 ${list.length} 项任务经验聚合:`, ...lines].join('\n') })
+      }
+      this.reflectCounts.set(agentId, rows.length)
+      log.info(`[memory] 反思蒸馏:agent=${agentId.slice(0, 8)} 当月 ${rows.length} 项任务已聚合`)
+    }
+  }
+
   private buildBus(cr: ChannelRuntime): ChannelBus {
     const eventListeners = new Set<(event: AgentEvent, source: A2AMessage) => void>()
     const taskListeners = new Set<(e: { taskId: string, state?: TaskState, progress?: number }) => void>()
@@ -868,6 +977,9 @@ export class AgentChannelManager {
       updateTask: (taskId, patch) => this.updateTask(channelId, agent.id, taskId, patch),
       reassignTask: (taskId, toAgentId) => this.reassignTask(channelId, agent.id, taskId, toAgentId),
       sendMessage: input => this.sendA2A(channelId, agent.id, input),
+      sendCrossChannelMessage: input => this.sendCrossChannelMessage(channelId, agent.id, input),
+      listOtherTeams: () => this.listOtherTeamsOverview(channelId, agent.id),
+      searchOtherTeamsMemory: input => this.recallOtherTeamsMemory(channelId, agent.id, input),
       refuseTask: (taskId, reason) => this.refuseTask(channelId, agent.id, taskId, reason),
       pollMailbox: limit => this.pollMailbox(channelId, agent.id, limit),
       waitMailbox: (limit, waitMs) => this.waitMailbox(channelId, agent.id, limit ?? 10, waitMs ?? 0),
@@ -885,6 +997,11 @@ export class AgentChannelManager {
         this.buses.get(channelId)?.notifyMemory({ agentId: agent.id, scope: input.scope, title: input.title, dedupKey: saved.dedupKey })
         return saved
       },
+      // 会话压缩摘要入库(harvest 桥):omp 压缩产出 → 本成员 episodic-session 记忆
+      recordSessionMemory: async (input) => {
+        const saved = await memory.recordSessionCompaction(input)
+        this.buses.get(channelId)?.notifyMemory({ agentId: agent.id, scope: 'private', title: `会话压缩摘要(${input.summary.length}字)`, dedupKey: saved.dedupKey })
+      },
       // 团队成员管理(仅 lead;manager 内二次校验角色,工具面与决策面共用)
       createTeamMember: input => this.createTeamMember(channelId, agent.id, input),
       updateTeamMember: (agentId, patch) => this.updateTeamMember(channelId, agent.id, agentId, patch),
@@ -2349,6 +2466,200 @@ export class AgentChannelManager {
     return message
   }
 
+  /**
+   * 跨 Channel 点对点通信(仅 lead):把消息直投目标 channel 的 lead mailbox。
+   * 沿用既有 mailbox/route 机制(投递/唤醒/消费/回执全复用),仅新增跨 channel 路由:
+   *  - 权限:发送方必须是本 channel 启用成员中的 lead(worker/系统拒绝);
+   *  - 同主约束:两个 channel 必须属于同一 owner(用户级隔离不破);
+   *  - 守卫通行:x-aw-cross-channel 标记由服务端在发送时盖章(REST/工具入参不可伪造),
+   *    目标 channel 信箱守卫据此放行非成员发送方的跨 channel 消息;
+   *  - 回执:目标 lead 经同一机制回信(其 send_message_to_agent / 本方法均可,
+   *    in_reply_to 关联触发实时推送)。
+   */
+  async sendCrossChannelMessage(
+    fromChannelId: string,
+    fromAgentId: string,
+    input: { toChannelId: string, parts: Part[], requireReply?: boolean, inReplyTo?: string },
+  ): Promise<{ messageId: string, toChannelId: string, toChannelName: string, toLeadAgentId: string }> {
+    // 权限闸:发送方 = 本 channel 启用成员中的 lead
+    const sender = this.deps.repos.channelAgents.findByChannelAgent(fromChannelId, fromAgentId)
+    if (!sender || sender.enabled !== 1) {
+      throw new AppError(403, 'SCOPE_VIOLATION', '跨 Channel 通信的发送方必须是本 channel 的启用成员')
+    }
+    if (sender.role !== 'lead') {
+      throw new AppError(403, 'ROLE_FORBIDDEN', `跨 Channel 通信仅限 Leader 发起(${sender.name} 是 ${sender.role})`)
+    }
+
+    // 目标 channel 解析(id 精确 > 名字精确 > 名字唯一包含);禁自指/禁停用/须有 lead
+    const needle = input.toChannelId.trim().toLowerCase()
+    const rows = this.deps.repos.channels.list()
+    const target = rows.find(c => c.id === input.toChannelId)
+      ?? rows.find(c => c.name.toLowerCase() === needle)
+      ?? (() => {
+        const partial = rows.filter(c => c.name.toLowerCase().includes(needle))
+        return partial.length === 1 ? partial[0] : undefined
+      })()
+    if (!target || target.id === fromChannelId) {
+      throw new AppError(404, 'CHANNEL_NOT_FOUND', `目标 channel 未命中(且不可为本 channel): ${input.toChannelId}`)
+    }
+    if (target.enabled !== 1) throw new AppError(400, 'CHANNEL_DISABLED', `目标 channel 已停用: ${target.name}`)
+    if (!target.leadAgentId) throw new AppError(400, 'NO_LEAD', `目标 channel 没有 lead,无法接收跨 Channel 消息: ${target.name}`)
+
+    // 同主约束:跨团队协作不越用户边界
+    const sourceChannel = this.deps.repos.channels.findById(fromChannelId)
+    if (sourceChannel && target.ownerUserId !== null && sourceChannel.ownerUserId !== null
+      && sourceChannel.ownerUserId !== target.ownerUserId) {
+      throw new AppError(403, 'SCOPE_VIOLATION', '跨 Channel 通信仅限同一用户的 channel 之间')
+    }
+
+    // 目标 lead 必须是目标 channel 的启用成员(防悬空 leadAgentId)
+    const targetLead = this.deps.repos.channelAgents.findByChannelAgent(target.id, target.leadAgentId)
+    if (!targetLead || targetLead.enabled !== 1) {
+      throw new AppError(400, 'NO_LEAD', `目标 channel 的 lead 成员缺失或已停用: ${target.name}`)
+    }
+
+    const message = buildMessage(target.id, 'ROLE_AGENT', input.parts, {
+      'x-aw-target-agent': targetLead.id,
+      'x-aw-from-agent': fromAgentId,
+      'x-aw-from-channel': fromChannelId,
+      'x-aw-cross-channel': 'true',
+      'x-aw-from-label': `跨Channel:${sourceChannel?.name ?? fromChannelId} / ${sender.name}`,
+      ...(input.requireReply ? { 'x-aw-require-reply': 'true' } : {}),
+      // in_reply_to 关联:channel-runtime 将其视为 realtime,回复即时推送对端
+      ...(input.inReplyTo ? { 'x-aw-in-reply-to': input.inReplyTo } : {}),
+    })
+    const delivered = this.route(target.id, message)
+    if (!delivered.includes(targetLead.id)) {
+      throw new AppError(502, 'DELIVERY_FAILED', `跨 Channel 消息未能投递到「${target.name}」的 lead 信箱,请重试`)
+    }
+    return {
+      messageId: message.messageId,
+      toChannelId: target.id,
+      toChannelName: target.name,
+      toLeadAgentId: targetLead.id,
+    }
+  }
+
+  /**
+   * 跨团队可见性(仅 lead):其他 channel 的场景任务概览(同主、启用)。
+   * 协同工作流的第一步——先看别的团队在做什么/做过什么,再决定是否发信请求协作。
+   */
+  listOtherTeamsOverview(channelId: string, agentId: string): Array<{
+    channelId: string, name: string, description: string, leadName: string | null,
+    activeTasks: Array<{ id: string, title: string, state: string }>,
+    recentCompleted: Array<{ title: string }>,
+  }> {
+    this.requireMember(channelId, agentId)
+    const sender = this.deps.repos.channelAgents.findByChannelAgent(channelId, agentId)
+    if (!sender || sender.role !== 'lead') {
+      throw new AppError(403, 'ROLE_FORBIDDEN', `团队任务概览仅限 Leader(${sender?.name ?? agentId} 是 ${sender?.role ?? '非成员'})`)
+    }
+    const terminal = new Set(['COMPLETED', 'FAILED', 'CANCELED'])
+    return this.otherSameOwnerChannels(channelId).map((c) => {
+      const tasks = this.deps.repos.tasks.listByChannel(c.id)
+      const leadRow = c.leadAgentId ? this.deps.repos.channelAgents.findById(c.leadAgentId) : undefined
+      return {
+        channelId: c.id,
+        name: c.name,
+        description: c.description ?? '',
+        leadName: leadRow?.name ?? null,
+        activeTasks: tasks
+          .filter(t => !terminal.has(t.state))
+          .map(t => ({ id: t.id, title: t.title, state: t.state })),
+        recentCompleted: tasks
+          .filter(t => t.state === 'COMPLETED')
+          .slice(0, 3)
+          .map(t => ({ title: t.title })),
+      }
+    })
+  }
+
+  /**
+   * 跨团队共享记忆检索(lead/worker 皆可,只读):其他 channel 的 __team__ 公共域。
+   * 全员可见——worker 由此知道别的团队做过什么;发现相关经验/结论可直接复用,
+   * 无需跨 channel 发信;查无所得而有协作必要时,再由 lead 发起跨 channel 通信。
+   */
+  recallOtherTeamsMemory(channelId: string, agentId: string, input: { query: string, limit?: number }): Array<{
+    channelId: string, channelName: string, title: string, content: string, importance: number, createdAt: string,
+  }> {
+    this.requireMember(channelId, agentId)
+    const q = input.query.trim()
+    if (!q) return []
+    const others = this.otherSameOwnerChannels(channelId)
+    if (others.length === 0) return []
+    const matchQuery = segmentCJK(q).split(/\s+/).filter(Boolean).join(' OR ')
+    const rows = this.deps.repos.memories.searchTeamSharedAcross(
+      matchQuery,
+      others.map(c => c.id),
+      Math.min(Math.max(input.limit ?? 5, 1), 20),
+    )
+    return rows.map(r => ({
+      channelId: r.channelId,
+      channelName: others.find(c => c.id === r.channelId)?.name ?? r.channelId,
+      title: r.title,
+      content: unsegmentCJK(r.content).slice(0, 400),
+      importance: r.importance,
+      createdAt: r.createdAt,
+    }))
+  }
+
+  /** 同主且启用的其他 channel 列表(跨团队可见性的作用域) */
+  private otherSameOwnerChannels(channelId: string): ChannelRow[] {
+    const self = this.deps.repos.channels.findById(channelId)
+    return this.deps.repos.channels.list().filter(c =>
+      c.id !== channelId
+      && c.enabled === 1
+      && (self?.ownerUserId == null || c.ownerUserId == null || c.ownerUserId === self.ownerUserId))
+  }
+
+  /**
+   * 工具桥(协作工具族):按 agentId 定位 channel 并调用其 workspace 方法。
+   * 与工业工具桥同一服务层,供 REST 直调(测试/运维/控制台)。
+   */
+  invokeAgentWorkspaceTool(agentId: string, tool: string, args: Record<string, unknown> = {}): { text: string, isError?: boolean } {
+    const row = this.deps.repos.channelAgents.findById(agentId)
+    if (!row || row.enabled !== 1) throw new AppError(404, 'NOT_FOUND', `agent 不存在或已停用: ${agentId}`)
+    const ws = this.ensureAgentRuntime(row.channelId, agentId)?.workspace
+    if (!ws) throw new AppError(400, 'AGENT_NOT_READY', `agent 运行时未装配: ${agentId}`)
+    switch (tool) {
+      case 'list_other_teams': {
+        const teams = ws.listOtherTeams()
+        if (teams.length === 0) return { text: '当前没有其他团队(或均未启用)。' }
+        const text = teams.map((t) => {
+          const active = t.activeTasks.length > 0
+            ? t.activeTasks.map(x => `「${x.title}」(${x.state})`).join('、')
+            : '无进行中任务'
+          const done = t.recentCompleted.length > 0
+            ? t.recentCompleted.map(x => `「${x.title}」`).join('、')
+            : '无'
+          return `- ${t.name}${t.description ? `(${t.description})` : ''} · lead=${t.leadName ?? '?'}\n  进行中: ${active}\n  近期完成: ${done}\n  channel_id: ${t.channelId}`
+        }).join('\n')
+        return { text: `其他团队概览:\n${text}\n(需要协作时用 send_cross_channel_message 向对应团队 Leader 发信;查具体知识用 search_other_teams_memory)` }
+      }
+      case 'search_other_teams_memory': {
+        const query = String(args.query ?? '')
+        if (!query) return { text: '缺少 query', isError: true }
+        const rows = ws.searchOtherTeamsMemory({ query, limit: Number(args.limit ?? 5) })
+        if (rows.length === 0) return { text: `其他团队的共享记忆中没有命中「${query}」的内容。` }
+        const text = rows.map(r =>
+          `- [${r.channelName}] 「${r.title}」(${r.createdAt.slice(0, 10)}): ${r.content}`).join('\n')
+        return { text: `其他团队共享记忆命中 ${rows.length} 条:\n${text}` }
+      }
+      case 'send_cross_channel_message': {
+        if (!args.to_channel_id || !args.message) return { text: '缺少 to_channel_id 或 message', isError: true }
+        const r = ws.sendCrossChannelMessage({
+          toChannelId: String(args.to_channel_id),
+          parts: [{ text: String(args.message) }],
+          requireReply: args.require_reply === true,
+          inReplyTo: typeof args.in_reply_to === 'string' ? args.in_reply_to : undefined,
+        })
+        return { text: `跨 Channel 消息已送达「${r.toChannelName}」的 Leader(channel=${r.toChannelId}, lead=${r.toLeadAgentId.slice(0, 8)}),消息 id=${r.messageId.slice(0, 8)}。` }
+      }
+      default:
+        throw new AppError(400, 'BAD_REQUEST', `工具桥不支持该协作工具: ${tool}`)
+    }
+  }
+
   /** 阻塞长轮询(poll_messages):到信即时唤醒,250ms 兜底重查 */
   async waitMailbox(channelId: string, callerAgentId: string, limit: number, waitMs: number): Promise<A2AMessage[]> {
     this.requireMember(channelId, callerAgentId)