dsh-plugin-tlmemory 0.1.0

package/dist/index.js

@@ -0,0 +1,1647 @@
+// ../../node_modules/.pnpm/cosmokit@1.8.1/node_modules/cosmokit/lib/index.mjs
+function isNullable(value) {
+  return value === null || value === void 0;
+}
+function isPlainObject(data) {
+  return data && typeof data === "object" && !Array.isArray(data);
+}
+function filterKeys(object, filter) {
+  return Object.fromEntries(Object.entries(object).filter(([key, value]) => filter(key, value)));
+}
+function mapValues(object, transform) {
+  return Object.fromEntries(Object.entries(object).map(([key, value]) => [key, transform(value, key)]));
+}
+function pick(source, keys, forced) {
+  if (!keys) return { ...source };
+  const result = {};
+  for (const key of keys) {
+    if (forced || source[key] !== void 0) result[key] = source[key];
+  }
+  return result;
+}
+function is(type, value) {
+  if (arguments.length === 1) return (value2) => is(type, value2);
+  return type in globalThis && value instanceof globalThis[type] || Object.prototype.toString.call(value).slice(8, -1) === type;
+}
+function isArrayBufferLike(value) {
+  return is("ArrayBuffer", value) || is("SharedArrayBuffer", value);
+}
+function isArrayBufferSource(value) {
+  return isArrayBufferLike(value) || ArrayBuffer.isView(value);
+}
+var Binary;
+((Binary2) => {
+  Binary2.is = isArrayBufferLike;
+  Binary2.isSource = isArrayBufferSource;
+  function fromSource(source) {
+    if (ArrayBuffer.isView(source)) {
+      return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
+    } else {
+      return source;
+    }
+  }
+  Binary2.fromSource = fromSource;
+  function toBase64(source) {
+    source = fromSource(source);
+    if (typeof Buffer !== "undefined") {
+      return Buffer.from(source).toString("base64");
+    }
+    let binary = "";
+    const bytes = new Uint8Array(source);
+    for (let i = 0; i < bytes.byteLength; i++) {
+      binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+  }
+  Binary2.toBase64 = toBase64;
+  function fromBase64(source) {
+    if (typeof Buffer !== "undefined") return fromSource(Buffer.from(source, "base64"));
+    return Uint8Array.from(atob(source), (c) => c.charCodeAt(0));
+  }
+  Binary2.fromBase64 = fromBase64;
+  function toHex(source) {
+    source = fromSource(source);
+    if (typeof Buffer !== "undefined") return Buffer.from(source).toString("hex");
+    return Array.from(new Uint8Array(source), (byte) => byte.toString(16).padStart(2, "0")).join("");
+  }
+  Binary2.toHex = toHex;
+  function fromHex(source) {
+    if (typeof Buffer !== "undefined") return fromSource(Buffer.from(source, "hex"));
+    const hex = source.length % 2 === 0 ? source : source.slice(0, source.length - 1);
+    const buffer = [];
+    for (let i = 0; i < hex.length; i += 2) {
+      buffer.push(parseInt(`${hex[i]}${hex[i + 1]}`, 16));
+    }
+    return Uint8Array.from(buffer).buffer;
+  }
+  Binary2.fromHex = fromHex;
+})(Binary || (Binary = {}));
+var base64ToArrayBuffer = Binary.fromBase64;
+var arrayBufferToBase64 = Binary.toBase64;
+var hexToArrayBuffer = Binary.fromHex;
+var arrayBufferToHex = Binary.toHex;
+function clone(source, refs = /* @__PURE__ */ new Map()) {
+  if (!source || typeof source !== "object") return source;
+  if (is("Date", source)) return new Date(source.valueOf());
+  if (is("RegExp", source)) return new RegExp(source.source, source.flags);
+  if (isArrayBufferLike(source)) return source.slice(0);
+  if (ArrayBuffer.isView(source)) return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
+  const cached = refs.get(source);
+  if (cached) return cached;
+  if (Array.isArray(source)) {
+    const result2 = [];
+    refs.set(source, result2);
+    source.forEach((value, index) => {
+      result2[index] = Reflect.apply(clone, null, [value, refs]);
+    });
+    return result2;
+  }
+  const result = Object.create(Object.getPrototypeOf(source));
+  refs.set(source, result);
+  for (const key of Reflect.ownKeys(source)) {
+    const descriptor = { ...Reflect.getOwnPropertyDescriptor(source, key) };
+    if ("value" in descriptor) {
+      descriptor.value = Reflect.apply(clone, null, [descriptor.value, refs]);
+    }
+    Reflect.defineProperty(result, key, descriptor);
+  }
+  return result;
+}
+function deepEqual(a, b, strict) {
+  if (a === b) return true;
+  if (!strict && isNullable(a) && isNullable(b)) return true;
+  if (typeof a !== typeof b) return false;
+  if (typeof a !== "object") return false;
+  if (!a || !b) return false;
+  function check(test, then) {
+    return test(a) ? test(b) ? then(a, b) : false : test(b) ? false : void 0;
+  }
+  return check(Array.isArray, (a2, b2) => a2.length === b2.length && a2.every((item, index) => deepEqual(item, b2[index]))) ?? check(is("Date"), (a2, b2) => a2.valueOf() === b2.valueOf()) ?? check(is("RegExp"), (a2, b2) => a2.source === b2.source && a2.flags === b2.flags) ?? check(isArrayBufferLike, (a2, b2) => {
+    if (a2.byteLength !== b2.byteLength) return false;
+    const viewA = new Uint8Array(a2);
+    const viewB = new Uint8Array(b2);
+    for (let i = 0; i < viewA.length; i++) {
+      if (viewA[i] !== viewB[i]) return false;
+    }
+    return true;
+  }) ?? Object.keys({ ...a, ...b }).every((key) => deepEqual(a[key], b[key], strict));
+}
+var Time;
+((Time2) => {
+  Time2.millisecond = 1;
+  Time2.second = 1e3;
+  Time2.minute = Time2.second * 60;
+  Time2.hour = Time2.minute * 60;
+  Time2.day = Time2.hour * 24;
+  Time2.week = Time2.day * 7;
+  let timezoneOffset = (/* @__PURE__ */ new Date()).getTimezoneOffset();
+  function setTimezoneOffset(offset) {
+    timezoneOffset = offset;
+  }
+  Time2.setTimezoneOffset = setTimezoneOffset;
+  function getTimezoneOffset() {
+    return timezoneOffset;
+  }
+  Time2.getTimezoneOffset = getTimezoneOffset;
+  function getDateNumber(date = /* @__PURE__ */ new Date(), offset) {
+    if (typeof date === "number") date = new Date(date);
+    if (offset === void 0) offset = timezoneOffset;
+    return Math.floor((date.valueOf() / Time2.minute - offset) / 1440);
+  }
+  Time2.getDateNumber = getDateNumber;
+  function fromDateNumber(value, offset) {
+    const date = new Date(value * Time2.day);
+    if (offset === void 0) offset = timezoneOffset;
+    return new Date(+date + offset * Time2.minute);
+  }
+  Time2.fromDateNumber = fromDateNumber;
+  const numeric = /\d+(?:\.\d+)?/.source;
+  const timeRegExp = new RegExp(`^${[
+    "w(?:eek(?:s)?)?",
+    "d(?:ay(?:s)?)?",
+    "h(?:our(?:s)?)?",
+    "m(?:in(?:ute)?(?:s)?)?",
+    "s(?:ec(?:ond)?(?:s)?)?"
+  ].map((unit) => `(${numeric}${unit})?`).join("")}$`);
+  function parseTime(source) {
+    const capture = timeRegExp.exec(source);
+    if (!capture) return 0;
+    return (parseFloat(capture[1]) * Time2.week || 0) + (parseFloat(capture[2]) * Time2.day || 0) + (parseFloat(capture[3]) * Time2.hour || 0) + (parseFloat(capture[4]) * Time2.minute || 0) + (parseFloat(capture[5]) * Time2.second || 0);
+  }
+  Time2.parseTime = parseTime;
+  function parseDate(date) {
+    const parsed = parseTime(date);
+    if (parsed) {
+      date = Date.now() + parsed;
+    } else if (/^\d{1,2}(:\d{1,2}){1,2}$/.test(date)) {
+      date = `${(/* @__PURE__ */ new Date()).toLocaleDateString()}-${date}`;
+    } else if (/^\d{1,2}-\d{1,2}-\d{1,2}(:\d{1,2}){1,2}$/.test(date)) {
+      date = `${(/* @__PURE__ */ new Date()).getFullYear()}-${date}`;
+    }
+    return date ? new Date(date) : /* @__PURE__ */ new Date();
+  }
+  Time2.parseDate = parseDate;
+  function format(ms) {
+    const abs = Math.abs(ms);
+    if (abs >= Time2.day - Time2.hour / 2) {
+      return Math.round(ms / Time2.day) + "d";
+    } else if (abs >= Time2.hour - Time2.minute / 2) {
+      return Math.round(ms / Time2.hour) + "h";
+    } else if (abs >= Time2.minute - Time2.second / 2) {
+      return Math.round(ms / Time2.minute) + "m";
+    } else if (abs >= Time2.second) {
+      return Math.round(ms / Time2.second) + "s";
+    }
+    return ms + "ms";
+  }
+  Time2.format = format;
+  function toDigits(source, length = 2) {
+    return source.toString().padStart(length, "0");
+  }
+  Time2.toDigits = toDigits;
+  function template(template2, time = /* @__PURE__ */ new Date()) {
+    return template2.replace("yyyy", time.getFullYear().toString()).replace("yy", time.getFullYear().toString().slice(2)).replace("MM", toDigits(time.getMonth() + 1)).replace("dd", toDigits(time.getDate())).replace("hh", toDigits(time.getHours())).replace("mm", toDigits(time.getMinutes())).replace("ss", toDigits(time.getSeconds())).replace("SSS", toDigits(time.getMilliseconds(), 3));
+  }
+  Time2.template = template;
+})(Time || (Time = {}));
+
+// ../../node_modules/.pnpm/schemastery@3.18.0/node_modules/schemastery/lib/index.mjs
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var require_index = __commonJS({
+  "src/index.ts"(exports, module) {
+    var kSchema = /* @__PURE__ */ Symbol.for("schemastery");
+    var kValidationError = /* @__PURE__ */ Symbol.for("ValidationError");
+    globalThis.__schemastery_index__ ??= 0;
+    globalThis.__schemastery_refs__ = void 0;
+    var ValidationError = class extends TypeError {
+      constructor(message, options) {
+        let prefix = "$";
+        for (const segment of options.path || []) {
+          if (typeof segment === "string") {
+            prefix += "." + segment;
+          } else if (typeof segment === "number") {
+            prefix += "[" + segment + "]";
+          } else if (typeof segment === "symbol") {
+            prefix += `[Symbol(${segment.toString()})]`;
+          }
+        }
+        if (prefix.startsWith(".")) prefix = prefix.slice(1);
+        super((prefix === "$" ? "" : `${prefix} `) + message);
+        this.options = options;
+      }
+      static {
+        __name(this, "ValidationError");
+      }
+      name = "ValidationError";
+      static is(error) {
+        return !!error?.[kValidationError];
+      }
+    };
+    Object.defineProperty(ValidationError.prototype, kValidationError, {
+      value: true
+    });
+    var Schema = /* @__PURE__ */ __name(function(options) {
+      const schema = /* @__PURE__ */ __name(function(data, options2 = {}) {
+        return Schema.resolve(data, schema, options2)[0];
+      }, "schema");
+      if (options.refs) {
+        const refs = mapValues(options.refs, (options2) => new Schema(options2));
+        const getRef = /* @__PURE__ */ __name((uid) => refs[uid], "getRef");
+        for (const key in refs) {
+          const options2 = refs[key];
+          options2.sKey = getRef(options2.sKey);
+          options2.inner = getRef(options2.inner);
+          options2.list = options2.list && options2.list.map(getRef);
+          options2.dict = options2.dict && mapValues(options2.dict, getRef);
+        }
+        return refs[options.uid];
+      }
+      Object.assign(schema, options);
+      if (typeof schema.callback === "string") {
+        try {
+          schema.callback = new Function("return " + schema.callback)();
+        } catch {
+        }
+      }
+      Object.defineProperty(schema, "uid", { value: globalThis.__schemastery_index__++ });
+      Object.setPrototypeOf(schema, Schema.prototype);
+      schema.meta ||= {};
+      schema.toString = schema.toString.bind(schema);
+      return schema;
+    }, "Schema");
+    Schema.prototype = Object.create(Function.prototype);
+    Schema.prototype[kSchema] = true;
+    Object.defineProperty(Schema.prototype, "~standard", {
+      get() {
+        return {
+          version: 1,
+          vendor: "schemastery",
+          validate: /* @__PURE__ */ __name((value) => {
+            try {
+              return { value: Schema.resolve(value, this, {})[0] };
+            } catch (error) {
+              if (ValidationError.is(error)) {
+                return { issues: [{ message: error.message, path: error.options.path }] };
+              }
+              throw error;
+            }
+          }, "validate")
+        };
+      }
+    });
+    Schema.ValidationError = ValidationError;
+    Schema.prototype.toJSON = /* @__PURE__ */ __name(function toJSON() {
+      if (globalThis.__schemastery_refs__) {
+        globalThis.__schemastery_refs__[this.uid] ??= JSON.parse(JSON.stringify({ ...this }));
+        return this.uid;
+      }
+      globalThis.__schemastery_refs__ = { [this.uid]: { ...this } };
+      globalThis.__schemastery_refs__[this.uid] = JSON.parse(JSON.stringify({ ...this }));
+      const result = { uid: this.uid, refs: globalThis.__schemastery_refs__ };
+      globalThis.__schemastery_refs__ = void 0;
+      return result;
+    }, "toJSON");
+    Schema.prototype.set = /* @__PURE__ */ __name(function set(key, value) {
+      this.dict[key] = value;
+      return this;
+    }, "set");
+    Schema.prototype.push = /* @__PURE__ */ __name(function push(value) {
+      this.list.push(value);
+      return this;
+    }, "push");
+    function mergeDesc(original, messages) {
+      const result = typeof original === "string" ? { "": original } : { ...original };
+      for (const locale in messages) {
+        const value = messages[locale];
+        if (value?.$description || value?.$desc) {
+          result[locale] = value.$description || value.$desc;
+        } else if (typeof value === "string") {
+          result[locale] = value;
+        }
+      }
+      return result;
+    }
+    __name(mergeDesc, "mergeDesc");
+    function getInner(value) {
+      return value?.$value ?? value?.$inner;
+    }
+    __name(getInner, "getInner");
+    function extractKeys(data) {
+      return filterKeys(data ?? {}, (key) => !key.startsWith("$"));
+    }
+    __name(extractKeys, "extractKeys");
+    Schema.prototype.i18n = /* @__PURE__ */ __name(function i18n(messages) {
+      const schema = Schema(this);
+      const desc = mergeDesc(schema.meta.description, messages);
+      if (Object.keys(desc).length) schema.meta.description = desc;
+      if (schema.dict) {
+        schema.dict = mapValues(schema.dict, (inner, key) => {
+          return inner.i18n(mapValues(messages, (data) => getInner(data)?.[key] ?? data?.[key]));
+        });
+      }
+      if (schema.list) {
+        schema.list = schema.list.map((inner, index) => {
+          return inner.i18n(mapValues(messages, (data = {}) => {
+            if (Array.isArray(getInner(data))) return getInner(data)[index];
+            if (Array.isArray(data)) return data[index];
+            return extractKeys(data);
+          }));
+        });
+      }
+      if (schema.inner) {
+        schema.inner = schema.inner.i18n(mapValues(messages, (data) => {
+          if (getInner(data)) return getInner(data);
+          return extractKeys(data);
+        }));
+      }
+      if (schema.sKey) {
+        schema.sKey = schema.sKey.i18n(mapValues(messages, (data) => data?.$key));
+      }
+      return schema;
+    }, "i18n");
+    Schema.prototype.extra = /* @__PURE__ */ __name(function extra(key, value) {
+      const schema = Schema(this);
+      schema.meta = { ...schema.meta, [key]: value };
+      return schema;
+    }, "extra");
+    for (const key of ["required", "disabled", "collapse", "hidden", "loose"]) {
+      Object.assign(Schema.prototype, {
+        [key](value = true) {
+          const schema = Schema(this);
+          schema.meta = { ...schema.meta, [key]: value };
+          return schema;
+        }
+      });
+    }
+    Schema.prototype.deprecated = /* @__PURE__ */ __name(function deprecated() {
+      const schema = Schema(this);
+      schema.meta.badges ||= [];
+      schema.meta.badges.push({ text: "deprecated", type: "danger" });
+      return schema;
+    }, "deprecated");
+    Schema.prototype.experimental = /* @__PURE__ */ __name(function experimental() {
+      const schema = Schema(this);
+      schema.meta.badges ||= [];
+      schema.meta.badges.push({ text: "experimental", type: "warning" });
+      return schema;
+    }, "experimental");
+    Schema.prototype.pattern = /* @__PURE__ */ __name(function pattern(regexp) {
+      const schema = Schema(this);
+      const pattern2 = pick(regexp, ["source", "flags"]);
+      schema.meta = { ...schema.meta, pattern: pattern2 };
+      return schema;
+    }, "pattern");
+    Schema.prototype.simplify = /* @__PURE__ */ __name(function simplify(value) {
+      if (deepEqual(value, this.meta.default, this.type === "dict")) return null;
+      if (isNullable(value)) return value;
+      if (this.type === "object" || this.type === "dict") {
+        const result = {};
+        for (const key in value) {
+          const schema = this.type === "object" ? this.dict[key] : this.inner;
+          const item = schema?.simplify(value[key]);
+          if (this.type === "dict" || !isNullable(item)) result[key] = item;
+        }
+        if (deepEqual(result, this.meta.default, this.type === "dict")) return null;
+        return result;
+      } else if (this.type === "array" || this.type === "tuple") {
+        const result = [];
+        value.forEach((value2, index) => {
+          const schema = this.type === "array" ? this.inner : this.list[index];
+          const item = schema ? schema.simplify(value2) : value2;
+          result.push(item);
+        });
+        return result;
+      } else if (this.type === "intersect") {
+        const result = {};
+        for (const item of this.list) {
+          Object.assign(result, item.simplify(value));
+        }
+        return result;
+      } else if (this.type === "union") {
+        for (const schema of this.list) {
+          try {
+            Schema.resolve(value, schema, {});
+            return schema.simplify(value);
+          } catch {
+          }
+        }
+      }
+      return value;
+    }, "simplify");
+    Schema.prototype.toString = /* @__PURE__ */ __name(function toString(inline) {
+      return formatters[this.type]?.(this, inline) ?? `Schema<${this.type}>`;
+    }, "toString");
+    Schema.prototype.role = /* @__PURE__ */ __name(function role(role, extra) {
+      const schema = Schema(this);
+      schema.meta = { ...schema.meta, role, extra };
+      return schema;
+    }, "role");
+    for (const key of ["default", "link", "comment", "description", "max", "min", "step"]) {
+      Object.assign(Schema.prototype, {
+        [key](value) {
+          const schema = Schema(this);
+          schema.meta = { ...schema.meta, [key]: value };
+          return schema;
+        }
+      });
+    }
+    var resolvers = {};
+    Schema.extend = /* @__PURE__ */ __name(function extend(type, resolve) {
+      resolvers[type] = resolve;
+    }, "extend");
+    Schema.resolve = /* @__PURE__ */ __name(function resolve(data, schema, options = {}, strict = false) {
+      if (!schema) return [data];
+      if (options.ignore?.(data, schema)) return [data];
+      if (isNullable(data) && schema.type !== "lazy") {
+        if (schema.meta.required) throw new ValidationError(`missing required value`, options);
+        let current = schema;
+        let fallback = schema.meta.default;
+        while (current?.type === "intersect" && isNullable(fallback)) {
+          current = current.list[0];
+          fallback = current?.meta.default;
+        }
+        if (isNullable(fallback)) return [data];
+        data = clone(fallback);
+      }
+      const callback = resolvers[schema.type];
+      if (!callback) throw new ValidationError(`unsupported type "${schema.type}"`, options);
+      try {
+        return callback(data, schema, options, strict);
+      } catch (error) {
+        if (!schema.meta.loose) throw error;
+        return [schema.meta.default];
+      }
+    }, "resolve");
+    Schema.from = /* @__PURE__ */ __name(function from(source) {
+      if (isNullable(source)) {
+        return Schema.any();
+      } else if (["string", "number", "boolean"].includes(typeof source)) {
+        return Schema.const(source).required();
+      } else if (source[kSchema]) {
+        return source;
+      } else if (typeof source === "function") {
+        switch (source) {
+          case String:
+            return Schema.string().required();
+          case Number:
+            return Schema.number().required();
+          case Boolean:
+            return Schema.boolean().required();
+          case Function:
+            return Schema.function().required();
+          default:
+            return Schema.is(source).required();
+        }
+      } else {
+        throw new TypeError(`cannot infer schema from ${source}`);
+      }
+    }, "from");
+    Schema.lazy = /* @__PURE__ */ __name(function lazy(builder) {
+      const toJSON = /* @__PURE__ */ __name(() => {
+        if (!schema.inner[kSchema]) {
+          schema.inner = schema.builder();
+          schema.inner.meta = { ...schema.meta, ...schema.inner.meta };
+        }
+        return schema.inner.toJSON();
+      }, "toJSON");
+      const schema = new Schema({ type: "lazy", builder, inner: { toJSON } });
+      return schema;
+    }, "lazy");
+    Schema.natural = /* @__PURE__ */ __name(function natural() {
+      return Schema.number().step(1).min(0);
+    }, "natural");
+    Schema.percent = /* @__PURE__ */ __name(function percent() {
+      return Schema.number().step(0.01).min(0).max(1).role("slider");
+    }, "percent");
+    Schema.date = /* @__PURE__ */ __name(function date() {
+      return Schema.union([
+        Schema.is(Date),
+        Schema.transform(Schema.string().role("datetime"), (value, options) => {
+          const date2 = new Date(value);
+          if (isNaN(+date2)) throw new ValidationError(`invalid date "${value}"`, options);
+          return date2;
+        }, true)
+      ]);
+    }, "date");
+    Schema.regExp = /* @__PURE__ */ __name(function regExp(flag = "") {
+      return Schema.union([
+        Schema.is(RegExp),
+        Schema.transform(Schema.string().role("regexp", { flag }), (value, options) => {
+          try {
+            return new RegExp(value, flag);
+          } catch (e) {
+            throw new ValidationError(e.message, options);
+          }
+        }, true)
+      ]);
+    }, "regExp");
+    Schema.arrayBuffer = /* @__PURE__ */ __name(function arrayBuffer(encoding) {
+      return Schema.union([
+        Schema.is(ArrayBuffer),
+        Schema.is(SharedArrayBuffer),
+        Schema.transform(Schema.any(), (value, options) => {
+          if (Binary.isSource(value)) return Binary.fromSource(value);
+          throw new ValidationError(`expected ArrayBufferSource but got ${value}`, options);
+        }, true),
+        ...encoding ? [Schema.transform(Schema.string(), (value, options) => {
+          try {
+            return encoding === "base64" ? Binary.fromBase64(value) : Binary.fromHex(value);
+          } catch (e) {
+            throw new ValidationError(e.message, options);
+          }
+        }, true)] : []
+      ]);
+    }, "arrayBuffer");
+    Schema.extend("lazy", (data, schema, options, strict) => {
+      if (!schema.inner[kSchema]) {
+        schema.inner = schema.builder();
+        schema.inner.meta = { ...schema.meta, ...schema.inner.meta };
+      }
+      return Schema.resolve(data, schema.inner, options, strict);
+    });
+    Schema.extend("any", (data) => {
+      return [data];
+    });
+    Schema.extend("never", (data, _, options) => {
+      throw new ValidationError(`expected nullable but got ${data}`, options);
+    });
+    Schema.extend("const", (data, { value }, options) => {
+      if (deepEqual(data, value)) return [value];
+      throw new ValidationError(`expected ${value} but got ${data}`, options);
+    });
+    function checkWithinRange(data, meta, description, options, skipMin = false) {
+      const { max = Infinity, min = -Infinity } = meta;
+      if (data > max) throw new ValidationError(`expected ${description} <= ${max} but got ${data}`, options);
+      if (data < min && !skipMin) throw new ValidationError(`expected ${description} >= ${min} but got ${data}`, options);
+    }
+    __name(checkWithinRange, "checkWithinRange");
+    Schema.extend("string", (data, { meta }, options) => {
+      if (typeof data !== "string") throw new ValidationError(`expected string but got ${data}`, options);
+      if (meta.pattern) {
+        const regexp = new RegExp(meta.pattern.source, meta.pattern.flags);
+        if (!regexp.test(data)) throw new ValidationError(`expect string to match regexp ${regexp}`, options);
+      }
+      checkWithinRange(data.length, meta, "string length", options);
+      return [data];
+    });
+    function decimalShift(data, digits) {
+      const str = data.toString();
+      if (str.includes("e")) return data * Math.pow(10, digits);
+      const index = str.indexOf(".");
+      if (index === -1) return data * Math.pow(10, digits);
+      const frac = str.slice(index + 1);
+      const integer = str.slice(0, index);
+      if (frac.length <= digits) return +(integer + frac.padEnd(digits, "0"));
+      return +(integer + frac.slice(0, digits) + "." + frac.slice(digits));
+    }
+    __name(decimalShift, "decimalShift");
+    function isMultipleOf(data, min, step) {
+      step = Math.abs(step);
+      if (!/^\d+\.\d+$/.test(step.toString())) {
+        return (data - min) % step === 0;
+      }
+      const index = step.toString().indexOf(".");
+      const digits = step.toString().slice(index + 1).length;
+      return Math.abs(decimalShift(data, digits) - decimalShift(min, digits)) % decimalShift(step, digits) === 0;
+    }
+    __name(isMultipleOf, "isMultipleOf");
+    Schema.extend("number", (data, { meta }, options) => {
+      if (typeof data !== "number") throw new ValidationError(`expected number but got ${data}`, options);
+      checkWithinRange(data, meta, "number", options);
+      const { step } = meta;
+      if (step && !isMultipleOf(data, meta.min ?? 0, step)) {
+        throw new ValidationError(`expected number multiple of ${step} but got ${data}`, options);
+      }
+      return [data];
+    });
+    Schema.extend("boolean", (data, _, options) => {
+      if (typeof data === "boolean") return [data];
+      throw new ValidationError(`expected boolean but got ${data}`, options);
+    });
+    Schema.extend("bitset", (data, { bits, meta }, options) => {
+      let value = 0, keys = [];
+      if (typeof data === "number") {
+        value = data;
+        for (const key in bits) {
+          if (data & bits[key]) {
+            keys.push(key);
+          }
+        }
+      } else if (Array.isArray(data)) {
+        keys = data;
+        for (const key of keys) {
+          if (typeof key !== "string") throw new ValidationError(`expected string but got ${key}`, options);
+          if (key in bits) value |= bits[key];
+        }
+      } else {
+        throw new ValidationError(`expected number or array but got ${data}`, options);
+      }
+      if (value === meta.default) return [value];
+      return [value, keys];
+    });
+    Schema.extend("function", (data, _, options) => {
+      if (typeof data === "function") return [data];
+      throw new ValidationError(`expected function but got ${data}`, options);
+    });
+    Schema.extend("is", (data, { constructor }, options) => {
+      if (typeof constructor === "function") {
+        if (data instanceof constructor) return [data];
+        throw new ValidationError(`expected ${constructor.name} but got ${data}`, options);
+      } else {
+        if (isNullable(data)) {
+          throw new ValidationError(`expected ${constructor} but got ${data}`, options);
+        }
+        let prototype = Object.getPrototypeOf(data);
+        while (prototype) {
+          if (prototype.constructor?.name === constructor) return [data];
+          prototype = Object.getPrototypeOf(prototype);
+        }
+        throw new ValidationError(`expected ${constructor} but got ${data}`, options);
+      }
+    });
+    function property(data, key, schema, options) {
+      try {
+        const [value, adapted] = Schema.resolve(data[key], schema, {
+          ...options,
+          path: [...options.path || [], key]
+        });
+        if (adapted !== void 0) data[key] = adapted;
+        return value;
+      } catch (e) {
+        if (!options?.autofix) throw e;
+        delete data[key];
+        return schema.meta.default;
+      }
+    }
+    __name(property, "property");
+    Schema.extend("array", (data, { inner, meta }, options) => {
+      if (!Array.isArray(data)) throw new ValidationError(`expected array but got ${data}`, options);
+      checkWithinRange(data.length, meta, "array length", options, !isNullable(inner.meta.default));
+      return [data.map((_, index) => property(data, index, inner, options))];
+    });
+    Schema.extend("dict", (data, { inner, sKey }, options, strict) => {
+      if (!isPlainObject(data)) throw new ValidationError(`expected object but got ${data}`, options);
+      const result = {};
+      for (const key in data) {
+        let rKey;
+        try {
+          rKey = Schema.resolve(key, sKey, options)[0];
+        } catch (error) {
+          if (strict) continue;
+          throw error;
+        }
+        result[rKey] = property(data, key, inner, options);
+        data[rKey] = data[key];
+        if (key !== rKey) delete data[key];
+      }
+      return [result];
+    });
+    Schema.extend("tuple", (data, { list }, options, strict) => {
+      if (!Array.isArray(data)) throw new ValidationError(`expected array but got ${data}`, options);
+      const result = list.map((inner, index) => property(data, index, inner, options));
+      if (strict) return [result];
+      result.push(...data.slice(list.length));
+      return [result];
+    });
+    function merge(result, data) {
+      for (const key in data) {
+        if (key in result) continue;
+        result[key] = data[key];
+      }
+    }
+    __name(merge, "merge");
+    Schema.extend("object", (data, { dict }, options, strict) => {
+      if (!isPlainObject(data)) throw new ValidationError(`expected object but got ${data}`, options);
+      const result = {};
+      for (const key in dict) {
+        const value = property(data, key, dict[key], options);
+        if (!isNullable(value) || key in data) {
+          result[key] = value;
+        }
+      }
+      if (!strict) merge(result, data);
+      return [result];
+    });
+    Schema.extend("union", (data, { list, toString }, options, strict) => {
+      const messages = [];
+      for (const inner of list) {
+        try {
+          return Schema.resolve(data, inner, options, strict);
+        } catch (error) {
+          messages.push(error);
+        }
+      }
+      throw new ValidationError(`expected ${toString()} but got ${JSON.stringify(data)}`, options);
+    });
+    Schema.extend("intersect", (data, { list, toString }, options, strict) => {
+      if (!list.length) return [data];
+      let result;
+      for (const inner of list) {
+        const value = Schema.resolve(data, inner, options, true)[0];
+        if (isNullable(value)) continue;
+        if (isNullable(result)) {
+          result = value;
+        } else if (typeof result !== typeof value) {
+          throw new ValidationError(`expected ${toString()} but got ${JSON.stringify(data)}`, options);
+        } else if (typeof value === "object") {
+          merge(result ??= {}, value);
+        } else if (result !== value) {
+          throw new ValidationError(`expected ${toString()} but got ${JSON.stringify(data)}`, options);
+        }
+      }
+      if (!strict && isPlainObject(data)) merge(result, data);
+      return [result];
+    });
+    Schema.extend("transform", (data, { inner, callback, preserve }, options) => {
+      const [result, adapted = data] = Schema.resolve(data, inner, options, true);
+      if (preserve) {
+        return [callback(result)];
+      } else {
+        return [callback(result), callback(adapted)];
+      }
+    });
+    var formatters = {};
+    function defineMethod(name2, keys, format) {
+      formatters[name2] = format;
+      Object.assign(Schema, {
+        [name2](...args) {
+          const schema = new Schema({ type: name2 });
+          keys.forEach((key, index) => {
+            switch (key) {
+              case "sKey":
+                schema.sKey = args[index] ?? Schema.string();
+                break;
+              case "inner":
+                schema.inner = Schema.from(args[index]);
+                break;
+              case "list":
+                schema.list = args[index].map(Schema.from);
+                break;
+              case "dict":
+                schema.dict = mapValues(args[index], Schema.from);
+                break;
+              case "bits": {
+                schema.bits = {};
+                for (const key2 in args[index]) {
+                  if (typeof args[index][key2] !== "number") continue;
+                  schema.bits[key2] = args[index][key2];
+                }
+                break;
+              }
+              case "callback": {
+                const callback = schema.callback = args[index];
+                callback["toJSON"] ||= () => callback.toString();
+                break;
+              }
+              case "constructor": {
+                const constructor = schema.constructor = args[index];
+                if (typeof constructor === "function") {
+                  ;
+                  constructor["toJSON"] ||= () => constructor["name"];
+                }
+                break;
+              }
+              default:
+                schema[key] = args[index];
+            }
+          });
+          if (name2 === "object" || name2 === "dict") {
+            schema.meta.default = {};
+          } else if (name2 === "array" || name2 === "tuple") {
+            schema.meta.default = [];
+          } else if (name2 === "bitset") {
+            schema.meta.default = 0;
+          }
+          return schema;
+        }
+      });
+    }
+    __name(defineMethod, "defineMethod");
+    defineMethod("is", ["constructor"], ({ constructor }) => {
+      if (typeof constructor === "function") {
+        return constructor.name;
+      } else {
+        return constructor;
+      }
+    });
+    defineMethod("any", [], () => "any");
+    defineMethod("never", [], () => "never");
+    defineMethod("const", ["value"], ({ value }) => typeof value === "string" ? JSON.stringify(value) : value);
+    defineMethod("string", [], () => "string");
+    defineMethod("number", [], () => "number");
+    defineMethod("boolean", [], () => "boolean");
+    defineMethod("bitset", ["bits"], () => "bitset");
+    defineMethod("function", [], () => "function");
+    defineMethod("array", ["inner"], ({ inner }) => `${inner.toString(true)}[]`);
+    defineMethod("dict", ["inner", "sKey"], ({ inner, sKey }) => `{ [key: ${sKey.toString()}]: ${inner.toString()} }`);
+    defineMethod("tuple", ["list"], ({ list }) => `[${list.map((inner) => inner.toString()).join(", ")}]`);
+    defineMethod("object", ["dict"], ({ dict }) => {
+      if (Object.keys(dict).length === 0) return "{}";
+      return `{ ${Object.entries(dict).map(([key, inner]) => {
+        return `${key}${inner.meta.required ? "" : "?"}: ${inner.toString()}`;
+      }).join(", ")} }`;
+    });
+    defineMethod("union", ["list"], ({ list }, inline) => {
+      const result = list.map(({ toString: format }) => format()).join(" | ");
+      return inline ? `(${result})` : result;
+    });
+    defineMethod("intersect", ["list"], ({ list }) => {
+      return `${list.map((inner) => inner.toString(true)).join(" & ")}`;
+    });
+    defineMethod("transform", ["inner", "callback", "preserve"], ({ inner }, isInner) => inner.toString(isInner));
+    module.exports = Schema;
+  }
+});
+var lib_default = require_index();
+
+// src/index.ts
+import path3 from "path";
+import fs3 from "fs";
+import crypto from "crypto";
+
+// src/db.ts
+import path from "path";
+import fs from "fs";
+import os from "os";
+import Database from "better-sqlite3";
+var SEGMENT_WHITELIST = /[^a-zA-Z0-9_\u4e00-\u9fa5\-]/g;
+function sanitizeSegment(seg) {
+  return String(seg ?? "").replace(SEGMENT_WHITELIST, "").trim();
+}
+function escapeLikePattern(input) {
+  return input.replace(/[\\%_]/g, (m) => `\\${m}`);
+}
+var MemoryDB = class {
+  db;
+  constructor(dbPath) {
+    const resolvedPath = dbPath === ":memory:" ? ":memory:" : dbPath ?? path.join(os.homedir(), ".dsh", "tlmemory.db");
+    if (resolvedPath !== ":memory:") {
+      fs.mkdirSync(path.dirname(resolvedPath), { recursive: true });
+    }
+    this.db = new Database(resolvedPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("foreign_keys = ON");
+    this.migrate();
+  }
+  migrate() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS nodes (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        tree_type TEXT NOT NULL,
+        parent_id INTEGER REFERENCES nodes(id),
+        path TEXT NOT NULL,
+        name TEXT NOT NULL,
+        is_leaf INTEGER NOT NULL DEFAULT 0,
+        content TEXT,
+        keywords TEXT,
+        reinforce_count INTEGER NOT NULL DEFAULT 1,
+        is_pinned INTEGER NOT NULL DEFAULT 0,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        UNIQUE (tree_type, path, name)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_nodes_tree_path ON nodes(tree_type, path);
+
+      CREATE VIRTUAL TABLE IF NOT EXISTS memory_fts USING fts5(
+        tree_type, path, name, content, keywords,
+        tokenize = 'trigram'
+      );
+
+      CREATE TRIGGER IF NOT EXISTS trg_nodes_ai AFTER INSERT ON nodes BEGIN
+        INSERT INTO memory_fts(rowid, tree_type, path, name, content, keywords)
+        VALUES (new.id, new.tree_type, new.path, new.name, new.content, new.keywords);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS trg_nodes_ad AFTER DELETE ON nodes BEGIN
+        DELETE FROM memory_fts WHERE rowid = old.id;
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS trg_nodes_au AFTER UPDATE ON nodes BEGIN
+        DELETE FROM memory_fts WHERE rowid = old.id;
+        INSERT INTO memory_fts(rowid, tree_type, path, name, content, keywords)
+        VALUES (new.id, new.tree_type, new.path, new.name, new.content, new.keywords);
+      END;
+    `);
+  }
+  /**
+   * 沿物化路径递归构建目录节点并在末端挂载/强化原子断言叶子。
+   * 同 (tree_type, path, name) 冲突时执行强化：reinforce_count + 1 并更新内容与关键词。
+   */
+  upsertLeaf(treeType, pathSegments, name2, content, keywords) {
+    const cleanSegments = (Array.isArray(pathSegments) ? pathSegments : []).map(sanitizeSegment).filter(Boolean);
+    const fallbackSegments = cleanSegments.length > 0 ? cleanSegments : ["\u672A\u5206\u7C7B"];
+    const cleanName = sanitizeSegment(name2) || "\u672A\u547D\u540D\u89C4\u5219";
+    const cleanContent = String(content ?? "").trim().slice(0, 80);
+    const cleanKeywords = (Array.isArray(keywords) ? keywords : []).map((k) => sanitizeSegment(k)).filter(Boolean).join(" ");
+    let parentId = null;
+    let fullPath = "";
+    for (const seg of fallbackSegments) {
+      fullPath += `/${seg}`;
+      parentId = this.upsertDirectory(treeType, parentId, `${fullPath}/`, seg);
+    }
+    return this.upsertNode(treeType, parentId, `${fullPath}/`, cleanName, 1, cleanContent, cleanKeywords);
+  }
+  upsertDirectory(treeType, parentId, dirPath, name2) {
+    const row = this.upsertNode(treeType, parentId, dirPath, name2, 0, null, null);
+    return Number(row.id);
+  }
+  upsertNode(treeType, parentId, nodePath, name2, isLeaf, content, keywords) {
+    const now = Date.now();
+    const result = this.db.prepare(`
+        INSERT INTO nodes (tree_type, parent_id, path, name, is_leaf, content, keywords, reinforce_count, is_pinned, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, 1, 0, ?, ?)
+        ON CONFLICT(tree_type, path, name) DO UPDATE SET
+          content = excluded.content,
+          keywords = excluded.keywords,
+          reinforce_count = reinforce_count + 1,
+          updated_at = excluded.updated_at
+        RETURNING *
+      `).get(treeType, parentId, nodePath, name2, isLeaf, content, keywords, now, now);
+    return this.rowToNode(result);
+  }
+  /** FTS5 Trigram 全文检索：BM25 排序，输出 score（越高越相关）与 bm25_rank */
+  search(query, options = {}) {
+    const cleanQuery = String(query ?? "").trim();
+    if (!cleanQuery) return [];
+    const { treeType, pathPrefix, limit = 5 } = options;
+    const matchQuery = `"${cleanQuery.replace(/"/g, '""')}"`;
+    const where = ["memory_fts MATCH ?"];
+    const params = [matchQuery];
+    if (treeType) {
+      where.push("n.tree_type = ?");
+      params.push(treeType);
+    }
+    if (pathPrefix) {
+      where.push(`n.path LIKE ? ESCAPE '\\'`);
+      params.push(`${escapeLikePattern(pathPrefix)}%`);
+    }
+    params.push(limit);
+    const rows = this.db.prepare(`
+        SELECT n.*, bm25(memory_fts) AS bm25_score
+        FROM memory_fts
+        JOIN nodes n ON n.id = memory_fts.rowid
+        WHERE ${where.join(" AND ")}
+        ORDER BY bm25(memory_fts)
+        LIMIT ?
+      `).all(...params);
+    return rows.map((row, index) => {
+      const node = this.rowToNode(row);
+      const bm25 = Number(row.bm25_score ?? 0);
+      return {
+        ...node,
+        score: Math.round(-bm25 * 100) / 100,
+        bm25_rank: index + 1
+      };
+    });
+  }
+  getAllNodes(treeType) {
+    const rows = treeType ? this.db.prepare("SELECT * FROM nodes WHERE tree_type = ? ORDER BY tree_type, path, name").all(treeType) : this.db.prepare("SELECT * FROM nodes ORDER BY tree_type, path, name").all();
+    return rows.map((row) => this.rowToNode(row));
+  }
+  /**
+   * 人工剪枝：删除指定节点并级联移除其全部后代（沿 parent_id 外键链递归收敛），
+   * 每行删除均经 trg_nodes_ad 触发器同步清理 FTS5 索引，杜绝孤立句柄残留。
+   */
+  deleteNode(id) {
+    const result = this.db.prepare(`
+        WITH RECURSIVE subtree(id) AS (
+          SELECT id FROM nodes WHERE id = ?
+          UNION ALL
+          SELECT n.id FROM nodes n JOIN subtree s ON n.parent_id = s.id
+        )
+        DELETE FROM nodes WHERE id IN (SELECT id FROM subtree)
+      `).run(Number(id));
+    return result.changes > 0;
+  }
+  close() {
+    if (this.db.open) this.db.close();
+  }
+  rowToNode(row) {
+    return {
+      id: String(row.id),
+      tree_type: String(row.tree_type),
+      parent_id: row.parent_id == null ? null : String(row.parent_id),
+      path: String(row.path),
+      name: String(row.name),
+      is_leaf: Number(row.is_leaf ?? 0),
+      content: row.content == null ? null : String(row.content),
+      keywords: row.keywords == null ? null : String(row.keywords),
+      reinforce_count: Number(row.reinforce_count ?? 0),
+      is_pinned: Number(row.is_pinned ?? 0),
+      created_at: Number(row.created_at ?? 0),
+      updated_at: Number(row.updated_at ?? 0)
+    };
+  }
+};
+
+// src/extractor.ts
+var REFLECTION_SYSTEM_PROMPT = `\u4F60\u662F\u4E00\u4E2A\u8F6F\u4EF6\u5DE5\u7A0B\u7ECF\u9A8C\u6C89\u6DC0\u5F15\u64CE\u3002\u8BF7\u5BA1\u89C6\u521A\u624D\u8FD9\u4E00\u8F6E\u4EBA\u673A\u4EA4\u4E92\uFF0C\u63D0\u53D6\u957F\u671F\u6709\u6548\u7684\u9AD8\u4EF7\u503C\u67B6\u6784\u89C4\u7EA6\u3001\u5F00\u53D1\u89C4\u8303\u6216\u907F\u5751\u7ECF\u9A8C\u3002
+
+\u3010\u63D0\u70BC\u89C4\u5219\u3011
+1. \u575A\u51B3\u820D\u5F03\uFF1A\u5355\u6B21\u4E34\u65F6\u5BF9\u8BDD\u3001\u95F2\u804A\u5BA2\u5957\u3001\u7B80\u5355\u62FC\u5199\u4FEE\u590D\u4EE5\u53CA\u672A\u5F97\u51FA\u660E\u786E\u7ED3\u8BBA\u7684\u63A8\u6F14\u8FC7\u7A0B\u3002
+2. \u4F5C\u7528\u57DF\u5212\u5206\u6807\u51C6\uFF1A
+   - global\uFF1A\u8DE8\u9879\u76EE\u901A\u7528\u7684\u7528\u6237\u7F16\u7801\u504F\u597D\u3001\u901A\u7528\u5DE5\u5177\u94FE\u89C4\u7EA6\u6216\u901A\u7528\u5F00\u53D1\u4E60\u60EF\u3002
+   - project\uFF1A\u5F53\u524D\u4ED3\u5E93\u4E13\u6709\u7684\u67B6\u6784\u8BBE\u8BA1\u3001\u6A21\u5757\u5212\u5206\u7EA6\u5B9A\u3001\u7279\u5B9A\u4F9D\u8D56\u7248\u672C\u89C4\u7EA6\u4E0E\u7279\u6709\u8E29\u5751\u53CD\u601D\u3002
+3. \u6587\u672C\u538B\u7F29\u7EA6\u675F\uFF1A
+   - content \u5B57\u6BB5\u5FC5\u987B\u662F\u63D0\u70BC\u540E\u7684\u539F\u5B50\u65AD\u8A00\u6216\u64CD\u4F5C\u7EA6\u675F\uFF0C\u4E25\u7981\u8F93\u51FA\u4EE3\u7801\u5757\u6216\u60C5\u7EEA\u5316\u957F\u6587\u3002
+   - \u5B57\u7B26\u957F\u5EA6\u4E25\u683C\u9650\u5236\u5728 40 \u81F3 80 \u4E2A\u4E2D\u6587\u5B57\u7B26\u4EE5\u5185\u3002
+4. \u8DEF\u5F84\u5206\u6BB5\uFF08path_segments\uFF09\u901A\u5E38\u5305\u542B 2 \u81F3 3 \u7EA7\u4E2D\u6587\u5206\u7C7B\u540D\uFF08\u4F8B\u5982 ["\u6280\u672F\u9009\u578B", "\u6784\u5EFA\u5DE5\u5177"]\uFF09\u3002
+
+\u3010\u8F93\u51FA\u683C\u5F0F\u3011
+\u5FC5\u987B\u4E25\u683C\u8F93\u51FA\u7EAF JSON \u5BF9\u8C61\uFF0C\u4E25\u7981\u5305\u88F9\u4EFB\u4F55\u4EE3\u7801\u5757\u5916\u7684 Markdown \u89E3\u91CA\u6027\u6587\u672C\uFF1A
+{
+  "reflections": [
+    {
+      "tree": "global" | "project",
+      "path_segments": ["\u5206\u7C7B\u4E00\u7EA7", "\u5206\u7C7B\u4E8C\u7EA7"],
+      "name": "\u89C4\u5219\u7B80\u540D",
+      "content": "40\u523080\u5B57\u9AD8\u5EA6\u7CBE\u70BC\u7684\u6838\u5FC3\u65AD\u8A00\u89C4\u5219",
+      "keywords": ["\u5173\u952E\u8BCD1", "\u5173\u952E\u8BCD2"]
+    }
+  ]
+}
+\u82E5\u672C\u8F6E\u4EA4\u4E92\u65E0\u957F\u671F\u4EF7\u503C\uFF0C\u8BF7\u76F4\u63A5\u8F93\u51FA {"reflections": []}\u3002`;
+var MemoryExtractor = class {
+  constructor(ctx, db) {
+    this.ctx = ctx;
+    this.db = db;
+  }
+  ctx;
+  db;
+  /** 第一重门禁：启发式过滤网关，丢弃寒暄客套与长度不足的文本 */
+  passesFilterGate(text) {
+    if (!text || text.trim().length < 15) return false;
+    const trivialPatterns = [
+      /^(你好|在吗|hi|hello|继续|收到|好的|ok|yes)$/i,
+      /^(谢谢|thank you|thanks)$/i
+    ];
+    return !trivialPatterns.some((pattern) => pattern.test(text.trim()));
+  }
+  async extractAndConsolidate(userMessage, assistantResponse, projectScope) {
+    if (!this.passesFilterGate(userMessage) && !this.passesFilterGate(assistantResponse)) {
+      return;
+    }
+    if (!this.ctx.llm?.stream) {
+      this.ctx.logger?.warn?.("[tlmemory] \u5BBF\u4E3B ctx.llm \u672A\u5C31\u7EEA\uFF0C\u8DF3\u8FC7\u53CD\u601D\u63D0\u53D6");
+      return;
+    }
+    const conversationContext = `[\u7528\u6237\u8F93\u5165]
+${userMessage}
+
+[\u667A\u80FD\u4F53\u7B54\u590D\u4E0E\u64CD\u4F5C]
+${assistantResponse}`;
+    try {
+      const stream = this.ctx.llm.stream({
+        messages: [
+          { role: "system", content: REFLECTION_SYSTEM_PROMPT },
+          { role: "user", content: conversationContext }
+        ],
+        temperature: 0.1
+      });
+      let rawOutput = "";
+      for await (const chunk of stream) {
+        rawOutput += chunk.delta || chunk.text || chunk.content || "";
+      }
+      const cleanJson = this.sanitizeJsonString(rawOutput);
+      const parsed = JSON.parse(cleanJson);
+      if (!parsed.reflections || !Array.isArray(parsed.reflections)) {
+        return;
+      }
+      for (const item of parsed.reflections) {
+        this.processSingleReflection(item, projectScope);
+      }
+    } catch (err) {
+      this.ctx.logger?.error?.("[tlmemory] \u5F02\u6B65\u53CD\u601D\u63D0\u70BC\u8FC7\u7A0B\u5F02\u5E38:", err);
+    }
+  }
+  /** 剥离 Markdown 代码块围栏并收敛至首个 JSON 对象边界 */
+  sanitizeJsonString(raw) {
+    let sanitized = raw.trim();
+    if (sanitized.startsWith("```json")) {
+      sanitized = sanitized.slice(7);
+    } else if (sanitized.startsWith("```")) {
+      sanitized = sanitized.slice(3);
+    }
+    if (sanitized.endsWith("```")) {
+      sanitized = sanitized.slice(0, -3);
+    }
+    sanitized = sanitized.trim();
+    const start = sanitized.indexOf("{");
+    const end = sanitized.lastIndexOf("}");
+    if (start !== -1 && end !== -1 && end > start) {
+      sanitized = sanitized.slice(start, end + 1);
+    }
+    return sanitized.trim();
+  }
+  processSingleReflection(item, projectScope) {
+    if (!item.content || !item.name) return;
+    const boundedContent = item.content.trim().slice(0, 80);
+    const targetTreeType = item.tree === "global" ? "global" : projectScope;
+    const cleanSegments = (item.path_segments || ["\u9ED8\u8BA4"]).map((seg) => seg.replace(/[^a-zA-Z0-9_\u4e00-\u9fa5]/g, "")).filter(Boolean);
+    if (cleanSegments.length === 0) cleanSegments.push("\u901A\u7528");
+    const cleanKeywords = Array.isArray(item.keywords) ? item.keywords.map((k) => k.trim()).filter((k) => k.length > 0) : [item.name];
+    this.db.upsertLeaf(
+      targetTreeType,
+      cleanSegments,
+      item.name.replace(/[^a-zA-Z0-9_\u4e00-\u9fa5]/g, ""),
+      boundedContent,
+      cleanKeywords
+    );
+    this.ctx.logger?.info?.(`[tlmemory] \u77E5\u8BC6\u6C89\u6DC0\u5165\u5E93 [${targetTreeType}]: ${item.name}`);
+  }
+};
+
+// src/tools.ts
+function registerMemoryTools(ctx, db, resolveCurrentScope) {
+  if (!ctx.tools?.register) {
+    ctx.logger?.warn?.("[tlmemory] ctx.tools \u672A\u5C31\u7EEA\uFF0C\u8DF3\u8FC7\u5DE5\u5177\u6CE8\u518C");
+    return () => {
+    };
+  }
+  const unregisterSave = ctx.tools.register({
+    name: "tlmemory_save",
+    description: "\u663E\u5F0F\u5C06\u91CD\u8981\u7528\u6237\u89C4\u8303\u3001\u6280\u672F\u67B6\u6784\u7EA6\u675F\u6216\u8E29\u5751\u907F\u5751\u65AD\u8A00\u6301\u4E45\u5316\u81F3\u957F\u671F\u8BB0\u5FC6\u6811\u4E2D",
+    parameters: {
+      type: "object",
+      properties: {
+        tree_scope: {
+          type: "string",
+          enum: ["global", "project"],
+          description: "\u4F5C\u7528\u57DF\uFF1Aglobal \u5C5E\u4E8E\u8DE8\u5DE5\u7A0B\u5168\u5C40\u504F\u597D\uFF0Cproject \u5C5E\u4E8E\u5F53\u524D\u4ED3\u5E93\u4E13\u5C5E\u89C4\u7EA6"
+        },
+        path_segments: {
+          type: "array",
+          items: { type: "string" },
+          description: '\u6811\u5F62\u5206\u7C7B\u8DEF\u5F84\u6BB5\uFF0C\u4F8B\u5982 ["\u5DE5\u7A0B\u5316", "\u5305\u7BA1\u7406"]'
+        },
+        rule_name: {
+          type: "string",
+          description: '\u89C4\u5219\u7B80\u8FF0\u6807\u9898\uFF0C\u4F8B\u5982 "pnpm\u4F9D\u8D56\u6784\u5EFA\u653E\u884C"'
+        },
+        content: {
+          type: "string",
+          description: "\u539F\u5B50\u65AD\u8A00\u6587\u672C\uFF0C\u4E25\u683C\u9650\u5236\u572840\u81F380\u5B57\u7B26\u4EE5\u5185\uFF0C\u7981\u6B62\u5305\u542B\u591A\u4F59\u4EE3\u7801\u5757"
+        },
+        keywords: {
+          type: "array",
+          items: { type: "string" },
+          description: "\u68C0\u7D22\u5173\u952E\u8BCD\u5217\u8868"
+        }
+      },
+      required: [
+        "tree_scope",
+        "path_segments",
+        "rule_name",
+        "content",
+        "keywords"
+      ]
+    },
+    output: {
+      schema: {
+        type: "object",
+        properties: {
+          status: { type: "string", description: "\u6267\u884C\u72B6\u6001" },
+          message: { type: "string", description: "\u8BE6\u7EC6\u63D0\u793A\u4FE1\u606F" },
+          node_id: { type: "string", description: "\u8BB0\u5FC6\u8282\u70B9\u552F\u4E00\u6807\u8BC6" }
+        },
+        required: ["status", "message", "node_id"]
+      },
+      render: (result) => result?.message ?? JSON.stringify(result)
+    },
+    async execute(args) {
+      const targetTree = args.tree_scope === "global" ? "global" : resolveCurrentScope();
+      const sanitizedSegments = args.path_segments.map(
+        (s) => s.replace(/[^a-zA-Z0-9_\u4e00-\u9fa5]/g, "")
+      );
+      const sanitizedName = args.rule_name.replace(
+        /[^a-zA-Z0-9_\u4e00-\u9fa5]/g,
+        ""
+      );
+      const boundedContent = args.content.slice(0, 80);
+      const node = db.upsertLeaf(
+        targetTree,
+        sanitizedSegments,
+        sanitizedName,
+        boundedContent,
+        args.keywords || [sanitizedName]
+      );
+      return {
+        status: "success",
+        message: `\u8BB0\u5FC6\u5DF2\u6210\u529F\u5165\u5E93 [${node.tree_type}]: ${node.path}${node.name}`,
+        node_id: node.id
+      };
+    }
+  });
+  const unregisterQuery = ctx.tools.register({
+    name: "tlmemory_query",
+    description: "\u901A\u8FC7 FTS5 Trigram \u5168\u6587\u7D22\u5F15\u68C0\u7D22\u4E0E\u5F53\u524D\u4EFB\u52A1\u7D27\u5BC6\u76F8\u5173\u7684\u957F\u671F\u8BB0\u5FC6\u65AD\u8A00",
+    parameters: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "\u67E5\u8BE2\u6587\u672C\u6216\u6280\u672F\u5173\u952E\u5B57"
+        },
+        scope: {
+          type: "string",
+          enum: ["all", "global", "project"],
+          description: "\u67E5\u8BE2\u8303\u56F4\uFF0C\u9ED8\u8BA4 all \u8986\u76D6\u5168\u5C40\u4E0E\u5F53\u524D\u5DE5\u7A0B"
+        },
+        limit: {
+          type: "number",
+          description: "\u6700\u5927\u68C0\u7D22\u7ED3\u679C\u6570\uFF0C\u9ED8\u8BA4 5"
+        }
+      },
+      required: ["query"]
+    },
+    output: {
+      schema: {
+        type: "object",
+        properties: {
+          status: { type: "string", description: "\u6267\u884C\u72B6\u6001" },
+          hits_count: { type: "number", description: "\u547D\u4E2D\u6761\u6570" },
+          memories: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                tree: { type: "string" },
+                path: { type: "string" },
+                content: { type: "string" },
+                score: { type: "number" }
+              }
+            },
+            description: "\u547D\u4E2D\u7684\u8BB0\u5FC6\u5217\u8868"
+          }
+        },
+        required: ["status", "hits_count", "memories"]
+      },
+      render: (result) => {
+        if (!result.memories || result.memories.length === 0) {
+          return "\u672A\u68C0\u7D22\u5230\u76F8\u5173\u7684\u957F\u671F\u8BB0\u5FC6\u3002";
+        }
+        return result.memories.map(
+          (m) => `* [${m.tree}] ${m.path}: ${m.content} (\u5F97\u5206: ${m.score.toFixed(1)})`
+        ).join("\n");
+      }
+    },
+    async execute(args) {
+      const currentScope = resolveCurrentScope();
+      let treeType;
+      if (args.scope === "global") treeType = "global";
+      if (args.scope === "project") treeType = currentScope;
+      const results = db.search(args.query, {
+        treeType,
+        limit: args.limit || 5
+      });
+      return {
+        status: "success",
+        hits_count: results.length,
+        memories: results.map((r) => ({
+          tree: r.tree_type === "global" ? "\u5168\u5C40\u504F\u597D" : "\u5F53\u524D\u5DE5\u7A0B",
+          path: `${r.path}${r.name}`,
+          content: r.content ?? "",
+          score: r.score
+        }))
+      };
+    }
+  });
+  return () => {
+    unregisterSave();
+    unregisterQuery();
+  };
+}
+
+// src/recall.ts
+var PROJECT_SCOPE_BIAS = 5;
+function escapeXmlEntities(input) {
+  return input.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+var MemoryRecallEngine = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  /**
+   * 双轨召回：项目记忆与全局记忆分别经 FTS5 检索后合流，
+   * 项目命中叠加作用域偏置，按加权分数降序去重截断。
+   * 用户输入为长句时，FTS5 Trigram 短语匹配要求完整连续子串、几乎必然零命中，
+   * 因此先执行查询候选展开（整句 / 标点切分 token / 中英文段 / 中文滑窗子串），
+   * 再跨候选聚合加权去重，保证长句输入同样能命中语义相关的记忆断言。
+   */
+  recall(query, projectScope, maxCount = 5) {
+    const cleanQuery = query.trim();
+    if (!cleanQuery) return [];
+    const candidates = this.expandQueryCandidates(cleanQuery);
+    const merged = /* @__PURE__ */ new Map();
+    for (const candidate of candidates) {
+      const projectHits = this.db.search(candidate, { treeType: projectScope, limit: maxCount });
+      const globalHits = this.db.search(candidate, { treeType: "global", limit: maxCount });
+      for (const hit of projectHits) {
+        const uniqueKey = `${hit.tree_type}:${hit.path}${hit.name}`;
+        merged.set(uniqueKey, { ...hit, score: hit.score + PROJECT_SCOPE_BIAS });
+      }
+      for (const hit of globalHits) {
+        const uniqueKey = `${hit.tree_type}:${hit.path}${hit.name}`;
+        if (!merged.has(uniqueKey)) merged.set(uniqueKey, hit);
+      }
+    }
+    return Array.from(merged.values()).sort((a, b) => b.score - a.score).slice(0, maxCount);
+  }
+  /** 查询候选展开：整句 -> 标点/空白切分 -> 中英文边界分段 -> 中文长段 Trigram 级滑窗子串 */
+  expandQueryCandidates(query) {
+    const candidates = /* @__PURE__ */ new Set([query]);
+    const tokens = query.split(/[\s,，。;；、:：!！?？"'()（）\[\]{}]+/).filter((t) => t.length > 0);
+    for (const token of tokens) {
+      candidates.add(token);
+      const segments = token.match(/[a-zA-Z0-9_-]+|[\u4e00-\u9fa5]+/g) ?? [token];
+      for (const seg of segments) {
+        candidates.add(seg);
+        if (/[\u4e00-\u9fa5]/.test(seg) && seg.length > 3) {
+          for (let i = 0; i <= seg.length - 3; i += 2) {
+            candidates.add(seg.slice(i, i + 3));
+          }
+          candidates.add(seg.slice(-3));
+        }
+      }
+    }
+    return Array.from(candidates).slice(0, 16);
+  }
+  /** 将召回记忆格式化为受控 XML 标签包裹的同步注入文本，空结果返回空串 */
+  formatPromptBlock(memories) {
+    if (memories.length === 0) return "";
+    const lines = memories.map((m) => {
+      const scopeLabel = m.tree_type === "global" ? "\u5168\u5C40\u504F\u597D" : "\u5F53\u524D\u5DE5\u7A0B";
+      const cleanPath = escapeXmlEntities(`${m.path}${m.name}`);
+      const cleanContent = escapeXmlEntities(m.content || "");
+      return `  - [${scopeLabel}] ${cleanPath}: ${cleanContent}`;
+    });
+    return [
+      "<long_term_memory_context>",
+      "\u4EE5\u4E0B\u662F\u7CFB\u7EDF\u81EA\u52A8\u68C0\u7D22\u5339\u914D\u7684\u957F\u671F\u5DE5\u7A0B\u5951\u7EA6\u4E0E\u907F\u5751\u7ECF\u9A8C\uFF0C\u4F60\u5728\u672C\u8F6E\u63A8\u7406\u4E0E\u5DE5\u5177\u8C03\u7528\u4E2D\u5FC5\u987B\u4E25\u683C\u9075\u5B88\uFF1A",
+      ...lines,
+      "</long_term_memory_context>"
+    ].join("\n");
+  }
+};
+
+// src/server.ts
+import http from "http";
+import fs2 from "fs";
+import path2 from "path";
+import { fileURLToPath } from "url";
+import { WebSocketServer, WebSocket } from "ws";
+var LOOPBACK_HOST = "127.0.0.1";
+var MIME_MAP = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript",
+  ".css": "text/css",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".json": "application/json; charset=utf-8"
+};
+function isAllowedHost(hostHeader) {
+  if (!hostHeader) return false;
+  const hostname = hostHeader.split(":")[0].toLowerCase();
+  return hostname === "127.0.0.1" || hostname === "localhost";
+}
+function isAllowedOrigin(originHeader) {
+  if (!originHeader) return true;
+  return originHeader.includes("127.0.0.1") || originHeader.includes("localhost");
+}
+function resolveWebDist() {
+  const currentDir = typeof __dirname !== "undefined" ? __dirname : path2.dirname(fileURLToPath(import.meta.url));
+  return path2.resolve(currentDir, "../web/dist");
+}
+var MemoryServer = class {
+  constructor(db, port = 4890, logger) {
+    this.db = db;
+    this.port = port;
+    this.logger = logger;
+    this.distPath = resolveWebDist();
+  }
+  db;
+  port;
+  logger;
+  server = null;
+  wss = null;
+  clients = /* @__PURE__ */ new Set();
+  distPath;
+  get actualPort() {
+    const addr = this.server?.address();
+    return typeof addr === "object" && addr !== null ? addr.port : 0;
+  }
+  start() {
+    if (this.server) return;
+    this.server = http.createServer((req, res) => {
+      this.handleHttp(req, res);
+    });
+    this.wss = new WebSocketServer({ noServer: true });
+    this.wss.on("connection", (ws) => {
+      this.clients.add(ws);
+      ws.on("close", () => this.clients.delete(ws));
+    });
+    this.server.on("upgrade", (request, socket, head) => {
+      if (!isAllowedHost(request.headers.host) || !isAllowedOrigin(request.headers.origin)) {
+        socket.destroy();
+        return;
+      }
+      this.wss?.handleUpgrade(request, socket, head, (ws) => {
+        this.wss?.emit("connection", ws, request);
+      });
+    });
+    this.server.listen(this.port, LOOPBACK_HOST, () => {
+      this.logger?.info?.(`[tlmemory-server] \u672C\u5730\u7BA1\u7406\u670D\u52A1\u5C31\u7EEA: http://127.0.0.1:${this.port}`);
+    });
+    this.server.on("error", (err) => {
+      this.logger?.error?.("[tlmemory-server] \u672C\u5730\u7F51\u7EDC\u670D\u52A1\u5F02\u5E38:", err.message);
+    });
+  }
+  broadcastHits(treeType, hitNodeIds) {
+    const payload = JSON.stringify({
+      type: "MEMORY_HITS",
+      treeType,
+      hitNodeIds,
+      timestamp: Date.now()
+    });
+    for (const client of this.clients) {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(payload);
+      }
+    }
+  }
+  notifyTreeChanged(treeType) {
+    const payload = JSON.stringify({
+      type: "TREE_CHANGED",
+      treeType,
+      timestamp: Date.now()
+    });
+    for (const client of this.clients) {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(payload);
+      }
+    }
+  }
+  handleHttp(req, res) {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    const url = new URL(req.url || "/", `http://${req.headers.host || "127.0.0.1"}`);
+    const pathname = url.pathname;
+    try {
+      if (req.method === "GET" && pathname === "/api/nodes") {
+        const treeType = url.searchParams.get("treeType") ?? void 0;
+        const nodes = this.db.getAllNodes(treeType);
+        this.sendJson(res, 200, { data: nodes });
+        return;
+      }
+      if (req.method === "GET" && pathname === "/api/memories") {
+        const treeType = url.searchParams.get("tree") ?? url.searchParams.get("treeType") ?? void 0;
+        const nodes = this.db.getAllNodes(treeType);
+        this.sendJson(res, 200, { data: nodes });
+        return;
+      }
+      if (req.method === "GET" && pathname === "/api/search") {
+        const query = url.searchParams.get("q") || "";
+        const treeType = url.searchParams.get("treeType") ?? void 0;
+        const hits = this.db.search(query, { treeType });
+        this.sendJson(res, 200, { data: hits });
+        return;
+      }
+      if (req.method === "DELETE" && pathname.startsWith("/api/nodes/")) {
+        const id = pathname.slice("/api/nodes/".length);
+        const removed = this.db.deleteNode(id);
+        this.sendJson(res, 200, { success: removed });
+        return;
+      }
+      this.serveStatic(req, res, pathname);
+    } catch (e) {
+      this.sendJson(res, 500, { error: e.message });
+    }
+  }
+  serveStatic(req, res, pathname) {
+    const distPath = this.distPath;
+    let safePath = path2.normalize(path2.join(distPath, pathname === "/" ? "index.html" : pathname));
+    if (!safePath.startsWith(distPath + path2.sep)) {
+      res.writeHead(403);
+      res.end("Forbidden");
+      return;
+    }
+    if (!fs2.existsSync(safePath) || fs2.statSync(safePath).isDirectory()) {
+      safePath = path2.join(distPath, "index.html");
+    }
+    if (!fs2.existsSync(safePath)) {
+      res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
+      res.end("\u524D\u7AEF\u9759\u6001\u8D44\u6E90\u5C1A\u672A\u6784\u5EFA\uFF0C\u8BF7\u8FDB\u5165 packages/tlmemory/web \u6267\u884C pnpm build");
+      return;
+    }
+    const ext = path2.extname(safePath);
+    res.writeHead(200, { "Content-Type": MIME_MAP[ext] || "application/octet-stream" });
+    fs2.createReadStream(safePath).pipe(res);
+  }
+  sendJson(res, statusCode, data) {
+    res.writeHead(statusCode, { "Content-Type": "application/json; charset=utf-8" });
+    res.end(JSON.stringify(data));
+  }
+  stop() {
+    for (const client of this.clients) {
+      client.terminate();
+    }
+    this.clients.clear();
+    this.wss?.close();
+    this.server?.close();
+    this.wss = null;
+    this.server = null;
+  }
+};
+
+// src/index.ts
+var Config = lib_default.object({
+  dbPath: lib_default.string().description("SQLite \u6570\u636E\u5E93\u7269\u7406\u6587\u4EF6\u8DEF\u5F84\uFF08\u9ED8\u8BA4\u7F6E\u4E8E\u5168\u5C40 ~/.dsh/tlmemory.db\uFF09"),
+  serverPort: lib_default.number().default(4890).description("\u4FA7\u8FB9\u680F\u4E0E REST API \u670D\u52A1\u7AEF\u53E3"),
+  maxRecallCount: lib_default.number().default(5).description("\u5355\u8F6E\u6700\u5927\u7CFB\u7EDF\u63D0\u793A\u8BCD\u6CE8\u5165\u8BB0\u5FC6\u6761\u6570"),
+  enableAutoReflection: lib_default.boolean().default(true).description("\u662F\u5426\u5F00\u542F\u4F1A\u8BDD\u7ED3\u675F\u5F02\u6B65\u81EA\u52A8\u53CD\u601D\u63D0\u70BC")
+});
+var name = "tlmemory";
+var inject = ["tools", "llm", "systemPrompt"];
+function resolveProjectScope() {
+  let currentDir = process.cwd();
+  while (currentDir !== path3.parse(currentDir).root) {
+    if (fs3.existsSync(path3.join(currentDir, ".git"))) {
+      const hash = crypto.createHash("sha256").update(path3.normalize(currentDir)).digest("hex");
+      return `repo:${hash.slice(0, 12)}`;
+    }
+    currentDir = path3.dirname(currentDir);
+  }
+  const fallbackHash = crypto.createHash("sha256").update(path3.normalize(process.cwd())).digest("hex");
+  return `repo:${fallbackHash.slice(0, 12)}`;
+}
+function apply(ctx, config) {
+  ctx.logger?.info?.(`[tlmemory] \u63D2\u4EF6\u88C5\u914D\u542F\u52A8\u4E2D...`);
+  const db = new MemoryDB(config.dbPath);
+  const recallEngine = new MemoryRecallEngine(db);
+  const extractor = new MemoryExtractor(ctx, db);
+  const projectScope = resolveProjectScope();
+  let activeRecalledMemories = [];
+  let activePromptSectionText = "";
+  const unregisterSection = ctx.systemPrompt?.section?.({
+    name: "tlmemory:injected-context",
+    order: 115,
+    text: () => activePromptSectionText
+  }) ?? (() => {
+  });
+  const unregisterTools = registerMemoryTools(ctx, db, () => projectScope);
+  const server = new MemoryServer(db, config.serverPort ?? 4890, ctx.logger);
+  server.start();
+  let lastUserMessage = "";
+  const unregisterSessionEvent = ctx.on("session/event", (event) => {
+    if (event?.type === "user/message") {
+      const text = typeof event.content === "string" ? event.content : event.content?.text ?? "";
+      lastUserMessage = text;
+      activeRecalledMemories = recallEngine.recall(text, projectScope, config.maxRecallCount ?? 5);
+      activePromptSectionText = recallEngine.formatPromptBlock(activeRecalledMemories);
+      server.broadcastHits(projectScope, activeRecalledMemories.map((m) => m.id));
+    }
+    if (event?.type === "turn/end" && (config.enableAutoReflection ?? true)) {
+      const assistantText = event.last_assistant_message ?? "";
+      if (lastUserMessage && assistantText) {
+        setImmediate(() => {
+          extractor.extractAndConsolidate(lastUserMessage, assistantText, projectScope).then(() => server.notifyTreeChanged(projectScope)).catch((err) => ctx.logger?.error?.("[tlmemory] \u540E\u53F0\u63D0\u70BC\u957F\u53F6\u5931\u8D25:", err));
+        });
+      }
+      activePromptSectionText = "";
+      lastUserMessage = "";
+    }
+  });
+  return () => {
+    ctx.logger?.info?.("[tlmemory] \u6B63\u5728\u6267\u884C\u5168\u91CF\u526F\u4F5C\u7528\u6CE8\u9500...");
+    unregisterSection();
+    unregisterTools();
+    unregisterSessionEvent();
+    server.stop();
+    db.close();
+    ctx.logger?.info?.("[tlmemory] \u63D2\u4EF6\u5DF2\u5F7B\u5E95\u5B89\u5168\u6CE8\u9500");
+  };
+}
+export {
+  Config,
+  MemoryDB,
+  MemoryExtractor,
+  MemoryServer,
+  apply,
+  inject,
+  name,
+  registerMemoryTools
+};
+//# sourceMappingURL=index.js.map