dsh-plugin-xujie-memory 0.5.0 → 0.7.0

package/lib/controller.js

@@ -0,0 +1,307 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
+    return __privateGet(this, extra);
+  }, set [name](x) {
+    return __privateSet(this, extra, x);
+  } }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
+      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
+    if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null) __typeError("Object expected");
+    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// vendor/dsh-protocol/index.ts
+import { Context, Service } from "@deepseek-ai/cordis";
+
+// vendor/dsh-protocol/remote-error.ts
+var RemoteError = class extends Error {
+  /**
+   * @param code - stable failure code declared in {@link RemoteErrorDetailsMap}.
+   * @param message - human diagnostic carried across the wire.
+   * @param details - structured payload typed by the code.
+   * @param options - standard Error options (`cause` survives in-process only).
+   */
+  constructor(code, message, details, options) {
+    super(message, options);
+    this.code = code;
+    this.details = details;
+    this.name = "RemoteError";
+  }
+  /** Structural marker: cross-realm/bundle identification never uses instanceof. */
+  isDSHRemoteError = true;
+};
+
+// vendor/dsh-protocol/owned-value.ts
+var TYPERT_OWNED_VALUE = Symbol.for("dsh.typert.owned-value");
+
+// vendor/dsh-protocol/index.ts
+var TYPERT_REMOTE_SEGMENT_PATTERN = /^[A-Za-z0-9_$.-]+$/;
+function isTypertRemoteSegment(value) {
+  return value !== "." && value !== ".." && TYPERT_REMOTE_SEGMENT_PATTERN.test(value);
+}
+var REMOTE_METHOD_DESCRIPTOR = "@deepseek-ai/dsh-typert-protocol/remote-methods";
+function bindTypertRemote(service, serviceKey, options = {}) {
+  validateName("service key", serviceKey);
+  const namespace = options.namespace ?? serviceKey;
+  validateName("namespace", namespace);
+  const ctx = Reflect.get(service, "ctx");
+  if (Context.is(ctx)) provideInvocationAccessor(ctx);
+  return Object.freeze({ service, serviceKey, namespace });
+}
+var TypertRemoteService = class extends Service {
+  /** Visible binding consumed by the Gateway's source-mode discovery. */
+  typertRemote;
+  /**
+   * Register the Service and bind the same key to Typert Gateway.
+   * @param ctx - owning Cordis Context.
+   * @param serviceKey - exact Cordis service key and default wire namespace.
+   * @param options - optional wire namespace.
+   */
+  constructor(ctx, serviceKey, options = {}) {
+    super(ctx, serviceKey);
+    this.typertRemote = bindTypertRemote(this, this.name, options);
+  }
+};
+function provideInvocationAccessor(ctx) {
+  if (Object.hasOwn(ctx.root.reflect.props, "invocation")) return;
+  ctx.root.accessor("invocation", { get: () => void 0 });
+}
+function Remote(methodExportOrOptions, context) {
+  if (typeof methodExportOrOptions === "string") {
+    validateName("Remote export name", methodExportOrOptions);
+    return remoteDecorator({ kind: "direct" }, { exportName: methodExportOrOptions });
+  }
+  if (typeof methodExportOrOptions === "object") {
+    return remoteDecorator({ kind: "direct" }, markerOptions(
+      methodExportOrOptions,
+      REMOTE_OPTION_KEYS,
+      'Remote options require name, mode: "stream", or resources'
+    ));
+  }
+  if (context === void 0) throw new TypeError("typert-protocol: Remote decorator context is missing");
+  addMarkerInitializer(context, { kind: "direct" });
+}
+var REMOTE_OPTION_KEYS = /* @__PURE__ */ new Set(["name", "mode", "resources"]);
+function markerOptions(options, accepted, requirement) {
+  const keys = Reflect.ownKeys(options);
+  if (keys.length === 0 || keys.some((key) => typeof key !== "string" || !accepted.has(key)) || Object.hasOwn(options, "mode") && options.mode !== "stream") {
+    throw new TypeError(`typert-protocol: ${requirement}`);
+  }
+  const { mode, name, resources } = options;
+  if (name !== void 0) validateName("Remote export name", name);
+  return {
+    ...mode === void 0 ? {} : { mode },
+    ...name === void 0 ? {} : { exportName: name },
+    ...resources === void 0 ? {} : { resources: resourceReaders(resources) }
+  };
+}
+function resourceReaders(resources) {
+  const readers = {};
+  for (const [kind, reader] of Object.entries(resources)) {
+    if (typeof reader !== "function") {
+      throw new TypeError(`typert-protocol: Remote resource reader "${kind}" must be a function`);
+    }
+    readers[kind] = reader;
+  }
+  if (Object.keys(readers).length === 0) throw new TypeError("typert-protocol: Remote resources require at least one reader");
+  return Object.freeze(readers);
+}
+function remoteDecorator(invocation, options = {}) {
+  return function(_method, context) {
+    addMarkerInitializer(context, invocation, options);
+  };
+}
+function readRemoteMethodDescriptor(prototype) {
+  const property = Object.getOwnPropertyDescriptor(prototype, REMOTE_METHOD_DESCRIPTOR);
+  if (property === void 0) return void 0;
+  const descriptor = property.value;
+  if (descriptor === null || typeof descriptor !== "object") {
+    throw new TypeError("typert-protocol: Remote method descriptor must be an object");
+  }
+  const version = Reflect.get(descriptor, "version");
+  if (version !== 1) {
+    throw new TypeError(`typert-protocol: unsupported Remote method descriptor version ${String(version)}`);
+  }
+  const methods = Reflect.get(descriptor, "methods");
+  if (!Array.isArray(methods)) {
+    throw new TypeError("typert-protocol: Remote method descriptor methods must be an array");
+  }
+  return descriptor;
+}
+function addMarkerInitializer(context, invocation, options = {}) {
+  if (context.private || context.static || typeof context.name !== "string") {
+    throw new TypeError("typert-protocol: Remote decorators require a public instance method with a string name");
+  }
+  const method = context.name;
+  context.addInitializer(function() {
+    const prototype = Object.getPrototypeOf(this);
+    if (prototype === null) {
+      throw new TypeError(`typert-protocol: cannot mark Remote method "${method}" on an object without a prototype`);
+    }
+    mark(prototype, method, invocation, options);
+  });
+}
+function mark(prototype, method, invocation, { mode, exportName, resources }) {
+  const descriptor = readRemoteMethodDescriptor(prototype);
+  const marker = Object.freeze({
+    method,
+    ...exportName === void 0 || exportName === method ? {} : { exportName },
+    ...mode === void 0 ? {} : { mode },
+    invocation: Object.freeze(invocation),
+    ...resources === void 0 ? {} : { resources }
+  });
+  const current = descriptor?.methods.find((candidate) => candidate.method === method);
+  if (current !== void 0) {
+    if (current.exportName === marker.exportName && current.mode === marker.mode && current.resources === marker.resources && sameInvocation(current.invocation, invocation)) return;
+    throw new Error(`typert-protocol: Remote method "${method}" has conflicting invocation markers`);
+  }
+  Object.defineProperty(prototype, REMOTE_METHOD_DESCRIPTOR, {
+    configurable: true,
+    value: Object.freeze({
+      version: 1,
+      methods: Object.freeze([...descriptor?.methods ?? [], marker])
+    })
+  });
+}
+function sameInvocation(left, right) {
+  if (left.kind === "direct") return right.kind === "direct";
+  if (right.kind === "direct") return false;
+  return left.context === right.context;
+}
+function validateName(subject, value) {
+  if (!isTypertRemoteSegment(value)) {
+    throw new TypeError(`typert-protocol: ${subject} must contain only RPC endpoint segment characters`);
+  }
+}
+
+// src/controller.ts
+var _forget_dec, _edit_dec, _search_dec, _detail_dec, _snapshot_dec, _catalog_dec, _a, _init;
+var MemoryController = class extends (_a = TypertRemoteService, _catalog_dec = [Remote], _snapshot_dec = [Remote], _detail_dec = [Remote], _search_dec = [Remote], _edit_dec = [Remote], _forget_dec = [Remote], _a) {
+  constructor(ctx, bridge) {
+    super(ctx, "xujieMemory");
+    this.bridge = bridge;
+    __runInitializers(_init, 5, this);
+  }
+  owner() {
+    if (this.ctx.invocation?.peer.principal.kind !== "owner") {
+      throw new RemoteError("xujie-memory/owner-required", "\u53EA\u6709 DSH \u6240\u6709\u8005\u53EF\u4EE5\u7BA1\u7406\u8BB0\u5FC6\u5E93", { action: "memory/manage" });
+    }
+  }
+  async call(path, body) {
+    this.owner();
+    try {
+      return await this.bridge.request(path, body);
+    } catch (error) {
+      throw new RemoteError("xujie-memory/rejected", "\u8BB0\u5FC6\u5E93\u64CD\u4F5C\u672A\u5B8C\u6210", {
+        reason: error instanceof Error ? error.message : "kernel_unavailable"
+      });
+    }
+  }
+  async catalog() {
+    const r = await this.call("/manage/catalog", {});
+    return { scope_mode: r.scope_mode, scopes: r.scopes };
+  }
+  async snapshot(scopeId) {
+    const r = await this.call("/manage/snapshot", { scope_id: scopeId });
+    const cards = r.cards.map((c) => ({
+      account_id: c.profile.account_id,
+      display_name: c.profile.display_name ?? c.profile.account_id,
+      status: c.profile.status,
+      tags: c.tags.map((t) => ({
+        tag_id: t.tag_id,
+        kind: t.kind,
+        value: t.value,
+        source: t.source,
+        confidence: t.confidence
+      }))
+    }));
+    const { scope_id, scope_mode, nodes, edges, truncated, limit } = r;
+    const { traces, traces_erased, events, states, anchors, clarifications_open, summaries } = r.stats;
+    return {
+      scope_id,
+      scope_mode,
+      nodes,
+      edges,
+      cards,
+      truncated,
+      limit,
+      stats: { traces, traces_erased, events, states, anchors, clarifications_open, summaries }
+    };
+  }
+  async detail(scopeId, traceId) {
+    return (await this.call("/manage/detail", { scope_id: scopeId, trace_id: traceId })).trace;
+  }
+  async search(scopeId, query) {
+    const r = await this.call("/manage/search", { scope_id: scopeId, query });
+    return r.hits.map((h) => ({
+      trace_id: h.trace_id,
+      content: h.content,
+      content_hash: h.content_hash,
+      score: h.score,
+      priority: Number(h.priority ?? 0),
+      importance: Number(h.importance ?? 1),
+      anchor: Boolean(h.anchor),
+      recorded_at: h.recorded_at ?? "",
+      layer: h.layer
+    }));
+  }
+  async edit(scopeId, traceId, content, expectedHash) {
+    const r = await this.call("/manage/edit", { scope_id: scopeId, trace_id: traceId, content, expected_hash: expectedHash });
+    return {
+      changed: r.changed,
+      trace: r.trace,
+      ...r.replaced_trace_id ? { replaced_trace_id: r.replaced_trace_id, pending: r.pending } : {}
+    };
+  }
+  async forget(scopeId, traceId, expectedHash) {
+    const r = await this.call("/manage/forget", { scope_id: scopeId, trace_id: traceId, expected_hash: expectedHash });
+    return { trace_id: r.trace_id, erased: r.erased, already_erased: r.already_erased, state_keys: r.state_keys };
+  }
+};
+_init = __decoratorStart(_a);
+__decorateElement(_init, 1, "catalog", _catalog_dec, MemoryController);
+__decorateElement(_init, 1, "snapshot", _snapshot_dec, MemoryController);
+__decorateElement(_init, 1, "detail", _detail_dec, MemoryController);
+__decorateElement(_init, 1, "search", _search_dec, MemoryController);
+__decorateElement(_init, 1, "edit", _edit_dec, MemoryController);
+__decorateElement(_init, 1, "forget", _forget_dec, MemoryController);
+__decoratorMetadata(_init, MemoryController);
+export {
+  MemoryController
+};

package/lib/index.js

@@ -21,6 +21,8 @@
  *   其余类型、以及 source.kind 不是 user 的 user/message → 跳过
  */
 
+import { MemoryController } from './controller.js'
+export { MemoryController } from './controller.js'
 import { spawn } from 'node:child_process'
 import { appendFileSync, existsSync, mkdirSync, openSync, closeSync, readFileSync, statSync, renameSync } from 'node:fs'
 import { homedir } from 'node:os'
@@ -34,6 +36,7 @@ const PACKAGE_ROOT = dirname(dirname(fileURLToPath(import.meta.url)))
 const BUNDLED_KERNEL = join(PACKAGE_ROOT, 'python')
 const DEFAULT_ENDPOINT = 'http://127.0.0.1:8765'
 const TURN_TIMEOUT_MS = 4000
+const TOOL_TIMEOUT_MS = 5000
 const HEALTH_TIMEOUT_MS = 800
 const READY_WAIT_MS = 10000
 const WATCHDOG_MS = 5000
@@ -42,14 +45,13 @@ const MAX_TEXT_CHARS = 2000
 const MAX_SESSIONS = 32
 const LOG_ROTATE_BYTES = 2 * 1024 * 1024
 
-/** 每个会话最近一轮的材料。 */
-const contexts = new Map()
-/** 每个会话正在进行的 /turn（串行队列的尾巴）。 */
-const pending = new Map()
-let lastContext = ''
-let shapeLogged = false
-
 export function apply(ctx, config = {}) {
+  // Per-plugin-instance caches: two profiles/databases never share material.
+  const contexts = new Map()
+  const pending = new Map()
+  const latestByUser = new Map()
+  const cacheState = { contexts, latestByUser, epoch: 0, disposed: false }
+  let shapeLogged = false
   const configured = new URL((config.endpoint || DEFAULT_ENDPOINT).replace(/\/+$/, ''))
   const host = configured.hostname || '127.0.0.1'
   const basePort = Number(configured.port || 8765)
@@ -73,6 +75,33 @@ export function apply(ctx, config = {}) {
   let endpoint = `http://${host}:${basePort}`
   let token = readToken(tokenFile)
 
+  // A single queue owns kernel operations and prompt-cache publication. UI edits,
+  // model deletions and new turns cannot race to republish stale material.
+  let operationTail = Promise.resolve()
+  const enqueue = (run) => {
+    const job = operationTail.catch(() => {}).then(run)
+    operationTail = job.catch(() => {})
+    return job
+  }
+  const clearMemoryCache = () => { cacheState.epoch++; contexts.clear(); latestByUser.clear() }
+  ctx.effect(() => () => { cacheState.disposed = true; clearMemoryCache() }, 'xujie-memory: instance caches')
+  ctx.inject(['typert'], (remoteCtx) => {
+    new MemoryController(remoteCtx, {
+      request: (path, body) => enqueue(async () => {
+        if (cacheState.disposed) throw new Error('memory_plugin_unloaded')
+        if (kernelReady) await kernelReady
+        const mutation = path === '/manage/edit' || path === '/manage/forget'
+        if (mutation) clearMemoryCache()
+        const resp = await fetchJson(`${endpoint}${path}`, body, 15000, token)
+        if (!resp || resp.ok !== true) {
+          throw new Error(resp?.detail ?? resp?.error ?? 'memory_kernel_unavailable')
+        }
+        if (mutation) clearMemoryCache()
+        return resp
+      }),
+    })
+  })
+
   const log = (level, message) => {
     const logger = ctx.logger
     if (logger && typeof logger[level] === 'function') logger[level](`xujie-memory: ${message}`)
@@ -236,7 +265,7 @@ export function apply(ctx, config = {}) {
       // 没有这个会话的材料（新会话第一句之前 / 宿主内部组装）：
       // user 模式下记忆本来就跨会话共享，用最近一次的材料；
       // session 模式下绝不串会话，返回空。
-      return scope === 'user' ? lastContext : ''
+      return scope === 'user' && raw ? (latestByUser.get(String(raw.userId ?? raw.account ?? 'user')) ?? '') : ''
     }
     service.section({
       name: 'xujie-memory',
@@ -254,6 +283,159 @@ export function apply(ctx, config = {}) {
     })
   })
 
+  // ------------------------------------------------------------ 工具
+  // 注入全自动，但"主动回忆"和"记错了删掉"必须给模型一只手：
+  // 只会被动接收召回结果 = 只许它看，不许它查、不许它改。
+  // 三个都是可解释的低危操作：搜（只读）、忘（软删，可审计）、看账（只读）。
+  const toolDisposers = []
+  ctx.inject(['tools'], (toolCtx) => {
+    // 宿主没给 tools 服务（老版本 / 测试替身）时静默跳过：
+    // 工具是增强，不能因为它让整块记忆插件挂不上。
+    if (typeof toolCtx?.tools?.register !== 'function') {
+      log('warn', '宿主没有 tools 服务，检索/删除工具不会注册（注入照常）')
+      return
+    }
+    const sessionOf = (exec) => exec?.agent?.session ?? exec?.session
+    const call = async (path, payload, exec) => {
+      const resp = await enqueue(async () => {
+        if (path === '/memory/forget' || path === '/memory/edit') clearMemoryCache()
+        return await fetchJson(
+          `${endpoint}${path}`,
+          { session: sessionKey(sessionOf(exec)), user: String(sessionOf(exec)?.userId ?? sessionOf(exec)?.account ?? 'user'), ...payload },
+          TOOL_TIMEOUT_MS,
+          token,
+        )
+      })
+      if (!resp || resp.ok !== true) {
+        throw new Error(`xujie-memory: ${resp?.detail ?? resp?.error ?? 'memory kernel did not respond'}`)
+      }
+      return resp
+    }
+    const text = (value) => [{ type: 'text', text: value }]
+
+    toolDisposers.push(toolCtx.tools.register({
+      name: 'memory_search',
+      description: '在用户的长期记忆里检索他说过的话（支持短词与错字模糊匹配）。只读。返回原话、trace_id 与权重点。要删除某条记忆前，先用它拿到 trace_id。',
+      parameters: {
+        type: 'object',
+        properties: {
+          query: { type: 'string', description: '要检索的内容；两个字也能搜，错一个字也能命中' },
+          limit: { type: 'number', description: '最多返回几条，默认 5（1-20）' },
+        },
+        required: ['query'],
+      },
+      output: {
+        schema: { type: 'object' },
+        render: (_args, value) => {
+          const hits = value?.hits ?? []
+          if (hits.length === 0) return text(`没有搜到与「${value?.query ?? ''}」相关的记忆。`)
+          const lines = hits.map((h) => {
+            const tags = [h.anchor ? '锚点' : '', h.importance ? `重要度 ${h.importance}` : ''].filter(Boolean)
+            return `- ${h.content}（trace_id: ${h.trace_id}${tags.length ? '，' + tags.join('，') : ''}）`
+          })
+          return text(`搜到 ${hits.length} 条：\n${lines.join('\n')}`)
+        },
+      },
+      execute: async (args, exec) => {
+        const query = String(args?.query ?? '').trim().slice(0, MAX_TEXT_CHARS)
+        if (!query) throw new Error('memory_search: query 不能为空')
+        const limit = Math.max(1, Math.min(20, Math.round(Number(args?.limit) || 5)))
+        const resp = await call('/memory/search', { query, limit }, exec)
+        return { ok: true, query: resp.query ?? query, hits: resp.hits ?? [] }
+      },
+    }))
+
+    toolDisposers.push(toolCtx.tools.register({
+      name: 'memory_forget',
+      description: '删掉一条记忆（软删：内容清空、FTS 移除、由它推出的事实一起失效并重算；库里保留 erased_at 供审计，不可恢复）。trace_id 用 memory_search 取。用户说「忘掉这条」时用。',
+      parameters: {
+        type: 'object',
+        properties: {
+          trace_id: { type: 'string', description: '要删的记忆条目 id（memory_search 返回的 trace_id）' },
+        },
+        required: ['trace_id'],
+      },
+      output: {
+        schema: { type: 'object' },
+        render: (_args, value) => {
+          if (!value?.erased) return text('删除失败：内核没有确认。')
+          const tail = value.already_erased ? '（这条之前已经删过）' : ''
+          return text(`已删除 ${value.trace_id}${tail}，连带失效 ${value.state_keys?.length ?? 0} 组状态。`)
+        },
+      },
+      execute: async (args, exec) => {
+        const traceId = String(args?.trace_id ?? '').trim()
+        if (!traceId) throw new Error('memory_forget: trace_id 不能为空')
+        const result = await call('/memory/forget', { trace_id: traceId }, exec)
+        contexts.clear()
+        latestByUser.clear()
+        return result
+      },
+    }))
+
+    toolDisposers.push(toolCtx.tools.register({
+      name: 'memory_edit',
+      description: '仅在用户明确要求纠正记忆时，替换一条原话并重算事实与画像。先用 memory_search 取得 trace_id 和 content_hash；保存成功后返回新的 trace_id。不能用来偷偷改写用户历史。',
+      parameters: {
+        type: 'object',
+        properties: {
+          trace_id: { type: 'string', description: '要纠正的原话 id' },
+          content: { type: 'string', description: '用户明确确认的新内容，最多 2000 字' },
+          expected_hash: { type: 'string', description: 'memory_search 返回的 content_hash，防止覆盖其他修改' },
+        },
+        required: ['trace_id', 'content', 'expected_hash'],
+      },
+      output: {
+        schema: { type: 'object' },
+        render: (_args, value) => text(value?.ok
+          ? `已纠正记忆，新 trace_id: ${value.trace?.trace_id}。`
+          : '纠正未完成，请重新检索后再试。'),
+      },
+      execute: async (args, exec) => {
+        const trace_id = String(args?.trace_id ?? '').trim()
+        const content = String(args?.content ?? '').trim()
+        const expected_hash = String(args?.expected_hash ?? '').trim()
+        if (!trace_id || !content || content.length > MAX_TEXT_CHARS || !expected_hash) {
+          throw new Error('memory_edit: 缺少记录、有效内容或版本 hash')
+        }
+        const result = await call('/memory/edit', { trace_id, content, expected_hash }, exec)
+        clearMemoryCache()
+        return result
+      },
+    }))
+
+    toolDisposers.push(toolCtx.tools.register({
+      name: 'memory_status',
+      description: '看记忆库现状：原话条数、已删条数、锚点数、未确认项，以及内核健康信息。用户问「你记得我什么」「记忆正常吗」时用。只读。',
+      parameters: { type: 'object', properties: {} },
+      output: {
+        schema: { type: 'object' },
+        render: (_args, value) => {
+          const kernel = value?.kernel ?? {}
+          const head = `记忆库：原话 ${value?.traces ?? 0} 条（已删 ${value?.traces_erased ?? 0} 条），`
+            + `状态 ${value?.states ?? 0} 条，锚点 ${value?.anchors ?? 0} 个，`
+            + `未确认 ${value?.clarifications_open ?? 0} 个。`
+          const tail = kernel.ok
+            ? `内核：pid ${kernel.pid}，版本 ${kernel.version}，scope=${kernel.scope_mode}，库 ${kernel.db}`
+            : '内核：当前连不上（注入会降级为「这一轮没有记忆」）。'
+          return text(`${head}\n${tail}`)
+        },
+      },
+      execute: async (_args, exec) => {
+        const [stats, kernel] = await Promise.all([
+          call('/memory/stats', {}, exec),
+          health(endpoint, token),
+        ])
+        return { ...stats, kernel }
+      },
+    }))
+  })
+  ctx.effect(() => () => {
+    for (const dispose of toolDisposers.splice(0)) {
+      try { dispose?.() } catch { /* 已释放 */ }
+    }
+  }, 'xujie-memory: tools')
+
   // ------------------------------------------------------------ 写记忆
   ctx.on('session/event', (session, event) => {
     const type = event?.type
@@ -281,10 +463,7 @@ export function apply(ctx, config = {}) {
 
     const key = sessionKey(session)
     // 同一会话串行：上一句没写完，下一句排在后面，保证顺序。
-    const prev = pending.get(key) || Promise.resolve()
-    const job = prev
-      .catch(() => {})
-      .then(() => remember(() => endpoint, () => token, session, text, maxAskedTotal, log))
+    const job = enqueue(() => remember(() => endpoint, () => token, session, text, maxAskedTotal, log, cacheState))
       .finally(() => { if (pending.get(key) === job) pending.delete(key) })
     pending.set(key, job)
   })
@@ -412,7 +591,10 @@ function sessionKey(session) {
 
 // ---------------------------------------------------------------- 请求
 
-async function remember(getEndpoint, getToken, session, text, maxAskedTotal, log) {
+async function remember(getEndpoint, getToken, session, text, maxAskedTotal, log, cache) {
+  if (cache.disposed) return
+  const { contexts, latestByUser } = cache
+  const epoch = cache.epoch
   const key = sessionKey(session)
   const body = {
     session: key,
@@ -430,6 +612,7 @@ async function remember(getEndpoint, getToken, session, text, maxAskedTotal, log
     try {
       const resp = await fetchJson(`${getEndpoint()}/turn`, body, TURN_TIMEOUT_MS, getToken())
       if (resp?.ok && typeof resp.context === 'string') {
+        if (cache.disposed || cache.epoch !== epoch) return
         contexts.delete(key)
         contexts.set(key, resp.context)          // 重新插入 = 移到最新
         while (contexts.size > MAX_SESSIONS) {
@@ -437,7 +620,10 @@ async function remember(getEndpoint, getToken, session, text, maxAskedTotal, log
           if (oldest === undefined) break
           contexts.delete(oldest)
         }
-        lastContext = resp.context
+        const user = String(session?.userId ?? session?.account ?? 'user')
+        latestByUser.delete(user)
+        latestByUser.set(user, resp.context)
+        while (latestByUser.size > MAX_SESSIONS) latestByUser.delete(latestByUser.keys().next().value)
         log('debug',
           `记下 ${resp.outcomes?.length ?? 0} 条判定，材料 ${resp.context.length} 字，会话 ${key}`)
         return

package/lib/typert.host.d.ts

@@ -0,0 +1,3 @@
+/* Generated by @deepseek-ai/dsh-typert-generator from FaceModel — do not edit. */
+
+export declare const TYPERT: unknown