agentworkshop 0.5.5 → 0.5.6

package/server/services/workshop/agents/agent-interface.ts

@@ -5,7 +5,7 @@
  * 权威契约见 docs/superpowers/plans/2026-08-13-agent-workshop-multi-agent.md 核心契约块。
  */
 import type { A2AMessage, A2AArtifact, A2AError, ChannelMail, Part } from '../types/a2a'
-import type { WorkspaceTask, AgentTaskQueueView, AgentStatusView } from '../types/task'
+import type { WorkspaceTask, AgentTaskQueueView, AgentStatusView, AgentContextStats } from '../types/task'
 
 /** Agent 元信息:Channel 内成员声明(hook harness 类型与配置) */
 export interface AgentInfo {
@@ -59,6 +59,16 @@ export interface AgentWorkspace {
   cancelTask(taskId: string): Promise<WorkspaceTask>
   /** 点对点发消息给同事 */
   sendMessage(input: { toAgentId: string, parts: Part[], metadata?: Record<string, unknown> }): Promise<A2AMessage>
+  /**
+   * (仅 lead)跨 Channel 点对点:直投目标 channel 的 lead mailbox(沿用 mailbox/route 机制)。
+   * 权限:发送方必须是本 channel 的 lead;目标 channel 与本 channel 须同主且启用、有 lead。
+   */
+  sendCrossChannelMessage(input: { toChannelId: string, parts: Part[], requireReply?: boolean, inReplyTo?: string }): Promise<{
+    messageId: string
+    toChannelId: string
+    toChannelName: string
+    toLeadAgentId: string
+  }>
   /**
    * 拒绝指派给自己的任务(能力/范畴不匹配):任务置 FAILED(调度器改派他人),
    * 并向派发方(任务创建者,缺省 channel lead)回执拒绝原因。
@@ -91,6 +101,11 @@ export interface AgentWorkspace {
    * scope='private' → 本人记忆库;scope='shared' → Channel 公共记忆域(全员可检索)。
    */
   saveMemory(input: { title: string, content: string, importance?: number, scope: 'private' | 'shared', dedupKey?: string }): Promise<{ scope: 'private' | 'shared', dedupKey: string }>
+  /**
+   * 会话压缩摘要入库(harvest 桥;omp compaction 产出的会话摘要 → 本成员持久记忆)。
+   * 平台 70% 主动压缩与 omp 原生 auto-compaction 双路统一经此落库(episodic-session)。
+   */
+  recordSessionMemory?(input: { summary: string, tokensBefore?: number, tokensAfter?: number, reason?: string }): Promise<void>
   /** 订阅同事产出 */
   subscribe(input: { agentIds?: string[] }): Promise<void>
   /** (lead)在本 channel 内新建团队成员(worker):按需建模板并克隆为独立实例 */
@@ -216,4 +231,14 @@ export interface AgentInterface {
    * 探到进程已死时收敛为已退出,让在途回合归位、下一回合自动重生子进程。
    */
   reconcileProcess?(): void
+  /**
+   * 可选:harness 上下文用量快照(omp;被动缓存值,无探测 RPC)。
+   * 进程内 harness(mock/claude)不实现 → getStatus 不透出 context 字段。
+   */
+  getContextStats?(): AgentContextStats | null
+  /**
+   * 可选:回合落定后的后台钩子(post-settle 上下文压缩检查)。
+   * 实现方自守卫(仅回合间隙发起、异常不抛出);调用方 AgentRuntime 在信箱无排队消息时调用。
+   */
+  onTurnSettled?(): Promise<void>
 }

package/server/services/workshop/agents/mock-agent.ts

@@ -352,6 +352,18 @@ export class MockAgentImpl implements AgentInterface {
       const text = request.message.parts
         .map(p => ('text' in p ? p.text : 'data' in p ? JSON.stringify(p.data) : ''))
         .join('\n')
+      // 跨 Channel 来信:发送方不是本 channel 成员,回复须走 lead 级跨 Channel 发送(回源 channel)
+      const crossChannel = request.message.metadata?.['x-aw-cross-channel'] === 'true'
+      const fromChannel = request.message.metadata?.['x-aw-from-channel']
+      if (crossChannel && typeof fromChannel === 'string') {
+        await ctx.workspace.sendCrossChannelMessage({
+          toChannelId: fromChannel,
+          parts: [{ text: `mock 跨Channel回复(${ctx.agentId}):已处理「${text.slice(0, 60)}」。执行结果:完成;你所需的内容已包含在本回复中。本回复不需要再响应。` }],
+          inReplyTo: request.message.messageId,
+        })
+        yield { kind: 'done' }
+        return
+      }
       await ctx.workspace.sendMessage({
         toAgentId: fromId,
         parts: [{ text: `mock 回复(${ctx.agentId}):已处理「${text.slice(0, 60)}」。执行结果:完成;你所需的内容已包含在本回复中。本回复不需要再响应。` }],

package/server/services/workshop/agents/omp-agent.ts

@@ -28,10 +28,11 @@ import type {
   SupervisionSnapshot,
 } from './agent-interface'
 import type { A2AArtifact, A2AMessage, Part } from '../types/a2a'
-import type { WorkspaceTask } from '../types/task'
+import type { AgentContextStats, WorkspaceTask } from '../types/task'
 import {
   OmpRpcClient,
   type AgentSessionEvent,
+  type CompactionResult,
   type RpcHostToolDefinition,
   type HostToolCallRequest,
 } from './adapters/omp-rpc-client'
@@ -52,6 +53,7 @@ import {
 import { toolDaqQuery, toolDcwControl, toolDcwJudge, toolDcwJournal, toolDcwRollback, toolMyIndustrialNodes } from './industrial-tools'
 import { buildIndustrialContext, industrialLoopGuide } from './industrial-context'
 import { extractTaskMode } from '../runtime/execution-mode'
+import { envNum } from '../runtime/memory'
 
 const log = createLogger('workshop.omp')
 
@@ -217,6 +219,194 @@ export class OmpRpcAgentImpl implements AgentInterface {
    */
   private replyContext: { fromId: string, messageId: string } | null = null
 
+  // ===== 上下文治理(70% 无中断压缩环)=====
+  /** 压缩进行中(平台 gate 与 omp 原生压缩共用互斥位) */
+  private compacting = false
+  private lastCompactAt = 0
+  /** omp 不支持 compact 命令(旧版)→ 永久停用平台压缩;原生 auto-compaction 兜底,harvest 照常 */
+  private compactLegacy = false
+  /** 模型上下文窗口(get_state/get_session_stats 探测;null = 未知,percent 不可算) */
+  private contextWindow: number | null = null
+  private sessionId: string | null = null
+  /** harvest 双路去重(compact 响应与 compaction_end 事件可能双达) */
+  private lastHarvestKey = ''
+  private lastHarvestAt = 0
+
+  /** 总开关(AW_OMP_COMPACT_ENABLED=0 显式关闭;envNum 拒 0,故单独解析) */
+  private compactEnabled(): boolean {
+    const v = Number(process.env.AW_OMP_COMPACT_ENABLED)
+    return !(Number.isFinite(v) && v === 0)
+  }
+
+  private compactThreshold(): number {
+    return Math.min(1, envNum('AW_OMP_COMPACT_THRESHOLD', 0.7))
+  }
+
+  private compactMinIntervalMs(): number {
+    return envNum('AW_OMP_COMPACT_MIN_INTERVAL_MS', 300_000)
+  }
+
+  private compactWaitMs(): number {
+    return envNum('AW_OMP_COMPACT_WAIT_MS', 120_000)
+  }
+
+  /** 被动上下文用量快照(无探测 RPC;getStatus 透出用) */
+  getContextStats(): AgentContextStats | null {
+    const usage = this.client?.getContextUsage() ?? null
+    const window = this.contextWindow ?? usage?.contextWindow ?? null
+    if (!usage && window === null) return null
+    const usedTokens = usage?.tokens ?? 0
+    return {
+      usedTokens,
+      contextWindow: window,
+      percent: window && window > 0 ? Math.min(1, usedTokens / window) : null,
+      compacting: this.compacting,
+    }
+  }
+
+  /**
+   * 上下文用量探测:get_session_stats 权威值;不可用退化为被动 usage + 已探测窗口。
+   * percent 归一化到 0-1(omp 可能返回 0-100)。
+   */
+  private async probeUsage(client: OmpRpcClient): Promise<{ tokens: number, contextWindow: number | null, percent: number | null } | null> {
+    try {
+      const resp = await client.send({ type: 'get_session_stats' })
+      const cu = ((resp.data ?? {}) as Record<string, unknown>).contextUsage as
+        | { tokens?: number, contextWindow?: number, percent?: number }
+        | undefined
+      if (cu && typeof cu.tokens === 'number' && cu.tokens > 0) {
+        if (typeof cu.contextWindow === 'number' && cu.contextWindow > 0) {
+          this.contextWindow = cu.contextWindow
+          client.setContextWindow(cu.contextWindow)
+        }
+        const window = this.contextWindow ?? cu.contextWindow ?? null
+        const rawPercent = typeof cu.percent === 'number' ? (cu.percent > 1 ? cu.percent / 100 : cu.percent) : null
+        const percent = rawPercent ?? (window && window > 0 ? Math.min(1, cu.tokens / window) : null)
+        return { tokens: cu.tokens, contextWindow: window, percent }
+      }
+    }
+    catch { /* get_session_stats 不可用 → 被动跟踪 */ }
+    return client.getContextUsage()
+  }
+
+  /**
+   * 上下文治理门控:三条 prompt 路径(worker/peer/supervise)在回合间隙统一调用;
+   * post-settle 经 onTurnSettled 复用同一守卫。任何失败路径都放行——压缩晚一轮
+   * 永远好过中断作业。三重防线:仅回合间隙发起 → get_state 复查 isStreaming/
+   * isCompacting → compacting 互斥位 + 最小间隔防振荡。
+   */
+  private async contextGate(reason: string): Promise<void> {
+    if (!this.compactEnabled() || this.compactLegacy || this.compacting) return
+    const client = this.client
+    if (!client || !client.alive) return
+    try {
+      const usage = await this.probeUsage(client)
+      if (!usage || usage.percent === null || usage.percent < this.compactThreshold()) return
+      if (Date.now() - this.lastCompactAt < this.compactMinIntervalMs()) return
+      // 回合间隙硬校验:流式中/压缩中绝不发起(不中断执行的硬约束)
+      const st = await client.send({ type: 'get_state' })
+      const s = (st.data ?? {}) as Record<string, unknown>
+      if (s.isStreaming === true || s.isCompacting === true) return
+      if (typeof s.sessionId === 'string' && s.sessionId) this.sessionId = s.sessionId
+      this.compacting = true
+      this.lastCompactAt = Date.now()
+      try {
+        const result = await this.runCompaction(client)
+        if (result?.summary) {
+          await this.harvestCompaction(
+            result.summary,
+            result.tokensBefore,
+            result.tokensAfter ?? result.estimatedTokensAfter,
+            reason,
+          )
+        }
+      }
+      finally {
+        this.compacting = false
+      }
+    }
+    catch (err) {
+      const msg = err instanceof Error ? err.message : String(err)
+      if (/compact/i.test(msg) && /unknown|unsupported|invalid|无效|未知|不支持/i.test(msg)) this.compactLegacy = true
+      log.warn(`[OmpRpcAgent:${this.selfAgentId}] contextGate(${reason}) 失败,放行: ${msg}`)
+    }
+  }
+
+  /**
+   * 发起 compact 并等待 compaction_end(响应内含 result 则立即收口;
+   * 超时放行——压缩在 harness 内后台继续,isCompacting 防后续双发)。
+   */
+  private runCompaction(client: OmpRpcClient): Promise<CompactionResult | null> {
+    return new Promise<CompactionResult | null>((resolve) => {
+      let settled = false
+      const finish = (r: CompactionResult | null): void => {
+        if (settled) return
+        settled = true
+        off()
+        clearTimeout(timer)
+        resolve(r)
+      }
+      const off = client.onEvent((event) => {
+        if (event.type === 'compaction_end') {
+          finish((event as { result?: CompactionResult }).result ?? null)
+        }
+        else if (event.type === '__process_exit__') {
+          finish(null)
+        }
+      })
+      const timer = setTimeout(() => {
+        log.warn(`[OmpRpcAgent:${this.selfAgentId}] compact 等待超时(${this.compactWaitMs()}ms)→ 放行(压缩后台继续)`)
+        finish(null)
+      }, this.compactWaitMs())
+      void client.send({ type: 'compact', customInstructions: this.compactionHints() })
+        .then((resp) => {
+          const result = (resp.data as { result?: CompactionResult } | undefined)?.result
+          if (result?.summary) finish(result)
+          // 响应无 result:等 compaction_end 事件(协议权威语义)
+        })
+        .catch((err) => {
+          const msg = err instanceof Error ? err.message : String(err)
+          if (/compact/i.test(msg)) this.compactLegacy = true
+          log.warn(`[OmpRpcAgent:${this.selfAgentId}] compact 发起失败: ${msg}`)
+          finish(null)
+        })
+    })
+  }
+
+  /** 压缩摘要指令(外置 prompts;缺失时省略,omp 用默认策略) */
+  private compactionHints(): string | undefined {
+    try {
+      return renderPrompt('compaction-hints')
+    }
+    catch {
+      return undefined
+    }
+  }
+
+  /**
+   * 压缩摘要 harvest(三路统一:平台主动 compact / omp 阈值自动 / overflow):
+   * 经 workspace.recordSessionMemory 落库为本人 episodic-session 记忆。
+   * 双路去重:同摘要 60s 内只入库一次。
+   */
+  private async harvestCompaction(summary: string, tokensBefore?: number, tokensAfter?: number, reason?: string): Promise<void> {
+    const key = summary.slice(0, 120)
+    if (key === this.lastHarvestKey && Date.now() - this.lastHarvestAt < 60_000) return
+    this.lastHarvestKey = key
+    this.lastHarvestAt = Date.now()
+    try {
+      await this.workspace?.recordSessionMemory?.({ summary, tokensBefore, tokensAfter, reason })
+      log.info(`[OmpRpcAgent:${this.selfAgentId}] 压缩摘要已入记忆(${summary.length} 字,reason=${reason ?? 'auto'})`)
+    }
+    catch (err) {
+      log.warn(`[OmpRpcAgent:${this.selfAgentId}] 压缩摘要入库失败(不影响会话):`, err instanceof Error ? err.message : err)
+    }
+  }
+
+  /** 回合落定钩子(AgentRuntime 在信箱空时调用):后台压缩检查,自守卫不抛错 */
+  async onTurnSettled(): Promise<void> {
+    await this.contextGate('post-settle')
+  }
+
   constructor(config: Record<string, unknown> = {}) {
     this.config = config as OmpAgentConfig
     // factory 注入的 agent 身份(无需等待 init())
@@ -449,6 +639,9 @@ export class OmpRpcAgentImpl implements AgentInterface {
     if (!this.client) return []
     if (this.supervising) return [] // 上一轮 supervise 未收口:跳过本拍(节流即正确)
 
+    // 上下文门控(≥70% 先压缩再调度;回合间隙发起,失败放行)
+    await this.contextGate('supervise')
+
     const prompt = await this.buildSupervisePrompt(snapshot, ctx.memory)
     // 150s 上界:supervise 持 lead.execLock 期间信箱消费停顿(更久会拖垮 worker 回执处理);
     // supervise 是一次真实 LLM 回合:omp 冷启动(插件/MCP 加载 30~90s)+ 慢 provider
@@ -589,9 +782,14 @@ export class OmpRpcAgentImpl implements AgentInterface {
     const msgText = partsToText(msg.parts)
     const requireReply = msg.metadata?.['x-aw-require-reply'] === 'true'
     const isReply = typeof msg.metadata?.['x-aw-in-reply-to'] === 'string'
+    // 跨 Channel 来信:发送方是其他 channel 的 lead,回执必须走 send_cross_channel_message
+    const crossChannel = msg.metadata?.['x-aw-cross-channel'] === 'true'
+    const fromChannel = typeof msg.metadata?.['x-aw-from-channel'] === 'string'
+      ? String(msg.metadata['x-aw-from-channel'])
+      : ''
     // 回执自动关联仅对真实 agent 发送者生效(人类无 agentId 可回投;
     // 对人类的回复经事件流/时间线可见)
-    this.replyContext = requireReply && request.fromAgentId
+    this.replyContext = requireReply && request.fromAgentId && !crossChannel
       ? { fromId: request.fromAgentId, messageId: msg.messageId }
       : null
 
@@ -599,11 +797,13 @@ export class OmpRpcAgentImpl implements AgentInterface {
       ? `You are "${this.agentName}", the LEAD coordinator of a multi-agent team (Channel: ${this.channelId}). A team member sent you a direct message.`
       : `You are "${this.agentName}", a worker agent in a multi-agent team (Channel: ${this.channelId}).`
 
-    // 消息应答指令:必复/可选两态 + lead 名册提示(全部外置 prompts/)
-    const respondBlock = renderPrompt(requireReply ? 'peer-reply-required' : 'peer-reply-optional', {
-      fromId,
-      messageId: msg.messageId,
-    })
+    // 消息应答指令:必复/可选/跨 Channel 三态 + lead 名册提示(全部外置 prompts/)
+    const respondBlock = crossChannel
+      ? renderPrompt('peer-reply-cross-channel', { fromId, messageId: msg.messageId, fromChannel })
+      : renderPrompt(requireReply ? 'peer-reply-required' : 'peer-reply-optional', {
+          fromId,
+          messageId: msg.messageId,
+        })
     const peerBody = renderPrompt('peer-message', {
       fromId,
       messageId: msg.messageId,
@@ -647,6 +847,8 @@ export class OmpRpcAgentImpl implements AgentInterface {
     if (!client) {
       throw new Error('omp 客户端未就绪')
     }
+    // 上下文门控(≥70% 时在回合间隙先压缩再发 prompt;等待有界,失败放行)
+    await this.contextGate('pre-prompt')
     const queue: AgentEvent[] = []
     let resolveWait: (() => void) | null = null
     let isDone = false
@@ -929,6 +1131,29 @@ export class OmpRpcAgentImpl implements AgentInterface {
           error: { code: 'OMP_PROCESS_EXIT', message: 'omp 子进程意外退出' },
         }]
 
+      // ===== 上下文治理事件(回合中到达的原生阈值/overflow 压缩;不污染事件流)=====
+      case 'compaction_start':
+        this.compacting = true
+        return []
+
+      case 'compaction_end': {
+        this.compacting = false
+        const result = (event as { result?: CompactionResult }).result
+        if (result?.summary) {
+          void this.harvestCompaction(
+            result.summary,
+            result.tokensBefore,
+            result.tokensAfter ?? result.estimatedTokensAfter,
+            (event as { reason?: string }).reason,
+          )
+        }
+        return []
+      }
+
+      // 回合完全落定(无自动重试/压缩重试/排队续跑):后续压缩检查由 AgentRuntime 驱动
+      case 'agent_settled':
+        return []
+
       case '__error__':
         return [{
           kind: 'error',
@@ -1176,7 +1401,12 @@ export class OmpRpcAgentImpl implements AgentInterface {
       // 只配其一时也显式发送,避免 respawn 后静默回落默认模型)
       if (this.config.provider || this.config.model) {
         try {
-          await client.send({ type: 'set_model', provider: this.config.provider, modelId: this.config.model })
+          // 未配置一侧保持 undefined(JSON 序列化丢键)→ omp 以当前已设值补全
+          await client.send({
+            type: 'set_model',
+            provider: this.config.provider as string,
+            modelId: this.config.model as string,
+          })
         }
         catch {
           // 模型设置失败不致命(用 omp 默认模型)
@@ -1187,11 +1417,30 @@ export class OmpRpcAgentImpl implements AgentInterface {
       client.onHostToolCall(req => this.handleHostTool(req))
       await client.send({ type: 'set_host_tools', tools: hostToolsForRole(this.agentRole) })
 
+      // 上下文治理探测(feature-detect 一次;失败退化被动 usage 跟踪)+ 原生压缩兜底保持开启
+      void this.probeContext(client).catch(() => {})
+      void client.send({ type: 'set_auto_compaction', enabled: true }).catch(() => {})
+
       this.client = client
       this.hostToolsRegistered = true
     }
   }
 
+  /** 上下文状态探测:get_state 取 contextWindow/sessionId(一次;失败仅损失 percent 精度) */
+  private async probeContext(client: OmpRpcClient): Promise<void> {
+    try {
+      const resp = await client.send({ type: 'get_state' })
+      const data = (resp.data ?? {}) as Record<string, unknown>
+      const model = data.model as { contextWindow?: number } | undefined
+      if (typeof model?.contextWindow === 'number' && model.contextWindow > 0) {
+        this.contextWindow = model.contextWindow
+        client.setContextWindow(model.contextWindow)
+      }
+      if (typeof data.sessionId === 'string' && data.sessionId) this.sessionId = data.sessionId
+    }
+    catch { /* get_state 不可用:仅被动 usage */ }
+  }
+
   // ===== 内部:host tool handler(workspace 桥接) =====
 
   private async handleHostTool(req: HostToolCallRequest): Promise<{ text: string, isError?: boolean }> {
@@ -1309,6 +1558,26 @@ export class OmpRpcAgentImpl implements AgentInterface {
           return { text: `消息 ${sent.messageId.slice(0, 8)}… 已发送给 ${toAgentId}(priority=${priority})${triggerNote}` }
         }
 
+        case 'send_cross_channel_message': {
+          // 跨 Channel 通信(仅 lead):直投目标 channel 的 lead mailbox
+          const toChannelId = req.arguments.to_channel_id as string
+          const message = req.arguments.message as string
+          if (!toChannelId || !message) return { text: '缺少 to_channel_id 或 message', isError: true }
+          try {
+            const r = await ws.sendCrossChannelMessage({
+              toChannelId,
+              parts: [{ text: message }],
+              requireReply: req.arguments.require_reply === true,
+              inReplyTo: req.arguments.in_reply_to as string | undefined,
+            })
+            const note = req.arguments.require_reply === true ? '(已要求对方 Leader 回复)' : ''
+            return { text: `跨 Channel 消息 ${r.messageId.slice(0, 8)}… 已送达 channel「${r.toChannelName}」的 Leader(${r.toLeadAgentId.slice(0, 8)}…)${note}。对方将按你的信息需求处理;其回复会经 mailbox 到达你这里。` }
+          }
+          catch (err) {
+            return { text: `跨 Channel 发送失败: ${err instanceof Error ? err.message : String(err)}(仅 Leader 可跨 Channel 通信)`, isError: true }
+          }
+        }
+
         case 'refuse_task': {
           const taskId = req.arguments.task_id as string
           const reason = req.arguments.reason as string

package/server/services/workshop/db/database.ts

@@ -549,12 +549,27 @@ export interface TeamMemberRow {
   createdAt: string
 }
 
+/**
+ * 记忆类别:episodic-task/episodic-peer/episodic-session/episodic-team-task(harvest 族,
+ * 参与过期+淘汰)/ semantic(知识,免衰减)/ brief/chronicle/reflection(策展层,
+ * 免向量化免维护)。TEXT 自由列(无 CHECK),联合类型仅约束调用面。
+ */
+export type MemoryKind
+  = | 'episodic-task'
+    | 'episodic-peer'
+    | 'episodic-session'
+    | 'episodic-team-task'
+    | 'semantic'
+    | 'brief'
+    | 'chronicle'
+    | 'reflection'
+
 /** agent_memories 表行(content 为已 CJK 切分存储文本;agentId='__team__' 为团队共享行) */
 export interface MemoryRow {
   id: string
   channelId: string
   agentId: string
-  kind: 'episodic-task' | 'episodic-peer' | 'semantic'
+  kind: MemoryKind
   title: string
   content: string
   importance: number

package/server/services/workshop/db/memory.repo.ts

@@ -6,7 +6,7 @@
  */
 import { randomUUID } from 'node:crypto'
 import type { DatabaseSync, StatementSync } from 'node:sqlite'
-import type { MemoryRow } from './database'
+import type { MemoryKind, MemoryRow } from './database'
 
 /** 团队共享记忆域 sentinel(单 channel 内全员可读) */
 export const TEAM_AGENT_ID = '__team__'
@@ -14,7 +14,8 @@ export const TEAM_AGENT_ID = '__team__'
 export interface MemoryUpsertInput {
   channelId: string
   agentId: string
-  kind: 'episodic-task' | 'episodic-peer' | 'semantic'
+  /** 语义见 database.ts MemoryKind(harvest 族参与维护;semantic 知识;策展层双免) */
+  kind: MemoryKind
   title: string
   /** title 的 CJK 切分副本(FTS 索引用;调用方经 AgentMemory.segmentCJK 处理,V8) */
   titleFts: string
@@ -75,6 +76,15 @@ export function createMemoryRepo(db: DatabaseSync) {
   const agentIdsStmt = db.prepare(
     `SELECT DISTINCT agent_id FROM agent_memories WHERE agent_id != ?`,
   )
+  const channelIdsStmt = db.prepare(
+    `SELECT DISTINCT channel_id AS channelId FROM agent_memories`,
+  )
+  const getByIdStmt = db.prepare(
+    `SELECT id, channel_id AS channelId, agent_id AS agentId, kind, title, content,
+       importance, task_id AS taskId, access_count AS accessCount,
+       last_accessed_at AS lastAccessedAt, created_at AS createdAt
+     FROM agent_memories WHERE id = ?`,
+  )
   // ===== 向量方法(P1;vec0 分区表 + mem_rowid 辅助列映射)=====
   // 已实测事实:
   // - vec0 分区表不支持显式 rowid 插入 → 以 +mem_rowid 辅助列映射 agent_memories.rowid
@@ -188,6 +198,16 @@ export function createMemoryRepo(db: DatabaseSync) {
       return (agentIdsStmt.all(TEAM_AGENT_ID) as Array<{ agent_id: string }>).map(r => r.agent_id)
     },
 
+    /** 有记忆的 channel 清单(team 域行按 channel 迭代维护用) */
+    listChannelIds(): string[] {
+      return (channelIdsStmt.all() as Array<{ channelId: string }>).map(r => r.channelId)
+    },
+
+    /** 按 id 取单行(brief 置顶注入等直取场景;不存在返回 null) */
+    getById(id: string): MemoryRow | null {
+      return (getByIdStmt.get(id) as MemoryRow | undefined) ?? null
+    },
+
     // ===== vec:延迟建表(vecInit)/ 刷新写入(vecSet)/ 删除(vecDelete)/ 分区 kNN(vecSearch)=====
 
     /** 首次调用按 dims 建表;同 dims 幂等 true;不同 dims 拒绝 false(禁用向量,绝不重建) */

package/server/services/workshop/prompts/loader.ts

@@ -18,7 +18,7 @@
 import { copyFileSync, existsSync, readdirSync, readFileSync, statSync, mkdirSync } from 'node:fs'
 import { dirname, join, resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
-import { awHome, findLocalConfigRoot } from '../../../../shared/config/home.mjs'
+import { awHome, findLocalConfigRoot } from '@/shared/config/home.mjs'
 import { AppError } from '../../../utils/errors'
 
 /** 模板变量值(字符串化注入) */
@@ -40,7 +40,8 @@ function packagedPromptsDir(): string | null {
   return existsSync(candidate) ? candidate : null
 }
 
-/** 首次解析时把包内初始 prompts 播种到 ~/.AgentWorkShop/prompts(只补缺,不覆盖) */
+/** 首次/每次解析把包内初始 prompts 补种到 ~/.AgentWorkShop/prompts(逐文件只补缺,不覆盖)。
+ *  每次解析都执行:包升级新增的提示词文件能进入已存在的 Home(用户已定制文件不回写)。 */
 function seedHomePrompts(homePrompts: string): void {
   const src = packagedPromptsDir()
   if (!src || resolve(src) === resolve(homePrompts)) return
@@ -55,7 +56,7 @@ function seedHomePrompts(homePrompts: string): void {
     }
     catch { /* 单文件失败不阻断播种 */ }
   }
-  if (seeded > 0) console.log(`[prompts] 已向 ${homePrompts} 播种 ${seeded} 个初始提示词文件`)
+  if (seeded > 0) console.log(`[prompts] 已向 ${homePrompts} 补种 ${seeded} 个提示词文件`)
 }
 
 /**
@@ -72,9 +73,9 @@ export function promptsDir(): string {
     return base
   }
 
-  // ~/.AgentWorkShop/prompts:默认兜底目录,首次解析自动播种初始文件(只补缺,不覆盖用户定制)
+  // ~/.AgentWorkShop/prompts:默认兜底目录,解析时自动补种初始文件(只补缺,不覆盖用户定制)
   const homePrompts = join(awHome(process.env), 'prompts')
-  if (!existsSync(homePrompts)) seedHomePrompts(homePrompts)
+  seedHomePrompts(homePrompts)
 
   // ② 项目内 ./.AgentWorkShop/prompts 真实存在 → 项目内优先
   const localConfigRoot = findLocalConfigRoot(process.cwd())