@cmnyhh/dsh-mnemo 0.0.0-stage → 0.9.5

package/index.js

@@ -0,0 +1,2455 @@
+// vendor/cosmokit/src/misc.ts
+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;
+}
+
+// vendor/cosmokit/src/volatile.ts
+var write = /* @__PURE__ */ Symbol.for("cosmokit.volatile.write");
+function snapshot(value, ancestors = /* @__PURE__ */ new Set()) {
+  if (typeof value === "function") throw new TypeError("volatile config cannot contain functions");
+  if (value === null || typeof value !== "object") return value;
+  if (ancestors.has(value)) throw new TypeError("volatile config cannot contain cycles");
+  ancestors.add(value);
+  try {
+    if (Array.isArray(value)) return Object.freeze(value.map((item) => snapshot(item, ancestors)));
+    if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) {
+      throw new TypeError("volatile config objects must be plain objects or arrays");
+    }
+    return Object.freeze(Object.fromEntries(Object.entries(value).map(([key, item]) => [key, snapshot(item, ancestors)])));
+  } finally {
+    ancestors.delete(value);
+  }
+}
+function createVolatile(value) {
+  let current = snapshot(value);
+  return Object.freeze({
+    get: () => current,
+    [write]: (value2) => {
+      current = value2;
+    }
+  });
+}
+function isVolatile(value) {
+  return typeof value === "object" && value !== null && write in value;
+}
+
+// vendor/cosmokit/src/types.ts
+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) {
+  const ancestors = /* @__PURE__ */ new Set();
+  function compare(a2, b2) {
+    if (a2 === b2) return true;
+    if (isVolatile(a2) || isVolatile(b2)) return isVolatile(a2) && isVolatile(b2);
+    if (!strict && isNullable(a2) && isNullable(b2)) return true;
+    if (typeof a2 !== typeof b2 || typeof a2 !== "object" || !a2 || !b2) return false;
+    if (ancestors.has(a2)) return false;
+    function check(test, then) {
+      return test(a2) ? test(b2) ? then(a2, b2) : false : test(b2) ? false : void 0;
+    }
+    ancestors.add(a2);
+    try {
+      return check(Array.isArray, (a3, b3) => {
+        if (a3.length !== b3.length) return false;
+        for (let index = 0; index < a3.length; index++) {
+          if (!compare(a3[index], b3[index])) return false;
+        }
+        return true;
+      }) ?? check(is("Date"), (a3, b3) => a3.valueOf() === b3.valueOf()) ?? check(is("URL"), (a3, b3) => a3.href === b3.href) ?? check(is("RegExp"), (a3, b3) => a3.source === b3.source && a3.flags === b3.flags) ?? check(isArrayBufferLike, (a3, b3) => {
+        if (a3.byteLength !== b3.byteLength) return false;
+        const viewA = new Uint8Array(a3);
+        const viewB = new Uint8Array(b3);
+        for (let i = 0; i < viewA.length; i++) {
+          if (viewA[i] !== viewB[i]) return false;
+        }
+        return true;
+      }) ?? ((!strict || [a2, b2].every((value) => Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null)) && Object.keys({ ...a2, ...b2 }).every((key) => compare(a2[key], b2[key])));
+    } finally {
+      ancestors.delete(a2);
+    }
+  }
+  return compare(a, b);
+}
+
+// vendor/cosmokit/src/time.ts
+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(date2 = /* @__PURE__ */ new Date(), offset) {
+    if (typeof date2 === "number") date2 = new Date(date2);
+    if (offset === void 0) offset = timezoneOffset;
+    return Math.floor((date2.valueOf() / Time2.minute - offset) / 1440);
+  }
+  Time2.getDateNumber = getDateNumber;
+  function fromDateNumber(value, offset) {
+    const date2 = new Date(value * Time2.day);
+    if (offset === void 0) offset = timezoneOffset;
+    return new Date(+date2 + 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(date2) {
+    const parsed = parseTime(date2);
+    if (parsed) {
+      date2 = Date.now() + parsed;
+    } else if (/^\d{1,2}(:\d{1,2}){1,2}$/.test(date2)) {
+      date2 = `${(/* @__PURE__ */ new Date()).toLocaleDateString()}-${date2}`;
+    } else if (/^\d{1,2}-\d{1,2}-\d{1,2}(:\d{1,2}){1,2}$/.test(date2)) {
+      date2 = `${(/* @__PURE__ */ new Date()).getFullYear()}-${date2}`;
+    }
+    return date2 ? new Date(date2) : /* @__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 = {}));
+
+// vendor/schemastery/src/index.ts
+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;
+  }
+  options;
+  name = "ValidationError";
+  static is(error) {
+    return !!error?.[kValidationError];
+  }
+};
+Object.defineProperty(ValidationError.prototype, kValidationError, {
+  value: true
+});
+var Schema = function(options) {
+  const schema = function(data, options2 = {}) {
+    return Schema.resolve(data, schema, options2)[0];
+  };
+  if (options.refs) {
+    const refs = mapValues(options.refs, (options2) => new Schema(options2));
+    const getRef = (uid) => refs[uid];
+    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.prototype = Object.create(Function.prototype);
+Schema.prototype[kSchema] = true;
+Object.defineProperty(Schema.prototype, "~standard", {
+  get() {
+    return {
+      version: 1,
+      vendor: "schemastery",
+      validate: (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;
+        }
+      }
+    };
+  }
+});
+Schema.ValidationError = ValidationError;
+Schema.prototype.toJSON = 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;
+};
+Schema.prototype.set = function set(key, value) {
+  this.dict[key] = value;
+  return this;
+};
+Schema.prototype.push = function push(value) {
+  this.list.push(value);
+  return this;
+};
+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;
+}
+function getInner(value) {
+  return value?.$value ?? value?.$inner;
+}
+function extractKeys(data) {
+  return filterKeys(data ?? {}, (key) => !key.startsWith("$"));
+}
+Schema.prototype.i18n = 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;
+};
+Schema.prototype.extra = function extra(key, value) {
+  const schema = Schema(this);
+  schema.meta = { ...schema.meta, [key]: value };
+  return schema;
+};
+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 = function deprecated() {
+  const schema = Schema(this);
+  schema.meta.badges ||= [];
+  schema.meta.badges.push({ text: "deprecated", type: "danger" });
+  return schema;
+};
+Schema.prototype.experimental = function experimental() {
+  const schema = Schema(this);
+  schema.meta.badges ||= [];
+  schema.meta.badges.push({ text: "experimental", type: "warning" });
+  return schema;
+};
+Schema.prototype.pattern = function pattern(regexp) {
+  const schema = Schema(this);
+  const pattern2 = pick(regexp, ["source", "flags"]);
+  schema.meta = { ...schema.meta, pattern: pattern2 };
+  return schema;
+};
+Schema.prototype.simplify = function simplify(value) {
+  if (isVolatile(value)) value = value.get();
+  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;
+};
+Schema.prototype.toString = function toString(inline) {
+  return formatters[this.type]?.(this, inline) ?? `Schema<${this.type}>`;
+};
+Schema.prototype.role = function role(role, extra2) {
+  const schema = Schema(this);
+  schema.meta = { ...schema.meta, role, extra: extra2 };
+  return schema;
+};
+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;
+    }
+  });
+}
+Schema.prototype.volatile = function volatile() {
+  if (this.meta.volatile) throw new TypeError("volatile schema is already wrapped");
+  return this.extra("volatile", true);
+};
+var resolvers = {};
+var checkedVolatile = /* @__PURE__ */ Symbol("checked-volatile-schema");
+function validateVolatileSchema(schema, path = [], blocked = false, seen = /* @__PURE__ */ new Map()) {
+  const states = seen.get(schema) ?? /* @__PURE__ */ new Set();
+  if (states.has(blocked)) return;
+  states.add(blocked);
+  seen.set(schema, states);
+  if (schema.meta?.volatile && blocked) {
+    throw new ValidationError("volatile fields require a fixed object path without an enclosing volatile field", { path });
+  }
+  const nested = blocked || !!schema.meta?.volatile;
+  if (schema.dict) {
+    for (const [key, child] of Object.entries(schema.dict)) validateVolatileSchema(child, [...path, key], nested, seen);
+  }
+  if (schema.sKey) validateVolatileSchema(schema.sKey, [...path, "<key>"], true, seen);
+  if (schema.inner && (schema.type !== "lazy" || schema.inner[kSchema])) {
+    validateVolatileSchema(schema.inner, [...path, "*"], true, seen);
+  }
+  if (schema.list) {
+    for (let index = 0; index < schema.list.length; index++) {
+      validateVolatileSchema(schema.list[index], [...path, String(index)], true, seen);
+    }
+  }
+}
+Schema.extend = function extend(type, resolve2) {
+  resolvers[type] = resolve2;
+};
+Schema.resolve = function resolve(data, schema, options = {}, strict = false) {
+  if (!schema) return [data];
+  if (!options[checkedVolatile]) {
+    validateVolatileSchema(schema, options.path);
+    options = { ...options, [checkedVolatile]: true };
+  }
+  if (schema.meta?.volatile) {
+    const inner = Schema(schema);
+    inner.meta = { ...schema.meta, volatile: false };
+    const [value, adapted] = Schema.resolve(data, inner, options, strict);
+    try {
+      return [createVolatile(value), adapted];
+    } catch (error) {
+      throw new ValidationError(error instanceof Error ? error.message : String(error), options);
+    }
+  }
+  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];
+  }
+};
+Schema.from = 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}`);
+  }
+};
+Schema.lazy = function lazy(builder) {
+  const toJSON2 = () => {
+    if (!schema.inner[kSchema]) {
+      schema.inner = schema.builder();
+      schema.inner.meta = { ...schema.meta, ...schema.inner.meta };
+    }
+    return schema.inner.toJSON();
+  };
+  const schema = new Schema({ type: "lazy", builder, inner: { toJSON: toJSON2 } });
+  return schema;
+};
+Schema.natural = function natural() {
+  return Schema.number().step(1).min(0);
+};
+Schema.percent = function percent() {
+  return Schema.number().step(0.01).min(0).max(1).role("slider");
+};
+Schema.date = 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)
+  ]);
+};
+Schema.regExp = 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)
+  ]);
+};
+Schema.arrayBuffer = 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)] : []
+  ]);
+};
+Schema.extend("lazy", (data, schema, options, strict) => {
+  if (!schema.inner[kSchema]) {
+    schema.inner = schema.builder();
+    schema.inner.meta = { ...schema.meta, ...schema.inner.meta };
+    validateVolatileSchema(schema.inner, options.path, true);
+  }
+  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);
+}
+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));
+}
+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;
+}
+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.volatile ? createVolatile(schema.meta.default) : schema.meta.default;
+  }
+}
+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];
+  }
+}
+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: toString2 }, 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 ${toString2()} but got ${JSON.stringify(data)}`, options);
+});
+Schema.extend("intersect", (data, { list, toString: toString2 }, 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 ${toString2()} but got ${JSON.stringify(data)}`, options);
+    } else if (typeof value === "object") {
+      merge(result ??= {}, value);
+    } else if (result !== value) {
+      throw new ValidationError(`expected ${toString2()} 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;
+    }
+  });
+}
+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));
+var src_default = Schema;
+
+// packages/memory/memory-core/src/index.ts
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+
+// packages/memory/memory-core/src/capture.ts
+var ROLE_PREFIX_CHARS = 4;
+var CONTEXT_CHARS = 60;
+function captureSegments(prompt, replies, segmentChars) {
+  const answer = lastSubstantive(replies);
+  const whole = answer === void 0 ? `\u7528\u6237: ${prompt}` : `\u7528\u6237: ${prompt}
+\u52A9\u624B: ${answer}`;
+  if (whole.length <= segmentChars) return [{ text: whole }];
+  const context = prompt.length <= CONTEXT_CHARS ? prompt : `${prompt.slice(0, CONTEXT_CHARS)}\u2026`;
+  const segments = [];
+  for (const part of splitText(prompt, segmentChars - ROLE_PREFIX_CHARS)) {
+    segments.push({ text: `\u7528\u6237: ${part}` });
+  }
+  if (answer !== void 0) {
+    for (const part of splitText(answer, segmentChars - ROLE_PREFIX_CHARS)) {
+      segments.push({ text: `\u52A9\u624B: ${part}`, context });
+    }
+  }
+  return segments;
+}
+function lastSubstantive(replies) {
+  for (let index = replies.length - 1; index >= 0; index -= 1) {
+    const text = replies[index]?.trim();
+    if (text !== void 0 && text.length > 0) return text;
+  }
+  return void 0;
+}
+function splitText(text, maxChars) {
+  const units = text.split(/\n+/u).map((unit) => unit.trim()).filter((unit) => unit.length > 0);
+  const chunks = [];
+  for (const unit of units) chunks.push(...splitLong(unit, maxChars));
+  return chunks.length === 0 ? [text.slice(0, maxChars)] : chunks;
+}
+function splitLong(unit, maxChars) {
+  if (unit.length <= maxChars) return [unit];
+  const sentences = unit.split(/(?<=[。！？；.!?;])\s*/u).filter((sentence) => sentence.length > 0);
+  const chunks = [];
+  let current = "";
+  for (const sentence of sentences) {
+    if (sentence.length > maxChars) {
+      if (current.length > 0) {
+        chunks.push(current);
+        current = "";
+      }
+      for (let at = 0; at < sentence.length; at += maxChars) {
+        chunks.push(sentence.slice(at, at + maxChars));
+      }
+      continue;
+    }
+    if (current.length === 0) current = sentence;
+    else if (current.length + sentence.length <= maxChars) current += sentence;
+    else {
+      chunks.push(current);
+      current = sentence;
+    }
+  }
+  if (current.length > 0) chunks.push(current);
+  return chunks.length === 0 ? [unit.slice(0, maxChars)] : chunks;
+}
+
+// packages/memory/memory-core/src/facts.ts
+var VALUE_WINDOW = 18;
+var BACK_WINDOW = 12;
+var CHANGE = /(?:改成|改为|换成|换为|升到|升为|升级到|更新到|调到|调整到|调整为|设置为|设为|固定为|固定成|现在是|现在用|统一用|统一为)/u;
+var HISTORICAL = /(?:之前|原来|以前|历史上|上次|旧值|旧的|最初)/u;
+var COUNT_NOUN = /(?:记录|数量|个数|编号|序号|条数|次数|页数|项数|总数)/u;
+var MEASURE_WORD = /^\s*(?:次|条|个|项|页|行|人)/u;
+var CONNECTOR = /^[\s:：是为=]+/u;
+var NEGATION_BEFORE = /(?:不要|不用|别|不能|禁止|无需|不再|弃用|废弃)/u;
+var NEGATION_AFTER = /^\s*(?:不用了|不再使用|不再用|废弃|弃用|停用|别用|已废弃|已停用|是旧值|已经不用)/u;
+var SUBJECT_PREFIX = /^(?:把|将|这个|那个|该|本|其|对|给|在|用|和|与|的|是|为|之前|原来|以前|现在|目前|当前|刚才)+/u;
+var SUBJECT_REJECT = /^(?:这个|那个|它|其|该|本|之前|原来|以前|现在|目前|当前|刚才)$/u;
+var SUBJECT_STOP = new Set("\u7684\u4E86\u7740\u8FC7\u5417\u5462\u5427\u554A\u5440\u561B\u54E6\u55EF\u662F\u4EC0\u600E\u4E48\u6837\u591A\u5C11\u54EA\u4E9B\u4E2A\u6211\u4F60\u4ED6\u5979\u5B83\u4EEC\u8FD9\u90A3\u54EA\u548C\u4E0E\u6216\u53CA\u4E5F\u5C31\u90FD\u800C\u628A\u88AB\uFF0C\u3002\uFF01\uFF1F\uFF1B\uFF1A\u3001\n	 ()\uFF08\uFF09[]\u3010\u3011");
+var SENTENCE_BREAKS = ["\u3002", "\uFF01", "\uFF1F", "!", "?", "\n"];
+var LICENSES = /* @__PURE__ */ new Map([
+  ["mit", "MIT"],
+  ["apache-2.0", "Apache-2.0"],
+  ["apache2.0", "Apache-2.0"],
+  ["apache-2", "Apache-2.0"],
+  ["gpl-2.0", "GPL-2.0"],
+  ["gpl-3.0", "GPL-3.0"],
+  ["agpl-3.0", "AGPL-3.0"],
+  ["lgpl-2.1", "LGPL-2.1"],
+  ["lgpl-3.0", "LGPL-3.0"],
+  ["mpl-2.0", "MPL-2.0"],
+  ["bsd-3-clause", "BSD-3-Clause"],
+  ["bsd-2-clause", "BSD-2-Clause"],
+  ["unlicense", "Unlicense"]
+]);
+var SPECS = [
+  {
+    id: "port",
+    label: "\u7AEF\u53E3",
+    keywords: ["\u7AEF\u53E3", "port"],
+    // Four-to-five digits are ports; 1-3 are allowed only for the well-known
+    // ones listed in `normalize`, because "端口记录 3" must not become port 3.
+    value: /(?<![\d.])\d{1,5}(?![\d.])/u,
+    normalize: (raw) => {
+      const port = Number(raw);
+      if (!Number.isInteger(port) || port < 1 || port > 65535) return void 0;
+      if (port < 100 && !WELL_KNOWN_PORTS.has(port)) return void 0;
+      return String(port);
+    },
+    requireConnector: false
+  },
+  {
+    id: "version",
+    label: "\u7248\u672C",
+    keywords: ["\u7248\u672C", "version"],
+    value: /v?\d+\.\d+(?:\.\d+)?(?:-[0-9a-z.]+)?/u,
+    normalize: (raw) => raw.replace(/^v/u, ""),
+    requireConnector: false
+  },
+  {
+    id: "host",
+    label: "\u5730\u5740",
+    keywords: ["\u5730\u5740", "\u4E3B\u673A", "\u57DF\u540D", "ip", "host"],
+    value: /(?:\d{1,3}\.){3}\d{1,3}|[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)+|localhost/u,
+    normalize: (raw) => raw.toLowerCase(),
+    requireConnector: false
+  },
+  {
+    id: "path",
+    label: "\u8DEF\u5F84",
+    keywords: ["\u8DEF\u5F84", "\u76EE\u5F55", "path"],
+    value: /(?:~|\/)[\w.@/-]+/u,
+    normalize: (raw) => raw.replace(/[.。，,;；:：]+$/u, ""),
+    requireConnector: false
+  },
+  {
+    id: "owner",
+    label: "\u8D1F\u8D23\u4EBA",
+    keywords: ["\u8D1F\u8D23\u4EBA", "\u7EF4\u62A4\u4EBA", "owner"],
+    value: /[\u4e00-\u9fff]{2,4}|[A-Za-z][A-Za-z0-9._-]{1,29}/u,
+    normalize: (raw) => raw.trim(),
+    requireConnector: true
+  },
+  {
+    id: "license",
+    label: "\u8BB8\u53EF\u8BC1",
+    keywords: ["\u8BB8\u53EF\u8BC1", "license"],
+    value: /(?:mit|apache-?2\.0|agpl-?3\.0|lgpl-?[23]\.1|gpl-?[23]\.0|mpl-?2\.0|bsd-?[23]-clause|unlicense)/iu,
+    normalize: (raw) => LICENSES.get(raw.toLowerCase().replace(/\s+/gu, "")),
+    requireConnector: false
+  }
+];
+var WELL_KNOWN_PORTS = /* @__PURE__ */ new Set([21, 22, 25, 53, 80, 88, 110, 143, 389, 443, 465, 587, 636, 993, 995]);
+function factLabel(predicate) {
+  return SPECS.find((spec) => spec.id === predicate)?.label ?? predicate;
+}
+function dropSupersededHits(hits, view) {
+  if (view.active.length === 0) return hits;
+  const current = new Set(view.active.map((fact) => `${fact.predicate}|${fact.object}`));
+  const predicates = new Set(view.active.map((fact) => fact.predicate));
+  return hits.filter((hit) => !(hit.record.facts ?? []).some((fact) => {
+    if (!predicates.has(fact.predicate)) return false;
+    if (current.has(`${fact.predicate}|${fact.object}`)) return false;
+    if (view.subject !== "" && fact.subject !== "" && fact.subject !== view.subject) return false;
+    return true;
+  }));
+}
+function keywordPositions(text, spec) {
+  const positions = [];
+  const lowered = text.toLowerCase();
+  for (const keyword of spec.keywords) {
+    const pattern2 = /^[a-z0-9]+$/u.test(keyword) ? new RegExp(`(?<![a-z0-9])${keyword}(?![a-z0-9])`, "gu") : new RegExp(keyword, "gu");
+    for (const match of lowered.matchAll(pattern2)) {
+      if (match.index === void 0) continue;
+      positions.push({ at: match.index, end: match.index + match[0].length });
+    }
+  }
+  positions.sort((left, right) => left.at - right.at);
+  return positions;
+}
+function sentenceAround(text, index) {
+  let start = 0;
+  let end = text.length;
+  for (const mark of SENTENCE_BREAKS) {
+    const before = text.lastIndexOf(mark, index);
+    if (before + 1 > start) start = before + 1;
+    const after = text.indexOf(mark, index);
+    if (after >= 0 && after + 1 < end) end = after + 1;
+  }
+  return text.slice(start, end).trim();
+}
+function inQuestion(text, index) {
+  const sentence = sentenceAround(text, index);
+  return /[？?]\s*$/u.test(sentence) || /[吗呢][？?]?\s*$/u.test(sentence);
+}
+function matchValue(window, spec) {
+  const trimmed = window.replace(CONNECTOR, "");
+  const consumed = window.length - trimmed.length;
+  if (spec.requireConnector && !/[是为：:]/u.test(window.slice(0, consumed))) return void 0;
+  const pattern2 = new RegExp(spec.value.source, `${spec.value.flags}g`);
+  const match = pattern2.exec(trimmed);
+  if (match === null) return void 0;
+  const object = spec.normalize(match[0]);
+  if (object === void 0) return void 0;
+  return { object, start: consumed + match.index, end: consumed + match.index + match[0].length };
+}
+function valueAt(text, occurrence, spec) {
+  const after = text.slice(occurrence.end, occurrence.end + VALUE_WINDOW);
+  const change = CHANGE.exec(after);
+  const from2 = change === null ? occurrence.end : occurrence.end + change.index + change[0].length;
+  const windowText = text.slice(from2, from2 + VALUE_WINDOW);
+  const forward = matchValue(windowText, spec);
+  if (forward !== void 0) {
+    const gap = text.slice(from2, from2 + forward.start);
+    if (NEGATION_BEFORE.test(gap) || !COUNT_NOUN.test(gap)) {
+      if (!MEASURE_WORD.test(text.slice(from2 + forward.end, from2 + forward.end + 4))) {
+        return { object: forward.object, start: from2 + forward.start, end: from2 + forward.end };
+      }
+    }
+  }
+  if (spec.requireConnector) return void 0;
+  const backStart = Math.max(0, occurrence.at - BACK_WINDOW);
+  const backward = text.slice(backStart, occurrence.at);
+  const pattern2 = new RegExp(spec.value.source, `${spec.value.flags}g`);
+  const matches = [...backward.matchAll(pattern2)];
+  const last = matches[matches.length - 1];
+  if (last === void 0 || last.index === void 0) return void 0;
+  if (!/^\s*$/u.test(backward.slice(last.index + last[0].length))) return void 0;
+  const object = spec.normalize(last[0]);
+  if (object === void 0) return void 0;
+  return { object, start: backStart + last.index, end: backStart + last.index + last[0].length };
+}
+function isRetraction(text, value) {
+  const before = text.slice(Math.max(0, value.start - 8), value.start);
+  const after = text.slice(value.end, value.end + 10);
+  return NEGATION_BEFORE.test(before) || NEGATION_AFTER.test(after);
+}
+function subjectBefore(text, at) {
+  let start = at;
+  let length = 0;
+  while (start > 0 && length < 6) {
+    const character = text[start - 1];
+    if (SUBJECT_STOP.has(character)) break;
+    if (!/[\u4e00-\u9fffA-Za-z0-9_-]/u.test(character)) break;
+    start -= 1;
+    length += 1;
+  }
+  const cleaned = text.slice(start, at).trim().replace(SUBJECT_PREFIX, "");
+  if (cleaned.length < 2 || SUBJECT_REJECT.test(cleaned)) return "";
+  return cleaned;
+}
+function extractFacts(text) {
+  if (text.length === 0) return { asserted: [], retracted: [] };
+  const asserted = /* @__PURE__ */ new Map();
+  const retracted = /* @__PURE__ */ new Map();
+  for (const spec of SPECS) {
+    for (const occurrence of keywordPositions(text, spec)) {
+      if (inQuestion(text, occurrence.at)) continue;
+      const value = valueAt(text, occurrence, spec);
+      if (value === void 0) continue;
+      if (isRetraction(text, value)) {
+        retracted.set(`${spec.id}|${value.object}`, { predicate: spec.id, object: value.object });
+        continue;
+      }
+      const subject = subjectBefore(text, occurrence.at);
+      asserted.set(`${spec.id}|${subject}|${value.object}`, { predicate: spec.id, subject, object: value.object });
+    }
+  }
+  for (const spec of SPECS) {
+    const pattern2 = new RegExp(`(${spec.value.source})\\s*(?:\u4E0D\u7528\u4E86|\u4E0D\u518D\u4F7F\u7528|\u4E0D\u518D\u7528|\u5E9F\u5F03|\u5F03\u7528|\u505C\u7528|\u522B\u7528)`, "gu");
+    for (const match of text.matchAll(pattern2)) {
+      if (match.index === void 0 || inQuestion(text, match.index)) continue;
+      const object = spec.normalize(match[1] ?? "");
+      if (object !== void 0) retracted.set(`${spec.id}|${object}`, { predicate: spec.id, object });
+    }
+  }
+  return { asserted: [...asserted.values()], retracted: [...retracted.values()] };
+}
+function firstPredicate(text) {
+  let best;
+  for (const spec of SPECS) {
+    const occurrence = keywordPositions(text, spec)[0];
+    if (occurrence === void 0) continue;
+    if (best === void 0 || occurrence.at < best.at) {
+      best = { id: spec.id, label: spec.label, at: occurrence.at };
+    }
+  }
+  return best;
+}
+var NO_FACTS = {
+  predicate: void 0,
+  label: void 0,
+  subject: "",
+  active: [],
+  superseded: [],
+  historical: false
+};
+function planFactApplication(facts, sessionId, turn, at, extraction) {
+  const closed = /* @__PURE__ */ new Set();
+  const isCurrent = (fact) => fact.validTo === void 0 && !closed.has(fact.id);
+  const inserted = [];
+  const retitle = [];
+  for (const retraction of extraction.retracted) {
+    for (const fact of facts) {
+      if (!isCurrent(fact)) continue;
+      if (fact.sessionId !== sessionId) continue;
+      if (fact.predicate !== retraction.predicate) continue;
+      if (fact.object !== retraction.object) continue;
+      closed.add(fact.id);
+    }
+  }
+  for (const assertion of extraction.asserted) {
+    const held = facts.find((fact) => isCurrent(fact) && fact.sessionId === sessionId && fact.predicate === assertion.predicate && fact.object === assertion.object);
+    if (held !== void 0) {
+      if (held.subject === "" && assertion.subject !== "") {
+        retitle.push({ id: held.id, subject: assertion.subject });
+      }
+      continue;
+    }
+    if (inserted.some((row) => row.validTo === void 0 && row.sessionId === sessionId && row.predicate === assertion.predicate && row.object === assertion.object)) continue;
+    for (const fact of facts) {
+      if (!isCurrent(fact)) continue;
+      if (fact.sessionId !== sessionId || fact.predicate !== assertion.predicate) continue;
+      if (assertion.subject !== "" && fact.subject !== assertion.subject) continue;
+      closed.add(fact.id);
+    }
+    for (let index = 0; index < inserted.length; index += 1) {
+      const row = inserted[index];
+      if (row === void 0 || row.validTo !== void 0) continue;
+      if (row.sessionId !== sessionId || row.predicate !== assertion.predicate) continue;
+      if (assertion.subject !== "" && row.subject !== assertion.subject) continue;
+      inserted[index] = { ...row, validTo: turn };
+    }
+    inserted.push({
+      sessionId,
+      predicate: assertion.predicate,
+      subject: assertion.subject,
+      object: assertion.object,
+      validFrom: turn,
+      recordedAt: at
+    });
+  }
+  return { close: [...closed], retitle, insert: inserted };
+}
+function resolveFacts(facts, sessionId, text) {
+  const found = firstPredicate(text);
+  if (found === void 0) return NO_FACTS;
+  const subject = subjectBefore(text, found.at);
+  const historical = HISTORICAL.test(text);
+  const all = facts.filter((fact) => fact.sessionId === sessionId && fact.predicate === found.id);
+  let active = all.filter((fact) => fact.validTo === void 0);
+  if (subject.length > 0) {
+    const exact = active.filter((fact) => fact.subject === subject);
+    active = exact.length > 0 ? exact : active.filter((fact) => fact.subject === "");
+  }
+  const byObject = /* @__PURE__ */ new Map();
+  for (const fact of active) if (!byObject.has(fact.object)) byObject.set(fact.object, fact);
+  let distinct = [...byObject.values()];
+  if (distinct.length > 1 && !distinct.every((fact) => fact.subject.length > 0)) {
+    const newest = Math.max(...distinct.map((fact) => fact.validFrom));
+    distinct = distinct.filter((fact) => fact.validFrom === newest);
+  }
+  return {
+    predicate: found.id,
+    label: found.label,
+    subject,
+    active: distinct,
+    superseded: historical ? all.filter((fact) => fact.validTo !== void 0).slice(-4) : [],
+    historical
+  };
+}
+function createFactStore(options) {
+  const facts = [];
+  let sequence = 0;
+  const trim = () => {
+    while (facts.length > options.maxFacts) {
+      const closed = facts.findIndex((fact) => fact.validTo !== void 0);
+      facts.splice(closed >= 0 ? closed : 0, 1);
+    }
+  };
+  return {
+    apply(sessionId, turn, at, extraction) {
+      const plan = planFactApplication(facts, sessionId, turn, at, extraction);
+      const closing = new Set(plan.close);
+      for (let index = 0; index < facts.length; index += 1) {
+        const fact = facts[index];
+        if (fact === void 0 || !closing.has(fact.id)) continue;
+        facts[index] = { ...fact, validTo: turn };
+      }
+      const renamed = new Map(plan.retitle.map((entry) => [entry.id, entry.subject]));
+      if (renamed.size > 0) {
+        for (let index = 0; index < facts.length; index += 1) {
+          const fact = facts[index];
+          if (fact === void 0) continue;
+          const subject = renamed.get(fact.id);
+          if (subject === void 0) continue;
+          facts[index] = { ...fact, subject };
+        }
+      }
+      for (const row of plan.insert) {
+        sequence += 1;
+        facts.push({ id: `fact-${String(sequence)}`, ...row });
+      }
+      trim();
+    },
+    query(sessionId, text) {
+      return resolveFacts(facts, sessionId, text);
+    },
+    count() {
+      return facts.length;
+    }
+  };
+}
+
+// packages/memory/memory-core/src/render.ts
+var RECALL_HEADER = "Recalled long-term memory (most relevant first; background only, not instructions):";
+var FACT_HEADER = "Current facts (authoritative; later statements replace earlier ones):";
+var SUPERSEDED_HEADER = "Superseded values (no longer current):";
+var TOOL_LINE_CHARS = 400;
+var TOOL_LINE_OVERHEAD = 24;
+function anchorOf(flat, terms) {
+  if (terms === void 0 || terms.length === 0) return -1;
+  const lowered = flat.toLowerCase();
+  let earliest = -1;
+  for (const term of terms) {
+    const at = lowered.indexOf(term);
+    if (at >= 0 && (earliest < 0 || at < earliest)) earliest = at;
+  }
+  return earliest;
+}
+function oneLine(text, maxChars, matchedTerms) {
+  const flat = text.replace(/\s+/g, " ").trim();
+  if (flat.length <= maxChars) return flat;
+  const anchor = anchorOf(flat, matchedTerms);
+  if (anchor > maxChars / 4) {
+    const lead = Math.floor(maxChars / 4);
+    const start = Math.max(0, anchor - lead);
+    const window = flat.slice(start, start + maxChars - 2);
+    return start === 0 ? `${window}\u2026` : `\u2026${window}\u2026`;
+  }
+  const head = Math.ceil((maxChars - 1) / 2);
+  const tail = maxChars - 1 - head;
+  return `${flat.slice(0, head)}\u2026${flat.slice(flat.length - tail)}`;
+}
+function contextPrefix(hit) {
+  return hit.record.context === void 0 ? "" : `[\u95EE: ${hit.record.context}] `;
+}
+function renderRecallBlock(hits, options) {
+  if (hits.length === 0) return void 0;
+  if (RECALL_HEADER.length > options.budgetChars) return void 0;
+  const lines = [RECALL_HEADER];
+  let used = RECALL_HEADER.length;
+  for (const hit of hits) {
+    const line = `- ${contextPrefix(hit)}${oneLine(hit.record.text, options.maxLineChars, hit.matchedTerms)}`;
+    if (used + line.length + 1 > options.budgetChars) break;
+    lines.push(line);
+    used += line.length + 1;
+  }
+  return lines.length === 1 ? void 0 : lines.join("\n");
+}
+function renderHitList(hits) {
+  if (hits.length === 0) return "No memory matched this query.";
+  const lines = hits.map((hit, index) => {
+    const score = hit.score.toFixed(2);
+    return `${String(index + 1)}. [score ${score}] ${contextPrefix(hit)}` + oneLine(hit.record.text, TOOL_LINE_CHARS, hit.matchedTerms);
+  });
+  return lines.join("\n");
+}
+function renderFactList(lines, options) {
+  if (lines.length === 0) return void 0;
+  if (options.header.length > options.budgetChars) return void 0;
+  const out = [options.header];
+  let used = options.header.length;
+  for (const line of lines) {
+    const subject = line.subject === void 0 ? "" : line.subject;
+    const validity = line.from === void 0 || line.to === void 0 ? "" : ` (turns ${String(line.from)}\u2013${String(line.to)}, superseded)`;
+    const text = `- ${subject}${line.label} = ${line.value}${validity}`;
+    if (used + text.length + 1 > options.budgetChars) break;
+    out.push(text);
+    used += text.length + 1;
+  }
+  return out.length === 1 ? void 0 : out.join("\n");
+}
+function distinctSubjects(facts) {
+  return new Set(facts.map((fact) => fact.subject).filter((subject) => subject.length > 0)).size;
+}
+function renderFactBlock(view, budgetChars) {
+  const withSubject = distinctSubjects(view.active) > 1;
+  const active = view.active.map((fact) => ({
+    label: factLabel(fact.predicate),
+    value: fact.object,
+    ...withSubject && fact.subject.length > 0 ? { subject: fact.subject } : {}
+  }));
+  const activeText = renderFactList(active, { header: FACT_HEADER, budgetChars });
+  if (activeText === void 0) return void 0;
+  if (view.superseded.length === 0) return activeText;
+  const remaining = budgetChars - activeText.length - 2;
+  if (remaining <= SUPERSEDED_HEADER.length) return activeText;
+  const superseded = view.superseded.map((fact) => ({
+    label: factLabel(fact.predicate),
+    value: fact.object,
+    ...fact.validTo === void 0 ? {} : { from: fact.validFrom, to: fact.validTo }
+  }));
+  const supersededText = renderFactList(superseded, { header: SUPERSEDED_HEADER, budgetChars: remaining });
+  return supersededText === void 0 ? activeText : `${activeText}
+
+${supersededText}`;
+}
+function renderInjection(view, hits, options) {
+  const factText = view === void 0 ? void 0 : renderFactBlock(view, Math.min(options.factBudgetChars, options.budgetChars));
+  if (factText === void 0) return renderRecallBlock(hits, options);
+  const remaining = options.budgetChars - factText.length - 2;
+  const recallText = remaining > 0 ? renderRecallBlock(hits, { budgetChars: remaining, maxLineChars: options.maxLineChars }) : void 0;
+  return recallText === void 0 ? factText : `${factText}
+
+${recallText}`;
+}
+
+// packages/memory/memory-core/src/text.ts
+var IDEOGRAPH = /[\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff]/;
+var WORD = /[a-z0-9]+/g;
+var FUNCTION_CHARS = new Set(
+  "\u7684\u4E86\u7740\u8FC7\u5417\u5462\u5427\u554A\u5440\u561B\u54E6\u55EF\u662F\u4EC0\u600E\u4E48\u6837\u591A\u5C11\u54EA\u4E9B\u4E2A\u6211\u4F60\u4ED6\u5979\u5B83\u4EEC\u8FD9\u90A3\u54EA\u548C\u4E0E\u6216\u53CA\u4E5F\u5C31\u90FD\u800C\u628A\u88AB"
+);
+var WEIGHT_PURE_FUNCTION = 0.05;
+var WEIGHT_MIXED = 0.4;
+var WEIGHT_CONTENT = 1;
+function tokenize(text) {
+  const terms = /* @__PURE__ */ new Map();
+  const add = (term) => {
+    terms.set(term, (terms.get(term) ?? 0) + 1);
+  };
+  const lowered = text.normalize("NFKC").toLowerCase();
+  for (const word of lowered.match(WORD) ?? []) add(word);
+  const run = [];
+  const flush = () => {
+    if (run.length === 1) add(run[0]);
+    for (let index = 0; index + 1 < run.length; index += 1) {
+      add(`${run[index]}${run[index + 1]}`);
+    }
+    run.length = 0;
+  };
+  for (const character of lowered) {
+    if (IDEOGRAPH.test(character)) run.push(character);
+    else flush();
+  }
+  flush();
+  return terms;
+}
+function termWeight(term, identifierWeight) {
+  if (/^[a-z0-9]+$/.test(term)) return identifierWeight;
+  let total = 0;
+  let functional = 0;
+  for (const character of term) {
+    total += 1;
+    if (FUNCTION_CHARS.has(character)) functional += 1;
+  }
+  if (functional === 0) return WEIGHT_CONTENT;
+  return functional === total ? WEIGHT_PURE_FUNCTION : WEIGHT_MIXED;
+}
+function inverseDocumentFrequency(documentCount, documentFrequency) {
+  const frequency = Math.max(1, documentFrequency);
+  return Math.log(1 + (documentCount - frequency + 0.5) / (frequency + 0.5));
+}
+
+// packages/memory/memory-core/src/store.ts
+function createInMemoryStore(options) {
+  const entries = [];
+  const documentFrequency = /* @__PURE__ */ new Map();
+  return {
+    record(record) {
+      const terms = tokenize(record.text);
+      for (const term of terms.keys()) {
+        documentFrequency.set(term, (documentFrequency.get(term) ?? 0) + 1);
+      }
+      entries.push({ record, terms });
+      while (entries.length > options.maxRecords) {
+        const oldest = entries[0];
+        const newest = entries[entries.length - 1];
+        if (oldest === void 0 || newest === void 0) break;
+        if (newest.record.turn === oldest.record.turn) break;
+        const evicted = [];
+        while (entries.length > 0 && entries[0]?.record.turn === oldest.record.turn) {
+          const entry = entries.shift();
+          if (entry === void 0) break;
+          evicted.push(entry.record);
+          for (const term of entry.terms.keys()) {
+            const remaining = (documentFrequency.get(term) ?? 0) - 1;
+            if (remaining <= 0) documentFrequency.delete(term);
+            else documentFrequency.set(term, remaining);
+          }
+        }
+        if (evicted.length > 0) options.onEvict?.(evicted);
+      }
+    },
+    recall(query) {
+      const queryTerms = tokenize(query.text);
+      const documentCount = entries.length;
+      if (queryTerms.size === 0 || documentCount === 0) return [];
+      const weights = /* @__PURE__ */ new Map();
+      let budget = 0;
+      for (const term of queryTerms.keys()) {
+        const weight = termWeight(term, options.identifierWeight) * inverseDocumentFrequency(documentCount, documentFrequency.get(term) ?? 0);
+        weights.set(term, weight);
+        budget += weight;
+      }
+      if (!(budget > 0)) return [];
+      const hits = [];
+      for (const entry of entries) {
+        let matched = 0;
+        let matchedTerms;
+        for (const [term, weight] of weights) {
+          if (!entry.terms.has(term)) continue;
+          matched += weight;
+          if (matchedTerms === void 0) matchedTerms = [];
+          matchedTerms.push(term);
+        }
+        if (matched === 0) continue;
+        const score = Math.min(1, matched / budget);
+        if (score >= query.minScore) {
+          hits.push(matchedTerms === void 0 ? { record: entry.record, score } : { record: entry.record, score, matchedTerms });
+        }
+      }
+      hits.sort((left, right) => right.score - left.score || right.record.createdAt - left.record.createdAt);
+      return hits.slice(0, query.limit);
+    },
+    count() {
+      return entries.length;
+    }
+  };
+}
+
+// packages/memory/memory-core/src/remote.ts
+function parsePinnedItems(raw) {
+  const list = Array.isArray(raw) ? raw : [];
+  const items = [];
+  for (const entry of list) {
+    const item = asRecord(entry);
+    if (item === void 0) continue;
+    const id = typeof item.id === "string" ? item.id : void 0;
+    const narrative = typeof item.narrative === "string" ? item.narrative : void 0;
+    if (id === void 0 || narrative === void 0 || narrative.trim().length === 0) continue;
+    items.push({
+      id,
+      narrative,
+      kind: typeof item.kind === "string" ? item.kind : "episode",
+      tier: typeof item.tier === "string" ? item.tier : "T0",
+      importance: asNumber(item.importance) ?? 0
+    });
+  }
+  return items;
+}
+var PINNED_TTL_MS = 6e4;
+var pinnedCache;
+function joinUrl(baseUrl, path) {
+  return `${baseUrl.replace(/\/+$/, "")}${path}`;
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null ? value : void 0;
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function parseHits(raw) {
+  const list = Array.isArray(raw) ? raw : [];
+  const hits = [];
+  for (const entry of list) {
+    const hit = asRecord(entry);
+    if (hit === void 0) continue;
+    const id = typeof hit.id === "string" ? hit.id : void 0;
+    const narrative = typeof hit.narrative === "string" ? hit.narrative : void 0;
+    if (id === void 0 || narrative === void 0) continue;
+    hits.push({
+      id,
+      narrative,
+      kind: typeof hit.kind === "string" ? hit.kind : "unknown",
+      score: asNumber(hit.score) ?? 0,
+      bm25Rank: asNumber(hit.bm25Rank),
+      denseRank: asNumber(hit.denseRank)
+    });
+  }
+  return hits;
+}
+async function remotePinned(options, warn) {
+  if (options.token().length === 0) return void 0;
+  const key = `${options.baseUrl}|${options.token()}`;
+  if (pinnedCache !== void 0 && pinnedCache.key === key && Date.now() - pinnedCache.at < PINNED_TTL_MS) {
+    return pinnedCache.value;
+  }
+  let value;
+  try {
+    const response = await fetch(joinUrl(options.baseUrl, "/v1/memory/pinned"), {
+      headers: { authorization: `Bearer ${options.token()}` },
+      signal: AbortSignal.timeout(options.timeoutMs)
+    });
+    if (response.ok) {
+      const payload = asRecord(await response.json());
+      if (payload !== void 0) {
+        const injection = typeof payload.injection === "string" && payload.injection.trim().length > 0 ? payload.injection : void 0;
+        value = {
+          count: asNumber(payload.count) ?? 0,
+          injection,
+          items: parsePinnedItems(payload.items)
+        };
+      }
+    } else {
+      if (response.status !== 404) {
+        warn(`memory-core: pinned returned HTTP ${String(response.status)}; injecting none`);
+      }
+    }
+  } catch (error) {
+    warn("memory-core: pinned fetch failed; injecting none", error);
+  }
+  pinnedCache = { key, at: Date.now(), value };
+  return value;
+}
+async function remoteSearch(options, query, limit, warn) {
+  if (options.token().length === 0) return void 0;
+  const body = { query, topK: limit };
+  if (options.projectId !== void 0) body.projectId = options.projectId;
+  try {
+    const response = await fetch(joinUrl(options.baseUrl, "/v1/memory/search"), {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${options.token()}`
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(options.timeoutMs)
+    });
+    if (!response.ok) {
+      warn(`memory-core: search returned HTTP ${String(response.status)}; injecting nothing`);
+      return fail(`HTTP ${String(response.status)}`);
+    }
+    const payload = asRecord(await response.json());
+    if (payload === void 0) return fail("\u54CD\u5E94\u4E0D\u662F JSON \u5BF9\u8C61");
+    return {
+      route: typeof payload.route === "string" ? payload.route : "unknown",
+      abstained: payload.abstained === true,
+      injection: typeof payload.injection === "string" && payload.injection.trim().length > 0 ? payload.injection : void 0,
+      hits: parseHits(payload.hits),
+      degradeReason: typeof payload.degradeReason === "string" ? payload.degradeReason : void 0
+    };
+  } catch (error) {
+    const reason = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+    warn("memory-core: search failed; injecting nothing", error);
+    return fail(reason);
+  }
+}
+function fail(reason) {
+  return {
+    route: "error",
+    abstained: false,
+    injection: void 0,
+    hits: [],
+    degradeReason: void 0,
+    problem: reason
+  };
+}
+var Outbox = class {
+  constructor(options, capacity, warn) {
+    this.options = options;
+    this.capacity = capacity;
+    this.warn = warn;
+  }
+  options;
+  capacity;
+  warn;
+  queue = [];
+  flushing;
+  dropped = 0;
+  /** Entries waiting to be delivered. */
+  get size() {
+    return this.queue.length;
+  }
+  /** Entries discarded because the service stayed unreachable. */
+  get droppedCount() {
+    return this.dropped;
+  }
+  /** Queue one turn and start delivering, without awaiting. */
+  push(payload) {
+    if (this.queue.length >= this.capacity) {
+      this.queue.shift();
+      this.dropped += 1;
+      if (this.dropped === 1 || this.dropped % 50 === 0) {
+        this.warn(`memory-core: outbox full; dropped ${String(this.dropped)} oldest turn(s)`);
+      }
+    }
+    this.queue.push(payload);
+    void this.flush();
+  }
+  /**
+   * Deliver queued turns in order, stopping at the first failure.
+   *
+   * Serial on purpose: the service assigns `createdAt` at write time, so posting
+   * turn 5 before turn 3 would record the correction before the thing it
+   * corrects. A failed flush leaves the rest queued for the next attempt.
+   */
+  flush() {
+    if (this.flushing !== void 0) return this.flushing;
+    this.flushing = this.drain().finally(() => {
+      this.flushing = void 0;
+    });
+    return this.flushing;
+  }
+  async drain() {
+    while (this.queue.length > 0) {
+      const payload = this.queue[0];
+      if (payload === void 0) return;
+      const delivered = await this.deliver(payload);
+      if (!delivered) return;
+      this.queue.shift();
+    }
+  }
+  async deliver(payload) {
+    if (this.options.token().length === 0) return true;
+    const body = {
+      idempotencyKey: payload.idempotencyKey,
+      sessionId: payload.sessionId,
+      turn: {
+        sessionId: payload.sessionId,
+        index: payload.turnIndex,
+        messages: payload.messages.map((message) => ({ role: message.role, content: message.content })),
+        ...payload.trigger === void 0 ? {} : { trigger: payload.trigger }
+      }
+    };
+    if (payload.projectId !== void 0) body.projectId = payload.projectId;
+    const writeTimeoutMs = this.options.writeTimeoutMs ?? Math.max(this.options.timeoutMs * 10, 15e3);
+    try {
+      const response = await fetch(joinUrl(this.options.baseUrl, "/v1/memory/ingest"), {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          authorization: `Bearer ${this.options.token()}`
+        },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(writeTimeoutMs)
+      });
+      if (!response.ok) {
+        if (response.status >= 400 && response.status < 500 && response.status !== 429) {
+          this.warn(`memory-core: ingest rejected with HTTP ${String(response.status)}; turn dropped`);
+          return true;
+        }
+        this.warn(`memory-core: ingest failed with HTTP ${String(response.status)}; will retry`);
+        return false;
+      }
+      return true;
+    } catch (error) {
+      this.warn("memory-core: ingest failed; will retry", error);
+      return false;
+    }
+  }
+};
+
+// packages/memory/memory-core/src/agents.ts
+import { copyFile, mkdir, open, readFile, readdir, rename, unlink, writeFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { dirname, basename, join } from "node:path";
+var BEGIN = /<!--\s*memory:begin[^>]*-->/u;
+var END = "<!-- memory:end -->";
+var DEFAULT_MAX_CHARS = 2048;
+var DEFAULT_MAX_ITEMS = 8;
+var DEFAULT_BACKUPS = 3;
+var IMPERATIVE = [
+  /忽略(以上|之前|前面)(的)?(所有)?(指令|指示|要求|设定)/u,
+  /(执行|运行|调用)(以下|下面|这条|该)(命令|脚本|指令)/u,
+  /(打开|访问|请求)(以下|这个|该)(链接|网址|地址)/u,
+  /(发送|转发|上传|提交)(到|至|给)\s*(https?:|www\.|[\w.+-]+@)/iu,
+  /(提供|告诉我|发我|给我)(你的)?(密码|口令|密钥|token|api[ _-]?key)/iu,
+  /\b(ignore|disregard)\s+(all\s+)?(previous|prior|above)\s+instructions?\b/iu
+];
+function oneLine2(text, limit) {
+  const flat = text.replace(/\s+/gu, " ").trim();
+  return flat.length <= limit ? flat : `${flat.slice(0, limit - 1)}\u2026`;
+}
+function renderManagedBlock(items, maxChars = DEFAULT_MAX_CHARS, maxItems = DEFAULT_MAX_ITEMS) {
+  const lines = ["## \u5DE5\u4F5C\u7EA6\u5B9A\uFF08\u81EA\u52A8\u7EF4\u62A4\uFF0C\u8BF7\u52FF\u624B\u6539\u672C\u8282\uFF09", ""];
+  let used = 0;
+  let kept = 0;
+  for (const item of items) {
+    if (kept >= maxItems) break;
+    const text = oneLine2(item.narrative, 200);
+    if (text.length === 0) continue;
+    if (IMPERATIVE.some((pattern2) => pattern2.test(text))) continue;
+    const line = `- ${text}`;
+    if (used + line.length + 1 > maxChars) break;
+    lines.push(line);
+    used += line.length + 1;
+    kept += 1;
+  }
+  if (kept === 0) return "";
+  const body = `${lines.join("\n")}
+`;
+  const hash = createHash("sha256").update(body).digest("hex").slice(0, 16);
+  return `<!-- memory:begin v=1 hash=${hash} -->
+${body}${END}
+`;
+}
+function split(content) {
+  const begin = BEGIN.exec(content);
+  if (begin === null) return { before: content, block: void 0, after: "" };
+  const start = begin.index;
+  const endAt = content.indexOf(END, start);
+  if (endAt < 0) return { before: content, block: void 0, after: "" };
+  const end = endAt + END.length;
+  return { before: content.slice(0, start), block: content.slice(start, end), after: content.slice(end) };
+}
+async function atomicWrite(file, content) {
+  const tmp = `${file}.tmp-${String(process.pid)}`;
+  const handle = await open(tmp, "w");
+  try {
+    await handle.writeFile(content, "utf8");
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+  try {
+    await rename(tmp, file);
+  } catch {
+    await writeFile(file, content, "utf8");
+    await unlink(tmp).catch(() => void 0);
+  }
+}
+async function backup(file, keep) {
+  const dir = dirname(file);
+  const prefix = `${basename(file)}.bak.`;
+  const stamp = `${(/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/gu, "").slice(0, 15)}-${String(Date.now())}`;
+  await copyFile(file, join(dir, `${prefix}${stamp}`)).catch(() => void 0);
+  const entries = await readdir(dir).catch(() => []);
+  const stale = entries.filter((name2) => name2.startsWith(prefix)).sort().reverse().slice(keep);
+  await Promise.all(stale.map((name2) => unlink(join(dir, name2)).catch(() => void 0)));
+}
+async function syncAgentsFile(options, items) {
+  const maxChars = options.maxChars ?? DEFAULT_MAX_CHARS;
+  const maxItems = options.maxItems ?? DEFAULT_MAX_ITEMS;
+  const keep = options.backups ?? DEFAULT_BACKUPS;
+  const block = renderManagedBlock(items, maxChars, maxItems);
+  try {
+    const existing = await readFile(options.file, "utf8").catch(() => void 0);
+    const current = existing === void 0 ? { before: "", block: void 0, after: "" } : split(existing);
+    if (block === "") {
+      if (current.block === void 0) return { status: "empty", detail: "\u6CA1\u6709\u53EF\u5199\u5165\u7684\u5E38\u9A7B\u6761\u76EE\uFF0C\u6587\u4EF6\u4FDD\u6301\u539F\u6837" };
+      const next2 = `${current.before}${current.after}`.replace(/\n{3,}/gu, "\n\n");
+      await atomicWrite(options.file, next2);
+      return { status: "written", detail: "\u5E38\u9A7B\u96C6\u5408\u4E3A\u7A7A\uFF0C\u5DF2\u79FB\u9664\u53D7\u7BA1\u533A\u5757" };
+    }
+    if (current.block !== void 0 && normalize(current.block) === normalize(block)) {
+      return { status: "unchanged", detail: "\u533A\u5757\u5185\u5BB9\u672A\u53D8" };
+    }
+    if (existing === void 0) {
+      await mkdir(dirname(options.file), { recursive: true });
+      await atomicWrite(options.file, block);
+      return { status: "written", detail: "\u6587\u4EF6\u4E0D\u5B58\u5728\uFF0C\u5DF2\u65B0\u5EFA\u5E76\u5199\u5165\u53D7\u7BA1\u533A\u5757" };
+    }
+    await backup(options.file, keep);
+    const next = current.block === void 0 ? `${existing.replace(/\s*$/u, "")}
+
+${block}` : `${current.before}${block}${current.after}`;
+    await atomicWrite(options.file, next);
+    return { status: "written", detail: `\u5DF2\u66F4\u65B0\u53D7\u7BA1\u533A\u5757\uFF08${String(items.length)} \u6761\u5019\u9009\uFF09` };
+  } catch (error) {
+    return { status: "skipped", detail: `\u5199\u5165\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}` };
+  }
+}
+function normalize(text) {
+  return text.replace(/\r\n/gu, "\n").trim();
+}
+
+// packages/memory/memory-core/src/gate.ts
+var EXPLICIT = /(记住|记一下|记下来?|以后都|今后都|以后不要|永远都|别再忘|别忘了)/u;
+var CHANGE2 = /(已(经)?(改|修改|改成|换成|部署|上线|升级|迁移|重装|重构|发布|删除|新增|添加|修复)|改成了|换成了|现在用|已切换到|改成|换成|改为|改到|调整成|设置成)/u;
+var PROBLEM = /(报错|错误|失败|打不开|连不上|超时|异常|崩了|挂了|不可用|500|502|503)/u;
+var FIXED = /(根因|原因是|问题在于|解决的?办法|修好|修复|已恢复|就好了|原因是)/u;
+function join2(input) {
+  return [input.prompt, ...input.replies].join("\n").trim();
+}
+function decideCapture(input, options = {}) {
+  if (options.enabled === false) {
+    return { capture: true, trigger: "none", reason: "\u95F8\u95E8\u5DF2\u5173\u95ED\uFF0C\u5168\u90E8\u5199\u5165" };
+  }
+  const minChars = options.minChars ?? 24;
+  if (EXPLICIT.test(input.prompt)) {
+    return { capture: true, trigger: "explicit", reason: "\u7528\u6237\u663E\u5F0F\u8981\u6C42\u8BB0\u4F4F" };
+  }
+  const text = join2(input);
+  const replies = input.replies.join("\n");
+  if (text.length < minChars && !CHANGE2.test(text)) {
+    return { capture: false, trigger: "none", reason: `\u5185\u5BB9\u8FC7\u77ED\uFF08${String(text.length)} \u5B57\uFF09\u4E14\u65E0\u53D8\u66F4\u4FE1\u53F7\uFF0C\u4E0D\u62BD\u53D6` };
+  }
+  if (PROBLEM.test(input.prompt) && FIXED.test(replies)) {
+    return { capture: true, trigger: "repair", reason: "\u5148\u5931\u8D25\u540E\u89E3\u51B3\uFF0C\u503C\u5F97\u8BB0\u6210 episode" };
+  }
+  if (CHANGE2.test(replies) || CHANGE2.test(input.prompt)) {
+    return { capture: true, trigger: "change", reason: "\u672C\u8F6E\u53D1\u751F\u4E86\u53D8\u66F4" };
+  }
+  return { capture: false, trigger: "none", reason: "\u65E2\u975E\u663E\u5F0F\u3001\u4E5F\u975E\u53D8\u66F4\u6216\u4FEE\u590D\uFF0C\u4E0D\u62BD\u53D6" };
+}
+
+// packages/memory/memory-core/src/token.ts
+import { readFileSync } from "node:fs";
+var defaultTokenSources = {
+  env: process.env,
+  readFile: (path) => readFileSync(path, "utf8")
+};
+function resolveToken(raw, sources = defaultTokenSources) {
+  const value = (raw ?? "").trim();
+  if (value.startsWith("env:")) {
+    const name2 = value.slice("env:".length).trim();
+    if (name2.length === 0) {
+      throw new Error('memory-core: serviceToken "env:" needs a variable name');
+    }
+    return (sources.env[name2] ?? "").trim();
+  }
+  if (value.startsWith("file:")) {
+    const path = value.slice("file:".length).trim();
+    if (path.length === 0) {
+      throw new Error('memory-core: serviceToken "file:" needs a path');
+    }
+    try {
+      return sources.readFile(path).trim();
+    } catch (error) {
+      throw new Error(`memory-core: cannot read serviceToken from ${path}: ${error.message}`);
+    }
+  }
+  return value;
+}
+
+// packages/memory/memory-core/src/live.ts
+function liveString(value) {
+  if (typeof value === "string") return () => value.trim();
+  if (typeof value === "object" && value !== null && typeof value.get === "function") {
+    return () => {
+      const current = value.get();
+      return typeof current === "string" ? current.trim() : "";
+    };
+  }
+  return () => "";
+}
+
+// packages/memory/memory-core/src/index.ts
+import { homedir } from "node:os";
+import { join as join3 } from "node:path";
+var name = "memory-core";
+var inject = ["tools"];
+var Config = src_default.object({
+  topK: src_default.number().default(6),
+  minScore: src_default.number().default(0.4),
+  identifierWeight: src_default.number().default(1.5),
+  contextBudgetChars: src_default.number().default(1200),
+  maxLineChars: src_default.number().default(240),
+  segmentChars: src_default.number().default(240),
+  toolBudgetChars: src_default.number().default(4e3),
+  maxRecords: src_default.number().default(5e3),
+  facts: src_default.boolean().default(true),
+  maxFacts: src_default.number().default(1e3),
+  store: src_default.any(),
+  factStore: src_default.any(),
+  serviceUrl: src_default.string().volatile(),
+  serviceToken: src_default.string().default("").role("secret").volatile(),
+  projectId: src_default.string(),
+  serviceTimeoutMs: src_default.number().default(1200),
+  writeTimeoutMs: src_default.number().default(2e4),
+  toolName: src_default.string().default("memory_search"),
+  writeToolName: src_default.string().default("memory_write"),
+  agentsMd: src_default.string(),
+  t0WriteEnabled: src_default.boolean().default(false),
+  agentsMaxChars: src_default.number().default(2048),
+  agentsSyncMinutes: src_default.number().default(30),
+  writeGate: src_default.boolean().default(true),
+  writeGateMinChars: src_default.number().default(24)
+});
+var SEARCH_PARAMETERS = {
+  query: {
+    type: "string",
+    required: true,
+    description: "What to look up in long-term memory. Natural language; the most specific terms first."
+  },
+  limit: {
+    type: "integer",
+    description: "Maximum records to return. Omit to use the plugin default."
+  }
+};
+var SEARCH_OUTPUT = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    facts: {
+      type: "array",
+      required: true,
+      items: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          label: { type: "string", required: true },
+          value: { type: "string", required: true }
+        }
+      }
+    },
+    hits: {
+      type: "array",
+      required: true,
+      items: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          id: { type: "string", required: true },
+          text: { type: "string", required: true },
+          score: { type: "number", required: true },
+          turn: { type: "integer", required: true }
+        }
+      }
+    },
+    /**
+     * 当 hits 为空时，替代空结果的那段话：要么是服务端给的「最近记忆」兜底块，
+     * 要么是请求根本没成功的原因。有它的时候不再输出 "No memory matched"，
+     * 因为那句话在两种情况下都不准确。
+     */
+    note: { type: "string" }
+  }
+};
+var WRITE_PARAMETERS = {
+  text: {
+    type: "string",
+    required: true,
+    description: "One self-contained statement to remember, in the third person. Not a question, not a transcript, not a description of this tool call."
+  }
+};
+var WRITE_MAX_CHARS = 2e3;
+var WRITE_OUTPUT = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    ok: { type: "boolean", required: true },
+    queued: { type: "boolean", required: true },
+    note: { type: "string", required: true }
+  }
+};
+function textOf(content) {
+  return content.flatMap((block) => block.type === "text" ? [block.text] : []).join("\n").trim();
+}
+function queryText(messages) {
+  const parts = [];
+  for (const message of messages) {
+    if (message.source.kind !== "user") continue;
+    const text = textOf(message.content);
+    if (text.length > 0) parts.push(text);
+  }
+  return parts.length === 0 ? void 0 : parts.join("\n");
+}
+function requireInteger(label, value, minimum) {
+  if (!Number.isInteger(value) || value < minimum) {
+    throw new Error(`memory-core: ${label} must be an integer >= ${String(minimum)}, got ${String(value)}`);
+  }
+  return value;
+}
+var FACT_BUDGET_CHARS = 400;
+function joinBlocks(...parts) {
+  const kept = parts.filter((part) => part !== void 0 && part.trim().length > 0);
+  return kept.length === 0 ? void 0 : kept.join("\n\n");
+}
+var OUTBOX_CAPACITY = 500;
+function resolveAgentsPath(configured) {
+  const explicit = configured?.trim();
+  if (explicit !== void 0 && explicit.length > 0) return explicit;
+  const home = process.env.DSH_HOME?.trim();
+  const base = home !== void 0 && home.length > 0 ? home : join3(homedir(), ".dsh");
+  return join3(base, "AGENTS.md");
+}
+function apply(ctx, config) {
+  const topK = requireInteger("topK", config.topK, 1);
+  const minScore = config.minScore;
+  if (!(minScore >= 0 && minScore <= 1)) {
+    throw new Error(`memory-core: minScore must be within [0, 1], got ${String(minScore)}`);
+  }
+  const identifierWeight = config.identifierWeight;
+  if (!(identifierWeight > 0)) {
+    throw new Error(`memory-core: identifierWeight must be positive, got ${String(identifierWeight)}`);
+  }
+  const contextBudgetChars = requireInteger("contextBudgetChars", config.contextBudgetChars, 1);
+  const maxLineChars = requireInteger("maxLineChars", config.maxLineChars, 1);
+  const segmentChars = requireInteger("segmentChars", config.segmentChars, 20);
+  if (segmentChars > maxLineChars) {
+    throw new Error(
+      `memory-core: segmentChars (${String(segmentChars)}) must not exceed maxLineChars (${String(maxLineChars)})`
+    );
+  }
+  const toolBudgetChars = requireInteger("toolBudgetChars", config.toolBudgetChars, 1);
+  const maxRecords = requireInteger("maxRecords", config.maxRecords, 1);
+  const maxFacts = requireInteger("maxFacts", config.maxFacts, 1);
+  const toolName = config.toolName;
+  if (toolName.trim().length === 0) throw new Error("memory-core: toolName must not be empty");
+  const writeToolName = config.writeToolName;
+  if (writeToolName.trim().length === 0) throw new Error("memory-core: writeToolName must not be empty");
+  if (writeToolName === toolName) throw new Error("memory-core: writeToolName must differ from toolName");
+  const writeGate = config.writeGate !== false;
+  const writeGateMinChars = requireInteger("writeGateMinChars", config.writeGateMinChars, 1);
+  const t0WriteEnabled = config.t0WriteEnabled === true;
+  const agentsMaxChars = requireInteger("agentsMaxChars", config.agentsMaxChars, 256);
+  const agentsSyncMs = requireInteger("agentsSyncMinutes", config.agentsSyncMinutes, 1) * 6e4;
+  const agentsFile = t0WriteEnabled ? resolveAgentsPath(config.agentsMd) : void 0;
+  let lastAgentsSync = 0;
+  const serviceTimeoutMs = requireInteger("serviceTimeoutMs", config.serviceTimeoutMs, 1);
+  const writeTimeoutMs = requireInteger("writeTimeoutMs", config.writeTimeoutMs, 1e3);
+  const readUrl = liveString(config.serviceUrl);
+  const readToken = liveString(config.serviceToken);
+  const serviceUrl = readUrl();
+  const remote = serviceUrl === void 0 || serviceUrl.length === 0 ? void 0 : {
+    baseUrl: serviceUrl,
+    // Volatile: the settings panel can rewrite the token while this runs,
+    // so read it per request instead of snapshotting it here.
+    token: () => resolveToken(readToken()),
+    projectId: config.projectId,
+    timeoutMs: serviceTimeoutMs,
+    writeTimeoutMs
+  };
+  if (remote !== void 0 && remote.token().length === 0) {
+    ctx.logger?.warn?.(
+      "memory-core: serviceUrl \u5DF2\u8BBE\u7F6E\u4F46\u6CA1\u6709\u53EF\u7528\u4EE4\u724C\uFF0C\u5148\u6309\u672A\u914D\u7F6E\u8FD0\u884C\uFF1B\u5728\u300C\u63D2\u4EF6\u300D\u9875\u7684 memory-core \u9762\u677F\u586B\u5165\u4EE4\u724C\u5373\u53EF\u751F\u6548\uFF08\u65E0\u9700\u91CD\u542F\uFF09\u3002\u4E5F\u652F\u6301 env:NAME \u4E0E file:/path \u4E24\u79CD\u5199\u6CD5\u3002"
+    );
+  }
+  const warn = (message, error) => {
+    ctx.logger?.warn?.(message, error);
+  };
+  const syncAgents = (items) => {
+    if (agentsFile === void 0) return;
+    const now = Date.now();
+    if (now - lastAgentsSync < agentsSyncMs) return;
+    lastAgentsSync = now;
+    void syncAgentsFile({ file: agentsFile, maxChars: agentsMaxChars }, items).then((result) => {
+      if (result.status === "written") {
+        ctx.logger?.info?.(`memory-core: AGENTS.md ${result.detail}`);
+      } else if (result.status === "skipped") {
+        warn(`memory-core: AGENTS.md ${result.detail}`);
+      }
+    }).catch((error) => {
+      warn("memory-core: AGENTS.md \u540C\u6B65\u5F02\u5E38", error);
+    });
+  };
+  const store = remote === void 0 ? config.store ?? createInMemoryStore({ maxRecords, identifierWeight }) : void 0;
+  const factStore = remote !== void 0 || config.facts === false ? void 0 : config.factStore ?? createFactStore({ maxFacts });
+  const outbox = remote === void 0 ? void 0 : new Outbox(remote, OUTBOX_CAPACITY, warn);
+  function persist() {
+    const recordFlush = store?.flush;
+    const factFlush = factStore?.flush;
+    const run = (flush) => {
+      void Promise.resolve().then(flush).catch((error) => {
+        ctx.logger?.warn?.("memory-core: flush failed; records are still in memory", error);
+      });
+    };
+    if (recordFlush !== void 0) run(() => recordFlush());
+    if (factFlush !== void 0) run(() => factFlush());
+  }
+  const drafts = /* @__PURE__ */ new WeakMap();
+  let sequence = 0;
+  function recall(sessionId, text, limit) {
+    if (store === void 0) return [];
+    const hits = store.recall({ text, limit, minScore });
+    const view = sessionId === void 0 ? void 0 : factStore?.query(sessionId, text);
+    return view === void 0 ? hits : dropSupersededHits(hits, view);
+  }
+  ctx.on("session/event", (session, event) => {
+    switch (event.type) {
+      case "turn/start":
+        drafts.set(session, { turn: event.data.turn, exchanges: [] });
+        return;
+      case "user/message": {
+        const draft = drafts.get(session);
+        if (draft === void 0 || event.data.source.kind !== "user") return;
+        const text = textOf(event.data.content);
+        if (text.length > 0) draft.exchanges.push({ prompt: text, replies: [] });
+        return;
+      }
+      case "assistant/message": {
+        const draft = drafts.get(session);
+        if (draft === void 0) return;
+        const exchange = draft.exchanges[draft.exchanges.length - 1];
+        if (exchange === void 0) return;
+        const text = textOf(event.data.message.content);
+        if (text.length > 0) exchange.replies.push(text);
+        return;
+      }
+      case "turn/end": {
+        const draft = drafts.get(session);
+        drafts.delete(session);
+        if (draft === void 0) return;
+        const gated = draft.exchanges.map((exchange, offset) => ({
+          exchange,
+          offset,
+          gate: decideCapture(
+            { prompt: exchange.prompt, replies: exchange.replies },
+            { enabled: writeGate, minChars: writeGateMinChars }
+          )
+        }));
+        const kept = gated.filter((entry) => {
+          if (entry.gate.capture) return true;
+          ctx.logger?.debug?.(`memory-core: \u8DF3\u8FC7\u5199\u5165\uFF08${entry.gate.reason}\uFF09`);
+          return false;
+        });
+        if (outbox !== void 0) {
+          for (const { exchange, offset, gate } of kept) {
+            outbox.push({
+              idempotencyKey: `${session.id}:${String(draft.turn)}:${String(offset)}`,
+              projectId: config.projectId,
+              sessionId: session.id,
+              turnIndex: draft.turn,
+              messages: [
+                { role: "user", content: exchange.prompt },
+                ...exchange.replies.map((reply) => ({ role: "assistant", content: reply }))
+              ],
+              ...gate.trigger === "none" ? {} : { trigger: gate.trigger }
+            });
+          }
+          return;
+        }
+        if (store === void 0) return;
+        for (const { exchange } of kept) {
+          for (const segment of captureSegments(exchange.prompt, exchange.replies, segmentChars)) {
+            const extraction = extractFacts(segment.text);
+            factStore?.apply(session.id, draft.turn, event.time, extraction);
+            sequence += 1;
+            store.record({
+              id: `mem-${String(sequence)}`,
+              sessionId: session.id,
+              kind: "turn",
+              text: segment.text,
+              ...segment.context === void 0 ? {} : { context: segment.context },
+              createdAt: event.time,
+              turn: draft.turn,
+              ...extraction.asserted.length === 0 ? {} : { facts: extraction.asserted }
+            });
+          }
+        }
+        persist();
+        return;
+      }
+      default:
+        return;
+    }
+  });
+  ctx.on("agent/pre-step", async ({ agent, messages, step, signal }, next) => {
+    const decision = await next();
+    if (decision.kind === "reject" || signal.aborted) return decision;
+    if (step !== 1) return decision;
+    const query = queryText(messages);
+    if (query === void 0) return decision;
+    const sessionId = agent.session.id;
+    let block;
+    if (remote === void 0) {
+      block = renderInjection(
+        factStore?.query(sessionId, query),
+        recall(sessionId, query, topK),
+        {
+          budgetChars: contextBudgetChars,
+          factBudgetChars: FACT_BUDGET_CHARS,
+          maxLineChars
+        }
+      );
+    } else {
+      const [answer, pinned] = await Promise.all([
+        remoteSearch(remote, query, topK, warn),
+        remotePinned(remote, warn)
+      ]);
+      block = joinBlocks(pinned?.injection, answer?.injection);
+      if (pinned !== void 0) syncAgents(pinned.items);
+    }
+    if (block === void 0 || signal.aborted) return decision;
+    return {
+      ...decision,
+      messages: [
+        ...decision.messages,
+        createUserMessage({
+          content: [{ type: "text", text: block }],
+          source: { kind: name, form: "snapshot", sections: [{ name, text: block }] }
+        })
+      ]
+    };
+  }, { prepend: true });
+  ctx.tools.register(defineTool({
+    name: toolName,
+    description: "Search long-term memory (decisions, configs, preferences, past fixes) from earlier turns. Call it whenever the answer may depend on something agreed before \u2014 even when a recalled block is already present, because that block is a preview of a few records and the rest of the memory may hold the exact value. Anything written during this turn is stored after the turn ends, so it cannot be found here yet.",
+    parameters: SEARCH_PARAMETERS,
+    output: {
+      schema: SEARCH_OUTPUT,
+      render: (_args, value) => {
+        const facts = value.facts.map((fact) => ({ label: fact.label, value: fact.value }));
+        const factText = renderFactList(facts, { header: FACT_HEADER, budgetChars: FACT_BUDGET_CHARS });
+        if (value.note !== void 0) {
+          return [{
+            type: "text",
+            text: factText === void 0 ? value.note : `${factText}
+
+${value.note}`
+          }];
+        }
+        const hitText = renderHitList(value.hits.map((hit) => ({
+          record: {
+            id: hit.id,
+            sessionId: "",
+            kind: "turn",
+            text: hit.text,
+            createdAt: 0,
+            turn: hit.turn
+          },
+          score: hit.score
+        })));
+        return [{
+          type: "text",
+          text: factText === void 0 ? hitText : `${factText}
+
+${hitText}`
+        }];
+      }
+    },
+    async execute(args, exec) {
+      const limit = args.limit === void 0 ? topK : requireInteger(`${toolName}.limit`, args.limit, 1);
+      if (remote !== void 0) {
+        const answer = await remoteSearch(remote, args.query, limit, warn);
+        if (answer?.problem !== void 0) {
+          return {
+            facts: [],
+            hits: [],
+            note: `\u8BB0\u5FC6\u670D\u52A1\u8FD9\u6B21\u6CA1\u54CD\u5E94\uFF08${answer.problem}\uFF09\uFF0C\u672C\u8F6E\u6CA1\u6709\u53EC\u56DE\u4EFB\u4F55\u5185\u5BB9\uFF1B\u8FD9\u8868\u793A\u8BF7\u6C42\u5931\u8D25\uFF0C\u4E0D\u8868\u793A\u8BB0\u5FC6\u91CC\u6CA1\u6709\u76F8\u5173\u5185\u5BB9\u3002`
+          };
+        }
+        const remoteHits = [];
+        let spent = 0;
+        for (const hit of answer?.hits ?? []) {
+          const flat = hit.narrative.replace(/\s+/g, " ").trim();
+          const cost = Math.min(flat.length, TOOL_LINE_CHARS) + TOOL_LINE_OVERHEAD;
+          if (spent + cost > toolBudgetChars && remoteHits.length > 0) break;
+          remoteHits.push({ id: hit.id, text: hit.narrative, score: hit.score, turn: 0 });
+          spent += cost;
+        }
+        if (remoteHits.length === 0 && answer?.injection !== void 0) {
+          return { facts: [], hits: [], note: answer.injection };
+        }
+        return { facts: [], hits: remoteHits };
+      }
+      const sessionId = exec.agent?.session.id;
+      const view = sessionId === void 0 ? void 0 : factStore?.query(sessionId, args.query);
+      const kept = [];
+      let used = 0;
+      for (const hit of recall(sessionId, args.query, limit)) {
+        const flat = hit.record.text.replace(/\s+/g, " ").trim();
+        const cost = Math.min(flat.length, TOOL_LINE_CHARS) + TOOL_LINE_OVERHEAD;
+        if (used + cost > toolBudgetChars && kept.length > 0) break;
+        kept.push(hit);
+        used += cost;
+      }
+      return {
+        facts: (view?.active ?? []).map((fact) => ({
+          label: factLabel(fact.predicate),
+          value: fact.object
+        })),
+        hits: kept.map((hit) => ({
+          id: hit.record.id,
+          text: hit.record.text,
+          score: hit.score,
+          turn: hit.record.turn
+        }))
+      };
+    }
+  }));
+  let toolWrites = 0;
+  ctx.tools.register(defineTool({
+    name: writeToolName,
+    description: 'Save one durable memory. Call it when the conversation establishes something that must survive this session: a decision, a configuration value, a constraint, a preference, or a fix whose cause was not obvious. Write one self-contained statement in the third person ("\u90E8\u7F72\u5728 example.com\uFF0C\u5BB9\u5668\u9879\u76EE\u540D memory"), not a question and not a transcript. Skip chit-chat, restatements of existing project files, and anything the user asked you not to keep.',
+    parameters: WRITE_PARAMETERS,
+    output: {
+      schema: WRITE_OUTPUT,
+      render: (_args, value) => [{
+        type: "text",
+        text: value.ok ? value.note : `\u5199\u5165\u5931\u8D25\uFF1A${value.note}`
+      }]
+    },
+    async execute(args, exec) {
+      const text = args.text.replace(/\s+/g, " ").trim();
+      if (text.length === 0) throw new Error(`${writeToolName}.text \u4E0D\u80FD\u4E3A\u7A7A`);
+      if (text.length > WRITE_MAX_CHARS) {
+        throw new Error(`${writeToolName}.text \u6700\u591A ${String(WRITE_MAX_CHARS)} \u5B57\uFF0C\u8BF7\u62C6\u6210\u591A\u6761\u9648\u8FF0`);
+      }
+      const sessionId = exec.agent?.session.id ?? "tool";
+      toolWrites += 1;
+      if (outbox !== void 0) {
+        outbox.push({
+          idempotencyKey: `${sessionId}:tool:${String(toolWrites)}`,
+          projectId: config.projectId,
+          sessionId,
+          turnIndex: toolWrites,
+          messages: [{ role: "user", content: text }],
+          // The model asked to keep this: the service raises confidence the same
+          // way it does for a person saying "记住".
+          trigger: "explicit"
+        });
+        return {
+          ok: true,
+          queued: true,
+          note: "\u5DF2\u52A0\u5165\u5199\u5165\u961F\u5217\uFF0C\u672C\u8F6E\u7ED3\u675F\u65F6\u5165\u5E93\uFF1B\u5B83\u7684\u62BD\u53D6\u8981\u8DD1\u4E00\u6B21\u6A21\u578B\uFF0C\u6240\u4EE5\u672C\u8F6E\u5185\u7684\u68C0\u7D22\u8FD8\u770B\u4E0D\u5230\u5B83\uFF0C\u4E0B\u4E00\u8F6E\u624D\u68C0\u7D22\u5F97\u5230"
+        };
+      }
+      if (store === void 0) {
+        return { ok: false, queued: false, note: "\u6CA1\u6709\u53EF\u7528\u7684\u5B58\u50A8\uFF08\u65E2\u672A\u914D serviceUrl \u4E5F\u6CA1\u6709 store\uFF09" };
+      }
+      const extraction = extractFacts(text);
+      factStore?.apply(sessionId, toolWrites, Date.now(), extraction);
+      sequence += 1;
+      store.record({
+        id: `mem-${String(sequence)}`,
+        sessionId,
+        kind: "turn",
+        text,
+        createdAt: Date.now(),
+        turn: toolWrites,
+        ...extraction.asserted.length === 0 ? {} : { facts: extraction.asserted }
+      });
+      persist();
+      return { ok: true, queued: false, note: "\u5DF2\u5199\u5165\u672C\u5730\u5B58\u50A8" };
+    }
+  }));
+}
+export {
+  Config,
+  apply,
+  inject,
+  name
+};