@amemhq/core 1.0.1 → 2.0.0

package/dist/chunk-K6WZTDM7.js

@@ -0,0 +1,2353 @@
+// src/auth.ts
+var SYSTEM_ACTOR = "__amem_system__";
+function canWrite(note, callerAgentId) {
+  return note.owner === callerAgentId || note.writers.includes(callerAgentId) || note.writers.includes("*");
+}
+function canRead(note, callerAgentId) {
+  return note.owner === callerAgentId || note.readers.includes(callerAgentId) || note.readers.includes("*");
+}
+
+// src/embedding.ts
+var pipeline = null;
+var extractor = null;
+var loadedKey = null;
+var cachedDim = null;
+var DEFAULT_EMBEDDING_MODEL = "Xenova/bge-m3";
+var LEGACY_DEFAULT_EMBEDDING_MODEL = "Xenova/paraphrase-multilingual-MiniLM-L12-v2";
+var LEGACY_DEFAULT_DIM = 384;
+var DEFAULT_MODEL_DTYPE = "fp16";
+var pinnedModel = null;
+function pinEmbeddingModel(model) {
+  if (pinnedModel === model) return;
+  pinnedModel = model;
+  extractor = null;
+  loadedKey = null;
+  cachedDim = null;
+}
+function getPinnedEmbeddingModel() {
+  return pinnedModel;
+}
+function getEmbeddingModel() {
+  return process.env.AMEM_EMBED_MODEL?.trim() || pinnedModel || DEFAULT_EMBEDDING_MODEL;
+}
+var CLS_POOLED_MODELS = /* @__PURE__ */ new Set([
+  "bge-m3",
+  "bge-base-zh-v1.5",
+  "bge-small-zh-v1.5",
+  "bge-base-en-v1.5",
+  "bge-small-en-v1.5",
+  "bge-large-en-v1.5",
+  "gte-multilingual-base",
+  "gte-modernbert-base",
+  "gte-large-en-v1.5",
+  "snowflake-arctic-embed-m",
+  "snowflake-arctic-embed-l"
+]);
+function getEmbeddingPooling() {
+  const explicit = process.env.AMEM_EMBED_POOLING?.trim().toLowerCase();
+  if (explicit === "mean" || explicit === "cls") return explicit;
+  const basename = getEmbeddingModel().split("/").pop()?.toLowerCase() ?? "";
+  return CLS_POOLED_MODELS.has(basename) ? "cls" : "mean";
+}
+function getEmbeddingDevice() {
+  return process.env.AMEM_EMBED_DEVICE?.trim() || void 0;
+}
+function getEmbeddingDtype() {
+  const explicit = process.env.AMEM_EMBED_DTYPE?.trim();
+  if (explicit) return explicit;
+  return getEmbeddingModel() === DEFAULT_EMBEDDING_MODEL ? DEFAULT_MODEL_DTYPE : void 0;
+}
+function extractorKey() {
+  return `${getEmbeddingModel()}|${getEmbeddingDevice() ?? ""}|${getEmbeddingDtype() ?? ""}`;
+}
+async function getExtractor() {
+  const wanted = extractorKey();
+  if (extractor && loadedKey === wanted) return extractor;
+  if (!pipeline) {
+    const mod = await import("@huggingface/transformers");
+    pipeline = mod.pipeline;
+  }
+  const device = getEmbeddingDevice();
+  const dtype = getEmbeddingDtype();
+  extractor = await pipeline("feature-extraction", getEmbeddingModel(), {
+    revision: "main",
+    // Omitted entirely when unset, so an unconfigured install gets exactly the
+    // library defaults it got before these existed.
+    ...device ? { device } : {},
+    ...dtype ? { dtype } : {}
+  });
+  loadedKey = wanted;
+  cachedDim = null;
+  return extractor;
+}
+async function getEmbeddingDim() {
+  if (cachedDim !== null && loadedKey === extractorKey()) return cachedDim;
+  const probe = await encode("dimension probe");
+  cachedDim = probe.length;
+  return cachedDim;
+}
+function poolNormalize(output, attentionMask, mode) {
+  const seqLen = output.length;
+  const dim = output[0].length;
+  const pooled = new Array(dim).fill(0);
+  if (mode === "cls") {
+    for (let j = 0; j < dim; j++) pooled[j] = output[0][j];
+  } else {
+    let maskSum = 0;
+    for (let i = 0; i < seqLen; i++) {
+      const m = attentionMask[i];
+      maskSum += m;
+      for (let j = 0; j < dim; j++) {
+        pooled[j] += output[i][j] * m;
+      }
+    }
+    for (let j = 0; j < dim; j++) {
+      pooled[j] /= Math.max(maskSum, 1e-9);
+    }
+  }
+  let norm = 0;
+  for (const v of pooled) norm += v * v;
+  norm = Math.sqrt(norm);
+  return pooled.map((v) => v / Math.max(norm, 1e-9));
+}
+async function encode(text) {
+  const ext = await getExtractor();
+  const pooling = getEmbeddingPooling();
+  const result = await ext(text, { pooling, normalize: true });
+  if (result && result.data) {
+    return Array.from(result.data);
+  }
+  const tensor = result;
+  if (tensor.dims && tensor.dims.length === 3) {
+    const seqLen = tensor.dims[1];
+    const dim = tensor.dims[2];
+    const raw = [];
+    for (let i = 0; i < seqLen; i++) {
+      const row = [];
+      for (let j = 0; j < dim; j++) {
+        row.push(tensor.data[i * dim + j]);
+      }
+      raw.push(row);
+    }
+    return poolNormalize(raw, new Array(seqLen).fill(1), pooling);
+  }
+  throw new Error("Unexpected embedding output shape");
+}
+async function loadModel() {
+  await getExtractor();
+}
+function isModelLoaded() {
+  return extractor !== null;
+}
+function cosineSimilarity(a, b) {
+  let dot = 0;
+  for (let i = 0; i < a.length; i++) dot += a[i] * b[i];
+  return dot;
+}
+
+// src/storage.ts
+var QDRANT_URL = "http://localhost:6333";
+var getCollection = () => process.env.AMEM_COLLECTION || "amem_notes";
+var EmbeddingDimensionMismatchError = class extends Error {
+  constructor(collection, collectionDim, modelDim, model) {
+    super(
+      `Collection "${collection}" stores ${collectionDim}-dimension vectors, but the embedding model "${model}" produces ${modelDim}. Qdrant fixes a collection's vector size at creation and cannot change it, so writes and searches would both fail.
+Either set AMEM_EMBED_MODEL back to the model this collection was built with, or ${migrationHint(collection, model)}`
+    );
+    this.collection = collection;
+    this.collectionDim = collectionDim;
+    this.modelDim = modelDim;
+    this.model = model;
+    this.name = "EmbeddingDimensionMismatchError";
+  }
+  collection;
+  collectionDim;
+  modelDim;
+  model;
+};
+function migrationHint(collection, targetModel) {
+  return `migrate onto it:
+
+  AMEM_EMBED_MODEL=${targetModel} \\
+    npx --package=@amemhq/core amem-migrate --from-collection ${collection}
+
+That only reports; it takes --apply to write anything, and "${collection}" is read either way. The new store ends up behind the name you already use, so there is nothing to change in your config afterwards. See https://amem.owo.lc/reference/embedding-models.`;
+}
+var EmbeddingModelMismatchError = class extends Error {
+  constructor(collection, collectionModel, configuredModel) {
+    super(
+      `Collection "${collection}" was built with the embedding model "${collectionModel}", but this process is configured for "${configuredModel}". Both produce vectors of the same width, so nothing would fail \u2014 searches would just quietly compare vectors from two different models.
+Either set AMEM_EMBED_MODEL back to "${collectionModel}", or ` + migrationHint(collection, configuredModel)
+    );
+    this.collection = collection;
+    this.collectionModel = collectionModel;
+    this.configuredModel = configuredModel;
+    this.name = "EmbeddingModelMismatchError";
+  }
+  collection;
+  collectionModel;
+  configuredModel;
+};
+var MixedEmbeddingModelsError = class extends Error {
+  constructor(collection, wanted, inUse) {
+    super(
+      `Collection "${collection}" was built with "${wanted}", but this process is already embedding with "${inUse}" for another collection. One process can only use one model.
+Migrate the remaining collections so they all agree:
+
+  npx --package=@amemhq/core amem-migrate --from-collection ${collection}
+
+Or set AMEM_EMBED_MODEL to pin every collection to one model, which is only correct if they really were all built with it.`
+    );
+    this.collection = collection;
+    this.wanted = wanted;
+    this.inUse = inUse;
+    this.name = "MixedEmbeddingModelsError";
+  }
+  collection;
+  wanted;
+  inUse;
+};
+async function recordCollectionModel(collection, model) {
+  try {
+    await qdrant("PATCH", `/collections/${collection}`, { metadata: { embedding_model: model } });
+  } catch {
+  }
+}
+async function qdrant(method, path4, body) {
+  const res = await fetch(`${QDRANT_URL}${path4}`, {
+    method,
+    headers: { "Content-Type": "application/json" },
+    body: body ? JSON.stringify(body) : void 0
+  });
+  const data = await res.json();
+  if (!res.ok || data.status && data.status !== "ok" && data.status !== "acknowledged") {
+    throw new Error(`Qdrant ${method} ${path4} failed: ${data.error || JSON.stringify(data)}`);
+  }
+  return data.result;
+}
+async function pingQdrant() {
+  const res = await fetch(`${QDRANT_URL}/readyz`);
+  if (!res.ok) throw new Error(`Qdrant GET /readyz failed: ${res.status}`);
+}
+var _collectionReady = false;
+var _collectionReadyMap = /* @__PURE__ */ new Map();
+async function ensureCollection(collectionName) {
+  const col = collectionName || getCollection();
+  if (collectionName) {
+    if (_collectionReadyMap.get(col)) return;
+  } else {
+    if (_collectionReady) return;
+  }
+  const markReady = () => {
+    if (collectionName) _collectionReadyMap.set(col, true);
+    else _collectionReady = true;
+  };
+  let existing = null;
+  try {
+    existing = await qdrant("GET", `/collections/${col}`);
+  } catch {
+  }
+  if (existing) {
+    const collectionDim = existing.config?.params?.vectors?.size;
+    const recorded = existing.config?.metadata?.embedding_model;
+    const explicit = process.env.AMEM_EMBED_MODEL?.trim();
+    const inferLegacy = !explicit && recorded === void 0 && collectionDim === LEGACY_DEFAULT_DIM;
+    if (!explicit) {
+      const wanted = (
+        // The collection says what built it, which outranks whatever the shipped
+        // default happens to be today. This is what keeps changing the default
+        // from breaking every install that already has data.
+        typeof recorded === "string" ? recorded : inferLegacy ? LEGACY_DEFAULT_EMBEDDING_MODEL : DEFAULT_EMBEDDING_MODEL
+      );
+      const inUse = getPinnedEmbeddingModel();
+      if (inUse !== null && inUse !== wanted) throw new MixedEmbeddingModelsError(col, wanted, inUse);
+      pinEmbeddingModel(wanted);
+      if (wanted === LEGACY_DEFAULT_EMBEDDING_MODEL) {
+        console.warn(
+          `[amem] "${col}" is on ${LEGACY_DEFAULT_EMBEDDING_MODEL} (${LEGACY_DEFAULT_DIM}-dim).
+[amem] ${DEFAULT_EMBEDDING_MODEL} reads 8192 tokens where that one stops at 128, so anything longer is being truncated before it reaches the vector.
+[amem] To move: npx --package=@amemhq/core amem-migrate --from-collection ${col}`
+        );
+      }
+    }
+    if (typeof collectionDim === "number") {
+      const modelDim = await getEmbeddingDim();
+      if (collectionDim !== modelDim) {
+        throw new EmbeddingDimensionMismatchError(col, collectionDim, modelDim, getEmbeddingModel());
+      }
+    }
+    const current = getEmbeddingModel();
+    if (typeof recorded === "string" && recorded !== current) {
+      throw new EmbeddingModelMismatchError(col, recorded, current);
+    }
+    if (recorded === void 0 && !inferLegacy) {
+      await recordCollectionModel(col, current);
+    }
+    markReady();
+    return;
+  }
+  try {
+    const size = await getEmbeddingDim();
+    await qdrant("PUT", `/collections/${col}`, {
+      vectors: { size, distance: "Cosine" }
+    });
+  } catch (err) {
+    if (!(err instanceof Error) || !err.message.includes("already exists")) throw err;
+  }
+  const created = getEmbeddingModel();
+  await recordCollectionModel(col, created);
+  if (!process.env.AMEM_EMBED_MODEL?.trim()) pinEmbeddingModel(created);
+  await qdrant("PUT", `/collections/${col}/index`, {
+    field_name: "agent_id",
+    field_schema: "keyword"
+  });
+  await qdrant("PUT", `/collections/${col}/index`, {
+    field_name: "hash",
+    field_schema: "keyword"
+  });
+  await qdrant("PUT", `/collections/${col}/index`, {
+    field_name: "topics",
+    field_schema: "keyword"
+  });
+  await qdrant("PUT", `/collections/${col}/index`, {
+    field_name: "subjects",
+    field_schema: "keyword"
+  });
+  markReady();
+}
+async function scrollAllRaw(collection, limit = 1e4) {
+  const out = [];
+  let offset = void 0;
+  for (; ; ) {
+    const body = { with_payload: true, with_vector: true, limit };
+    if (offset !== void 0 && offset !== null) body.offset = offset;
+    const res = await qdrant("POST", `/collections/${collection}/points/scroll`, body);
+    out.push(...res.points);
+    offset = res.next_page_offset;
+    if (offset === void 0 || offset === null || res.points.length === 0) break;
+  }
+  return out;
+}
+async function countPointsRaw(collection) {
+  const res = await qdrant("POST", `/collections/${collection}/points/count`, { exact: true });
+  return res.count;
+}
+async function collectionDimRaw(collection) {
+  try {
+    const info = await qdrant("GET", `/collections/${collection}`);
+    return info.config?.params?.vectors?.size ?? null;
+  } catch {
+    return null;
+  }
+}
+async function createCollectionRaw(collection, size) {
+  await qdrant("PUT", `/collections/${collection}`, { vectors: { size, distance: "Cosine" } });
+  await recordCollectionModel(collection, getEmbeddingModel());
+  for (const field_name of ["agent_id", "hash", "topics", "subjects"]) {
+    await qdrant("PUT", `/collections/${collection}/index`, { field_name, field_schema: "keyword" });
+  }
+}
+async function upsertPointsRaw(collection, points) {
+  await qdrant("PUT", `/collections/${collection}/points?wait=true`, { points });
+}
+async function scrollIdsRaw(collection, limit = 1e4) {
+  const ids = /* @__PURE__ */ new Set();
+  let offset = void 0;
+  for (; ; ) {
+    const body = { with_payload: false, with_vector: false, limit };
+    if (offset !== void 0 && offset !== null) body.offset = offset;
+    const res = await qdrant("POST", `/collections/${collection}/points/scroll`, body);
+    for (const p of res.points) ids.add(String(p.id));
+    offset = res.next_page_offset;
+    if (offset === void 0 || offset === null || res.points.length === 0) break;
+  }
+  return ids;
+}
+async function deleteCollectionRaw(collection) {
+  await qdrant("DELETE", `/collections/${collection}`);
+}
+async function resolveAliasRaw(alias) {
+  try {
+    const res = await qdrant("GET", `/aliases`);
+    return res.aliases.find((a) => a.alias_name === alias)?.collection_name ?? null;
+  } catch {
+    return null;
+  }
+}
+async function createAliasRaw(alias, collection) {
+  await qdrant("POST", `/collections/aliases`, {
+    actions: [{ create_alias: { collection_name: collection, alias_name: alias } }]
+  });
+}
+async function setAliasRaw(alias, collection) {
+  await qdrant("POST", `/collections/aliases`, {
+    actions: [
+      { delete_alias: { alias_name: alias } },
+      { create_alias: { collection_name: collection, alias_name: alias } }
+    ]
+  });
+}
+function noteToPoint(note) {
+  return {
+    id: note.id,
+    vector: note.embedding,
+    payload: {
+      content: note.content,
+      keywords: note.keywords,
+      tags: note.tags,
+      context: note.context,
+      links: note.links,
+      timestamp: note.timestamp,
+      agent_id: note.agent_id,
+      hash: note.hash,
+      // 13-A
+      retrieval_count: note.retrieval_count ?? 0,
+      last_accessed: note.last_accessed || note.timestamp,
+      // 13-B: stored as JSON string (Qdrant payload can't handle nested array-of-objects)
+      evolution_history: JSON.stringify(note.evolution_history ?? []),
+      // 13-E
+      category: note.category || "General",
+      is_active: note.is_active !== false,
+      // 26B
+      topics: note.topics ?? [],
+      // 26A
+      note_type: note.note_type || "memory",
+      // 29
+      pending_merge: note.pending_merge ?? false,
+      // 30
+      evolution_type: note.evolution_type || "",
+      conflict: note.conflict ?? false,
+      conflicts_with: note.conflicts_with ?? [],
+      conflict_reason: note.conflict_reason ?? "",
+      conflict_scanned_at: note.conflict_scanned_at ?? "",
+      subjects: note.subjects ?? [],
+      // 31
+      ephemeral: note.ephemeral ?? false,
+      low_quality: note.low_quality ?? false,
+      // 32
+      owner: note.owner || note.agent_id,
+      readers: note.readers ?? [note.agent_id],
+      writers: note.writers ?? [note.agent_id]
+    }
+  };
+}
+function pointToNote(point) {
+  const p = point.payload;
+  const timestamp = p.timestamp || "";
+  let evolutionHistory = [];
+  try {
+    const raw = p.evolution_history;
+    if (typeof raw === "string" && raw.length > 0) {
+      evolutionHistory = JSON.parse(raw);
+    } else if (Array.isArray(raw)) {
+      evolutionHistory = raw;
+    }
+  } catch {
+    evolutionHistory = [];
+  }
+  return {
+    id: String(point.id),
+    content: p.content || "",
+    keywords: p.keywords || [],
+    tags: p.tags || [],
+    context: p.context || "",
+    links: p.links || [],
+    timestamp,
+    agent_id: p.agent_id || "main",
+    embedding: point.vector || [],
+    hash: p.hash || "",
+    // 13-A
+    retrieval_count: typeof p.retrieval_count === "number" ? p.retrieval_count : 0,
+    last_accessed: p.last_accessed || timestamp,
+    // 13-B
+    evolution_history: evolutionHistory,
+    // 13-E
+    category: p.category || "General",
+    is_active: p.is_active !== false,
+    // 26A
+    note_type: p.note_type === "knowledge" ? "knowledge" : "memory",
+    // 26B
+    topics: Array.isArray(p.topics) ? p.topics : [],
+    // 29
+    pending_merge: p.pending_merge === true,
+    // 30
+    evolution_type: typeof p.evolution_type === "string" && ["EVOLVE", "CONFLICT", "EXPAND", "NEW"].includes(p.evolution_type) ? p.evolution_type : void 0,
+    conflict: p.conflict === true,
+    conflicts_with: Array.isArray(p.conflicts_with) ? p.conflicts_with.filter((v) => typeof v === "string") : [],
+    conflict_reason: typeof p.conflict_reason === "string" ? p.conflict_reason : "",
+    conflict_scanned_at: typeof p.conflict_scanned_at === "string" ? p.conflict_scanned_at : "",
+    subjects: Array.isArray(p.subjects) ? p.subjects.filter((v) => typeof v === "string") : [],
+    // 31
+    ephemeral: p.ephemeral === true,
+    low_quality: p.low_quality === true,
+    // 32
+    owner: p.owner || p.agent_id || "main",
+    readers: Array.isArray(p.readers) ? p.readers : [p.agent_id || "main"],
+    writers: Array.isArray(p.writers) ? p.writers : [p.agent_id || "main"]
+  };
+}
+function agentFilter(agentId, subject) {
+  const must = [
+    {
+      should: [
+        { key: "agent_id", match: { value: agentId } },
+        { key: "agent_id", match: { value: "shared" } }
+      ]
+    }
+  ];
+  if (subject !== void 0) {
+    must.push({
+      should: [{ key: "subjects", match: { value: subject } }, { is_empty: { key: "subjects" } }]
+    });
+  }
+  return {
+    must,
+    must_not: [{ key: "is_active", match: { value: false } }]
+  };
+}
+function makeCrud(collectionName, modeBIsolated = false) {
+  const col = collectionName;
+  function scopedAgentFilter(agentId, subject) {
+    if (modeBIsolated) {
+      const must = [];
+      if (subject !== void 0) {
+        must.push({
+          should: [{ key: "subjects", match: { value: subject } }, { is_empty: { key: "subjects" } }]
+        });
+      }
+      return {
+        ...must.length > 0 && { must },
+        must_not: [{ key: "is_active", match: { value: false } }]
+      };
+    }
+    return agentFilter(agentId, subject);
+  }
+  return {
+    async addNote(note) {
+      await ensureCollection(col);
+      await qdrant("PUT", `/collections/${col}/points?wait=true`, {
+        points: [noteToPoint(note)]
+      });
+    },
+    /**
+     * Story 36: this is the one read that bypasses the agent filter — it fetches
+     * straight by UUID. An unreadable note comes back as `null`, indistinguishable
+     * from missing, so nothing leaks and callers already handle it.
+     *
+     * `reader` is required. It used to be optional, and omitting it skipped the
+     * check — which meant the safe behaviour was the one you had to remember to
+     * ask for. Pass `SYSTEM_ACTOR` to read as the engine itself; that reads as a
+     * deliberate act at the call site, where an absent argument did not.
+     */
+    async getNote(id, reader) {
+      await ensureCollection(col);
+      try {
+        const result = await qdrant("POST", `/collections/${col}/points`, {
+          ids: [id],
+          with_payload: true,
+          with_vector: true
+        });
+        if (!result.length) return null;
+        const note = pointToNote(result[0]);
+        if (reader !== SYSTEM_ACTOR && !canRead(note, reader)) return null;
+        return note;
+      } catch {
+        return null;
+      }
+    },
+    async updateNote(note) {
+      await ensureCollection(col);
+      await qdrant("PUT", `/collections/${col}/points?wait=true`, {
+        points: [noteToPoint(note)]
+      });
+    },
+    async findByHash(hash, agentId) {
+      await ensureCollection(col);
+      const body = {
+        filter: {
+          must: [
+            { key: "hash", match: { value: hash } },
+            { key: "is_active", match: { value: true } },
+            ...modeBIsolated ? [] : [
+              {
+                should: [
+                  { key: "agent_id", match: { value: agentId } },
+                  { key: "agent_id", match: { value: "shared" } }
+                ]
+              }
+            ]
+          ]
+        },
+        with_payload: true,
+        with_vector: true,
+        limit: 1
+      };
+      const result = await qdrant("POST", `/collections/${col}/points/scroll`, body);
+      if (!result.points.length) return null;
+      return pointToNote(result.points[0]);
+    },
+    /**
+     * Story 33: enforces the writers policy. Returns false — without writing —
+     * when the caller may not write. This fetch-then-check path exists for callers
+     * that only have an id (the plugin's CRUD hook); callers already holding the
+     * note can check `canWrite` themselves and skip a round trip.
+     *
+     * `caller` is required. Pass `SYSTEM_ACTOR` for the engine's own maintenance
+     * writes. The self-read below is a genuine `SYSTEM_ACTOR` case: it fetches the
+     * note in order to decide whether the caller may write it, and gating that
+     * fetch on the same policy it exists to evaluate would be circular.
+     */
+    async updateNoteContent(id, content, embedding, hash, caller) {
+      await ensureCollection(col);
+      let existing = null;
+      if (caller !== SYSTEM_ACTOR) {
+        existing = await this.getNote(id, SYSTEM_ACTOR);
+        if (existing && !canWrite(existing, caller)) return false;
+      }
+      await qdrant("PUT", `/collections/${col}/points/vectors?wait=true`, {
+        points: [{ id, vector: embedding }]
+      });
+      const payload = { content, hash };
+      if (existing) {
+        const history = [
+          ...existing.evolution_history ?? [],
+          {
+            triggeredBy: "",
+            triggeredAt: (/* @__PURE__ */ new Date()).toISOString(),
+            oldContext: existing.context,
+            newContext: existing.context,
+            oldTags: existing.tags,
+            newTags: existing.tags,
+            action: "crud_update",
+            oldContent: existing.content
+          }
+        ];
+        payload.evolution_history = JSON.stringify(history);
+      }
+      await qdrant("POST", `/collections/${col}/points/payload?wait=true`, {
+        payload,
+        points: [id]
+      });
+      return true;
+    },
+    async queryByEmbedding(embedding, topK, agentId, scoreThreshold = 0, subject) {
+      await ensureCollection(col);
+      const result = await qdrant("POST", `/collections/${col}/points/search`, {
+        vector: embedding,
+        limit: topK,
+        with_payload: true,
+        with_vector: true,
+        score_threshold: scoreThreshold,
+        filter: scopedAgentFilter(agentId, subject)
+      });
+      const queryResults = result.map((r) => ({
+        note: pointToNote(r),
+        score: r.score
+      }));
+      if (queryResults.length > 0) {
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const ids = queryResults.map((r) => r.note.id);
+        const patches = queryResults.map((r) => ({
+          id: r.note.id,
+          retrieval_count: (r.note.retrieval_count || 0) + 1
+        }));
+        Promise.all([
+          qdrant("POST", `/collections/${col}/points/payload?wait=false`, {
+            payload: { last_accessed: now },
+            points: ids
+          }),
+          ...patches.map(
+            (p) => qdrant("POST", `/collections/${col}/points/payload?wait=false`, {
+              payload: { retrieval_count: p.retrieval_count },
+              points: [p.id]
+            })
+          )
+        ]).catch((err) => {
+          console.error(`[amem] retrieval tracking patch failed: ${err.message}`);
+        });
+        for (const r of queryResults) {
+          r.note.retrieval_count = (r.note.retrieval_count || 0) + 1;
+          r.note.last_accessed = now;
+        }
+      }
+      return queryResults;
+    },
+    async listNotes(agentId, subject) {
+      await ensureCollection(col);
+      const body = {
+        with_payload: true,
+        with_vector: true,
+        limit: 1e4
+      };
+      if (agentId) body.filter = scopedAgentFilter(agentId, subject);
+      const result = await qdrant("POST", `/collections/${col}/points/scroll`, body);
+      return result.points.map(pointToNote);
+    },
+    async deleteNote(id) {
+      await ensureCollection(col);
+      await qdrant("POST", `/collections/${col}/points/delete`, {
+        points: [id]
+      });
+    },
+    /** Story 33: see `updateNoteContent` — returns false, unwritten, when denied. */
+    async invalidateNote(id, caller) {
+      await ensureCollection(col);
+      if (caller !== SYSTEM_ACTOR) {
+        const existing = await this.getNote(id, SYSTEM_ACTOR);
+        if (existing && !canWrite(existing, caller)) return false;
+      }
+      await qdrant("POST", `/collections/${col}/points/payload?wait=true`, {
+        payload: { is_active: false },
+        points: [id]
+      });
+      return true;
+    },
+    async getNotesByDatePrefix(datePrefix, agentId) {
+      await ensureCollection(col);
+      const filterClauses = [{ key: "is_active", match: { value: true } }];
+      if (!modeBIsolated) {
+        filterClauses.push({
+          should: [
+            { key: "agent_id", match: { value: agentId } },
+            { key: "agent_id", match: { value: "shared" } }
+          ]
+        });
+      }
+      const body = {
+        filter: { must: filterClauses },
+        with_payload: true,
+        with_vector: true,
+        limit: 1e4
+      };
+      const result = await qdrant("POST", `/collections/${col}/points/scroll`, body);
+      return result.points.map(pointToNote).filter((n) => n.timestamp.startsWith(datePrefix));
+    },
+    async countNotes(agentId) {
+      await ensureCollection(col);
+      const body = { exact: true };
+      if (agentId) body.filter = scopedAgentFilter(agentId);
+      const result = await qdrant("POST", `/collections/${col}/points/count`, body);
+      return result.count;
+    },
+    async updateNoteLinks(id, links) {
+      await ensureCollection(col);
+      await qdrant("POST", `/collections/${col}/points/payload?wait=true`, {
+        payload: { links },
+        points: [id]
+      });
+    },
+    async patchNotePayload(id, fields) {
+      await ensureCollection(col);
+      await qdrant("POST", `/collections/${col}/points/payload?wait=true`, {
+        payload: fields,
+        points: [id]
+      });
+    },
+    async replaceLinkReferences(oldId, newId, agentId) {
+      const notes = await this.listNotes(agentId);
+      for (const note of notes) {
+        if (!canWrite(note, agentId)) continue;
+        if (note.links.includes(oldId)) {
+          const newLinks = note.links.map((linkId) => linkId === oldId ? newId : linkId);
+          const filteredLinks = newLinks.filter((linkId) => linkId !== note.id);
+          const uniqueLinks = Array.from(new Set(filteredLinks));
+          await this.updateNoteLinks(note.id, uniqueLinks);
+        }
+      }
+    }
+  };
+}
+function createStorageContext(collectionName, modeBIsolated = false) {
+  return makeCrud(collectionName || getCollection(), modeBIsolated);
+}
+async function getNote(id, reader) {
+  return makeCrud(getCollection()).getNote(id, reader);
+}
+async function updateNote(note) {
+  return makeCrud(getCollection()).updateNote(note);
+}
+async function listNotes(agentId, subject) {
+  return makeCrud(getCollection()).listNotes(agentId, subject);
+}
+async function deleteNote(id) {
+  return makeCrud(getCollection()).deleteNote(id);
+}
+async function invalidateNote(id, caller) {
+  return makeCrud(getCollection()).invalidateNote(id, caller);
+}
+async function patchNotePayload(id, fields) {
+  return makeCrud(getCollection()).patchNotePayload(id, fields);
+}
+
+// src/llm.ts
+import Anthropic from "@anthropic-ai/sdk";
+import OpenAI from "openai";
+
+// src/prompts.ts
+var LOCALE = process.env.AMEM_PROMPT_LOCALE === "zh" ? "zh" : "en";
+var en = {
+  crudDecision: (userText, assistantText, memoryList) => `You are a memory management agent. Analyze the conversation and decide what memory operations are needed.
+
+## Conversation
+
+User: ${userText}
+Assistant: ${assistantText}
+
+## Existing relevant memories (identified by integer idx)
+
+${memoryList}
+
+## Task
+
+Extract only genuinely important long-term facts (decisions, preferences, account info, project status, key insights). Skip small talk, confirmations, and information already captured in existing memories.
+
+## Operation types
+- NEW: Extract a brand new fact not present in existing memories
+- UPDATE: New information refines or supersedes an existing memory; specify existingIdx
+- DELETE: An existing memory is outdated, contradicted, or wrong; specify existingIdx, fact = original content
+- NONE: Nothing worth recording, or information already fully captured
+
+## Output format
+
+Return a JSON array. Each item:
+{"action": "NEW"|"UPDATE"|"DELETE"|"NONE", "fact": "fact content", "existingIdx": integer or omit, "reason": "optional"}
+
+Return at most 3 operations. If nothing is worth recording, return [].
+Return only the JSON array, no other text.
+
+Examples:
+
+1. New preference:
+[{"action": "NEW", "fact": "User prefers TypeScript over JavaScript", "reason": "Explicitly stated tech preference"}]
+
+2. Updating an existing memory (idx 0 was "User is evaluating React and Vue"):
+[{"action": "UPDATE", "fact": "User decided to use React (dropped Vue)", "existingIdx": 0, "reason": "Decision finalized, update evaluation status"}]
+
+3. Conversation is just "Sure, thanks" / "Got it" with no new info:
+[]`,
+  shouldMerge: (contentA, contentB) => `You are a memory deduplication assistant. Determine whether two memories express essentially the same information.
+
+Memory A: ${contentA}
+Memory B: ${contentB}
+
+Rules:
+- If both memories express the same core fact (possibly different wording or granularity), return:
+  {"shouldMerge": true, "merged": "Concise merged statement preserving key details from both, more complete than either alone"}
+- If the memories are complementary, on different topics, or contain different specific facts, return:
+  {"shouldMerge": false}
+
+Return only JSON, no other text.
+
+Examples:
+
+1. Should merge (different granularity):
+A: "Project uses PostgreSQL"
+B: "Project's primary database is PostgreSQL 16, deployed on AWS RDS"
+-> {"shouldMerge": true, "merged": "Project uses PostgreSQL 16 as primary database, deployed on AWS RDS"}
+
+2. Should NOT merge (complementary but distinct):
+A: "User prefers VS Code"
+B: "User's VS Code uses One Dark Pro theme"
+-> {"shouldMerge": false}`,
+  evolutionJudge: (oldContent, newContent) => `You are a memory evolution judge. Analyze the relationship between an old and new memory and return JSON.
+
+Old memory: ${oldContent}
+New memory: ${newContent}
+
+Classification rules:
+
+- EVOLVE: New content deepens or updates the old memory (e.g. "Considering Next.js" -> "Decided on Next.js 14 App Router")
+  Return: {"type": "EVOLVE", "mergedContent": "Merged content preserving the evolution trajectory"}
+
+- CONFLICT: Old and new information directly contradict each other on the same attribute (e.g. "Uses MySQL as primary DB" vs "Migrated to PostgreSQL")
+  Return: {"type": "CONFLICT"}
+
+- EXPAND: New information supplements the old memory on the same topic (e.g. "Handles backend dev" + "Backend uses Go and gRPC")
+  Return: {"type": "EXPAND", "mergedContent": "Merged content integrating both pieces of information"}
+
+- NEW: Completely unrelated information, no substantive connection to the old memory
+  Return: {"type": "NEW"}
+
+Return only JSON, no other text.`,
+  conflictScan: (numberedNotes) => `You are auditing a person's memory store for CONTRADICTIONS.
+
+Below are numbered memories. Find pairs that CANNOT both be true of the same person at the same time.
+
+${numberedNotes}
+
+What counts as a contradiction:
+- The same attribute holding two incompatible values ("lives in Paris" vs "moved to Berlin")
+- A stated preference or constraint that a later memory violates ("is vegetarian" vs "loved the steak")
+- A fact that a later memory supersedes ("uses MySQL" vs "migrated to PostgreSQL")
+
+What does NOT count \u2014 be strict, these are the common false positives:
+- Additive facts. Two things can both be true ("has a dog named Buddy" + "adopted a second dog, Scout" is NOT a contradiction)
+- Change over time that both memories already acknowledge
+- Merely similar or related topics
+- Different contexts (likes coffee at work, tea at home)
+
+For each contradicting pair, also say which one is SUPERSEDED \u2014 the one that is
+no longer true. Judge this from the WORDING, not from any assumed order: phrases
+like "used to", "back in 2019", "moved last month", "switched to" tell you which
+statement describes the past. The memories are NOT listed in chronological order,
+and the number does not imply age.
+
+If you cannot tell which one is superseded, set it to null. That is a normal and
+useful answer \u2014 say null rather than guessing, because a wrong guess retires a
+memory that is still true.
+
+Return ONLY a JSON array. Empty array if nothing genuinely contradicts:
+[{"a": 0, "b": 3, "superseded": 0, "reason": "one short sentence naming the incompatible attribute"}]
+
+"superseded" must be either the value of "a", the value of "b", or null.
+Use the numbers shown. Report a pair once. Prefer returning nothing over guessing.`
+};
+var zh = {
+  crudDecision: (userText, assistantText, memoryList) => `\u4F60\u662F\u4E00\u4E2A\u8BB0\u5FC6\u7BA1\u7406 agent\uFF0C\u8D1F\u8D23\u5206\u6790\u5BF9\u8BDD\u5185\u5BB9\u5E76\u51B3\u5B9A\u5982\u4F55\u64CD\u4F5C\u8BB0\u5FC6\u5E93\u3002
+
+## \u5BF9\u8BDD\u5185\u5BB9
+
+\u7528\u6237\uFF1A${userText}
+\u52A9\u624B\uFF1A${assistantText}
+
+## \u5DF2\u6709\u76F8\u5173\u8BB0\u5FC6\uFF08\u7528\u6574\u6570 idx \u6807\u8BC6\uFF09
+
+${memoryList}
+
+## \u4EFB\u52A1
+
+\u5206\u6790\u4E0A\u8FF0\u5BF9\u8BDD\uFF0C\u51B3\u5B9A\u9700\u8981\u54EA\u4E9B\u8BB0\u5FC6\u64CD\u4F5C\u3002\u53EA\u63D0\u53D6\u771F\u6B63\u91CD\u8981\u7684\u957F\u671F\u4E8B\u5B9E\uFF08\u51B3\u7B56\u3001\u504F\u597D\u3001\u8D26\u53F7\u4FE1\u606F\u3001\u9879\u76EE\u72B6\u6001\u3001\u5173\u952E\u6D1E\u5BDF\uFF09\u3002\u8DF3\u8FC7\u95F2\u804A\u3001\u786E\u8BA4\u8BED\u3001\u91CD\u590D\u4FE1\u606F\u3002
+
+## \u64CD\u4F5C\u7C7B\u578B
+- NEW\uFF1A\u63D0\u53D6\u5168\u65B0\u4E8B\u5B9E\uFF08\u5DF2\u6709\u8BB0\u5FC6\u4E2D\u6CA1\u6709\u7684\u4FE1\u606F\uFF09
+- UPDATE\uFF1A\u65B0\u4FE1\u606F\u66F4\u65B0\u4E86\u67D0\u6761\u5DF2\u6709\u8BB0\u5FC6\uFF0C\u7528 existingIdx \u6307\u5B9A\u8981\u66F4\u65B0\u7684\u6761\u76EE
+- DELETE\uFF1A\u67D0\u6761\u5DF2\u6709\u8BB0\u5FC6\u5DF2\u7ECF\u8FC7\u65F6\u3001\u53D1\u751F\u51B2\u7A81\u6216\u9519\u8BEF\uFF0C\u7528 existingIdx \u6307\u5B9A\uFF0Cfact \u586B\u539F\u5185\u5BB9
+- NONE\uFF1A\u4E0D\u503C\u5F97\u8BB0\u5F55\u6216\u5DF2\u6709\u5B8C\u5168\u76F8\u540C\u7684\u4FE1\u606F
+
+## \u8F93\u51FA\u683C\u5F0F
+
+\u8FD4\u56DE JSON \u6570\u7EC4\uFF0C\u6BCF\u6761\u683C\u5F0F\uFF1A
+{"action": "NEW"|"UPDATE"|"DELETE"|"NONE", "fact": "\u4E8B\u5B9E\u5185\u5BB9", "existingIdx": \u6574\u6570\u6216\u7701\u7565, "reason": "\u539F\u56E0\uFF08\u53EF\u9009\uFF09"}
+
+\u6BCF\u6B21\u6700\u591A\u8FD4\u56DE 3 \u6761\u64CD\u4F5C\u3002\u5982\u679C\u6CA1\u6709\u503C\u5F97\u64CD\u4F5C\u7684\u5185\u5BB9\uFF0C\u8FD4\u56DE []\u3002
+\u53EA\u8FD4\u56DE JSON \u6570\u7EC4\uFF0C\u4E0D\u8981\u4EFB\u4F55\u5176\u4ED6\u6587\u5B57\u3002
+
+\u793A\u4F8B\uFF1A
+
+1. \u63D0\u53D6\u65B0\u504F\u597D\uFF1A
+[{"action": "NEW", "fact": "\u7528\u6237\u504F\u597D TypeScript \u800C\u975E JavaScript", "reason": "\u660E\u786E\u8868\u8FBE\u7684\u6280\u672F\u504F\u597D"}]
+
+2. \u66F4\u65B0\u5DF2\u6709\u8BB0\u5FC6\uFF08idx 0 \u539F\u4E3A"\u7528\u6237\u6B63\u5728\u8BC4\u4F30 React \u548C Vue"\uFF09\uFF1A
+[{"action": "UPDATE", "fact": "\u7528\u6237\u51B3\u5B9A\u4F7F\u7528 React\uFF08\u653E\u5F03\u4E86 Vue\uFF09", "existingIdx": 0, "reason": "\u51B3\u7B56\u5DF2\u660E\u786E\uFF0C\u66F4\u65B0\u8BC4\u4F30\u72B6\u6001"}]
+
+3. \u5BF9\u8BDD\u4EC5\u4E3A"\u597D\u7684\uFF0C\u8C22\u8C22"/"\u6CA1\u95EE\u9898"\u7B49\u786E\u8BA4\u8BED\uFF0C\u65E0\u65B0\u4FE1\u606F\uFF1A
+[]`,
+  shouldMerge: (contentA, contentB) => `\u4F60\u662F\u4E00\u4E2A\u8BB0\u5FC6\u53BB\u91CD\u52A9\u624B\uFF0C\u8D1F\u8D23\u5224\u65AD\u4E24\u6761\u8BB0\u5FC6\u662F\u5426\u8868\u8FBE\u4E86\u672C\u8D28\u76F8\u540C\u7684\u4FE1\u606F\u3002
+
+\u8BB0\u5FC6A\uFF1A${contentA}
+\u8BB0\u5FC6B\uFF1A${contentB}
+
+\u5224\u65AD\u89C4\u5219\uFF1A
+- \u5982\u679C\u4E24\u6761\u8BB0\u5FC6\u8868\u8FBE\u7684\u662F\u672C\u8D28\u76F8\u540C\u7684\u4FE1\u606F\uFF08\u53EF\u80FD\u63AA\u8F9E\u4E0D\u540C\u3001\u7C92\u5EA6\u4E0D\u540C\uFF0C\u4F46\u6838\u5FC3\u4E8B\u5B9E\u4E00\u81F4\uFF09\uFF0C\u8FD4\u56DE JSON\uFF1A
+  {"shouldMerge": true, "merged": "\u5408\u5E76\u540E\u7684\u7B80\u6D01\u8868\u8FF0\uFF0C\u4FDD\u7559\u4E24\u6761\u8BB0\u5FC6\u7684\u5173\u952E\u4FE1\u606F\uFF0C\u6BD4\u4EFB\u4F55\u4E00\u6761\u90FD\u66F4\u5B8C\u6574"}
+- \u5982\u679C\u4E24\u6761\u8BB0\u5FC6\u662F\u4E92\u8865\u4FE1\u606F\u3001\u4E0D\u540C\u4E3B\u9898\u3001\u6216\u5305\u542B\u4E0D\u540C\u7684\u5177\u4F53\u4E8B\u5B9E\uFF0C\u8FD4\u56DE JSON\uFF1A
+  {"shouldMerge": false}
+
+\u53EA\u8FD4\u56DE JSON\uFF0C\u4E0D\u8981\u4EFB\u4F55\u5176\u4ED6\u6587\u5B57\u3002
+
+\u793A\u4F8B\uFF1A
+
+1. \u5E94\u5408\u5E76\uFF08\u7C92\u5EA6\u4E0D\u540C\uFF09\uFF1A
+A: "\u9879\u76EE\u4F7F\u7528 PostgreSQL \u6570\u636E\u5E93"
+B: "\u9879\u76EE\u7684\u4E3B\u6570\u636E\u5E93\u662F PostgreSQL 16\uFF0C\u90E8\u7F72\u5728 AWS RDS \u4E0A"
+\u2192 {"shouldMerge": true, "merged": "\u9879\u76EE\u4F7F\u7528 PostgreSQL 16 \u4F5C\u4E3A\u4E3B\u6570\u636E\u5E93\uFF0C\u90E8\u7F72\u5728 AWS RDS \u4E0A"}
+
+2. \u4E0D\u5E94\u5408\u5E76\uFF08\u4E92\u8865\u4F46\u4E0D\u540C\uFF09\uFF1A
+A: "\u7528\u6237\u559C\u6B22\u7528 VS Code"
+B: "\u7528\u6237\u7684 VS Code \u4F7F\u7528 One Dark Pro \u4E3B\u9898"
+\u2192 {"shouldMerge": false}`,
+  evolutionJudge: (oldContent, newContent) => `\u4F60\u662F\u4E00\u4E2A\u8BB0\u5FC6\u6F14\u5316\u5224\u65AD\u52A9\u624B\u3002\u5206\u6790\u4EE5\u4E0B\u4E24\u6761\u8BB0\u5FC6\u7684\u5173\u7CFB\u5E76\u8FD4\u56DE JSON\u3002
+
+\u65E7\u8BB0\u5FC6\uFF1A${oldContent}
+\u65B0\u8BB0\u5FC6\uFF1A${newContent}
+
+\u5224\u65AD\u89C4\u5219\uFF1A
+
+- EVOLVE\uFF1A\u65B0\u5185\u5BB9\u662F\u5BF9\u65E7\u8BB0\u5FC6\u7684\u6DF1\u5316/\u66F4\u65B0\uFF08\u5982\u300C\u6B63\u5728\u8003\u8651\u7528 Next.js\u300D\u2192\u300C\u51B3\u5B9A\u7528 Next.js 14 App Router\u300D\uFF09
+  \u8FD4\u56DE\uFF1A{"type": "EVOLVE", "mergedContent": "\u878D\u5408\u540E\u7684\u5B8C\u6574\u5185\u5BB9\uFF0C\u4FDD\u7559\u6F14\u5316\u8F68\u8FF9"}
+
+- CONFLICT\uFF1A\u65B0\u65E7\u4FE1\u606F\u5728\u540C\u4E00\u5C5E\u6027\u4E0A\u76F4\u63A5\u77DB\u76FE\uFF08\u5982\u300C\u4F7F\u7528 MySQL \u4F5C\u4E3A\u4E3B\u6570\u636E\u5E93\u300Dvs\u300C\u5DF2\u8FC1\u79FB\u5230 PostgreSQL\u300D\uFF09
+  \u8FD4\u56DE\uFF1A{"type": "CONFLICT"}
+
+- EXPAND\uFF1A\u65B0\u4FE1\u606F\u662F\u5BF9\u65E7\u8BB0\u5FC6\u540C\u4E00\u4E3B\u9898\u7684\u8865\u5145\u6269\u5C55\uFF08\u5982\u300C\u8D1F\u8D23\u540E\u7AEF\u5F00\u53D1\u300D+\u300C\u540E\u7AEF\u4F7F\u7528 Go \u548C gRPC\u300D\uFF09
+  \u8FD4\u56DE\uFF1A{"type": "EXPAND", "mergedContent": "\u5408\u5E76\u540E\u7684\u5B8C\u6574\u5185\u5BB9\uFF0C\u6574\u5408\u53CC\u65B9\u4FE1\u606F"}
+
+- NEW\uFF1A\u5168\u65B0\u4FE1\u606F\uFF0C\u4E0E\u65E7\u8BB0\u5FC6\u65E0\u5B9E\u8D28\u5173\u8054\uFF08\u5982\u300C\u559C\u6B22 dark mode\u300Dvs\u300C\u4E0B\u5468\u8981\u53BB\u51FA\u5DEE\u300D\uFF09
+  \u8FD4\u56DE\uFF1A{"type": "NEW"}
+
+\u53EA\u8FD4\u56DE JSON\uFF0C\u4E0D\u8981\u4EFB\u4F55\u5176\u4ED6\u6587\u5B57\u3002`,
+  conflictScan: (numberedNotes) => `\u4F60\u5728\u5BA1\u8BA1\u4E00\u4E2A\u4EBA\u7684\u8BB0\u5FC6\u5E93\uFF0C\u627E\u51FA\u5176\u4E2D**\u4E92\u76F8\u77DB\u76FE**\u7684\u6761\u76EE\u3002
+
+\u4E0B\u9762\u662F\u7F16\u53F7\u7684\u8BB0\u5FC6\u3002\u627E\u51FA\u90A3\u4E9B**\u4E0D\u53EF\u80FD\u540C\u65F6\u4E3A\u771F**\u7684\u914D\u5BF9\u3002
+
+${numberedNotes}
+
+\u7B97\u77DB\u76FE\u7684\u60C5\u51B5\uFF1A
+- \u540C\u4E00\u5C5E\u6027\u4E0A\u51FA\u73B0\u4E92\u65A5\u7684\u503C\uFF08\u300C\u4F4F\u5728\u5DF4\u9ECE\u300Dvs\u300C\u642C\u5230\u4E86\u67CF\u6797\u300D\uFF09
+- \u540E\u6765\u7684\u8BB0\u5FC6\u8FDD\u53CD\u4E86\u5148\u524D\u9648\u8FF0\u7684\u504F\u597D\u6216\u7EA6\u675F\uFF08\u300C\u5403\u7D20\u300Dvs\u300C\u90A3\u5757\u725B\u6392\u5F88\u597D\u5403\u300D\uFF09
+- \u540E\u6765\u7684\u4E8B\u5B9E\u53D6\u4EE3\u4E86\u5148\u524D\u7684\uFF08\u300C\u7528 MySQL\u300Dvs\u300C\u5DF2\u8FC1\u79FB\u5230 PostgreSQL\u300D\uFF09
+
+**\u4E0D\u7B97**\u77DB\u76FE \u2014\u2014 \u8BF7\u4E25\u683C\uFF0C\u4EE5\u4E0B\u662F\u6700\u5E38\u89C1\u7684\u8BEF\u5224\uFF1A
+- \u7D2F\u52A0\u7684\u4E8B\u5B9E\u3002\u4E24\u8005\u53EF\u4EE5\u540C\u65F6\u6210\u7ACB\uFF08\u300C\u517B\u4E86\u4E00\u53EA\u72D7\u53EB Buddy\u300D+\u300C\u53C8\u9886\u517B\u4E86\u7B2C\u4E8C\u53EA\u53EB Scout\u300D**\u4E0D\u662F**\u77DB\u76FE\uFF09
+- \u4E24\u6761\u8BB0\u5FC6\u672C\u8EAB\u5DF2\u7ECF\u4F53\u73B0\u4E86\u968F\u65F6\u95F4\u7684\u53D8\u5316
+- \u53EA\u662F\u4E3B\u9898\u76F8\u4F3C\u6216\u76F8\u5173
+- \u573A\u666F\u4E0D\u540C\uFF08\u5728\u516C\u53F8\u559D\u5496\u5561\uFF0C\u5728\u5BB6\u559D\u8336\uFF09
+
+\u5BF9\u6BCF\u4E00\u5BF9\u77DB\u76FE\uFF0C\u8FD8\u8981\u6307\u51FA\u54EA\u4E00\u6761\u662F**\u5DF2\u5931\u6548\u7684**\uFF08\u4E0D\u518D\u4E3A\u771F\u7684\u90A3\u6761\uFF09\u3002\u8BF7\u4ECE**\u63AA\u8F9E**\u5224\u65AD\uFF0C\u4E0D\u8981\u5047\u8BBE\u987A\u5E8F\uFF1A
+\u300C\u4EE5\u524D\u300D\u300C2019 \u5E74\u90A3\u4F1A\u513F\u300D\u300C\u4E0A\u4E2A\u6708\u642C\u4E86\u300D\u300C\u6539\u7528\u4E86\u300D\u8FD9\u7C7B\u8BF4\u6CD5\u80FD\u544A\u8BC9\u4F60\u54EA\u6761\u63CF\u8FF0\u7684\u662F\u8FC7\u53BB\u3002
+\u8FD9\u4E9B\u8BB0\u5FC6**\u4E0D\u662F\u6309\u65F6\u95F4\u987A\u5E8F\u6392\u5217\u7684**\uFF0C\u7F16\u53F7\u4E5F\u4E0D\u4EE3\u8868\u65B0\u65E7\u3002
+
+\u5982\u679C\u65E0\u6CD5\u5224\u65AD\u54EA\u6761\u5DF2\u5931\u6548\uFF0C\u5C31\u586B null\u3002\u8FD9\u662F\u4E00\u4E2A**\u6B63\u5E38\u4E14\u6709\u7528**\u7684\u56DE\u7B54 \u2014\u2014 \u5B81\u53EF\u586B null \u4E5F\u4E0D\u8981\u731C\uFF0C
+\u56E0\u4E3A\u731C\u9519\u4F1A\u8BA9\u4E00\u6761**\u4ECD\u7136\u4E3A\u771F**\u7684\u8BB0\u5FC6\u88AB\u505C\u7528\u3002
+
+\u53EA\u8FD4\u56DE JSON \u6570\u7EC4\u3002\u6CA1\u6709\u771F\u6B63\u77DB\u76FE\u5C31\u8FD4\u56DE\u7A7A\u6570\u7EC4\uFF1A
+[{"a": 0, "b": 3, "superseded": 0, "reason": "\u4E00\u53E5\u8BDD\u8BF4\u660E\u662F\u54EA\u4E2A\u5C5E\u6027\u4E92\u65A5"}]
+
+"superseded" \u53EA\u80FD\u662F "a" \u7684\u503C\u3001"b" \u7684\u503C\uFF0C\u6216 null\u3002
+\u4F7F\u7528\u4E0A\u9762\u663E\u793A\u7684\u7F16\u53F7\u3002\u540C\u4E00\u5BF9\u53EA\u62A5\u4E00\u6B21\u3002**\u5B81\u53EF\u4E0D\u62A5\uFF0C\u4E5F\u4E0D\u8981\u731C\u3002**`
+};
+var templates = { en, zh };
+var t = templates[LOCALE];
+
+// src/llm.ts
+var _override = {};
+function configureLlm(cfg) {
+  _override = { ...cfg };
+  _anthropicClients.clear();
+  _openaiClients.clear();
+}
+var _warned = /* @__PURE__ */ new Set();
+function warnOnce(key, message) {
+  if (_warned.has(key)) return;
+  _warned.add(key);
+  console.error(message);
+}
+function resolveProvider(role = "fast") {
+  const raw = role === "strong" ? process.env.AMEM_LLM_STRONG_PROVIDER || _override.strong?.provider || void 0 : void 0;
+  const p = (raw || process.env.AMEM_LLM_PROVIDER || _override.provider || "anthropic").trim().toLowerCase();
+  if (p !== "anthropic" && p !== "openai") {
+    warnOnce(`provider:${p}`, `[amem] unknown LLM provider "${p}"; falling back to anthropic`);
+  }
+  return p;
+}
+function resolveModel(role = "fast") {
+  const strong = role === "strong" ? process.env.AMEM_LLM_STRONG_MODEL || _override.strong?.model || void 0 : void 0;
+  return strong || process.env.AMEM_LLM_MODEL || _override.model || (resolveProvider(role) === "openai" ? "gpt-4o-mini" : "claude-sonnet-4-6");
+}
+function resolveBaseURL(role = "fast") {
+  const strong = role === "strong" ? process.env.AMEM_LLM_STRONG_BASE_URL || _override.strong?.baseURL || void 0 : void 0;
+  return strong || process.env.AMEM_LLM_BASE_URL || _override.baseURL || void 0;
+}
+function resolveCrudRole() {
+  const raw = (process.env.AMEM_LLM_CRUD_ROLE || _override.crudRole || "fast").trim().toLowerCase();
+  if (raw === "strong") return "strong";
+  if (raw !== "fast") {
+    warnOnce(`crudRole:${raw}`, `[amem] unknown AMEM_LLM_CRUD_ROLE "${raw}"; using fast`);
+  }
+  return "fast";
+}
+var DEFAULT_TIMEOUT_MS = 3e4;
+function resolveTimeoutMs() {
+  const envVal = Number(process.env.AMEM_LLM_TIMEOUT);
+  if (Number.isFinite(envVal) && envVal > 0) return envVal;
+  if (_override.timeoutMs && _override.timeoutMs > 0) return _override.timeoutMs;
+  return DEFAULT_TIMEOUT_MS;
+}
+var _anthropicClients = /* @__PURE__ */ new Map();
+function anthropic(baseURL) {
+  const key = baseURL ?? "";
+  let client = _anthropicClients.get(key);
+  if (!client) {
+    client = new Anthropic({
+      ...process.env.AMEM_LLM_API_KEY && { apiKey: process.env.AMEM_LLM_API_KEY },
+      ...baseURL && { baseURL },
+      timeout: resolveTimeoutMs()
+    });
+    _anthropicClients.set(key, client);
+  }
+  return client;
+}
+var _openaiClients = /* @__PURE__ */ new Map();
+function openai(baseURL) {
+  const key = baseURL ?? "";
+  let client = _openaiClients.get(key);
+  if (!client) {
+    client = new OpenAI({
+      // AMEM_LLM_API_KEY first (engine convention), then the SDK's own
+      // OPENAI_API_KEY (the standard) — passing an explicit key blocks the SDK's
+      // env fallback, so read it here. Placeholder last, so keyless local servers
+      // (Ollama, vLLM) still work.
+      apiKey: process.env.AMEM_LLM_API_KEY || process.env.OPENAI_API_KEY || "sk-no-key-required",
+      ...baseURL && { baseURL },
+      timeout: resolveTimeoutMs()
+    });
+    _openaiClients.set(key, client);
+  }
+  return client;
+}
+async function llmCall(prompt, maxTokens = 500, role = "fast") {
+  const provider = resolveProvider(role);
+  const model = resolveModel(role);
+  const baseURL = resolveBaseURL(role);
+  const isThinking = model.includes("gemini") || model.includes("pro-agent");
+  const effectiveMaxTokens = isThinking ? Math.max(maxTokens * 8, 4e3) : maxTokens;
+  try {
+    return provider === "openai" ? await openaiCall(prompt, model, effectiveMaxTokens, baseURL) : await anthropicCall(prompt, model, effectiveMaxTokens, baseURL);
+  } catch (e) {
+    console.error(`[amem] LLM call failed: ${e.message}`);
+    return null;
+  }
+}
+async function anthropicCall(prompt, model, maxTokens, baseURL) {
+  const resp = await anthropic(baseURL).messages.create({
+    model,
+    max_tokens: maxTokens,
+    messages: [{ role: "user", content: prompt }]
+  });
+  for (const block of resp.content) {
+    if (block.type === "text") return block.text.trim();
+  }
+  return null;
+}
+async function openaiCall(prompt, model, maxTokens, baseURL) {
+  const isReasoning = /^o\d/.test(model) || model.startsWith("gpt-5");
+  const resp = await openai(baseURL).chat.completions.create({
+    model,
+    ...isReasoning ? { max_completion_tokens: maxTokens } : { max_tokens: maxTokens },
+    messages: [{ role: "user", content: prompt }]
+  });
+  return resp.choices[0]?.message?.content?.trim() ?? null;
+}
+function stripReasoning(raw) {
+  return raw.replace(/<think>[\s\S]*?<\/think>/gi, "").replace(/<\|(?:eot_id|im_start|im_end|begin_of_text|end_of_text|endoftext)\|>/g, "").trim();
+}
+function stripFences(raw) {
+  raw = stripReasoning(raw);
+  if (raw.startsWith("```")) {
+    const lines = raw.split("\n");
+    lines.shift();
+    if (lines[lines.length - 1] === "```") lines.pop();
+    raw = lines.join("\n").trim();
+  }
+  if (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("'") && raw.endsWith("'")) {
+    try {
+      raw = JSON.parse(raw);
+    } catch {
+    }
+  }
+  return raw;
+}
+function parseJsonLoose(raw) {
+  const cleaned = stripFences(raw);
+  try {
+    return JSON.parse(cleaned);
+  } catch (e) {
+    const m = cleaned.match(/\{[\s\S]*\}/);
+    if (m) return JSON.parse(m[0]);
+    throw e;
+  }
+}
+var VALID_CONFIDENCE = /* @__PURE__ */ new Set(["high", "medium", "low"]);
+var VALID_CATEGORIES = /* @__PURE__ */ new Set([
+  "Technical",
+  "Business",
+  "Personal",
+  "Project",
+  "Research",
+  "System",
+  "General"
+]);
+async function llmConstructNote(content) {
+  const prompt = `Analyze the following text and respond with valid JSON only (no markdown fences, no explanation, no comments). All string values must use standard double quotes and be properly escaped:
+{
+  "keywords": ["keyword1", "keyword2"],
+  "tags": ["tag1", "tag2"],
+  "context": "one sentence summary in the same language as the input",
+  "category": "Technical|Business|Personal|Project|Research|System|General",
+  "note_type": "memory|knowledge",
+  "topics": ["Topic1", "Topic2"],
+  "confidence": "high|medium|low"
+}
+
+Category guide:
+- Technical: code, tools, configuration, APIs, debugging
+- Business: company, finance, compliance, contracts, invoices
+- Personal: personal state, habits, preferences, emotions
+- Project: project progress, decisions, milestones
+- Research: research, literature, evaluation, comparison
+- System: system services, monitoring, operations
+- General: anything that does not fit the above
+
+note_type guide:
+- knowledge: books, methodologies, tools, domain knowledge, reference material \u2014 durable, no strong time component
+- memory: events, decisions, preferences, states, observations \u2014 episodic, time-sensitive
+
+topics guide (Story 26B):
+- Only populate for knowledge notes (note_type=knowledge). For memory notes, return [].
+- List 1-5 concise subject tags representing the main topics of this knowledge, e.g. ["TypeScript", "Qdrant", "Vector DB"].
+
+confidence guide (Story 27):
+- high: note_type is unambiguous \u2014 clearly episodic (event/decision/state) or clearly durable knowledge (tool doc/methodology)
+- medium: some ambiguity \u2014 e.g. "learned X method" could be either memory or knowledge
+- low: LLM is uncertain \u2014 vague, fragmentary, or mixed content
+
+Text: ${content}`;
+  const raw = await llmCall(prompt, 400);
+  if (!raw)
+    return {
+      keywords: [],
+      tags: [],
+      context: "",
+      category: "General",
+      note_type: "memory",
+      topics: [],
+      confidence: "medium"
+    };
+  try {
+    const data = parseJsonLoose(raw);
+    const rawCategory = typeof data.category === "string" ? data.category : "General";
+    const category = VALID_CATEGORIES.has(rawCategory) ? rawCategory : "General";
+    const note_type = data.note_type === "knowledge" ? "knowledge" : "memory";
+    const topics = note_type === "knowledge" && Array.isArray(data.topics) ? data.topics.filter((v) => typeof v === "string") : [];
+    const rawConfidence = typeof data.confidence === "string" ? data.confidence : "medium";
+    const confidence = VALID_CONFIDENCE.has(rawConfidence) ? rawConfidence : "medium";
+    return {
+      keywords: Array.isArray(data.keywords) ? data.keywords : [],
+      tags: Array.isArray(data.tags) ? data.tags : [],
+      context: typeof data.context === "string" ? data.context : "",
+      category,
+      note_type,
+      topics,
+      confidence
+    };
+  } catch (e) {
+    console.error(`[amem] Note construction parse failed: ${e.message}`);
+    return {
+      keywords: [],
+      tags: [],
+      context: "",
+      category: "General",
+      note_type: "memory",
+      topics: [],
+      confidence: "medium"
+    };
+  }
+}
+async function llmShouldLink(noteContent, candidateContent) {
+  const prompt = `Do these two memory notes have a meaningful relationship that would be useful to link?
+Reply with only "yes" or "no".
+
+Note A: ${noteContent}
+Note B: ${candidateContent}`;
+  const raw = await llmCall(prompt, 10);
+  if (!raw) return false;
+  return raw.toLowerCase().startsWith("yes");
+}
+async function llmCrudDecision(userText, assistantText, existingMemories) {
+  const memoryList = existingMemories.length > 0 ? existingMemories.map((m) => `[${m.idx}] ${m.content}`).join("\n") : "(none)";
+  const prompt = t.crudDecision(userText.slice(0, 500), assistantText.slice(0, 500), memoryList);
+  try {
+    const raw = await llmCall(prompt, 400, resolveCrudRole());
+    if (!raw) return [];
+    const match = stripReasoning(raw).match(/\[.*\]/s);
+    if (!match) return [];
+    const parsed = JSON.parse(match[0]);
+    if (!Array.isArray(parsed)) return [];
+    const ops = [];
+    for (const item of parsed) {
+      if (!item || typeof item !== "object") continue;
+      const action = item.action;
+      if (!["NEW", "UPDATE", "DELETE", "NONE"].includes(action)) continue;
+      if (action === "NONE") continue;
+      const op = {
+        action,
+        fact: typeof item.fact === "string" ? item.fact : "",
+        reason: typeof item.reason === "string" ? item.reason : void 0
+      };
+      if (typeof item.existingIdx === "number") {
+        op.existingIdx = item.existingIdx;
+      }
+      ops.push(op);
+    }
+    return ops.slice(0, 3);
+  } catch (e) {
+    console.error(`[amem] llmCrudDecision failed: ${e.message}`);
+    return [];
+  }
+}
+async function llmShouldMerge(contentA, contentB) {
+  const prompt = t.shouldMerge(contentA, contentB);
+  const raw = await llmCall(prompt, 300, "strong");
+  if (!raw) return { shouldMerge: false };
+  try {
+    const data = parseJsonLoose(raw);
+    if (typeof data.shouldMerge !== "boolean") return { shouldMerge: false };
+    if (data.shouldMerge && typeof data.merged === "string") {
+      return { shouldMerge: true, merged: data.merged };
+    }
+    return { shouldMerge: false };
+  } catch (e) {
+    console.error(`[amem] llmShouldMerge parse failed: ${e.message}`);
+    return { shouldMerge: false };
+  }
+}
+var VALID_EVOLUTION_TYPES = /* @__PURE__ */ new Set(["EVOLVE", "CONFLICT", "EXPAND", "NEW"]);
+async function llmEvolutionJudge(oldContent, newContent) {
+  const prompt = t.evolutionJudge(oldContent, newContent);
+  const raw = await llmCall(prompt, 300, "strong");
+  if (!raw) return { type: "NEW" };
+  try {
+    const data = parseJsonLoose(raw);
+    const type = VALID_EVOLUTION_TYPES.has(data.type) ? data.type : "NEW";
+    return {
+      type,
+      mergedContent: typeof data.mergedContent === "string" ? data.mergedContent : void 0
+    };
+  } catch (e) {
+    console.error(`[amem] llmEvolutionJudge parse failed: ${e.message}`);
+    return { type: "NEW" };
+  }
+}
+async function llmEvolveNote(content, linkedNotes) {
+  const linkedStr = linkedNotes.map((n) => `- ID: ${n.id}
+  Content: ${n.content}`).join("\n");
+  const prompt = `A memory note has gained new connections. Update its context, tags, and decide whether to strengthen connections with specific neighbors.
+Reply with JSON only (no markdown):
+{
+  "tags": ["tag1", "tag2", ...],
+  "context": "updated one sentence summary",
+  "should_strengthen": true|false,
+  "suggested_connections": ["neighbor_id_1", "neighbor_id_2", ...],
+  "tags_to_update": ["tag_1", ..., "tag_n"]
+}
+
+Guidelines:
+- "tags" and "context" are for updating the original note based on new connections.
+- "should_strengthen" is a decision whether this note should strengthen its connections to any of the newly linked notes (neighbors).
+- "suggested_connections" must contain only IDs from the newly linked notes (neighbors) listed below.
+- "tags_to_update" are updated tags for the original note itself if we strengthen connections.
+
+Original note content: ${content}
+
+Newly linked notes (neighbors):
+${linkedStr}`;
+  const raw = await llmCall(prompt, 500);
+  if (!raw) return { tags: null, context: null, shouldStrengthen: false, suggestedConnections: [], tagsToUpdate: [] };
+  try {
+    const data = parseJsonLoose(raw);
+    return {
+      tags: Array.isArray(data.tags) ? data.tags : null,
+      context: typeof data.context === "string" ? data.context : null,
+      shouldStrengthen: typeof data.should_strengthen === "boolean" ? data.should_strengthen : false,
+      suggestedConnections: Array.isArray(data.suggested_connections) ? data.suggested_connections.map(String) : [],
+      tagsToUpdate: Array.isArray(data.tags_to_update) ? data.tags_to_update.map(String) : []
+    };
+  } catch (e) {
+    console.error(`[amem] Evolution parse failed: ${e.message}`);
+    return { tags: null, context: null, shouldStrengthen: false, suggestedConnections: [], tagsToUpdate: [] };
+  }
+}
+async function llmConflictScan(contents) {
+  if (contents.length < 2) return [];
+  const numbered = contents.map((c, i) => `[${i}] ${c}`).join("\n");
+  try {
+    const raw = await llmCall(t.conflictScan(numbered), 600, "strong");
+    if (!raw) return [];
+    const cleaned = stripReasoning(raw);
+    const match = cleaned.match(/\[[\s\S]*\]/);
+    if (!match) return [];
+    const parsed = JSON.parse(match[0]);
+    if (!Array.isArray(parsed)) return [];
+    const pairs = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const item of parsed) {
+      if (!item || typeof item !== "object") continue;
+      const { a, b } = item;
+      if (typeof a !== "number" || typeof b !== "number") continue;
+      if (!Number.isInteger(a) || !Number.isInteger(b)) continue;
+      if (a < 0 || b < 0 || a >= contents.length || b >= contents.length) continue;
+      if (a === b) continue;
+      const key = a < b ? `${a}:${b}` : `${b}:${a}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const rawSup = item.superseded;
+      const supersededIndex = rawSup === a || rawSup === b ? rawSup : null;
+      pairs.push({
+        a,
+        b,
+        reason: typeof item.reason === "string" ? item.reason : "",
+        supersededIndex
+      });
+    }
+    return pairs;
+  } catch (e) {
+    console.error(`[amem] llmConflictScan failed: ${e.message}`);
+    return [];
+  }
+}
+
+// src/config.ts
+import * as os from "os";
+import * as path from "path";
+var _dataDir = process.env.AMEM_DATA_DIR || path.join(os.homedir(), ".amem");
+function configure(opts) {
+  if (opts.dataDir) _dataDir = opts.dataDir;
+}
+function getDataDir() {
+  return _dataDir;
+}
+
+// src/memory.ts
+import { v4 as uuidv4 } from "uuid";
+import { createHash } from "crypto";
+import * as fs2 from "fs";
+import * as path3 from "path";
+
+// src/evo-counter.ts
+import * as fs from "fs";
+import * as path2 from "path";
+function counterFile() {
+  return process.env.AMEM_EVO_COUNTER_PATH || path2.join(getDataDir(), "amem_evo_cnt.json");
+}
+var EVO_THRESHOLD = 20;
+function getEvoCount() {
+  try {
+    const data = JSON.parse(fs.readFileSync(counterFile(), "utf-8"));
+    return data.count || 0;
+  } catch {
+    return 0;
+  }
+}
+function incrementEvoCount() {
+  const count = getEvoCount() + 1;
+  fs.writeFileSync(counterFile(), JSON.stringify({ count, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }));
+  return count;
+}
+function shouldRunEvolution() {
+  const count = incrementEvoCount();
+  return count % EVO_THRESHOLD === 0;
+}
+
+// src/memory.ts
+import { Jieba } from "@node-rs/jieba";
+var logSafe = (id) => id.replace(/[\r\n]/g, "");
+var _jieba = null;
+function getJieba() {
+  if (!_jieba) _jieba = new Jieba();
+  return _jieba;
+}
+function simpleTokenize(text) {
+  const hasChinese = /[\u4e00-\u9fff]/.test(text);
+  if (hasChinese) {
+    return getJieba().cut(text, true).map((t2) => t2.toLowerCase().trim()).filter((t2) => t2.length > 0 && /[\w\u4e00-\u9fff]/.test(t2));
+  }
+  return Array.from(text.toLowerCase().matchAll(/[\w]+/g)).map((m) => m[0]);
+}
+function buildBM25(notes) {
+  const ids = notes.map((n) => n.id);
+  const corpus = notes.map((n) => {
+    const text = [n.content, ...n.keywords, ...n.tags].join(" ");
+    return simpleTokenize(text);
+  });
+  const df = /* @__PURE__ */ new Map();
+  for (const tokens of corpus) {
+    for (const t2 of new Set(tokens)) df.set(t2, (df.get(t2) ?? 0) + 1);
+  }
+  const N = corpus.length;
+  const idf = /* @__PURE__ */ new Map();
+  df.forEach((freq, term) => {
+    idf.set(term, Math.log((N - freq + 0.5) / (freq + 0.5) + 1));
+  });
+  const avgdl = corpus.reduce((s, t2) => s + t2.length, 0) / Math.max(N, 1);
+  return { ids, corpus, idf, avgdl };
+}
+function bm25Score(state, queryTokens, k1 = 1.5, b = 0.75) {
+  const scores = state.ids.map((id, i) => {
+    const doc = state.corpus[i];
+    const dl = doc.length;
+    const tf = /* @__PURE__ */ new Map();
+    for (const t2 of doc) tf.set(t2, (tf.get(t2) ?? 0) + 1);
+    let score = 0;
+    for (const t2 of queryTokens) {
+      const f = tf.get(t2) ?? 0;
+      if (f === 0) continue;
+      const idfVal = state.idf.get(t2) ?? 0;
+      score += idfVal * (f * (k1 + 1) / (f + k1 * (1 - b + b * (dl / state.avgdl))));
+    }
+    return [id, score];
+  });
+  return scores.sort((a, b2) => b2[1] - a[1]);
+}
+function rrfMerge(embIds, bm25Ids, k = 60) {
+  const scores = /* @__PURE__ */ new Map();
+  embIds.forEach((id, rank) => scores.set(id, (scores.get(id) ?? 0) + 1 / (k + rank + 1)));
+  bm25Ids.forEach((id, rank) => scores.set(id, (scores.get(id) ?? 0) + 1 / (k + rank + 1)));
+  return Array.from(scores.entries()).sort((a, b) => b[1] - a[1]);
+}
+function buildEmbedText(note) {
+  let text = note.content;
+  if (note.keywords.length) text += " " + note.keywords.join(" ");
+  if (note.tags.length) text += " " + note.tags.join(" ");
+  if (note.context) text += " " + note.context;
+  return text;
+}
+var EPHEMERAL_SIGNALS = ["\u5F85\u8DD1", "\u7B49\u786E\u8BA4", "\u6628\u65E5", "\u660E\u5929\u5B8C\u6210"];
+function checkQuality(content) {
+  const trimmed = content.trim();
+  if (trimmed.length < 10) {
+    return { ok: false, ephemeral: false, reason: `\u5185\u5BB9\u8FC7\u77ED\uFF08${trimmed.length} \u5B57\uFF0C\u6700\u5C11 10 \u5B57\uFF09` };
+  }
+  const ephemeral = EPHEMERAL_SIGNALS.some((w) => trimmed.includes(w));
+  return { ok: true, ephemeral };
+}
+function defaultCtx() {
+  return createStorageContext();
+}
+async function addMemory(content, agentId = "main", opts) {
+  const scope = opts?.scope ?? "private";
+  const subjects = opts?.subjects ?? [];
+  const ctx = opts?.storageCtx ?? defaultCtx();
+  const quality = checkQuality(content);
+  if (!quality.ok) {
+    throw new Error(`[quality] \u5199\u5165\u62D2\u7EDD: ${quality.reason}`);
+  }
+  const effectiveNoteAgentId = scope === "shared" ? "shared" : agentId;
+  const hash = createHash("md5").update(content).digest("hex");
+  const existingByHash = await ctx.findByHash(hash, agentId);
+  if (existingByHash) {
+    console.log(`[add] dedup: exact hash match, skipping (id=${existingByHash.id.slice(0, 8)})`);
+    return existingByHash.id;
+  }
+  console.log("[add] Constructing note...");
+  const { keywords, tags, context, category, note_type, topics } = await llmConstructNote(content);
+  console.log(`  keywords: ${keywords.join(", ")}`);
+  console.log(`  tags: ${tags.join(", ")}`);
+  console.log(`  context: ${context}`);
+  console.log(`  category: ${category}`);
+  console.log(`  note_type: ${note_type}`);
+  console.log(`  topics: ${topics.join(", ")}`);
+  const fieldsText = buildEmbedText({ content, keywords, tags, context });
+  const embedding = await encode(fieldsText);
+  const topMatch = await ctx.queryByEmbedding(embedding, 1, agentId, 0);
+  if (topMatch.length > 0 && topMatch[0].score >= 0.85) {
+    if (canWrite(topMatch[0].note, agentId)) {
+      console.log(`[add] dedup: high-sim match (sim=${topMatch[0].score.toFixed(3)}), updating existing`);
+      await ctx.updateNoteContent(topMatch[0].note.id, content, embedding, hash, agentId);
+      return topMatch[0].note.id;
+    }
+    console.log(
+      `[add] dedup: high-sim match ${topMatch[0].note.id.slice(0, 8)} is not writable by ${logSafe(agentId)} \u2014 inserting a new note instead`
+    );
+  }
+  const pendingMerge = topMatch.length > 0 && topMatch[0].score >= 0.72 && topMatch[0].score < 0.85;
+  if (pendingMerge) {
+    console.log(`[add] dedup: borderline sim (sim=${topMatch[0].score.toFixed(3)}), marking pending_merge=true`);
+  }
+  const readers = scope === "shared" ? ["*"] : [agentId];
+  const writers = [agentId];
+  const note = {
+    id: uuidv4(),
+    subjects,
+    content,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    keywords,
+    tags,
+    context,
+    embedding,
+    links: [],
+    agent_id: effectiveNoteAgentId,
+    hash,
+    // 13-A
+    retrieval_count: 0,
+    last_accessed: (/* @__PURE__ */ new Date()).toISOString(),
+    // 13-B
+    evolution_history: [],
+    // 13-E
+    category,
+    is_active: true,
+    // 26A
+    note_type,
+    // 26B
+    topics,
+    // 29
+    pending_merge: pendingMerge,
+    // 30
+    conflict: false,
+    // 31
+    ephemeral: quality.ephemeral,
+    low_quality: false,
+    // 32
+    owner: agentId,
+    readers,
+    writers
+  };
+  await ctx.addNote(note);
+  console.log(`  saved note ${note.id}`);
+  try {
+    const total = await ctx.countNotes(agentId);
+    if (total > 1) {
+      const candidates = await ctx.queryByEmbedding(embedding, 6, agentId, 0);
+      const linkedIds = [];
+      const linkedContents = [];
+      for (const { note: cand, score } of candidates) {
+        if (cand.id === note.id) continue;
+        if (score < 0.3) continue;
+        console.log(`  candidate ${cand.id.slice(0, 8)}... sim=${score.toFixed(3)}, asking LLM...`);
+        const shouldLink = await llmShouldLink(content, cand.content);
+        if (shouldLink) {
+          linkedIds.push(cand.id);
+          linkedContents.push(cand.content);
+          console.log(`    \u2192 linked!`);
+        }
+      }
+      if (linkedIds.length > 0) {
+        note.links = linkedIds;
+        await ctx.updateNote(note);
+        for (const lid of linkedIds) {
+          const linked = await ctx.getNote(lid, agentId);
+          if (linked && !linked.links.includes(note.id)) {
+            if (!canWrite(linked, agentId)) {
+              console.log(`[link] back-link into ${lid.slice(0, 8)} skipped \u2014 not writable by ${logSafe(agentId)}`);
+              continue;
+            }
+            linked.links.push(note.id);
+            await ctx.updateNote(linked);
+          }
+        }
+        if (shouldRunEvolution()) {
+          console.log(`  [evo] threshold reached, running evolution for ${Math.min(linkedIds.length, 3)} linked notes`);
+          for (const lid of linkedIds.slice(0, 3)) {
+            const linked = await ctx.getNote(lid, agentId);
+            if (!linked) continue;
+            if (!canWrite(linked, agentId)) {
+              console.log(`  [evo] skipping ${lid.slice(0, 8)} \u2014 not writable by ${logSafe(agentId)}`);
+              continue;
+            }
+            const linkedNotes = [];
+            for (const llid of linked.links.slice(0, 5)) {
+              if (llid === note.id) continue;
+              const ln = await ctx.getNote(llid, agentId);
+              if (ln) linkedNotes.push({ id: ln.id, content: ln.content });
+            }
+            linkedNotes.push({ id: note.id, content });
+            const oldTags = [...linked.tags];
+            const oldContext = linked.context;
+            const {
+              tags: newTags,
+              context: newContext,
+              shouldStrengthen,
+              suggestedConnections,
+              tagsToUpdate
+            } = await llmEvolveNote(linked.content, linkedNotes);
+            let evolved = false;
+            if (newTags !== null || newContext !== null) {
+              if (newTags !== null) linked.tags = newTags;
+              if (newContext !== null) linked.context = newContext;
+              linked.evolution_history = linked.evolution_history || [];
+              linked.evolution_history.push({
+                triggeredBy: note.id,
+                triggeredAt: (/* @__PURE__ */ new Date()).toISOString(),
+                oldContext,
+                newContext: newContext ?? oldContext,
+                oldTags,
+                newTags: newTags ?? oldTags,
+                action: "update_neighbor"
+              });
+              evolved = true;
+            }
+            let noteChanged = false;
+            let noteTagsChanged = false;
+            if (shouldStrengthen && suggestedConnections.length > 0) {
+              for (const targetId of suggestedConnections) {
+                if (!note.links.includes(targetId)) {
+                  note.links.push(targetId);
+                  noteChanged = true;
+                }
+                const target = await ctx.getNote(targetId, agentId);
+                if (target && !target.links.includes(note.id)) {
+                  if (canWrite(target, agentId)) {
+                    target.links.push(note.id);
+                    await ctx.updateNote(target);
+                  } else {
+                    console.log(`  [evo] strengthen back-link into ${targetId.slice(0, 8)} skipped \u2014 not writable`);
+                  }
+                }
+              }
+              if (tagsToUpdate.length > 0) {
+                note.tags = tagsToUpdate;
+                noteChanged = true;
+                noteTagsChanged = true;
+              }
+              linked.evolution_history = linked.evolution_history || [];
+              linked.evolution_history.push({
+                triggeredBy: note.id,
+                triggeredAt: (/* @__PURE__ */ new Date()).toISOString(),
+                oldContext: linked.context,
+                newContext: linked.context,
+                oldTags: [...linked.tags],
+                newTags: [...linked.tags],
+                action: "strengthen",
+                suggestedConnections,
+                tagsUpdated: tagsToUpdate
+              });
+              evolved = true;
+            }
+            if (noteChanged) {
+              if (noteTagsChanged) {
+                note.embedding = await encode(buildEmbedText(note));
+              }
+              await ctx.updateNote(note);
+            }
+            if (evolved) {
+              if (newTags !== null || newContext !== null) {
+                linked.embedding = await encode(buildEmbedText(linked));
+              }
+              await ctx.updateNote(linked);
+              console.log(`  evolved/strengthened note ${lid.slice(0, 8)}...`);
+            }
+          }
+        } else {
+          console.log(`  [evo] threshold not reached, skipping evolution this round`);
+        }
+      }
+    }
+  } catch (e) {
+    console.error(`[warn] Link/Evolution phase failed: ${e.message}`);
+  }
+  console.log(`[done] Note added: ${note.id}`);
+  return note.id;
+}
+async function addEpisodic(content, agentId = "main", opts) {
+  const scope = opts?.scope ?? "private";
+  const subjects = opts?.subjects ?? [];
+  const ctx = opts?.storageCtx ?? defaultCtx();
+  const quality = checkQuality(content);
+  if (!quality.ok) {
+    throw new Error(`[quality] \u5199\u5165\u62D2\u7EDD: ${quality.reason}`);
+  }
+  const embedding = await encode(content);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const note = {
+    id: uuidv4(),
+    subjects,
+    content,
+    timestamp: now,
+    keywords: [],
+    tags: [],
+    context: "",
+    embedding,
+    links: [],
+    agent_id: scope === "shared" ? "shared" : agentId,
+    hash: createHash("md5").update(content).digest("hex"),
+    retrieval_count: 0,
+    last_accessed: now,
+    evolution_history: [],
+    category: "General",
+    is_active: true,
+    note_type: "memory",
+    topics: [],
+    pending_merge: false,
+    conflict: false,
+    ephemeral: quality.ephemeral,
+    low_quality: false,
+    owner: agentId,
+    readers: scope === "shared" ? ["*"] : [agentId],
+    writers: [agentId]
+  };
+  await ctx.addNote(note);
+  return note.id;
+}
+async function searchMemory(query, topK = 5, agentId = "main", opts) {
+  const useBfs = opts?.useBfs !== false;
+  const subject = opts?.subject;
+  const bfsSimThreshold = opts?.bfsSimThreshold ?? 0.25;
+  const ctx = opts?.storageCtx ?? defaultCtx();
+  const total = await ctx.countNotes(agentId);
+  if (total === 0) return [];
+  const queryEmbedding = await encode(query);
+  const n = Math.min(Math.max(topK * 4, 20), total);
+  const embResults = await ctx.queryByEmbedding(queryEmbedding, n, agentId, 0, subject);
+  const allNotes = await ctx.listNotes(agentId, subject);
+  const bm25State = buildBM25(allNotes);
+  const queryTokens = simpleTokenize(query);
+  const bm25Ranked = bm25Score(bm25State, queryTokens).filter(([, score]) => score > 0).slice(0, n);
+  const merged = rrfMerge(
+    embResults.map((r) => r.note.id),
+    bm25Ranked.map((r) => r[0])
+  );
+  const now = Date.now();
+  const noteMap = new Map(allNotes.map((n2) => [n2.id, n2]));
+  const boostedMerged = merged.map(([id, rrfScore]) => {
+    const note = noteMap.get(id);
+    if (!note) return [id, rrfScore];
+    if (note.note_type === "knowledge") return [id, rrfScore];
+    const lastAccessed = new Date(note.last_accessed || note.timestamp).getTime();
+    const ageDays = (now - lastAccessed) / 864e5;
+    const recencyBoost = 1 + 0.05 * Math.log(1 + (note.retrieval_count || 0)) / (ageDays + 1);
+    return [id, rrfScore * recencyBoost];
+  });
+  boostedMerged.sort((a, b) => b[1] - a[1]);
+  const topIds = boostedMerged.slice(0, topK).map(([id]) => id);
+  const BFS_MAX_HOPS = 2;
+  const BFS_MAX_EXPAND = 8;
+  const visitedIds = new Set(topIds);
+  const bfsQueue = useBfs ? topIds.map((id) => ({ id, hop: 0 })) : [];
+  const bfsExtra = [];
+  const bfsSimMap = /* @__PURE__ */ new Map();
+  while (bfsQueue.length > 0 && bfsExtra.length < BFS_MAX_EXPAND) {
+    const item = bfsQueue.shift();
+    if (item.hop >= BFS_MAX_HOPS) continue;
+    const note = noteMap.get(item.id);
+    if (!note) continue;
+    for (const linkedId of note.links) {
+      if (visitedIds.has(linkedId)) continue;
+      visitedIds.add(linkedId);
+      const linked = noteMap.get(linkedId);
+      if (!linked || linked.is_active === false) continue;
+      const sim = cosineSimilarity(queryEmbedding, linked.embedding);
+      if (bfsSimThreshold > 0 && sim < bfsSimThreshold) continue;
+      bfsSimMap.set(linkedId, sim);
+      bfsExtra.push(linkedId);
+      bfsQueue.push({ id: linkedId, hop: item.hop + 1 });
+      if (bfsExtra.length >= BFS_MAX_EXPAND) break;
+    }
+  }
+  const topicsFilter = opts?.topicsFilter;
+  const filteredTopIds = topicsFilter && topicsFilter.length > 0 ? topIds.filter((id) => {
+    const note = noteMap.get(id);
+    if (!note) return false;
+    if (note.note_type !== "knowledge") return true;
+    return topicsFilter.every((t2) => note.topics.map((s) => s.toLowerCase()).includes(t2.toLowerCase()));
+  }) : topIds;
+  const embSimMap = new Map(embResults.map((r) => [r.note.id, r.score]));
+  const rrfMap = new Map(boostedMerged.map(([id, score]) => [id, score]));
+  const results = [];
+  const ordered = [
+    ...filteredTopIds.map((id) => [id, "match"]),
+    ...bfsExtra.map((id) => [id, "link"])
+  ];
+  for (const [id, via] of ordered) {
+    const note = noteMap.get(id);
+    if (!note) continue;
+    results.push({
+      id: note.id,
+      content: note.content,
+      context: note.context,
+      tags: note.tags,
+      keywords: note.keywords,
+      links: note.links,
+      timestamp: note.timestamp,
+      similarity: embSimMap.get(id) ?? bfsSimMap.get(id) ?? 0,
+      rrf: rrfMap.get(id) ?? 0,
+      via,
+      topics: note.topics ?? [],
+      note_type: note.note_type ?? "memory"
+    });
+  }
+  return results;
+}
+async function listMemories(agentId = "main", storageCtx) {
+  const ctx = storageCtx ?? defaultCtx();
+  const count = await ctx.countNotes(agentId);
+  return { count };
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function mergeSimilarNotes(agentId, storageCtx) {
+  const ctx = storageCtx ?? defaultCtx();
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const allNotes = await ctx.getNotesByDatePrefix(today, agentId);
+  const notes = allNotes.filter((n) => n.agent_id !== "shared");
+  const pendingNotes = notes.filter((n) => n.pending_merge === true);
+  let evolvedCount = 0;
+  for (const pendingNote of pendingNotes) {
+    let bestSim = -1;
+    let bestNeighbor = null;
+    for (const other of notes) {
+      if (other.id === pendingNote.id) continue;
+      if (other.pending_merge) continue;
+      if (!other.embedding.length || !pendingNote.embedding.length) continue;
+      const sim = cosineSimilarity(pendingNote.embedding, other.embedding);
+      if (sim > bestSim) {
+        bestSim = sim;
+        bestNeighbor = other;
+      }
+    }
+    if (!bestNeighbor) {
+      await ctx.patchNotePayload(pendingNote.id, { pending_merge: false });
+      continue;
+    }
+    const judgment = await llmEvolutionJudge(bestNeighbor.content, pendingNote.content);
+    console.log(
+      `[merge] evolution judgment: ${pendingNote.id.slice(0, 8)} \u2192 ${bestNeighbor.id.slice(0, 8)}: ${judgment.type}`
+    );
+    if (judgment.type === "EVOLVE") {
+      const oldHistory = bestNeighbor.evolution_history || [];
+      oldHistory.push({
+        triggeredBy: pendingNote.id,
+        triggeredAt: (/* @__PURE__ */ new Date()).toISOString(),
+        oldContext: bestNeighbor.context,
+        newContext: bestNeighbor.context,
+        oldTags: [...bestNeighbor.tags],
+        newTags: [...bestNeighbor.tags],
+        action: "consolidate"
+      });
+      const mergedContent = judgment.mergedContent || pendingNote.content;
+      const newEmbedding = await encode(buildEmbedText({ ...bestNeighbor, content: mergedContent }));
+      const newHash = createHash("md5").update(mergedContent).digest("hex");
+      await ctx.updateNoteContent(bestNeighbor.id, mergedContent, newEmbedding, newHash, agentId);
+      await ctx.patchNotePayload(bestNeighbor.id, {
+        evolution_history: JSON.stringify(oldHistory),
+        evolution_type: "EVOLVE"
+      });
+      await ctx.deleteNote(pendingNote.id);
+      evolvedCount++;
+    } else if (judgment.type === "CONFLICT") {
+      await ctx.patchNotePayload(pendingNote.id, { pending_merge: false, conflict: true, evolution_type: "CONFLICT" });
+      await ctx.patchNotePayload(bestNeighbor.id, { conflict: true, evolution_type: "CONFLICT" });
+    } else if (judgment.type === "EXPAND") {
+      const oldHistory = bestNeighbor.evolution_history || [];
+      oldHistory.push({
+        triggeredBy: pendingNote.id,
+        triggeredAt: (/* @__PURE__ */ new Date()).toISOString(),
+        oldContext: bestNeighbor.context,
+        newContext: bestNeighbor.context,
+        oldTags: [...bestNeighbor.tags],
+        newTags: [...bestNeighbor.tags],
+        action: "consolidate"
+      });
+      const mergedContent = judgment.mergedContent || `${bestNeighbor.content}\uFF1B${pendingNote.content}`;
+      const newEmbedding = await encode(buildEmbedText({ ...bestNeighbor, content: mergedContent }));
+      const newHash = createHash("md5").update(mergedContent).digest("hex");
+      await ctx.updateNoteContent(bestNeighbor.id, mergedContent, newEmbedding, newHash, agentId);
+      await ctx.patchNotePayload(bestNeighbor.id, {
+        evolution_history: JSON.stringify(oldHistory),
+        evolution_type: "EXPAND"
+      });
+      await ctx.deleteNote(pendingNote.id);
+      evolvedCount++;
+    } else {
+      await ctx.patchNotePayload(pendingNote.id, { pending_merge: false, evolution_type: "NEW" });
+    }
+    await sleep(200);
+  }
+  if (notes.length < 5) return evolvedCount;
+  const pendingIds = new Set(pendingNotes.map((n) => n.id));
+  const pairs = [];
+  for (let i = 0; i < notes.length; i++) {
+    if (pendingIds.has(notes[i].id)) continue;
+    for (let j = i + 1; j < notes.length; j++) {
+      if (pendingIds.has(notes[j].id)) continue;
+      if (!notes[i].embedding.length || !notes[j].embedding.length) continue;
+      const sim = cosineSimilarity(notes[i].embedding, notes[j].embedding);
+      if (sim >= 0.8) {
+        pairs.push({ i, j, sim });
+      }
+    }
+  }
+  if (pairs.length === 0) return evolvedCount;
+  pairs.sort((a, b) => b.sim - a.sim);
+  const topPairs = pairs.slice(0, 10);
+  const deletedIds = /* @__PURE__ */ new Set();
+  let mergedCount = 0;
+  for (const { i, j } of topPairs) {
+    const noteA = notes[i];
+    const noteB = notes[j];
+    if (deletedIds.has(noteA.id) || deletedIds.has(noteB.id)) continue;
+    const result = await llmShouldMerge(noteA.content, noteB.content);
+    if (result.shouldMerge && result.merged) {
+      const [keepNote, dropNote] = noteA.content.length >= noteB.content.length ? [noteA, noteB] : [noteB, noteA];
+      const newEmbedding = await encode(result.merged);
+      const newHash = createHash("md5").update(result.merged).digest("hex");
+      await ctx.updateNoteContent(keepNote.id, result.merged, newEmbedding, newHash, agentId);
+      await ctx.deleteNote(dropNote.id);
+      deletedIds.add(dropNote.id);
+      mergedCount++;
+    }
+    await sleep(200);
+  }
+  return evolvedCount + mergedCount;
+}
+async function consolidateMemories(agentId, logger, storageCtx) {
+  const ctx = storageCtx ?? defaultCtx();
+  const log = {
+    info: (msg) => logger ? logger.info(msg) : console.log(msg),
+    warn: (msg) => logger ? logger.warn(msg) : console.warn(msg),
+    error: (msg) => logger ? logger.error(msg) : console.error(msg)
+  };
+  log.info(`[Consolidation] Starting consolidation for agentId: ${agentId}`);
+  const rawNotes = await ctx.listNotes(agentId);
+  const allNotes = rawNotes.filter((n) => n.agent_id !== "shared");
+  log.info(
+    `[Consolidation] Loaded ${allNotes.length} active private notes (${rawNotes.length - allNotes.length} shared skipped).`
+  );
+  const groups = /* @__PURE__ */ new Map();
+  for (const note of allNotes) {
+    if (note.note_type === "knowledge") continue;
+    const category = note.category || "General";
+    if (!groups.has(category)) {
+      groups.set(category, []);
+    }
+    groups.get(category).push(note);
+  }
+  const candidates = [];
+  for (const [category, groupNotes] of groups.entries()) {
+    log.info(`[Consolidation] Category "${category}" has ${groupNotes.length} notes.`);
+    for (let i = 0; i < groupNotes.length; i++) {
+      for (let j = i + 1; j < groupNotes.length; j++) {
+        const noteA = groupNotes[i];
+        const noteB = groupNotes[j];
+        if (!noteA.embedding.length || !noteB.embedding.length) continue;
+        const sim = cosineSimilarity(noteA.embedding, noteB.embedding);
+        if (sim >= 0.75) {
+          candidates.push({ noteA, noteB, similarity: sim });
+        }
+      }
+    }
+  }
+  candidates.sort((a, b) => b.similarity - a.similarity);
+  const topPairs = candidates.slice(0, 15);
+  log.info(
+    `[Consolidation] Found ${candidates.length} candidate pairs with similarity >= 0.75. Processing top ${topPairs.length}.`
+  );
+  const processedIds = /* @__PURE__ */ new Set();
+  let mergedCount = 0;
+  function logMergeToFile(keepId, dropId, mergedContent) {
+    const logDir = path3.join(getDataDir(), "logs");
+    const logFile = path3.join(logDir, "amem-consolidate.log");
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const logMsg = `[${timestamp}] Consolidated: KeepNote ${keepId} and DropNote ${dropId}. Merged length: ${mergedContent.length} chars.
+`;
+    try {
+      fs2.mkdirSync(logDir, { recursive: true });
+      fs2.appendFileSync(logFile, logMsg, "utf8");
+    } catch (err) {
+      log.error(`[Consolidation] Failed to write log: ${err.message}`);
+    }
+  }
+  for (const { noteA, noteB, similarity } of topPairs) {
+    if (processedIds.has(noteA.id) || processedIds.has(noteB.id)) {
+      log.info(
+        `[Consolidation] Skipping pair (${noteA.id.slice(0, 8)}, ${noteB.id.slice(0, 8)}) as one or both already merged.`
+      );
+      continue;
+    }
+    log.info(
+      `[Consolidation] Evaluating pair (${noteA.id.slice(0, 8)}, ${noteB.id.slice(0, 8)}) with sim ${similarity.toFixed(4)}...`
+    );
+    const mergeDecision = await llmShouldMerge(noteA.content, noteB.content);
+    if (mergeDecision.shouldMerge && mergeDecision.merged) {
+      log.info(`  -> LLM decision: MERGE!`);
+      const [keepNote, dropNote] = noteA.content.length >= noteB.content.length ? [noteA, noteB] : [noteB, noteA];
+      log.info(
+        `  -> KeepNote: ${keepNote.id.slice(0, 8)} (len: ${keepNote.content.length}), DropNote: ${dropNote.id.slice(0, 8)} (len: ${dropNote.content.length})`
+      );
+      const oldContext = keepNote.context;
+      const oldTags = [...keepNote.tags];
+      keepNote.content = mergeDecision.merged;
+      keepNote.tags = Array.from(/* @__PURE__ */ new Set([...keepNote.tags, ...dropNote.tags]));
+      keepNote.keywords = Array.from(/* @__PURE__ */ new Set([...keepNote.keywords, ...dropNote.keywords]));
+      keepNote.links = Array.from(/* @__PURE__ */ new Set([...keepNote.links, ...dropNote.links])).filter(
+        (id) => id !== keepNote.id && id !== dropNote.id
+      );
+      keepNote.retrieval_count = (keepNote.retrieval_count || 0) + (dropNote.retrieval_count || 0);
+      const keepAccessTime = new Date(keepNote.last_accessed || keepNote.timestamp).getTime();
+      const dropAccessTime = new Date(dropNote.last_accessed || dropNote.timestamp).getTime();
+      keepNote.last_accessed = keepAccessTime >= dropAccessTime ? keepNote.last_accessed || keepNote.timestamp : dropNote.last_accessed || dropNote.timestamp;
+      const embedText = buildEmbedText(keepNote);
+      keepNote.embedding = await encode(embedText);
+      keepNote.hash = createHash("md5").update(keepNote.content).digest("hex");
+      keepNote.evolution_history = keepNote.evolution_history || [];
+      keepNote.evolution_history.push({
+        triggeredBy: dropNote.id,
+        triggeredAt: (/* @__PURE__ */ new Date()).toISOString(),
+        oldContext,
+        newContext: keepNote.context,
+        oldTags,
+        newTags: keepNote.tags,
+        action: "consolidate"
+      });
+      await ctx.updateNote(keepNote);
+      await ctx.invalidateNote(dropNote.id, agentId);
+      await ctx.replaceLinkReferences(dropNote.id, keepNote.id, agentId);
+      logMergeToFile(keepNote.id, dropNote.id, keepNote.content);
+      processedIds.add(keepNote.id);
+      processedIds.add(dropNote.id);
+      mergedCount++;
+    } else {
+      log.info(`  -> LLM decision: DO NOT MERGE.`);
+    }
+    await sleep(200);
+  }
+  log.info(`[Consolidation] Completed consolidation run. Merged ${mergedCount} pairs.`);
+  return mergedCount;
+}
+function resolveConflictMode(override) {
+  const raw = (process.env.AMEM_CONFLICT_MODE || override || "review").trim().toLowerCase();
+  return raw === "auto" ? "auto" : "review";
+}
+var CONFLICT_BATCH_SIZE = 25;
+async function conflictSweep(agentId, opts) {
+  const ctx = opts?.storageCtx ?? defaultCtx();
+  const force = opts?.force === true;
+  const mode = resolveConflictMode(opts?.mode);
+  const log = opts?.logger?.info ?? ((m) => console.log(m));
+  const raw = await ctx.listNotes(agentId);
+  const notes = raw.filter((n) => n.agent_id !== "shared" && n.note_type !== "knowledge" && n.is_active !== false);
+  const groups = /* @__PURE__ */ new Map();
+  for (const n of notes) {
+    const c = n.category || "General";
+    if (!groups.has(c)) groups.set(c, []);
+    groups.get(c).push(n);
+  }
+  let pairsFound = 0;
+  let retired = 0;
+  let batchesScanned = 0;
+  let batchesSkipped = 0;
+  for (const [category, groupNotes] of groups.entries()) {
+    groupNotes.sort((a, b) => Date.parse(b.timestamp) - Date.parse(a.timestamp));
+    for (let start = 0; start < groupNotes.length; start += CONFLICT_BATCH_SIZE) {
+      const batch = groupNotes.slice(start, start + CONFLICT_BATCH_SIZE);
+      if (batch.length < 2) continue;
+      if (!force && batch.every((n) => n.conflict_scanned_at)) {
+        batchesSkipped++;
+        continue;
+      }
+      batchesScanned++;
+      const pairs = await llmConflictScan(batch.map((n) => n.content));
+      for (const { a, b, reason, supersededIndex } of pairs) {
+        const noteA = batch[a];
+        const noteB = batch[b];
+        if (!noteA || !noteB) continue;
+        pairsFound++;
+        await ctx.patchNotePayload(noteA.id, {
+          conflict: true,
+          evolution_type: "CONFLICT",
+          conflicts_with: Array.from(/* @__PURE__ */ new Set([...noteA.conflicts_with ?? [], noteB.id])),
+          conflict_reason: reason
+        });
+        await ctx.patchNotePayload(noteB.id, {
+          conflict: true,
+          evolution_type: "CONFLICT",
+          conflicts_with: Array.from(/* @__PURE__ */ new Set([...noteB.conflicts_with ?? [], noteA.id])),
+          conflict_reason: reason
+        });
+        log(`[conflict] ${category}: ${noteA.id.slice(0, 8)} \u2194 ${noteB.id.slice(0, 8)} \u2014 ${reason}`);
+        if (mode === "auto") {
+          const superseded = supersededIndex === a ? noteA : supersededIndex === b ? noteB : null;
+          if (!superseded) {
+            log(`[conflict] auto: no superseded side identified \u2014 marked only, nothing retired`);
+          } else {
+            const ok = await ctx.invalidateNote(superseded.id, agentId);
+            if (ok) {
+              retired++;
+              log(`[conflict] auto-retired the superseded note ${superseded.id.slice(0, 8)}`);
+            }
+          }
+        }
+      }
+      const scannedAt = (/* @__PURE__ */ new Date()).toISOString();
+      for (const n of batch) {
+        await ctx.patchNotePayload(n.id, { conflict_scanned_at: scannedAt });
+      }
+    }
+  }
+  log(
+    `[conflict] ${batchesScanned} batch(es) scanned, ${batchesSkipped} already up to date; ${pairsFound} pair(s) found, ${retired} retired`
+  );
+  return { scanned: notes.length, pairsFound, retired, batchesScanned, batchesSkipped };
+}
+
+// src/migrate.ts
+function missingDerivedFields(n) {
+  return n.keywords.length === 0 || n.tags.length === 0;
+}
+async function migrateCollection(opts) {
+  const { from, to } = opts;
+  const refreshFields = opts.refreshFields !== false;
+  const dryRun = opts.dryRun !== false;
+  const log = opts.logger?.info ?? ((m) => console.log(m));
+  const warn = opts.logger?.warn ?? ((m) => console.warn(m));
+  if (from === to) throw new Error(`migrate: source and target are the same collection ("${from}")`);
+  const model = getEmbeddingModel();
+  const targetDim = await getEmbeddingDim();
+  const sourceDim = await collectionDimRaw(from);
+  if (sourceDim === null) throw new Error(`migrate: source collection "${from}" does not exist`);
+  const points = await scrollAllRaw(from);
+  const notes = points.map(pointToNote);
+  const missingDerived = notes.filter(missingDerivedFields).length;
+  log(
+    `[migrate] ${from} (${sourceDim}d, ${notes.length} notes) \u2192 ${to} (${targetDim}d, ${model}); ${missingDerived} note(s) missing keywords/tags`
+  );
+  if (dryRun) {
+    log("[migrate] dry run \u2014 nothing written. Pass dryRun: false to apply.");
+    return {
+      total: notes.length,
+      missingDerived,
+      refreshed: 0,
+      migrated: 0,
+      skipped: 0,
+      sourceDim,
+      targetDim,
+      model,
+      dryRun: true
+    };
+  }
+  let alreadyDone = /* @__PURE__ */ new Set();
+  const existingTargetDim = await collectionDimRaw(to);
+  if (existingTargetDim === null) {
+    await createCollectionRaw(to, targetDim);
+    log(`[migrate] created ${to} at ${targetDim}d`);
+  } else {
+    if (existingTargetDim !== targetDim) {
+      throw new Error(`migrate: target "${to}" exists at ${existingTargetDim}d but the model produces ${targetDim}d`);
+    }
+    const present = await scrollIdsRaw(to);
+    if (present.size > 0) {
+      const sourceIds = new Set(notes.map((n) => n.id));
+      const foreign = [...present].filter((id) => !sourceIds.has(id));
+      if (foreign.length > 0) {
+        throw new Error(
+          `migrate: target "${to}" holds ${foreign.length} point(s) that are not in "${from}" (e.g. ${foreign[0]}). That is not an interrupted migration \u2014 use a different target.`
+        );
+      }
+      alreadyDone = present;
+      log(`[migrate] resuming: ${present.size} of ${notes.length} already in ${to}`);
+    }
+  }
+  let refreshed = 0;
+  let migrated = 0;
+  const BATCH = 64;
+  let buffer = [];
+  const flush = async () => {
+    if (!buffer.length) return;
+    await upsertPointsRaw(to, buffer);
+    migrated += buffer.length;
+    buffer = [];
+  };
+  for (const note of notes) {
+    if (alreadyDone.has(note.id)) continue;
+    if (refreshFields && missingDerivedFields(note)) {
+      try {
+        const built = await llmConstructNote(note.content);
+        if (note.keywords.length === 0) note.keywords = built.keywords;
+        if (note.tags.length === 0) note.tags = built.tags;
+        if (!note.context) note.context = built.context;
+        refreshed++;
+      } catch (e) {
+        warn(`[migrate] re-extract failed for ${note.id.slice(0, 8)} \u2014 keeping as-is: ${e.message}`);
+      }
+    }
+    const point = noteToPoint({ ...note, embedding: await encode(buildEmbedText(note)) });
+    buffer.push(point);
+    if (buffer.length >= BATCH) {
+      await flush();
+      log(`[migrate] ${alreadyDone.size + migrated}/${notes.length}`);
+    }
+  }
+  await flush();
+  const finalCount = await countPointsRaw(to);
+  if (finalCount !== notes.length) {
+    warn(`[migrate] target holds ${finalCount} point(s) but the source had ${notes.length} \u2014 check before switching`);
+  }
+  log(`[migrate] done: ${migrated} written, ${alreadyDone.size} already present, ${refreshed} re-extracted.`);
+  return {
+    total: notes.length,
+    missingDerived,
+    refreshed,
+    migrated,
+    skipped: alreadyDone.size,
+    sourceDim,
+    targetDim,
+    model,
+    dryRun: false
+  };
+}
+async function switchToMigrated(opts) {
+  const { name, to } = opts;
+  const log = opts.logger?.info ?? ((m) => console.log(m));
+  if (name === to) throw new Error(`switch: "${name}" and "${to}" are the same collection`);
+  const already = await resolveAliasRaw(name);
+  if (already === to) {
+    log(`[switch] "${name}" already points at "${to}" \u2014 nothing to do`);
+    return { name, to, moved: await countPointsRaw(to) };
+  }
+  const targetCount = await countPointsRaw(to);
+  if (targetCount === 0) throw new Error(`switch: "${to}" is empty \u2014 migrate into it first`);
+  if (already === null) {
+    const sourceCount = await countPointsRaw(name);
+    if (targetCount < sourceCount) {
+      throw new Error(
+        `switch: "${to}" holds ${targetCount} point(s) but "${name}" still holds ${sourceCount}. The migration is not finished \u2014 run it again before switching.`
+      );
+    }
+    log(`[switch] verified ${targetCount} in "${to}" against ${sourceCount} in "${name}"`);
+    await deleteCollectionRaw(name);
+    log(`[switch] dropped "${name}"`);
+    await createAliasRaw(name, to);
+  } else {
+    await setAliasRaw(name, to);
+  }
+  log(`[switch] "${name}" now resolves to "${to}"`);
+  return { name, to, moved: targetCount };
+}
+
+export {
+  SYSTEM_ACTOR,
+  canWrite,
+  canRead,
+  DEFAULT_EMBEDDING_MODEL,
+  LEGACY_DEFAULT_EMBEDDING_MODEL,
+  LEGACY_DEFAULT_DIM,
+  getEmbeddingModel,
+  getEmbeddingPooling,
+  getEmbeddingDevice,
+  getEmbeddingDtype,
+  getEmbeddingDim,
+  encode,
+  loadModel,
+  isModelLoaded,
+  cosineSimilarity,
+  getCollection,
+  EmbeddingDimensionMismatchError,
+  EmbeddingModelMismatchError,
+  MixedEmbeddingModelsError,
+  pingQdrant,
+  ensureCollection,
+  countPointsRaw,
+  collectionDimRaw,
+  scrollIdsRaw,
+  resolveAliasRaw,
+  createStorageContext,
+  getNote,
+  updateNote,
+  listNotes,
+  deleteNote,
+  invalidateNote,
+  patchNotePayload,
+  configureLlm,
+  llmCrudDecision,
+  configure,
+  checkQuality,
+  addMemory,
+  addEpisodic,
+  searchMemory,
+  listMemories,
+  mergeSimilarNotes,
+  consolidateMemories,
+  conflictSweep,
+  migrateCollection,
+  switchToMigrated
+};
+//# sourceMappingURL=chunk-K6WZTDM7.js.map