@aipack-ai/memory 0.0.1

package/dist/index.js

@@ -0,0 +1,1839 @@
+// src/store/file-memory-store.ts
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+
+// src/retrieval/tokenizer.ts
+function isCJK(ch) {
+  if (!ch) return false;
+  const code = ch.codePointAt(0) ?? 0;
+  return code >= 19968 && code <= 40959 || // CJK 统一表意文字
+  code >= 13312 && code <= 19903 || // CJK 扩展 A
+  code >= 63744 && code <= 64255 || // CJK 兼容表意
+  code >= 12352 && code <= 12543 || // 日文假名（平假名 + 片假名）
+  code >= 44032 && code <= 55215;
+}
+function isCJKSymbol(ch) {
+  const code = ch.charCodeAt(0);
+  return code >= 12288 && code <= 12351 || code >= 65280 && code <= 65519;
+}
+var STOPWORDS = /* @__PURE__ */ new Set([
+  // 英文
+  "the",
+  "a",
+  "an",
+  "and",
+  "or",
+  "but",
+  "if",
+  "then",
+  "else",
+  "when",
+  "of",
+  "to",
+  "in",
+  "on",
+  "at",
+  "by",
+  "for",
+  "with",
+  "without",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "can",
+  "could",
+  "should",
+  "shall",
+  "may",
+  "might",
+  "must",
+  "i",
+  "you",
+  "he",
+  "she",
+  "it",
+  "we",
+  "they",
+  "this",
+  "that",
+  "these",
+  "those",
+  "my",
+  "your",
+  "his",
+  "her",
+  "its",
+  "our",
+  "their",
+  "me",
+  "him",
+  "us",
+  "them",
+  "as",
+  "from",
+  "so",
+  "not",
+  "no",
+  "yes",
+  // 中文高频虚词
+  "\u7684",
+  "\u4E86",
+  "\u662F",
+  "\u5728",
+  "\u6211",
+  "\u4F60",
+  "\u4ED6",
+  "\u5979",
+  "\u5B83",
+  "\u4EEC",
+  "\u8FD9",
+  "\u90A3",
+  "\u548C",
+  "\u4E0E",
+  "\u6216",
+  "\u4E5F",
+  "\u90FD",
+  "\u5C31",
+  "\u628A",
+  "\u88AB",
+  "\u8BA9",
+  "\u7ED9",
+  "\u5BF9",
+  "\u4E3A",
+  "\u4ECE",
+  "\u5230",
+  "\u5411",
+  "\u7740",
+  "\u8FC7",
+  "\u5427",
+  "\u5417",
+  "\u5462",
+  "\u554A",
+  "\u54E6",
+  "\u55EF",
+  "\u4E2A",
+  "\u4E9B",
+  "\u4E0A",
+  "\u4E0B",
+  "\u91CC",
+  "\u4E2D"
+]);
+function tokenize(text) {
+  if (!text) return [];
+  const tokens = [];
+  let latinBuf = "";
+  let cjkBuf = "";
+  const flushLatin = () => {
+    if (latinBuf) {
+      const parts = latinBuf.toLowerCase().match(/[a-z0-9]+/g);
+      if (parts) tokens.push(...parts);
+      latinBuf = "";
+    }
+  };
+  const flushCJK = () => {
+    if (!cjkBuf) return;
+    const chars = [...cjkBuf];
+    if (chars.length === 1) {
+      tokens.push(chars[0]);
+    } else {
+      for (let i = 0; i + 1 < chars.length; i++) {
+        tokens.push(chars[i] + chars[i + 1]);
+      }
+      if (chars.length % 2 === 1) {
+        tokens.push(chars[chars.length - 1]);
+      }
+    }
+    cjkBuf = "";
+  };
+  for (const ch of text) {
+    if (isCJK(ch)) {
+      flushLatin();
+      cjkBuf += ch;
+    } else if (isCJKSymbol(ch)) {
+      flushLatin();
+      flushCJK();
+    } else {
+      flushCJK();
+      latinBuf += ch;
+    }
+  }
+  flushLatin();
+  flushCJK();
+  return tokens;
+}
+function extractConcepts(text, maxConcepts = 8) {
+  const tokens = tokenize(text);
+  const freq = /* @__PURE__ */ new Map();
+  for (const t of tokens) {
+    if (STOPWORDS.has(t)) continue;
+    if (t.length < 2 && !isCJK(t)) continue;
+    freq.set(t, (freq.get(t) ?? 0) + 1);
+  }
+  return [...freq.entries()].sort((a, b) => b[1] - a[1]).slice(0, maxConcepts).map(([t]) => t);
+}
+
+// src/retrieval/bm25.ts
+var BM25Index = class {
+  k1;
+  b;
+  /** 文档集合 */
+  docs = /* @__PURE__ */ new Map();
+  /** 倒排表：token -> 文档 id 集合 */
+  inverted = /* @__PURE__ */ new Map();
+  totalLength = 0;
+  constructor(options = {}) {
+    this.k1 = options.k1 ?? 1.5;
+    this.b = options.b ?? 0.75;
+  }
+  /** 平均文档长度 */
+  get avgdl() {
+    return this.docs.size === 0 ? 0 : this.totalLength / this.docs.size;
+  }
+  /** 文档总数 */
+  get size() {
+    return this.docs.size;
+  }
+  /** 添加或替换文档（同 id 覆盖） */
+  add(id, tokens) {
+    if (this.docs.has(id)) this.remove(id);
+    const tf = /* @__PURE__ */ new Map();
+    for (const t of tokens) tf.set(t, (tf.get(t) ?? 0) + 1);
+    this.docs.set(id, { id, tokens, length: tokens.length, tf });
+    this.totalLength += tokens.length;
+    for (const t of tf.keys()) {
+      let set = this.inverted.get(t);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        this.inverted.set(t, set);
+      }
+      set.add(id);
+    }
+  }
+  /** 移除文档 */
+  remove(id) {
+    const doc = this.docs.get(id);
+    if (!doc) return;
+    this.docs.delete(id);
+    this.totalLength -= doc.length;
+    for (const t of doc.tf.keys()) {
+      const set = this.inverted.get(t);
+      if (!set) continue;
+      set.delete(id);
+      if (set.size === 0) this.inverted.delete(t);
+    }
+  }
+  /** 清空索引 */
+  clear() {
+    this.docs.clear();
+    this.inverted.clear();
+    this.totalLength = 0;
+  }
+  /**
+   * 检索：返回 top-N 的 {id, score}（按分数降序）。
+   * 只扫描 query token 命中的文档，避免全量计算。
+   */
+  search(queryTokens, limit = 10) {
+    if (this.docs.size === 0 || queryTokens.length === 0) return [];
+    const N = this.docs.size;
+    const avgdl = this.avgdl;
+    const scores = /* @__PURE__ */ new Map();
+    for (const t of queryTokens) {
+      const set = this.inverted.get(t);
+      if (!set || set.size === 0) continue;
+      const df = set.size;
+      const idf = Math.log((N - df + 0.5) / (df + 0.5) + 1);
+      for (const docId of set) {
+        const doc = this.docs.get(docId);
+        if (!doc) continue;
+        const tf = doc.tf.get(t) ?? 0;
+        if (tf === 0) continue;
+        const denom = tf + this.k1 * (1 - this.b + this.b * doc.length / (avgdl || 1));
+        const contrib = idf * (tf * (this.k1 + 1)) / (denom || 1);
+        scores.set(docId, (scores.get(docId) ?? 0) + contrib);
+      }
+    }
+    return [...scores.entries()].map(([id, score]) => ({ id, score })).sort((a, b) => b.score - a.score).slice(0, limit);
+  }
+  /**
+   * 单个 token 的 idf（未出现返回 0）。
+   * 供上层计算查询的理论满分（完全同文、tf=1、len≈avgdl 时的分数），
+   * 把无界 BM25 原始分规范化为 [0,1] 相似度。
+   */
+  idf(token) {
+    const df = this.inverted.get(token)?.size ?? 0;
+    if (df === 0) return 0;
+    const N = this.docs.size;
+    return Math.log((N - df + 0.5) / (df + 0.5) + 1);
+  }
+};
+var BM25Retriever = class {
+  constructor(index, entries) {
+    this.index = index;
+    this.entries = entries;
+  }
+  index;
+  entries;
+  async search(query, limit = 5) {
+    const queryTokens = tokenize(query);
+    const hits = this.index.search(queryTokens, limit);
+    const maxPossible = queryTokens.reduce((acc, t) => acc + this.index.idf(t), 0);
+    return hits.map(({ id, score }) => ({
+      entry: this.entries.get(id),
+      score: maxPossible > 0 ? Math.min(1, score / maxPossible) : 0,
+      matchedBy: "bm25"
+    })).filter((r) => r.entry != null);
+  }
+};
+
+// src/retrieval/vector-index.ts
+function normOf(v) {
+  let s = 0;
+  for (let i = 0; i < v.length; i++) s += v[i] * v[i];
+  return Math.sqrt(s);
+}
+function dot(a, b) {
+  let s = 0;
+  for (let i = 0; i < a.length; i++) s += a[i] * b[i];
+  return s;
+}
+var VectorIndex = class {
+  entries = /* @__PURE__ */ new Map();
+  /** bucket -> id 列表（仅 ivfBuckets > 0 时使用） */
+  buckets = /* @__PURE__ */ new Map();
+  dim = 0;
+  bucketCount;
+  constructor(options = {}) {
+    this.bucketCount = options.ivfBuckets ?? 0;
+  }
+  get size() {
+    return this.entries.size;
+  }
+  /** 添加或替换向量（同 id 覆盖）。维度不一致时忽略，返回是否生效 */
+  add(id, vector) {
+    if (!vector || vector.length === 0) return false;
+    if (this.dim === 0) this.dim = vector.length;
+    if (vector.length !== this.dim) return false;
+    const prev = this.entries.get(id);
+    if (prev && this.bucketCount > 0) this.removeFromBucket(id, prev.bucket);
+    const entry = {
+      id,
+      vec: vector,
+      norm: normOf(vector),
+      bucket: this.bucketOf(vector)
+    };
+    this.entries.set(id, entry);
+    if (this.bucketCount > 0) {
+      let list = this.buckets.get(entry.bucket);
+      if (!list) {
+        list = [];
+        this.buckets.set(entry.bucket, list);
+      }
+      if (!list.includes(id)) list.push(id);
+    }
+    return true;
+  }
+  remove(id) {
+    const e = this.entries.get(id);
+    if (!e) return false;
+    this.entries.delete(id);
+    if (this.bucketCount > 0) this.removeFromBucket(id, e.bucket);
+    return true;
+  }
+  clear() {
+    this.entries.clear();
+    this.buckets.clear();
+    this.dim = 0;
+  }
+  /** 检索 top-k（cosine 降序，score > 0） */
+  search(query, k) {
+    if (this.entries.size === 0 || k <= 0 || !query || query.length === 0) return [];
+    if (query.length !== this.dim) return [];
+    const qNorm = normOf(query);
+    if (qNorm === 0) return [];
+    const pool = this.bucketCount > 0 ? this.probeCandidates(query, k * 4) : [...this.entries.values()];
+    const results = [];
+    for (const e of pool) {
+      const score = dot(query, e.vec) / (qNorm * e.norm || 1);
+      if (!(score > 0)) continue;
+      results.push({ id: e.id, score });
+    }
+    results.sort((a, b) => b.score - a.score);
+    return results.slice(0, k);
+  }
+  /** 主导维度（argmax |v|）分桶 */
+  bucketOf(vec) {
+    if (this.bucketCount <= 0) return 0;
+    let best = 0;
+    let bestAbs = -1;
+    for (let i = 0; i < vec.length; i++) {
+      const a = Math.abs(vec[i]);
+      if (a > bestAbs) {
+        bestAbs = a;
+        best = i;
+      }
+    }
+    return best % this.bucketCount;
+  }
+  /** 从查询桶开始探测邻近分桶，直到凑够 minCandidates */
+  probeCandidates(query, minCandidates) {
+    const qBucket = this.bucketOf(query);
+    const out = [];
+    for (let r = 0; r < this.bucketCount && out.length < minCandidates; r++) {
+      const list = this.buckets.get((qBucket + r) % this.bucketCount);
+      if (!list) continue;
+      for (const id of list) {
+        const e = this.entries.get(id);
+        if (e) out.push(e);
+        if (out.length >= minCandidates) break;
+      }
+    }
+    return out;
+  }
+  removeFromBucket(id, bucket) {
+    const list = this.buckets.get(bucket);
+    if (!list) return;
+    const i = list.indexOf(id);
+    if (i !== -1) list.splice(i, 1);
+    if (list.length === 0) this.buckets.delete(bucket);
+  }
+};
+
+// src/store/memory-index.ts
+function byUpdatedAtDesc(a, b) {
+  return b.updatedAt - a.updatedAt;
+}
+var MemoryIndex = class {
+  entries = /* @__PURE__ */ new Map();
+  index = new BM25Index();
+  /** 独立向量索引：保证向量召回不被 BM25 候选池封顶 */
+  vectors = new VectorIndex();
+  retriever = new BM25Retriever(this.index, this.entries);
+  /** 共享底层索引与条目表，返回一个 BM25Retriever（与 store 实时同步） */
+  getRetriever() {
+    return this.retriever;
+  }
+  get(id) {
+    return this.entries.get(id) ?? null;
+  }
+  /** 全部条目（updatedAt 降序） */
+  all() {
+    return [...this.entries.values()].sort(byUpdatedAtDesc);
+  }
+  list(limit) {
+    const all = this.all();
+    return limit != null ? all.slice(0, limit) : all;
+  }
+  count() {
+    return this.entries.size;
+  }
+  /** 索引内容 = content + concepts（提升概念命中） */
+  add(entry) {
+    this.entries.set(entry.id, entry);
+    const tokens = tokenize(`${entry.content} ${entry.concepts.join(" ")}`);
+    this.index.add(entry.id, tokens);
+    if (entry.embedding && entry.embedding.length > 0) {
+      this.vectors.add(entry.id, entry.embedding);
+    } else {
+      this.vectors.remove(entry.id);
+    }
+  }
+  remove(id) {
+    if (!this.entries.has(id)) return false;
+    this.index.remove(id);
+    this.vectors.remove(id);
+    this.entries.delete(id);
+    return true;
+  }
+  clear() {
+    this.entries.clear();
+    this.index.clear();
+    this.vectors.clear();
+  }
+  async search(query, limit) {
+    return this.retriever.search(query, limit ?? 5);
+  }
+  async searchVectors(queryVec, limit) {
+    const hits = this.vectors.search(queryVec, limit ?? 5);
+    const results = [];
+    for (const { id, score } of hits) {
+      const entry = this.entries.get(id);
+      if (entry) results.push({ entry, score, matchedBy: "embedding" });
+    }
+    return results;
+  }
+  /** 统计快照 */
+  stats() {
+    const bySource = { capture: 0, tool: 0, consolidation: 0 };
+    let avgConfidence = 0;
+    let recallTotal = 0;
+    let lastRecalledAt;
+    for (const e of this.entries.values()) {
+      if (bySource[e.source] == null) bySource[e.source] = 0;
+      bySource[e.source] += 1;
+      avgConfidence += e.confidence;
+      recallTotal += e.recallCount;
+      if (e.lastRecalledAt != null && (lastRecalledAt == null || e.lastRecalledAt > lastRecalledAt)) {
+        lastRecalledAt = e.lastRecalledAt;
+      }
+    }
+    const count = this.entries.size;
+    return {
+      count,
+      embeddingCount: this.vectors.size,
+      bySource,
+      avgConfidence: count > 0 ? avgConfidence / count : 0,
+      recallTotal,
+      lastRecalledAt
+    };
+  }
+};
+
+// src/utils/keyed-mutex.ts
+var KeyedMutex = class {
+  /** key -> 当前链尾 promise */
+  tails = /* @__PURE__ */ new Map();
+  /**
+   * 在 key 上串行执行 fn：同一 key 的并发调用按调用顺序排队，逐个执行。
+   * 不同 key 之间互不阻塞（`withLock('*', ...)` 可作全局锁）。
+   */
+  withLock(key, fn) {
+    const prev = this.tails.get(key) ?? Promise.resolve();
+    let release;
+    const gate = new Promise((resolve) => {
+      release = resolve;
+    });
+    const tail = prev.then(() => gate);
+    this.tails.set(key, tail);
+    return prev.then(async () => {
+      try {
+        return await fn();
+      } finally {
+        release();
+        if (this.tails.get(key) === tail) {
+          this.tails.delete(key);
+        }
+      }
+    });
+  }
+  /** 当前持锁 key 数量（调试用） */
+  get pending() {
+    return this.tails.size;
+  }
+};
+var globalMutex = new KeyedMutex();
+
+// src/store/in-memory-store.ts
+function genId() {
+  return `mem_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function finalizeEntry(entry, now = Date.now()) {
+  const createdAt = entry.createdAt ?? now;
+  const { ttlMs, ...rest } = entry;
+  return {
+    ...rest,
+    id: entry.id ?? genId(),
+    createdAt,
+    updatedAt: now,
+    recallCount: entry.recallCount ?? 0,
+    expiresAt: ttlMs != null ? createdAt + ttlMs : entry.expiresAt
+  };
+}
+var InMemoryStore = class {
+  idx = new MemoryIndex();
+  consolidator;
+  embedder;
+  onEvent;
+  writeLock = new KeyedMutex();
+  lastConsolidatedAt;
+  constructor(options = {}) {
+    this.embedder = options.embedder;
+    this.onEvent = options.onEvent;
+  }
+  setConsolidator(consolidator) {
+    this.consolidator = consolidator;
+  }
+  async save(entry) {
+    return this.writeLock.withLock(entry.id ?? "*", async () => {
+      const prev = entry.id ? this.idx.get(entry.id) : null;
+      const finalized = finalizeEntry(
+        {
+          ...entry,
+          embedding: entry.embedding ?? prev?.embedding,
+          // 显式 createdAt 优先（如合并器保留最早创建时间）；未提供时沿用已有条目的
+          createdAt: entry.createdAt ?? prev?.createdAt
+        },
+        Date.now()
+      );
+      if (this.embedder && !finalized.embedding) {
+        try {
+          finalized.embedding = await this.embedder.embed(finalized.content);
+        } catch (err) {
+          this.onEvent?.({ type: "embedding:error", id: finalized.id, error: err.message });
+        }
+      }
+      this.idx.add(finalized);
+      return finalized;
+    });
+  }
+  async get(id) {
+    return this.idx.get(id);
+  }
+  async delete(id) {
+    return this.writeLock.withLock(id, async () => this.idx.remove(id));
+  }
+  async list(limit) {
+    return this.idx.list(limit);
+  }
+  async search(query, limit) {
+    return this.idx.search(query, limit);
+  }
+  async searchVectors(queryVec, limit) {
+    return this.idx.searchVectors(queryVec, limit);
+  }
+  async touchRecall(id, at = Date.now()) {
+    return this.writeLock.withLock(id, async () => {
+      const e = this.idx.get(id);
+      if (!e) return;
+      e.lastRecalledAt = at;
+      e.recallCount += 1;
+      this.idx.add(e);
+    });
+  }
+  async consolidate(options) {
+    if (!this.consolidator) return { merged: 0, pruned: 0 };
+    const result = await this.consolidator.run(options);
+    this.lastConsolidatedAt = Date.now();
+    return result;
+  }
+  async prune(options) {
+    const now = Date.now();
+    const maxAge = options?.maxAgeMs;
+    const minConf = options?.minConfidence ?? 0;
+    let removed = 0;
+    for (const e of this.idx.all()) {
+      const expiredByAge = maxAge != null && now - e.updatedAt > maxAge;
+      const expiredByTtl = e.expiresAt != null && now > e.expiresAt;
+      const lowConf = e.confidence < minConf;
+      if (expiredByAge || expiredByTtl || lowConf) {
+        if (await this.delete(e.id)) removed++;
+      }
+    }
+    if (removed > 0) this.onEvent?.({ type: "prune", removed });
+    return removed;
+  }
+  async count() {
+    return this.idx.count();
+  }
+  markConsolidated(at = Date.now()) {
+    this.lastConsolidatedAt = at;
+  }
+  async stats() {
+    const base = this.idx.stats();
+    return { ...base, lastConsolidatedAt: this.lastConsolidatedAt };
+  }
+  dispose() {
+  }
+};
+function createInMemoryStore() {
+  return new InMemoryStore();
+}
+
+// src/store/file-memory-store.ts
+function resolveBaseDir(baseDir) {
+  if (baseDir) {
+    if (baseDir === "~") return os.homedir();
+    if (baseDir.startsWith("~/")) return path.join(os.homedir(), baseDir.slice(2));
+    if (path.isAbsolute(baseDir)) return baseDir;
+    return path.join(process.cwd(), baseDir);
+  }
+  return path.join(process.cwd(), ".aipack", "memory");
+}
+function encodeId(id) {
+  return encodeURIComponent(id);
+}
+var LOAD_CONCURRENCY = 64;
+async function runPool(tasks) {
+  let done = 0;
+  for (let i = 0; i < tasks.length; i += LOAD_CONCURRENCY) {
+    const batch = tasks.slice(i, i + LOAD_CONCURRENCY);
+    await Promise.all(
+      batch.map(async (t) => {
+        try {
+          await t();
+        } finally {
+          done++;
+        }
+      })
+    );
+  }
+  return done;
+}
+var FileMemoryStore = class {
+  baseDir;
+  maxAge;
+  idx;
+  loaded = false;
+  loading = null;
+  consolidator;
+  embedder;
+  onEvent;
+  /** 同 id 写互斥（save/delete/touchRecall） */
+  writeLocks = new KeyedMutex();
+  lastConsolidatedAt;
+  constructor(options = {}) {
+    this.baseDir = resolveBaseDir(options.baseDir);
+    this.maxAge = options.maxAge;
+    this.idx = options.index ?? new MemoryIndex();
+    this.embedder = options.embedder;
+    this.onEvent = options.onEvent;
+  }
+  get dir() {
+    return this.baseDir;
+  }
+  setConsolidator(consolidator) {
+    this.consolidator = consolidator;
+  }
+  // ─── 加载 ───────────────────────────────────────────────────────
+  /** 懒加载：读取目录所有 JSON → 内存索引。并发安全。 */
+  async ensureLoaded() {
+    if (this.loaded) return;
+    if (this.loading) return this.loading;
+    this.loading = (async () => {
+      const start = Date.now();
+      let loaded = 0;
+      let skipped = 0;
+      try {
+        await fs.mkdir(this.baseDir, { recursive: true });
+        const files = await fs.readdir(this.baseDir);
+        const now = Date.now();
+        const jsonFiles = files.filter((f) => f.endsWith(".json") && !f.endsWith(".tmp"));
+        await runPool(
+          jsonFiles.map((f) => async () => {
+            const filePath = path.join(this.baseDir, f);
+            try {
+              const raw = await fs.readFile(filePath, "utf-8");
+              const entry = JSON.parse(raw);
+              if (!entry?.id) {
+                skipped++;
+                return;
+              }
+              const expiredByAge = this.maxAge != null && now - entry.updatedAt > this.maxAge;
+              const expiredByTtl = entry.expiresAt != null && now > entry.expiresAt;
+              if (expiredByAge || expiredByTtl) {
+                await fs.unlink(filePath).catch(() => {
+                });
+                skipped++;
+                return;
+              }
+              this.idx.add(entry);
+              loaded++;
+            } catch {
+              skipped++;
+              this.onEvent?.({ type: "store:corrupt", file: f });
+            }
+          })
+        );
+      } catch (err) {
+        this.onEvent?.({ type: "store:corrupt", file: `<baseDir> ${err.message}` });
+      }
+      this.loaded = true;
+      this.loading = null;
+      if (loaded > 0 || skipped > 0) {
+        this.onEvent?.({
+          type: "store:load",
+          loaded,
+          skipped,
+          ms: Date.now() - start
+        });
+      }
+    })();
+    return this.loading;
+  }
+  entryPath(id) {
+    return path.join(this.baseDir, `${encodeId(id)}.json`);
+  }
+  async writeEntry(entry) {
+    await fs.mkdir(this.baseDir, { recursive: true });
+    const target = this.entryPath(entry.id);
+    const tmp = `${target}.${process.pid}.tmp`;
+    await fs.writeFile(tmp, JSON.stringify(entry, null, 2), "utf-8");
+    await fs.rename(tmp, target);
+  }
+  // ─── MemoryStore ────────────────────────────────────────────────
+  async save(entry) {
+    await this.ensureLoaded();
+    return this.writeLocks.withLock(entry.id ?? "*", async () => {
+      const prev = entry.id ? this.idx.get(entry.id) : null;
+      const finalized = finalizeEntry(
+        {
+          ...entry,
+          // 保留 embedding（若已存在且新 entry 未提供）
+          embedding: entry.embedding ?? prev?.embedding,
+          // 显式 createdAt 优先（如合并器保留最早创建时间）；未提供时沿用已有条目的
+          createdAt: entry.createdAt ?? prev?.createdAt
+        },
+        Date.now()
+      );
+      if (this.embedder && !finalized.embedding) {
+        try {
+          finalized.embedding = await this.embedder.embed(finalized.content);
+        } catch (err) {
+          this.onEvent?.({
+            type: "embedding:error",
+            id: finalized.id,
+            error: err.message
+          });
+        }
+      }
+      await this.writeEntry(finalized);
+      this.idx.add(finalized);
+      return finalized;
+    });
+  }
+  async get(id) {
+    await this.ensureLoaded();
+    return this.idx.get(id);
+  }
+  async delete(id) {
+    await this.ensureLoaded();
+    return this.writeLocks.withLock(id, async () => {
+      const existed = this.idx.remove(id);
+      if (existed) {
+        await fs.unlink(this.entryPath(id)).catch(() => {
+        });
+      }
+      return existed;
+    });
+  }
+  async list(limit) {
+    await this.ensureLoaded();
+    return this.idx.list(limit);
+  }
+  async search(query, limit) {
+    await this.ensureLoaded();
+    return this.idx.search(query, limit);
+  }
+  async searchVectors(queryVec, limit) {
+    await this.ensureLoaded();
+    return this.idx.searchVectors(queryVec, limit);
+  }
+  async touchRecall(id, at = Date.now()) {
+    await this.ensureLoaded();
+    return this.writeLocks.withLock(id, async () => {
+      const e = this.idx.get(id);
+      if (!e) return;
+      e.lastRecalledAt = at;
+      e.recallCount += 1;
+      await this.writeEntry(e);
+      this.idx.add(e);
+    });
+  }
+  async consolidate(options) {
+    if (!this.consolidator) return { merged: 0, pruned: 0 };
+    await this.ensureLoaded();
+    const result = await this.consolidator.run(options);
+    this.lastConsolidatedAt = Date.now();
+    return result;
+  }
+  async prune(options) {
+    await this.ensureLoaded();
+    const now = Date.now();
+    const maxAge = options?.maxAgeMs;
+    const minConf = options?.minConfidence ?? 0;
+    let removed = 0;
+    for (const e of this.idx.all()) {
+      const expiredByAge = maxAge != null && now - e.updatedAt > maxAge;
+      const expiredByTtl = e.expiresAt != null && now > e.expiresAt;
+      const lowConf = e.confidence < minConf;
+      if (expiredByAge || expiredByTtl || lowConf) {
+        if (await this.delete(e.id)) removed++;
+      }
+    }
+    if (removed > 0) this.onEvent?.({ type: "prune", removed });
+    return removed;
+  }
+  async count() {
+    await this.ensureLoaded();
+    return this.idx.count();
+  }
+  markConsolidated(at = Date.now()) {
+    this.lastConsolidatedAt = at;
+  }
+  async stats() {
+    await this.ensureLoaded();
+    const base = this.idx.stats();
+    return { ...base, lastConsolidatedAt: this.lastConsolidatedAt };
+  }
+  dispose() {
+  }
+};
+function createFileMemoryStore(options) {
+  return new FileMemoryStore(options);
+}
+
+// src/retrieval/embedder.ts
+function cosine(a, b) {
+  if (!a || !b || a.length === 0 || a.length !== b.length) return 0;
+  let dot2 = 0;
+  let na = 0;
+  let nb = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot2 += a[i] * b[i];
+    na += a[i] * a[i];
+    nb += b[i] * b[i];
+  }
+  if (na === 0 || nb === 0) return 0;
+  return dot2 / (Math.sqrt(na) * Math.sqrt(nb));
+}
+function minMaxNormalize(scores) {
+  if (scores.length === 0) return [];
+  const min = Math.min(...scores);
+  const max = Math.max(...scores);
+  if (max - min === 0) return scores.map(() => 1);
+  return scores.map((s) => (s - min) / (max - min));
+}
+
+// src/retrieval/hybrid-retriever.ts
+var HybridRetriever = class {
+  bm25;
+  vector;
+  embedder;
+  bm25Weight;
+  embedWeight;
+  minScore;
+  constructor(options) {
+    this.bm25 = options.bm25;
+    this.vector = options.vector;
+    this.embedder = options.embedder;
+    this.bm25Weight = options.bm25Weight ?? 0.5;
+    this.embedWeight = options.embedWeight ?? 0.5;
+    this.minScore = options.minScore ?? 0.1;
+  }
+  /** 是否启用了向量检索 */
+  get hasEmbedder() {
+    return !!this.embedder;
+  }
+  async search(query, limit = 5, opts) {
+    const minScore = opts?.minScore ?? this.minScore;
+    const raw = opts?.raw ?? false;
+    if (limit <= 0) return [];
+    const bm25Limit = this.embedder ? Math.max(limit * 3, limit) : limit;
+    const bm25Results = await this.bm25.search(query, bm25Limit);
+    if (!this.embedder) {
+      if (bm25Results.length === 0) return [];
+      return raw ? this.fuseRaw(bm25Results, [], minScore, limit) : this.fuseSingle(bm25Results, minScore, limit);
+    }
+    let queryVec = null;
+    try {
+      queryVec = await this.embedder.embed(query);
+    } catch {
+      queryVec = null;
+    }
+    if (!this.vector || !queryVec || queryVec.length === 0) {
+      if (bm25Results.length === 0) return [];
+      if (raw) return this.fuseRaw(bm25Results, [], minScore, limit);
+      return queryVec && this.vector ? this.rerank(bm25Results, queryVec, minScore, limit) : this.fuseSingle(bm25Results, minScore, limit);
+    }
+    let vecResults = [];
+    try {
+      vecResults = await this.vector.searchVectors(queryVec, bm25Limit);
+    } catch {
+      vecResults = [];
+    }
+    if (bm25Results.length === 0 && vecResults.length === 0) return [];
+    return raw ? this.fuseRaw(bm25Results, vecResults, minScore, limit) : this.fuseDual(bm25Results, vecResults, minScore, limit);
+  }
+  // ─── 融合策略 ───────────────────────────────────────────────────
+  /** 单路（纯 BM25）：归一化 + 过滤 + 截断 */
+  fuseSingle(results, minScore, limit) {
+    const normed = minMaxNormalize(results.map((r) => r.score));
+    return results.map((r, i) => ({ entry: r.entry, score: normed[i], matchedBy: "bm25" })).filter((r) => r.score >= minScore).sort((a, b) => b.score - a.score).slice(0, limit);
+  }
+  /** 候选重排（兼容路径）：BM25 候选 + 向量 cosine 加权融合 */
+  rerank(bm25Results, queryVec, minScore, limit) {
+    const cosScores = bm25Results.map((r) => {
+      const ev = r.entry.embedding;
+      return ev && ev.length === queryVec.length ? cosine(queryVec, ev) : 0;
+    });
+    const bm25Normed = minMaxNormalize(bm25Results.map((r) => r.score));
+    const cosNormed = minMaxNormalize(cosScores);
+    const wSum = this.bm25Weight + this.embedWeight || 1;
+    return bm25Results.map((r, i) => ({
+      entry: r.entry,
+      score: (this.bm25Weight * bm25Normed[i] + this.embedWeight * cosNormed[i]) / wSum,
+      matchedBy: cosNormed[i] >= bm25Normed[i] ? "embedding" : "hybrid"
+    })).filter((r) => r.score >= minScore).sort((a, b) => b.score - a.score).slice(0, limit);
+  }
+  /**
+   * 原始分数融合（raw 模式）：保留检索源原始分数，不做 min-max 归一化，
+   * 供合并器按「绝对相似度阈值」判定可合并项。双路命中时取 max
+   * （任一来源判定相似即相似），避免归一化把次优分数抹平。
+   *
+   * 量纲说明：BM25 分数在 BM25Retriever 层已按 Σidf 归一化到 [0,1]
+   * （完全同文≈1），cosine 本身在 [0,1]，因此这里的绝对阈值（如 0.85）
+   * 对两路统一成立。
+   */
+  fuseRaw(bm25Results, vecResults, minScore, limit) {
+    const union = /* @__PURE__ */ new Map();
+    for (const r of bm25Results) {
+      union.set(r.entry.id, { entry: r.entry, score: r.score, matchedBy: "bm25" });
+    }
+    for (const r of vecResults) {
+      const prev = union.get(r.entry.id);
+      if (!prev) {
+        union.set(r.entry.id, { entry: r.entry, score: r.score, matchedBy: "embedding" });
+      } else {
+        prev.score = Math.max(prev.score, r.score);
+        if (prev.matchedBy === "bm25") prev.matchedBy = "hybrid";
+      }
+    }
+    return [...union.values()].filter((x) => x.score >= minScore).sort((a, b) => b.score - a.score).slice(0, limit);
+  }
+  /** 双路独立召回融合：按 id 取并集，加权求和，再按权重和归一化 */
+  fuseDual(bm25Results, vecResults, minScore, limit) {
+    const bm25Normed = minMaxNormalize(bm25Results.map((r) => r.score));
+    const vecNormed = minMaxNormalize(vecResults.map((r) => r.score));
+    const wB = this.bm25Weight;
+    const wE = this.embedWeight;
+    const wSum = wB + wE || 1;
+    const union = /* @__PURE__ */ new Map();
+    bm25Results.forEach((r, i) => {
+      union.set(r.entry.id, { entry: r.entry, score: bm25Normed[i] * wB, matchedBy: "bm25" });
+    });
+    vecResults.forEach((r, i) => {
+      const prev = union.get(r.entry.id);
+      const s = vecNormed[i] * wE;
+      if (!prev) {
+        union.set(r.entry.id, { entry: r.entry, score: s, matchedBy: "embedding" });
+      } else {
+        prev.score += s;
+        if (prev.matchedBy === "bm25") prev.matchedBy = "hybrid";
+      }
+    });
+    return [...union.values()].map((x) => ({ entry: x.entry, score: x.score / wSum, matchedBy: x.matchedBy })).filter((r) => r.score >= minScore).sort((a, b) => b.score - a.score).slice(0, limit);
+  }
+};
+
+// ../agent/core/types.ts
+function createTextContent(text) {
+  return { type: "text", text };
+}
+
+// ../agent/core/context-resource.ts
+var ContextResourceBuilder = class {
+  _id;
+  _type = "custom";
+  _role = "user";
+  _content = "";
+  _timestamp = Date.now();
+  _dependencies = [];
+  _meta = {};
+  _pinned = false;
+  constructor(id) {
+    this._id = id || `res_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+  }
+  id(id) {
+    this._id = id;
+    return this;
+  }
+  type(t) {
+    this._type = t;
+    return this;
+  }
+  role(r) {
+    this._role = r;
+    return this;
+  }
+  content(c) {
+    this._content = c;
+    return this;
+  }
+  timestamp(ts) {
+    this._timestamp = ts;
+    return this;
+  }
+  dependsOn(...ids) {
+    this._dependencies.push(...ids);
+    return this;
+  }
+  meta(key, value) {
+    this._meta[key] = value;
+    return this;
+  }
+  pinned(p = true) {
+    this._pinned = p;
+    return this;
+  }
+  build() {
+    return {
+      id: this._id,
+      type: this._type,
+      role: this._role,
+      content: this._content,
+      timestamp: this._timestamp,
+      dependencies: this._dependencies,
+      meta: this._meta,
+      pinned: this._pinned
+    };
+  }
+};
+
+// ../agent/core/transformer.ts
+var BaseTransformer = class {
+  config;
+  constructor(options = {}) {
+    this.config = options.config ?? {};
+  }
+  async transform(resources, context) {
+    return this.run(resources, context);
+  }
+};
+
+// ../agent/core/extension.ts
+var BaseExtension = class {
+  apply(hooks, context) {
+    this.setup(hooks, context);
+  }
+};
+
+// src/capture/extractor.ts
+function truncate(text, max) {
+  if (text.length <= max) return text;
+  return `${text.slice(0, max - 1)}\u2026`;
+}
+function firstSentence(text, max) {
+  const trimmed = text.trim();
+  if (!trimmed) return "";
+  const match = trimmed.match(/^[^。！？!?.…\n]+[。！？!?.…]?/);
+  const first = match ? match[0].trim() : trimmed;
+  return truncate(first, max);
+}
+function extractFromTurn(userMessage, assistantContent, toolsUsed, options = {}) {
+  const maxChars = options.maxChars ?? 2e3;
+  const maxConcepts = options.maxConcepts ?? 8;
+  const parts = [];
+  if (userMessage) parts.push(`Q: ${firstSentence(userMessage, 160)}`);
+  if (assistantContent) parts.push(`A: ${firstSentence(assistantContent, 320)}`);
+  if (toolsUsed.length > 0) parts.push(`tools: ${toolsUsed.slice(0, 5).join(", ")}`);
+  const content = truncate(parts.join("\n"), maxChars);
+  const conceptSource = `${userMessage} ${assistantContent} ${toolsUsed.join(" ")}`;
+  const concepts = extractConcepts(conceptSource, maxConcepts);
+  return { content, concepts, summarized: false };
+}
+async function runCaptureExtractor(input, options = {}) {
+  const { userMessage, assistantContent, toolsUsed, summarizeFn } = input;
+  if (summarizeFn) {
+    try {
+      const result = await summarizeFn({
+        userMessage,
+        assistantContent,
+        toolsUsed
+      });
+      if (result && result.summary && result.summary.trim()) {
+        const maxChars = options.maxChars ?? 2e3;
+        const concepts = result.concepts && result.concepts.length > 0 ? result.concepts : extractConcepts(
+          `${userMessage} ${result.summary}`,
+          options.maxConcepts ?? 8
+        );
+        return {
+          content: truncate(result.summary.trim(), maxChars),
+          concepts,
+          summarized: true
+        };
+      }
+    } catch {
+    }
+  }
+  return extractFromTurn(userMessage, assistantContent, toolsUsed, options);
+}
+
+// src/capture/capture-extension.ts
+var MemoryCaptureExtension = class extends BaseExtension {
+  name = "memory-capture";
+  store;
+  summarizeFn;
+  minLength;
+  maxConcepts;
+  maxContentChars;
+  consolidateEvery;
+  ttlMs;
+  onEvent;
+  /** 本轮待捕获的用户消息（sessionKey -> 请求信息） */
+  pending = /* @__PURE__ */ new Map();
+  /** 捕获计数（用于触发 consolidate） */
+  captureCount = 0;
+  constructor(store, options = {}) {
+    super();
+    this.store = store;
+    this.summarizeFn = options.summarizeFn;
+    this.minLength = options.minLength ?? 12;
+    this.maxConcepts = options.maxConcepts ?? 8;
+    this.maxContentChars = options.maxContentChars ?? 2e3;
+    this.consolidateEvery = options.consolidateEvery ?? 0;
+    this.ttlMs = options.ttlMs;
+    this.onEvent = options.onEvent;
+  }
+  setup(hooks, context) {
+    const sessionKey = context.sessionKey;
+    hooks.beforeRun.tapPromise("memory-capture", async (request) => {
+      try {
+        this.pending.set(sessionKey, { message: request.message });
+      } catch {
+      }
+      return request;
+    });
+    hooks.done.tapPromise("memory-capture", async (result, _request) => {
+      await this.captureFromResult(result, sessionKey);
+    });
+  }
+  async captureFromResult(result, sessionKey) {
+    if (!sessionKey) return;
+    const stashed = this.pending.get(sessionKey);
+    this.pending.delete(sessionKey);
+    if (!stashed) return;
+    if (!result.success) return;
+    const userMessage = stashed.message;
+    const assistantContent = result.content ?? "";
+    if (!userMessage || userMessage.trim().length < this.minLength) return;
+    if (!assistantContent || !assistantContent.trim()) return;
+    try {
+      const extracted = await runCaptureExtractor(
+        {
+          userMessage,
+          assistantContent,
+          toolsUsed: result.toolsUsed ?? [],
+          summarizeFn: this.summarizeFn
+        },
+        { maxConcepts: this.maxConcepts, maxChars: this.maxContentChars }
+      );
+      await this.store.save({
+        content: extracted.content,
+        concepts: extracted.concepts,
+        confidence: extracted.summarized ? 0.8 : 0.6,
+        source: "capture",
+        sessionKey,
+        ttlMs: this.ttlMs
+      });
+      this.captureCount += 1;
+      if (this.consolidateEvery > 0 && this.captureCount % this.consolidateEvery === 0) {
+        try {
+          await this.store.consolidate();
+        } catch (err) {
+          this.onEvent?.({
+            type: "consolidate:failed",
+            error: err.message
+          });
+        }
+      }
+    } catch (err) {
+      this.onEvent?.({ type: "capture:failed", sessionKey, error: err.message });
+    }
+  }
+};
+
+// src/injection/sentinels.ts
+var MEMORY_BLOCK_START = "<<<AIPACK_MEMORY>>>";
+var MEMORY_BLOCK_END = "<<</AIPACK_MEMORY>>>";
+function stripMemoryBlock(text) {
+  if (!text) return text;
+  const re = new RegExp(
+    `${escapeRegex(MEMORY_BLOCK_START)}[\\s\\S]*?${escapeRegex(MEMORY_BLOCK_END)}\\s*`,
+    "g"
+  );
+  return text.replace(re, "").trim();
+}
+function hasMemoryBlock(text) {
+  if (!text) return false;
+  return text.includes(MEMORY_BLOCK_START);
+}
+function wrapMemoryBlock(lines) {
+  const body = lines.join("\n").trimEnd();
+  return `${MEMORY_BLOCK_START}
+${body}
+${MEMORY_BLOCK_END}`;
+}
+function buildMemoryBlock(results) {
+  if (results.length === 0) return "";
+  const lines = ["[Relevant memories]"];
+  for (const r of results) {
+    const score = r.score.toFixed(2);
+    const content = r.entry.content.replace(/\s+/g, " ").trim().slice(0, 500);
+    lines.push(`- ${content} (score=${score}, id=${r.entry.id})`);
+  }
+  return wrapMemoryBlock(lines);
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/injection/injection-transformer.ts
+var MemoryInjectionTransformer = class extends BaseTransformer {
+  name = "memory-injection";
+  retriever;
+  maxMemories;
+  minScore;
+  queryTransform;
+  onRecall;
+  constructor(retriever, options = {}) {
+    super();
+    this.retriever = retriever;
+    this.maxMemories = options.maxMemories ?? 5;
+    this.minScore = options.minScore ?? 0.1;
+    this.queryTransform = options.queryTransform;
+    this.onRecall = options.onRecall;
+  }
+  async run(resources, _context) {
+    if (resources.length === 0) return resources;
+    let cleaned = resources.map((r) => this.stripResource(r));
+    let latestIdx = -1;
+    for (let i = cleaned.length - 1; i >= 0; i--) {
+      if (cleaned[i].type === "user_message") {
+        latestIdx = i;
+        break;
+      }
+    }
+    if (latestIdx === -1) return cleaned;
+    const latest = cleaned[latestIdx];
+    const queryText = this.extractUserText(latest);
+    if (!queryText || !queryText.trim()) return cleaned;
+    const query = this.queryTransform ? this.queryTransform(queryText) : queryText;
+    const results = await this.retriever.search(query, this.maxMemories, {
+      minScore: this.minScore
+    });
+    if (results.length === 0) return cleaned;
+    if (this.onRecall) {
+      const ids = results.map((r) => r.entry.id);
+      Promise.resolve().then(() => this.onRecall(ids)).catch(() => {
+      });
+    }
+    const block = buildMemoryBlock(results);
+    const injected = this.injectIntoResource(latest, block);
+    cleaned = [...cleaned];
+    cleaned[latestIdx] = injected;
+    return cleaned;
+  }
+  // ─── 工具方法 ───────────────────────────────────────────────────
+  /** 从资源中抽取纯文本（兼容 string 与 ContentBlock[]） */
+  extractUserText(resource) {
+    const content = resource.content;
+    if (typeof content === "string") return stripMemoryBlock(content);
+    if (Array.isArray(content)) {
+      return content.map((b) => this.isTextBlock(b) ? stripMemoryBlock(b.text) : "").join("").trim();
+    }
+    return "";
+  }
+  isTextBlock(b) {
+    return b.type === "text";
+  }
+  /** 剥除单个资源中的 sentinel 块，返回新资源（若无需剥除返回原资源） */
+  stripResource(resource) {
+    if (resource.type !== "user_message") return resource;
+    const content = resource.content;
+    if (typeof content === "string") {
+      if (!hasMemoryBlock(content)) return resource;
+      return this.rebuildResource(resource, stripMemoryBlock(content));
+    }
+    if (Array.isArray(content)) {
+      let changed = false;
+      const newBlocks = [];
+      for (const b of content) {
+        if (this.isTextBlock(b)) {
+          if (!hasMemoryBlock(b.text)) {
+            newBlocks.push(b);
+            continue;
+          }
+          const stripped = stripMemoryBlock(b.text);
+          if (stripped) {
+            newBlocks.push({ type: "text", text: stripped });
+          }
+          changed = true;
+        } else {
+          newBlocks.push(b);
+        }
+      }
+      if (!changed) return resource;
+      return this.rebuildResource(resource, newBlocks);
+    }
+    return resource;
+  }
+  /** 把记忆块前插进资源内容 */
+  injectIntoResource(resource, block) {
+    const content = resource.content;
+    if (typeof content === "string") {
+      const original = stripMemoryBlock(content);
+      const injected = `${block}
+
+${original}`;
+      return this.rebuildResource(resource, injected);
+    }
+    if (Array.isArray(content)) {
+      const kept = content.filter(
+        (b) => !(this.isTextBlock(b) && hasMemoryBlock(b.text))
+      );
+      const injected = [
+        { type: "text", text: `${block}
+
+` },
+        ...kept
+      ];
+      return this.rebuildResource(resource, injected);
+    }
+    return resource;
+  }
+  /** 重建资源（保持 id/type/role/timestamp/dependencies/meta/pinned，替换 content） */
+  rebuildResource(resource, content) {
+    return new ContextResourceBuilder().id(resource.id).type(resource.type).role(resource.role).content(content).timestamp(resource.timestamp).pinned(resource.pinned).build();
+  }
+};
+
+// src/consolidation/consolidator.ts
+function mergeTwo(a, b) {
+  const newer = a.updatedAt >= b.updatedAt ? a : b;
+  const older = newer === a ? b : a;
+  const content = newer.content.length >= older.content.length ? newer.content : older.content;
+  const concepts = [.../* @__PURE__ */ new Set([...a.concepts, ...b.concepts])];
+  const confidence = Math.min(1, Math.max(a.confidence, b.confidence) + 0.05);
+  const lastRecalledAt = [a.lastRecalledAt, b.lastRecalledAt].filter((t) => t != null).sort().pop();
+  return {
+    id: newer.id,
+    content,
+    concepts,
+    confidence,
+    source: "consolidation",
+    sessionKey: newer.sessionKey,
+    createdAt: Math.min(a.createdAt, b.createdAt),
+    updatedAt: Date.now(),
+    lastRecalledAt,
+    recallCount: a.recallCount + b.recallCount,
+    embedding: newer.embedding ?? older.embedding,
+    expiresAt: newer.expiresAt ?? older.expiresAt,
+    meta: { ...older.meta ?? {}, ...newer.meta ?? {} }
+  };
+}
+var Consolidator = class {
+  store;
+  retriever;
+  similarityThreshold;
+  onEvent;
+  constructor(store, retriever, options = {}) {
+    this.store = store;
+    this.retriever = retriever;
+    this.similarityThreshold = options.similarityThreshold ?? 0.85;
+    this.onEvent = options.onEvent;
+  }
+  async run(options = {}) {
+    const start = Date.now();
+    const threshold = options.similarityThreshold ?? this.similarityThreshold;
+    const all = await this.store.list();
+    const stats = await this.store.stats();
+    const since = stats.lastConsolidatedAt;
+    const candidates = (since == null ? all : all.filter((e) => e.updatedAt >= since)).sort(
+      // 显式按 updatedAt 降序（新条目先处理，可吸收旧的相似条目）；
+      // 同毫秒写入时以 createdAt 决胜，保证处理顺序确定
+      (a, b) => b.updatedAt - a.updatedAt || b.createdAt - a.createdAt
+    );
+    const processed = /* @__PURE__ */ new Set();
+    let merged = 0;
+    for (const entry of candidates) {
+      if (processed.has(entry.id)) continue;
+      let results = [];
+      try {
+        results = await this.retriever.search(entry.content, 10, { raw: true });
+      } catch {
+        continue;
+      }
+      const similar = results.filter(
+        (r) => r.entry.id !== entry.id && !processed.has(r.entry.id) && r.score >= threshold
+      );
+      if (similar.length === 0) {
+        processed.add(entry.id);
+        continue;
+      }
+      let survivor = entry;
+      for (const r of similar) {
+        survivor = mergeTwo(survivor, r.entry);
+        processed.add(r.entry.id);
+      }
+      await this.store.save({
+        id: survivor.id,
+        content: survivor.content,
+        concepts: survivor.concepts,
+        confidence: survivor.confidence,
+        source: "consolidation",
+        sessionKey: survivor.sessionKey,
+        createdAt: survivor.createdAt,
+        embedding: survivor.embedding,
+        expiresAt: survivor.expiresAt,
+        recallCount: survivor.recallCount
+      });
+      merged += similar.length;
+      for (const r of similar) {
+        try {
+          await this.store.delete(r.entry.id);
+        } catch (err) {
+          this.onEvent?.({ type: "consolidate:failed", error: `delete:${err.message}` });
+        }
+      }
+      processed.add(survivor.id);
+    }
+    let pruned = 0;
+    try {
+      pruned += await this.store.prune({
+        maxAgeMs: options.maxAgeMs,
+        minConfidence: options.minConfidence ?? 0.1
+      });
+    } catch (err) {
+      this.onEvent?.({ type: "consolidate:failed", error: err.message });
+    }
+    if (options.maxMemories != null) {
+      const after = await this.store.list();
+      if (after.length > options.maxMemories) {
+        const sorted = [...after].sort(
+          (a, b) => b.confidence - a.confidence || b.updatedAt - a.updatedAt
+        );
+        const toRemove = sorted.slice(options.maxMemories);
+        for (const e of toRemove) {
+          const ok = await this.store.delete(e.id);
+          if (ok) pruned++;
+        }
+      }
+    }
+    this.store.markConsolidated();
+    const ms = Date.now() - start;
+    this.onEvent?.({ type: "consolidate", merged, pruned, ms });
+    return { merged, pruned };
+  }
+};
+
+// src/tools/memory-tools.ts
+var MAX_CONTENT_CHARS = 2e3;
+var MAX_CONCEPTS = 20;
+var MAX_LIST_LIMIT = 200;
+var MAX_SEARCH_LIMIT = 50;
+function clampInt(v, fallback, min, max) {
+  const n = typeof v === "number" && Number.isFinite(v) ? Math.floor(v) : fallback;
+  return Math.min(max, Math.max(min, n));
+}
+function createMemoryTools(store, options = {}) {
+  const listLimit = clampInt(options.listLimit, 20, 1, MAX_LIST_LIMIT);
+  const searchLimit = clampInt(options.searchLimit, 5, 1, MAX_SEARCH_LIMIT);
+  const saveTtlMs = options.saveTtlMs;
+  const saveMemory = {
+    name: "save_memory",
+    description: "\u4FDD\u5B58\u4E00\u6761\u957F\u671F\u8BB0\u5FC6\uFF08\u8DE8\u4F1A\u8BDD\u4FDD\u7559\uFF09\u3002\u7528\u4E8E\u8BB0\u5F55\u7528\u6237\u504F\u597D\u3001\u5173\u952E\u51B3\u7B56\u3001\u4E8B\u5B9E\u7EA6\u675F\u3001\u67B6\u6784\u7EA6\u5B9A\u7B49\uFF0C\u4EE5\u4FBF\u540E\u7EED\u4F1A\u8BDD\u81EA\u52A8\u68C0\u7D22\u6CE8\u5165\u3002content \u4E3A\u8BB0\u5FC6\u6B63\u6587\uFF0Cconcepts \u4E3A\u53EF\u9009\u5173\u952E\u8BCD\u6807\u7B7E\u3002",
+    parameters: {
+      type: "object",
+      properties: {
+        content: { type: "string", description: "\u8BB0\u5FC6\u6B63\u6587" },
+        concepts: {
+          type: "array",
+          items: { type: "string" },
+          description: "\u53EF\u9009\u5173\u952E\u8BCD / \u6982\u5FF5\u6807\u7B7E"
+        }
+      },
+      required: ["content"]
+    },
+    async execute(_toolCallId, args) {
+      const a = args ?? {};
+      if (!a.content || !a.content.trim()) {
+        return {
+          content: [createTextContent("save_memory \u5931\u8D25\uFF1Acontent \u4E0D\u80FD\u4E3A\u7A7A")],
+          details: { error: "empty content" }
+        };
+      }
+      const content = a.content.trim().slice(0, MAX_CONTENT_CHARS);
+      const concepts = (a.concepts ?? []).filter((c) => typeof c === "string" && c.length > 0).map((c) => c.trim().slice(0, 50)).slice(0, MAX_CONCEPTS);
+      return store.save({
+        content,
+        concepts,
+        confidence: 0.7,
+        source: "tool",
+        ttlMs: saveTtlMs
+      }).then((entry) => ({
+        content: [createTextContent(`\u5DF2\u4FDD\u5B58\u8BB0\u5FC6\uFF08id=${entry.id}\uFF09`)],
+        details: { id: entry.id, saved: true }
+      }));
+    }
+  };
+  const searchMemory = {
+    name: "search_memory",
+    description: "\u68C0\u7D22\u4E0E\u67E5\u8BE2\u76F8\u5173\u7684\u957F\u671F\u8BB0\u5FC6\uFF08BM25 \u5173\u952E\u8BCD + \u53EF\u9009\u5411\u91CF\u6DF7\u5408\u68C0\u7D22\uFF09\u3002\u8FD4\u56DE\u6309\u76F8\u5173\u5EA6\u6392\u5E8F\u7684\u8BB0\u5FC6\u5217\u8868\u3002",
+    parameters: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "\u68C0\u7D22\u67E5\u8BE2" },
+        limit: { type: "integer", description: "\u8FD4\u56DE\u4E0A\u9650\uFF08\u9ED8\u8BA4 5\uFF09" }
+      },
+      required: ["query"]
+    },
+    async execute(_toolCallId, args) {
+      const a = args ?? {};
+      if (!a.query || !a.query.trim()) {
+        return {
+          content: [createTextContent("search_memory \u5931\u8D25\uFF1Aquery \u4E0D\u80FD\u4E3A\u7A7A")],
+          details: { error: "empty query" }
+        };
+      }
+      const limit = clampInt(a.limit, searchLimit, 1, MAX_SEARCH_LIMIT);
+      const results = await store.search(a.query.trim(), limit);
+      if (results.length === 0) {
+        return {
+          content: [createTextContent("\u672A\u627E\u5230\u76F8\u5173\u8BB0\u5FC6\u3002")],
+          details: { count: 0 }
+        };
+      }
+      const lines = results.map(
+        (r, i) => `${i + 1}. [score=${r.score.toFixed(2)} id=${r.entry.id}] ${r.entry.content.replace(/\s+/g, " ").slice(0, 200)}`
+      );
+      return {
+        content: [createTextContent(`\u627E\u5230 ${results.length} \u6761\u76F8\u5173\u8BB0\u5FC6\uFF1A
+${lines.join("\n")}`)],
+        details: { count: results.length, ids: results.map((r) => r.entry.id) }
+      };
+    }
+  };
+  const listMemories = {
+    name: "list_memories",
+    description: "\u5217\u51FA\u6700\u8FD1\u7684\u957F\u671F\u8BB0\u5FC6\uFF08\u6309\u66F4\u65B0\u65F6\u95F4\u5012\u5E8F\uFF09\u3002",
+    parameters: {
+      type: "object",
+      properties: {
+        limit: { type: "integer", description: "\u8FD4\u56DE\u4E0A\u9650\uFF08\u9ED8\u8BA4 20\uFF09" }
+      }
+    },
+    async execute(_toolCallId, args) {
+      const a = args ?? {};
+      const limit = clampInt(a.limit, listLimit, 1, MAX_LIST_LIMIT);
+      const entries = await store.list(limit);
+      if (entries.length === 0) {
+        return {
+          content: [createTextContent("\u5F53\u524D\u65E0\u4EFB\u4F55\u8BB0\u5FC6\u3002")],
+          details: { count: 0 }
+        };
+      }
+      const lines = entries.map(
+        (e, i) => `${i + 1}. [id=${e.id} conf=${e.confidence.toFixed(2)}] ${e.content.replace(/\s+/g, " ").slice(0, 200)}`
+      );
+      return {
+        content: [
+          createTextContent(`\u5171 ${entries.length} \u6761\u8BB0\u5FC6\uFF1A
+${lines.join("\n")}`)
+        ],
+        details: { count: entries.length, ids: entries.map((e) => e.id) }
+      };
+    }
+  };
+  const deleteMemory = {
+    name: "delete_memory",
+    description: "\u6309 id \u5220\u9664\u4E00\u6761\u957F\u671F\u8BB0\u5FC6\u3002",
+    parameters: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "\u8BB0\u5FC6 id" }
+      },
+      required: ["id"]
+    },
+    async execute(_toolCallId, args) {
+      const a = args ?? {};
+      if (!a.id) {
+        return {
+          content: [createTextContent("delete_memory \u5931\u8D25\uFF1Aid \u4E0D\u80FD\u4E3A\u7A7A")],
+          details: { error: "empty id" }
+        };
+      }
+      const ok = await store.delete(a.id);
+      return {
+        content: [
+          createTextContent(ok ? `\u5DF2\u5220\u9664\u8BB0\u5FC6\uFF08id=${a.id}\uFF09` : `\u672A\u627E\u5230\u8BB0\u5FC6\uFF08id=${a.id}\uFF09`)
+        ],
+        details: { id: a.id, deleted: ok }
+      };
+    }
+  };
+  return [saveMemory, searchMemory, listMemories, deleteMemory];
+}
+
+// src/plugin.ts
+var StoreBackedRetriever = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  async search(query, limit = 5) {
+    return this.store.search(query, limit);
+  }
+};
+var StoreVectorSource = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  async searchVectors(queryVec, limit = 5) {
+    return this.store.searchVectors(queryVec, limit);
+  }
+};
+var FAILURE_EVENTS = /* @__PURE__ */ new Set([
+  "store:corrupt",
+  "embedding:error",
+  "capture:failed",
+  "consolidate:failed"
+]);
+function defaultEventSink(event) {
+  if (FAILURE_EVENTS.has(event.type)) {
+    console.warn(`[aipack-memory] ${event.type}: ${event.error ?? ""}`);
+  }
+}
+function isCaptureEnabled(v) {
+  if (v === false) return false;
+  return true;
+}
+function isInjectEnabled(v) {
+  if (v === false) return false;
+  return true;
+}
+function resolveCaptureOptions(v, fallback) {
+  if (typeof v === "object" && v !== null) {
+    return {
+      ...v,
+      summarizeFn: v.summarizeFn ?? fallback.summarizeFn,
+      consolidateEvery: v.consolidateEvery ?? fallback.consolidateEvery,
+      ttlMs: v.ttlMs ?? fallback.ttlMs,
+      onEvent: v.onEvent ?? fallback.onEvent
+    };
+  }
+  return {
+    summarizeFn: fallback.summarizeFn,
+    consolidateEvery: fallback.consolidateEvery,
+    ttlMs: fallback.ttlMs,
+    onEvent: fallback.onEvent
+  };
+}
+function resolveInjectOptions(v, fallback) {
+  if (typeof v === "object" && v !== null) {
+    return {
+      ...v,
+      maxMemories: v.maxMemories ?? fallback.maxMemories,
+      minScore: v.minScore ?? fallback.minScore
+    };
+  }
+  return {
+    maxMemories: fallback.maxMemories,
+    minScore: fallback.minScore
+  };
+}
+function createMemoryPlugin(options = {}) {
+  const embedder = options.embedder;
+  const onEvent = options.onEvent ?? defaultEventSink;
+  const store = options.store ?? new FileMemoryStore({
+    baseDir: options.baseDir,
+    embedder,
+    onEvent
+  });
+  const bm25Source = new StoreBackedRetriever(store);
+  const retriever = new HybridRetriever({
+    bm25: bm25Source,
+    vector: embedder ? new StoreVectorSource(store) : void 0,
+    embedder,
+    minScore: options.minScore ?? 0.1
+  });
+  const consolidator = new Consolidator(store, retriever, {
+    similarityThreshold: 0.85,
+    onEvent
+  });
+  store.setConsolidator(consolidator);
+  const extensions = [];
+  if (isCaptureEnabled(options.capture)) {
+    const captureOpts = resolveCaptureOptions(options.capture, {
+      summarizeFn: options.summarizeFn,
+      consolidateEvery: options.consolidateEvery,
+      ttlMs: options.captureTtlMs,
+      onEvent
+    });
+    extensions.push(new MemoryCaptureExtension(store, captureOpts));
+  }
+  const transformers = [];
+  if (isInjectEnabled(options.inject)) {
+    const injectOpts = resolveInjectOptions(options.inject, {
+      maxMemories: options.maxMemories,
+      minScore: options.minScore
+    });
+    transformers.push(
+      new MemoryInjectionTransformer(retriever, {
+        ...injectOpts,
+        // 命中后更新检索统计（fire-and-forget，不阻塞注入）；
+        // 失败不静默：告警日志便于排障（检索统计丢失不致命）
+        onRecall: async (ids) => {
+          await Promise.allSettled(ids.map(async (id) => {
+            try {
+              await store.touchRecall(id);
+            } catch (err) {
+              console.warn(`[memory] touchRecall \u5931\u8D25\uFF08id=${id}\uFF09: ${err.message}`);
+            }
+          }));
+        }
+      })
+    );
+  }
+  const tools = [];
+  if (options.tools !== false) {
+    tools.push(...createMemoryTools(store, { saveTtlMs: options.toolTtlMs }));
+  }
+  return {
+    store,
+    retriever,
+    extensions,
+    transformers,
+    tools,
+    install() {
+      return { extensions, transformers, tools };
+    },
+    dispose() {
+      store.dispose();
+    }
+  };
+}
+export {
+  BM25Index,
+  BM25Retriever,
+  Consolidator,
+  FileMemoryStore,
+  HybridRetriever,
+  InMemoryStore,
+  MEMORY_BLOCK_END,
+  MEMORY_BLOCK_START,
+  MemoryCaptureExtension,
+  MemoryIndex,
+  MemoryInjectionTransformer,
+  STOPWORDS,
+  VectorIndex,
+  buildMemoryBlock,
+  cosine,
+  createFileMemoryStore,
+  createInMemoryStore,
+  createMemoryPlugin,
+  createMemoryTools,
+  extractConcepts,
+  extractFromTurn,
+  finalizeEntry,
+  hasMemoryBlock,
+  isCJK,
+  minMaxNormalize,
+  runCaptureExtractor,
+  stripMemoryBlock,
+  tokenize,
+  wrapMemoryBlock
+};
+//# sourceMappingURL=index.js.map