@furongjun1999/dsh-memory 0.2.9 → 0.3.0

package/lib/tools.d.ts

@@ -17,7 +17,16 @@ export declare const CORE_TOOLS: readonly ["remember", "recall", "search", "time
 export declare const BRAIN_TOOLS: readonly ["remember", "recall", "search", "timeline", "session_note", "session_recall", "compact_context", "think", "relate", "reason", "predict_routes", "self_check", "gap_trend", "cognition", "cognition_report", "emotional_bias", "self_reliability", "action_log", "preflight", "recursive_reflect", "blindspots", "learn", "induce", "distill", "flywheel_report", "transfer_test", "calibrate", "ingest_text", "ingest_file", "ingest_url", "web_search", "step", "lifecycle_state", "longterm_snapshot", "promote_memories", "service_info"];
 /** tools 配置：'core' | 'brain' | 'all' | 显式名称数组。 */
 export type ToolSelection = 'core' | 'brain' | 'all' | string[];
-/** 按配置筛选工具名。 */
+/** 按工具名判定并发安全（只读查询 true；写操作 false） */
+export declare function isToolConcurrencySafe(name: string): boolean;
+/**
+ * P1 完善（GPT 审查·tools:all 自动扩权）：即使 selection='all' 也排除的宿主级
+ * 风险工具——此前后端新增工具即自动暴露给 Agent（动态扩权无 denylist）。
+ * 排除原则：宿主命令执行/权限终裁/外部设备/自主生命周期控制/角色卡写入。
+ * 显式名称数组（显式配置）不受此名单限制（配置者已明确选择）。
+ */
+export declare const RISK_TOOLS: Set<string>;
+/** 按配置筛选工具名（'all' 时排除 RISK_TOOLS 宿主级危险工具）。 */
 export declare function selectTools(all: string[], selection: ToolSelection): string[];
 /** 把 MCP JSON Schema 的属性表转换为 ParameterSchemaSpec。 */
 export declare function schemaToParameters(inputSchema: Record<string, unknown> | undefined): ParameterSchemaSpec;

package/lib/tools.js

@@ -49,10 +49,44 @@ export const BRAIN_TOOLS = [
     // 服务
     'service_info',
 ];
-/** 按配置筛选工具名。 */
+/** P1 修复（GPT 审查）：只读/无副作用工具才允许并发——写操作（记忆/关系/
+ * 生命周期/摄取/学习）标 false，防止 DSH 并行调用导致 SQLite 写入竞争、
+ * 状态顺序错乱、关系边重复等。 */
+const READ_TOOLS = new Set([
+    'recall', 'search', 'timeline', 'think', 'reason', 'predict_routes',
+    'self_check', 'service_info', 'session_recall', 'gap_trend', 'transfer_test',
+    'cognition_report', 'self_reliability', 'emotional_bias', 'flywheel_report',
+    'distill', 'insight_report', 'prediction_stats', 'blindspots', 'pattern_separation',
+]);
+/** 按工具名判定并发安全（只读查询 true；写操作 false） */
+export function isToolConcurrencySafe(name) {
+    return READ_TOOLS.has(name);
+}
+/**
+ * P1 完善（GPT 审查·tools:all 自动扩权）：即使 selection='all' 也排除的宿主级
+ * 风险工具——此前后端新增工具即自动暴露给 Agent（动态扩权无 denylist）。
+ * 排除原则：宿主命令执行/权限终裁/外部设备/自主生命周期控制/角色卡写入。
+ * 显式名称数组（显式配置）不受此名单限制（配置者已明确选择）。
+ */
+export const RISK_TOOLS = new Set([
+    'run_command', // 宿主命令执行（安全边界：不由 Agent 动态调用）
+    'designer_decide', // 设计者裁决（fail-closed 权限，绝不由 Agent 调用）
+    'device_call', // 外部设备统一调用（屏幕/进程/音频/浏览器）
+    'see', // 视觉感知（身体工具）
+    'world3d', // 时空 3D 重建（身体工具）
+    'vprim', // 视觉原语（身体工具）
+    'visual_check', // 视觉面检查（身体工具）
+    'start_lifecycle', // 启动自主生命周期循环
+    'stop_lifecycle', // 中断生命周期循环
+    'web_ingest_search', // 外部搜索摄取（网络调用 + 写知识层）
+    'role_create', // 角色卡创建（写角色数据）
+    'role_import', // 角色导入（写角色数据）
+    'role_block', // 角色扮演注入块组装
+]);
+/** 按配置筛选工具名（'all' 时排除 RISK_TOOLS 宿主级危险工具）。 */
 export function selectTools(all, selection) {
     if (selection === 'all')
-        return all;
+        return all.filter((name) => !RISK_TOOLS.has(name));
     const allowed = new Set(selection === 'core' ? CORE_TOOLS
         : selection === 'brain' ? BRAIN_TOOLS
             : selection);
@@ -107,7 +141,11 @@ function toValueSpec(raw) {
         }
         case 'object': {
             const props = schemaToParameters(node);
-            return { type: 'object', properties: props, additionalProperties: true, ...annotations };
+            // P1 修复（GPT 审查）：尊重后端 additionalProperties 声明（false 保留），
+            // 不再无条件 true——此前后端写 false 也会被覆盖成 true，DSH 侧认为
+            // 参数合法但后端拒绝。
+            const additional = node['additionalProperties'] === false ? false : true;
+            return { type: 'object', properties: props, additionalProperties: additional, ...annotations };
         }
         default:
             return { type: 'json', ...annotations };
@@ -142,9 +180,16 @@ export async function registerLingshuTools(ctx, bridge, opts) {
                     },
                 },
                 timeoutMs: 120_000,
-                isConcurrencySafe: () => true,
-                async execute(args) {
-                    const result = await bridge.callTool(tool.name, args);
+                // P1 修复（GPT 审查）：按工具分类——只读查询可并发，写操作串行
+                isConcurrencySafe: () => isToolConcurrencySafe(tool.name),
+                // P1 修复（GPT 审查）：接收 exec.signal（用户取消/上层超时）——
+                // 此前完全忽略取消，取消后写操作（remember/relate/ingest 等）仍可能产生副作用
+                async execute(args, exec) {
+                    if (exec.signal.aborted)
+                        throw new Error(`灵枢 ${tool.name} 已取消`);
+                    const result = await bridge.callTool(tool.name, args, exec.signal);
+                    if (exec.signal.aborted)
+                        throw new Error(`灵枢 ${tool.name} 已取消`);
                     if (result.isError) {
                         throw new Error(extractText(result.content) || `灵枢 ${tool.name} 执行失败`);
                     }

package/package.json

@@ -1,6 +1,6 @@
-{
+{
   "name": "@furongjun1999/dsh-memory",
-  "version": "0.2.9",
+  "version": "0.3.0",
   "description": "灵枢（Lingshu·líng shū）DeepSeek Harness 插件：完整大脑——长期记忆/知识飞轮/自我认知/递归反思接入 DSH，对话自动沉淀进记忆库",
   "type": "module",
   "main": "lib/index.js",
@@ -13,6 +13,7 @@
   },
   "files": [
     "lib",
+    "src",
     "README.md",
     "cordis.yml.example",
     "cordis.patch.yml",
@@ -51,6 +52,7 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "test": "npm run build && node --import tsx --test \"test/*.test.ts\"",
+    "prepare": "npm run build",
     "prepublishOnly": "npm run build && npm test"
   },
   "repository": {
@@ -58,7 +60,7 @@
     "url": "https://github.com/FuRongJun-1999/dsh-memory.git"
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=22.19"
   },
   "dsh": {
     "bundle": {

package/src/bridge.ts

@@ -0,0 +1,296 @@
+/**
+ * 灵枢 MCP stdio 桥：管理灵枢（AEIS）Python 子进程的生命周期，
+ * 通过逐行 JSON-RPC 完成握手、工具发现与调用。
+ *
+ * 与官方 @deepseek-ai/dsh-mcp-client 不同，本桥零运行时依赖（不引入
+ * @modelcontextprotocol/sdk），直接实现灵枢 server 使用的 2024-11-05 协议
+ * 子集——与灵枢库 D-005「核心零外部依赖」的工程哲学一致。
+ */
+
+import { spawn, type ChildProcess } from 'node:child_process'
+import { createInterface } from 'node:readline'
+import { mkdirSync } from 'node:fs'
+import { dirname } from 'node:path'
+
+/** 灵枢 MCP server 暴露的原始工具（tools/list 结果项）。 */
+export interface McpTool {
+  name: string
+  description: string
+  inputSchema?: Record<string, unknown>
+}
+
+/** 一次 tools/call 的标准化结果。 */
+export interface McpCallResult {
+  content: Array<{ type: string; text?: string; [key: string]: unknown }>
+  isError: boolean
+}
+
+/** 启动灵枢子进程的配置。 */
+export interface BridgeOptions {
+  /** Python 可执行文件（或 aeis-mcp console script），默认 python。 */
+  python: string
+  /** 传给 python 的参数，默认 ['-m', 'aeis.mcp.server']。 */
+  args: string[]
+  /** 追加到子进程的环境变量（AEIS_DB / AEIS_IDENTITY / 密钥等）。 */
+  env: Record<string, string>
+  /** 子进程工作目录。 */
+  cwd?: string
+  /** 单次工具调用超时（毫秒），默认 60s。 */
+  timeoutMs: number
+  /** 断线重连的最大间隔（毫秒），默认 30s。 */
+  maxRetryDelayMs: number
+}
+
+interface PendingCall {
+  resolve: (value: unknown) => void
+  reject: (reason: Error) => void
+  timer: NodeJS.Timeout
+}
+
+export class LingshuBridge {
+  private readonly options: BridgeOptions
+  private proc: ChildProcess | null = null
+  private rl: ReturnType<typeof createInterface> | null = null
+  private nextId = 1
+  private pending = new Map<number, PendingCall>()
+  private started = false
+  private disposed = false
+  private retryDelayMs = 1000
+  private retryTimer: NodeJS.Timeout | null = null
+  private bootQueue: Array<(ok: boolean) => void> = []
+  private readyState: 'pending' | 'ok' | 'failed' = 'pending'
+
+  constructor(options: BridgeOptions) {
+    this.options = options
+  }
+
+  /**
+   * 启动灵枢进程并完成握手（initialize → notifications/initialized）。
+   * 进程崩溃后自动指数退避重启，并重新握手。
+   */
+  start(): void {
+    if (this.started || this.disposed) return
+    this.started = true
+    this.spawnAndHandshake()
+  }
+
+  /** 拉取灵枢的全部工具清单（每次实时请求，不缓存）。 */
+  async listTools(): Promise<McpTool[]> {
+    const result = await this.request('tools/list', {})
+    const tools = result as { tools?: McpTool[] }
+    return tools.tools ?? []
+  }
+
+  /** 调用灵枢的一个工具，返回标准化 MCP 结果。 */
+  async callTool(name: string, args: Record<string, unknown>,
+                 signal?: AbortSignal): Promise<McpCallResult> {
+    const result = await this.request('tools/call', { name, arguments: args }, signal)
+    return result as McpCallResult
+  }
+
+  /** 关闭进程并释放资源（写 stdin EOF 优雅退出，超时兜底 kill）。 */
+  dispose(): void {
+    this.disposed = true
+    if (this.retryTimer) clearTimeout(this.retryTimer)
+    const proc = this.proc
+    if (!proc || proc.exitCode !== null) return
+    try {
+      proc.stdin?.end()
+    } catch {
+      /* 已关闭则忽略 */
+    }
+    const killer = setTimeout(() => proc.kill(), 2000)
+    killer.unref()
+  }
+
+  /** 进程是否存活。 */
+  get alive(): boolean {
+    return this.proc !== null && this.proc.exitCode === null
+  }
+
+  /** 桥是否已握手就绪（工具注册用；防止轮询访问 private readyState）。 */
+  isReady(): boolean {
+    return this.readyState === 'ok'
+  }
+
+  /** 等待握手完成（用于 apply 阶段同步就绪）。 */
+  waitReady(): Promise<boolean> {
+    if (this.readyState === 'ok') return Promise.resolve(true)
+    if (this.readyState === 'failed') return Promise.resolve(false)
+    return new Promise((resolve) => this.bootQueue.push(resolve))
+  }
+
+  private spawnAndHandshake(): void {
+    if (this.disposed) return
+    const { python, args, env, cwd } = this.options
+    const childEnv = { ...process.env, ...env }
+    // 确保 DB 目录存在（灵枢 server 也会防御性创建，这里提前为可读错误）
+    const dbPath = env['AEIS_DB']
+    if (dbPath && dbPath !== ':memory:') {
+      try {
+        mkdirSync(dirname(dbPath), { recursive: true })
+      } catch {
+        /* 目录创建失败由灵枢侧兜底 */
+      }
+    }
+    const proc = spawn(python, args, {
+      env: childEnv,
+      cwd,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      windowsHide: true,
+    })
+    this.proc = proc
+    this.rl = createInterface({ input: proc.stdout!, crlfDelay: Infinity })
+
+    proc.stderr?.on('data', (chunk: Buffer) => {
+      // stderr 透传日志（灵枢把日志写在 stderr，避免污染协议流）
+      const text = chunk.toString('utf8').trim()
+      if (text) console.error(`[lingshu-bridge] ${text}`)
+    })
+
+    this.rl.on('line', (line: string) => {
+      if (!line.trim()) return
+      let msg: Record<string, unknown>
+      try {
+        msg = JSON.parse(line)
+      } catch {
+        console.error(`[lingshu-bridge] 非 JSON 输出: ${line.slice(0, 200)}`)
+        return
+      }
+      if (typeof msg['id'] === 'number') {
+        this.settle(msg['id'] as number, msg)
+      }
+    })
+
+    proc.on('error', (err) => {
+      // 进程无法启动（python 不存在等）——响亮失败
+      if (!this.disposed) {
+        console.error(`[lingshu-bridge] 灵枢进程启动失败: ${err.message}`)
+        this.readyState = 'failed'
+        this.flushBootQueue(false)
+        this.scheduleRetry()
+      }
+    })
+
+    proc.on('exit', (code, signal) => {
+      console.error(`[lingshu-bridge] 灵枢进程退出 code=${code} signal=${signal}`)
+      this.rl?.close()
+      this.rl = null
+      this.rejectAll(new Error(`灵枢进程已退出（code=${code} signal=${signal ?? 'none'}）`))
+      if (!this.disposed) {
+        // 有挂起请求的失败是异常的；仅启动失败的等待者得到 false
+        this.readyState = 'failed'
+        this.flushBootQueue(false)
+        this.scheduleRetry()
+      }
+    })
+
+    void this.handshake()
+  }
+
+  private async handshake(): Promise<void> {
+    try {
+      await this.request('initialize', {
+        protocolVersion: '2024-11-05',
+        capabilities: {},
+        clientInfo: { name: 'dsh-memory', version: '0.1.0' },
+      })
+      // 初始化通知：无 id、无响应
+      this.writeRaw({ jsonrpc: '2.0', method: 'notifications/initialized' })
+      this.retryDelayMs = 1000
+      this.readyState = 'ok'
+      this.flushBootQueue(true)
+    } catch (err) {
+      if (!this.disposed) {
+        console.error(`[lingshu-bridge] 握手失败: ${(err as Error).message}`)
+        this.readyState = 'failed'
+        this.flushBootQueue(false)
+        this.scheduleRetry()
+      }
+    }
+  }
+
+  private scheduleRetry(): void {
+    if (this.disposed || this.retryTimer) return
+    const delay = this.retryDelayMs
+    this.retryDelayMs = Math.min(this.retryDelayMs * 2, this.options.maxRetryDelayMs)
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = null
+      if (!this.disposed) this.spawnAndHandshake()
+    }, delay)
+    this.retryTimer.unref()
+  }
+
+  private writeRaw(msg: Record<string, unknown>): void {
+    const proc = this.proc
+    if (!proc || !proc.stdin?.writable) {
+      throw new Error('灵枢进程不可写')
+    }
+    proc.stdin.write(JSON.stringify(msg) + '\n')
+  }
+
+  private request(method: string, params: Record<string, unknown>,
+                  signal?: AbortSignal): Promise<unknown> {
+    const id = this.nextId++
+    const timeout = this.options.timeoutMs
+    // P0 修复（GPT 审查）：定时器直接调 settle——settle 内部会 delete + clearTimeout
+    // 并 reject。此前先 pending.delete(id) 再 settle()，settle 找不到 entry 直接
+    // return，Promise 永不 resolve/reject（超时逻辑完全失效，子进程挂死时插件永久挂住）。
+    const timer = setTimeout(() => {
+      this.settle(id, {
+        error: { code: -32000, message: `灵枢调用超时（${timeout}ms）：${method}` },
+      })
+    }, timeout)
+    if (signal?.aborted) {
+      clearTimeout(timer)
+      return Promise.reject(new Error(`已取消：${method}`))
+    }
+    const onAbort = (): void => {
+      this.settle(id, { error: { code: -32800, message: `已取消：${method}` } })
+    }
+    signal?.addEventListener('abort', onAbort, { once: true })
+    const promise = new Promise<unknown>((resolve, reject) => {
+      this.pending.set(id, { resolve, reject, timer })
+    })
+    // settle 后移除 abort 监听，避免内存积累
+    promise.finally(() => {
+      signal?.removeEventListener('abort', onAbort)
+    }).catch(() => { /* finally 链的 catch 防未处理拒绝 */ })
+    try {
+      this.writeRaw({ jsonrpc: '2.0', id, method, params })
+    } catch (err) {
+      clearTimeout(timer)
+      this.pending.delete(id)
+      signal?.removeEventListener('abort', onAbort)
+      return Promise.reject(err)
+    }
+    return promise
+  }
+
+  private settle(id: number, msg: Record<string, unknown>): void {
+    const entry = this.pending.get(id)
+    if (!entry) return
+    this.pending.delete(id)
+    clearTimeout(entry.timer)
+    if (msg['error']) {
+      const err = msg['error'] as { message?: string; code?: number }
+      entry.reject(new Error(`灵枢错误 ${err.code ?? ''}: ${err.message ?? 'unknown'}`))
+    } else {
+      entry.resolve(msg['result'])
+    }
+  }
+
+  private rejectAll(reason: Error): void {
+    for (const [, entry] of this.pending) {
+      clearTimeout(entry.timer)
+      entry.reject(reason)
+    }
+    this.pending.clear()
+  }
+
+  private flushBootQueue(ok: boolean): void {
+    const queue = this.bootQueue
+    this.bootQueue = []
+    for (const cb of queue) cb(ok)
+  }
+}

package/src/hooks.ts

@@ -0,0 +1,138 @@
+/**
+ * 自动记忆钩子：把 DSH 的会话事件（经统一的 session/event 分发）沉淀进灵枢。
+ *
+ * 与 DSH 的 session-persistence 插件（保存会话日志）不同，这里是"语义沉淀"：
+ * 用户消息写入灵枢知识层（带去重与重要性），agent 回复与工具结果可选开启。
+ * 只记忆真实用户消息（source.kind === 'user'），过滤插件注入的噪音。
+ *
+ * P1 完善（GPT 审查·自动记忆只写不读）：新增 autoRecall——通过
+ * system-prompt/assemble 事件（waterfall，异步允许）在每次模型请求组装
+ * system prompt 时自动注入灵枢最近记忆（timeline），让记忆"自动可用"
+ * 而不只依赖 Agent 主动调用 recall/think 工具。失败静默（不影响请求）。
+ */
+
+import '@deepseek-ai/dsh-session'
+import '@deepseek-ai/dsh-system-prompt'
+import type { Context } from '@deepseek-ai/cordis'
+import type { SessionEvent } from '@deepseek-ai/dsh-session'
+import type { ContentBlock } from '@deepseek-ai/dsh-llm'
+import type { LingshuBridge } from './bridge.js'
+
+/** 自动记忆开关。 */
+export interface MemoryHooksOptions {
+  /** 用户消息 → remember（默认 true）。 */
+  userMessage: boolean
+  /** agent 回复 → remember（默认 false，防噪音）。 */
+  assistantMessage: boolean
+  /** 工具结果 → remember（默认 false，噪音大）。 */
+  toolResult: boolean
+  /** 写入记忆的重要性（0~1），默认 0.6。 */
+  importance: number
+  /** 自动召回注入：模型请求前自动注入灵枢最近记忆（默认 true，失败静默）。 */
+  autoRecall: boolean
+  /** 自动召回条数（默认 4）。 */
+  autoRecallLimit: number
+  /** 自动记忆脱敏：写入前过滤敏感信息（密钥/密码/令牌/身份证/手机号，默认 true）。 */
+  desensitize: boolean
+}
+
+/** 从 ContentBlock[] 提取纯文本。 */
+function extractText(blocks: ContentBlock[]): string {
+  const parts: string[] = []
+  for (const block of blocks) {
+    if (block && typeof block === 'object' && block.type === 'text' && typeof block.text === 'string') {
+      parts.push(block.text)
+    }
+  }
+  return parts.join('\n').trim()
+}
+
+/**
+ * 敏感信息模式（GPT 审查·自动记忆脱敏）：写入记忆库前过滤凭据/个人标识。
+ * 命中 → 替换为 [已过滤:类别]（保留对话主体）；过滤后只剩占位符/空白 → 整条跳过。
+ * 纯内容过滤，不涉及身份认证——开源场景下的隐私保护。
+ */
+const SENSITIVE_PATTERNS: Array<{ re: RegExp; label: string }> = [
+  { re: /sk-[A-Za-z0-9_-]{8,}/g, label: 'API密钥' },
+  { re: /\b(?:api[_-]?key|apikey|access[_-]?token)\b\s*[:=]\s*[^\s,，。;；]+/gi, label: 'API密钥' },
+  { re: /\b(?:password|passwd|pwd)\b\s*[:=]\s*[^\s,，。;；]+/gi, label: '密码' },
+  { re: /Bearer\s+[A-Za-z0-9._~+/=-]{8,}/gi, label: '令牌' },
+  // 中文密码：值限定非中文连续串（凭据特征），避免误伤「密码是重要的安全概念」
+  { re: /密码\s*[:：是]\s*[A-Za-z0-9_@#$%^&*!.-]{4,}/g, label: '密码' },
+  { re: /\b\d{17}[\dXx]\b/g, label: '身份证号' },
+  { re: /\b1[3-9]\d{9}\b/g, label: '手机号' },
+]
+
+/** 脱敏：替换敏感片段；返回 null 表示整条都是敏感内容（应跳过写入）。 */
+export function desensitize(text: string): string | null {
+  let out = text
+  for (const { re, label } of SENSITIVE_PATTERNS) {
+    out = out.replace(re, `[已过滤:${label}]`)
+  }
+  // 过滤后只剩占位符/空白 → 纯凭据消息，不写（或全部被替换）
+  const residue = out.replace(/\[已过滤:[^\]]+\]/g, '').trim()
+  if (!residue) return null
+  return out
+}
+
+/** 安装自动记忆钩子（effect 作用域内，随插件卸载自动移除）。 */
+export function installMemoryHooks(ctx: Context, bridge: LingshuBridge, opts: MemoryHooksOptions): void {
+  const memorize = (tool: string, args: Record<string, unknown>): void => {
+    void bridge
+      .callTool(tool, args)
+      .catch((err: Error) => ctx.logger.warn(`dsh-memory: ${tool} 自动记忆失败: ${err.message}`))
+  }
+
+  // P1 完善（GPT 审查·自动记忆脱敏）：写入前过滤敏感信息（默认开启）。
+  // 命中敏感模式 → 替换为 [已过滤:类别]；纯凭据消息 → 跳过写入（不落库）。
+  const sanitize = (text: string): string | null => {
+    if (!opts.desensitize) return text
+    return desensitize(text)
+  }
+
+  // P1 完善（自动 recall 注入）：每次模型请求组装 system prompt 时，注入灵枢最近记忆。
+  // 用 system-prompt/assemble 事件（waterfall）而非 llm/stream——后者请求 deep-frozen 不可改写。
+  if (opts.autoRecall) {
+    const recallLimit = Math.max(1, Math.min(10, opts.autoRecallLimit || 4))
+    ctx.on('system-prompt/assemble', async (assembly, _ctx, next) => {
+      try {
+        // 异步取最近记忆（失败静默——不阻塞模型请求）
+        const r = await bridge.callTool('timeline', { limit: recallLimit })
+        const text = extractText(r.content as unknown as ContentBlock[])
+        if (text) {
+          assembly.contexts.push({
+            name: 'lingshu:auto-recall',
+            text: `【灵枢最近记忆】\n${text.slice(0, 600)}`,
+          })
+        }
+      }
+      catch { /* 静默：召回失败不影响请求 */ }
+      return next()
+    })
+  }
+
+  ctx.on('session/event', (_session, event: SessionEvent) => {
+    if (event.type === 'user/message' && opts.userMessage) {
+      // 只记真实用户输入（kind='user'），跳过插件注入/系统上下文
+      if (event.data.source?.kind !== 'user') return
+      const text = extractText(event.data.content)
+      if (!text) return
+      const safe = sanitize(text)  // 脱敏：纯凭据消息 → null → 跳过写入
+      if (safe === null) return
+      memorize('remember', { content: safe, importance: opts.importance, tags: ['dsh', 'user'] })
+    } else if (event.type === 'assistant/message' && opts.assistantMessage) {
+      const text = extractText(event.data.message.content)
+      if (!text) return
+      const safe = sanitize(text)
+      if (safe === null) return
+      memorize('remember', { content: safe, importance: opts.importance * 0.8, tags: ['dsh', 'assistant'] })
+    } else if (event.type === 'tool/result' && opts.toolResult) {
+      if (event.data.error) return
+      const text = extractText(event.data.message.content)
+      if (!text) return
+      const safe = sanitize(text)
+      if (safe === null) return
+      memorize('remember', { content: safe, importance: opts.importance * 0.6, tags: ['dsh', 'tool'] })
+    }
+  })
+}