@amemhq/core 1.0.1 → 2.0.0

package/dist/index.js

@@ -1,2018 +1,50 @@
-// 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/embedding.ts
-var pipeline = null;
-var extractor = null;
-var loadedModelName = null;
-var cachedDim = null;
-var DEFAULT_EMBEDDING_MODEL = "Xenova/paraphrase-multilingual-MiniLM-L12-v2";
-function getEmbeddingModel() {
-  return process.env.AMEM_EMBED_MODEL?.trim() || 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 basename2 = getEmbeddingModel().split("/").pop()?.toLowerCase() ?? "";
-  return CLS_POOLED_MODELS.has(basename2) ? "cls" : "mean";
-}
-async function getExtractor() {
-  const wanted = getEmbeddingModel();
-  if (extractor && loadedModelName === wanted) return extractor;
-  if (!pipeline) {
-    const mod = await import("@huggingface/transformers");
-    pipeline = mod.pipeline;
-  }
-  extractor = await pipeline("feature-extraction", wanted, {
-    revision: "main"
-  });
-  loadedModelName = wanted;
-  cachedDim = null;
-  return extractor;
-}
-async function getEmbeddingDim() {
-  if (cachedDim !== null && loadedModelName === getEmbeddingModel()) 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/memory.ts
-import { v4 as uuidv4 } from "uuid";
-import { createHash } from "crypto";
-import * as fs2 from "fs";
-import * as path3 from "path";
-
-// src/auth.ts
-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/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 migrate: build a new collection with the new model, backfill it, then point AMEM_COLLECTION at it. See docs/reference/embedding-models.md.`
-    );
-    this.collection = collection;
-    this.collectionDim = collectionDim;
-    this.modelDim = modelDim;
-    this.model = model;
-    this.name = "EmbeddingDimensionMismatchError";
-  }
-  collection;
-  collectionDim;
-  modelDim;
-  model;
-};
-async function qdrant(method, path5, body) {
-  const res = await fetch(`${QDRANT_URL}${path5}`, {
-    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} ${path5} 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;
-    if (typeof collectionDim === "number") {
-      const modelDim = await getEmbeddingDim();
-      if (collectionDim !== modelDim) {
-        throw new EmbeddingDimensionMismatchError(col, collectionDim, modelDim, getEmbeddingModel());
-      }
-    }
-    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;
-  }
-  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" } });
-  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 });
-}
-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. Pass `readerAgentId` to enforce `readers`; an unreadable
-     * note comes back as `null` (indistinguishable from missing, so nothing leaks,
-     * and callers already handle null). Omitting it skips the check, preserving
-     * behaviour for internal callers that only ever hold their own ids.
-     */
-    async getNote(id, readerAgentId) {
-      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 (readerAgentId !== void 0 && !canRead(note, readerAgentId)) 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: pass `callerAgentId` to enforce the writers policy. Callers that
-     * hold the note already should prefer checking `canWrite` themselves; this
-     * fetch-then-check path exists for callers that only have an id (the plugin's
-     * CRUD hook). Returns false — without writing — when the caller may not write.
-     * Omitting `callerAgentId` skips the check, preserving existing behaviour for
-     * internal callers that are already scoped to their own notes.
-     */
-    async updateNoteContent(id, content, embedding, hash, callerAgentId) {
-      await ensureCollection(col);
-      let existing = null;
-      if (callerAgentId !== void 0) {
-        existing = await this.getNote(id);
-        if (existing && !canWrite(existing, callerAgentId)) 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, callerAgentId) {
-      await ensureCollection(col);
-      if (callerAgentId !== void 0) {
-        const existing = await this.getNote(id);
-        if (existing && !canWrite(existing, callerAgentId)) 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, readerAgentId) {
-  return makeCrud(getCollection()).getNote(id, readerAgentId);
-}
-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, callerAgentId) {
-  return makeCrud(getCollection()).invalidateNote(id, callerAgentId);
-}
-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/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);
-      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);
-          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);
-            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).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 = [];
-  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;
-      if (bfsSimThreshold > 0 && linked.embedding) {
-        const sim = cosineSimilarity(queryEmbedding, linked.embedding);
-        if (sim < bfsSimThreshold) continue;
-      }
-      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 = [];
-  for (const id of [...filteredTopIds, ...bfsExtra]) {
-    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) ?? 0,
-      rrf: rrfMap.get(id) ?? 0,
-      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((resolve2) => setTimeout(resolve2, 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);
-      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);
-      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);
-      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);
-      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 };
-}
+import {
+  DEFAULT_EMBEDDING_MODEL,
+  EmbeddingDimensionMismatchError,
+  EmbeddingModelMismatchError,
+  LEGACY_DEFAULT_DIM,
+  LEGACY_DEFAULT_EMBEDDING_MODEL,
+  MixedEmbeddingModelsError,
+  SYSTEM_ACTOR,
+  addEpisodic,
+  addMemory,
+  canRead,
+  canWrite,
+  checkQuality,
+  configure,
+  configureLlm,
+  conflictSweep,
+  consolidateMemories,
+  cosineSimilarity,
+  createStorageContext,
+  deleteNote,
+  encode,
+  ensureCollection,
+  getEmbeddingDevice,
+  getEmbeddingDim,
+  getEmbeddingDtype,
+  getEmbeddingModel,
+  getEmbeddingPooling,
+  getNote,
+  invalidateNote,
+  isModelLoaded,
+  listMemories,
+  listNotes,
+  llmCrudDecision,
+  loadModel,
+  mergeSimilarNotes,
+  migrateCollection,
+  patchNotePayload,
+  pingQdrant,
+  searchMemory,
+  switchToMigrated,
+  updateNote
+} from "./chunk-K6WZTDM7.js";
 
 // src/quality.ts
-import * as fs3 from "fs";
-import * as path4 from "path";
-var LOCALE2 = process.env.AMEM_PROMPT_LOCALE === "zh" ? "zh" : "en";
+import * as fs from "fs";
+import * as path from "path";
+var LOCALE = process.env.AMEM_PROMPT_LOCALE === "zh" ? "zh" : "en";
 async function scanLowQuality(agentId) {
   const notes = await listNotes(agentId);
   const now = Date.now();
@@ -2046,7 +78,7 @@ var DEFAULT_OUTPUT_DIR = process.env.AMEM_REVIEW_DIR || process.cwd();
 function nextBatchNumber(dir) {
   let max = 0;
   try {
-    const files = fs3.readdirSync(dir);
+    const files = fs.readdirSync(dir);
     for (const f of files) {
       const match = f.match(/^amem-review-batch(\d+)\.md$/);
       if (match) {
@@ -2059,7 +91,7 @@ function nextBatchNumber(dir) {
   return max + 1;
 }
 function reasonLabel(r) {
-  if (LOCALE2 === "zh") {
+  if (LOCALE === "zh") {
     switch (r) {
       case "too_short":
         return "\u5185\u5BB9\u8FC7\u77ED\uFF08<10\u5B57\uFF09";
@@ -2084,34 +116,34 @@ function severityBadge(reasons) {
   return "\u{1F7E0} CONFLICT";
 }
 async function generateReviewBatch(agentId, outputPath) {
-  const root = path4.resolve(DEFAULT_OUTPUT_DIR);
+  const root = path.resolve(DEFAULT_OUTPUT_DIR);
   let filePath;
   let batchN;
   if (outputPath) {
-    const name = path4.basename(outputPath);
+    const name = path.basename(outputPath);
     if (name !== outputPath || name === "" || name === "." || name === "..") {
       throw new Error(`[quality] outputPath \u5FC5\u987B\u662F\u7EAF\u6587\u4EF6\u540D\uFF08\u4E0D\u542B\u76EE\u5F55\uFF09: ${outputPath}`);
     }
-    filePath = path4.join(root, name);
+    filePath = path.join(root, name);
     batchN = 0;
   } else {
     batchN = nextBatchNumber(root);
-    filePath = path4.join(root, `amem-review-batch${batchN}.md`);
+    filePath = path.join(root, `amem-review-batch${batchN}.md`);
   }
   const items = await scanLowQuality(agentId);
   const now = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   const lines = [];
-  const title = LOCALE2 === "zh" ? "A-MEM \u8D28\u91CF\u5BA1\u6838" : "A-MEM Quality Review";
-  const genLabel = LOCALE2 === "zh" ? "\u751F\u6210\u65F6\u95F4" : "Generated";
-  const countLabel = LOCALE2 === "zh" ? `\u5171 ${items.length} \u6761\u4F4E\u8D28\u91CF\u6761\u76EE` : `${items.length} low-quality item(s)`;
-  const applyHint = LOCALE2 === "zh" ? "\u52FE\u9009\u540E\u4EA4\u7ED9\u52A9\u624B\u5904\u7406\u8FD9\u4E9B\u6761\u76EE" : "Tick your choices, then ask the assistant to act on them";
+  const title = LOCALE === "zh" ? "A-MEM \u8D28\u91CF\u5BA1\u6838" : "A-MEM Quality Review";
+  const genLabel = LOCALE === "zh" ? "\u751F\u6210\u65F6\u95F4" : "Generated";
+  const countLabel = LOCALE === "zh" ? `\u5171 ${items.length} \u6761\u4F4E\u8D28\u91CF\u6761\u76EE` : `${items.length} low-quality item(s)`;
+  const applyHint = LOCALE === "zh" ? "\u52FE\u9009\u540E\u4EA4\u7ED9\u52A9\u624B\u5904\u7406\u8FD9\u4E9B\u6761\u76EE" : "Tick your choices, then ask the assistant to act on them";
   lines.push(`# ${title} \u2014 Batch ${batchN || "custom"}`);
   lines.push("");
   lines.push(`> ${genLabel}\uFF1A${now} | ${countLabel}`);
   lines.push(`> ${applyHint}`);
   lines.push("");
   if (items.length === 0) {
-    lines.push(LOCALE2 === "zh" ? "\u2705 \u6CA1\u6709\u53D1\u73B0\u4F4E\u8D28\u91CF\u6761\u76EE\u3002" : "\u2705 No low-quality items found.");
+    lines.push(LOCALE === "zh" ? "\u2705 \u6CA1\u6709\u53D1\u73B0\u4F4E\u8D28\u91CF\u6761\u76EE\u3002" : "\u2705 No low-quality items found.");
   }
   const byId = new Map(items.map((it) => [it.note.id, it.note]));
   const renderedPairs = /* @__PURE__ */ new Set();
@@ -2124,13 +156,13 @@ async function generateReviewBatch(agentId, outputPath) {
       if (renderedPairs.has(key)) continue;
       renderedPairs.add(key);
       const [newer, older] = Date.parse(note.timestamp) >= Date.parse(other.timestamp) ? [note, other] : [other, note];
-      const zh2 = LOCALE2 === "zh";
-      pairLines.push(`### \u{1F7E0} ${zh2 ? "\u51B2\u7A81" : "CONFLICT"} | ${newer.category || "General"}`);
+      const zh = LOCALE === "zh";
+      pairLines.push(`### \u{1F7E0} ${zh ? "\u51B2\u7A81" : "CONFLICT"} | ${newer.category || "General"}`);
       if (newer.conflict_reason) {
-        pairLines.push(`**${zh2 ? "\u5224\u5B9A\u7406\u7531" : "Why"}\uFF1A** ${newer.conflict_reason}`);
+        pairLines.push(`**${zh ? "\u5224\u5B9A\u7406\u7531" : "Why"}\uFF1A** ${newer.conflict_reason}`);
         pairLines.push("");
       }
-      pairLines.push(`| | ${zh2 ? "\u65F6\u95F4" : "When"} | ${zh2 ? "\u5185\u5BB9" : "Content"} |`);
+      pairLines.push(`| | ${zh ? "\u65F6\u95F4" : "When"} | ${zh ? "\u5185\u5BB9" : "Content"} |`);
       pairLines.push("| :-- | :-- | :-- |");
       pairLines.push(`| **A** | ${newer.timestamp.slice(0, 10)} | ${newer.content.replace(/\n/g, " ")} |`);
       pairLines.push(`| **B** | ${older.timestamp.slice(0, 10)} | ${older.content.replace(/\n/g, " ")} |`);
@@ -2139,33 +171,33 @@ async function generateReviewBatch(agentId, outputPath) {
       pairLines.push(`\`B: ${older.id}\``);
       pairLines.push("");
       pairLines.push(
-        zh2 ? `- [ ] \u2705 **A \u662F\u5F53\u524D\u72B6\u6001\uFF0C\u505C\u7528 B**\uFF08\u63A8\u8350\uFF1AA \u66F4\u65B0\uFF09` : `- [ ] \u2705 **A is current \u2014 retire B** (recommended: A is newer)`
+        zh ? `- [ ] \u2705 **A \u662F\u5F53\u524D\u72B6\u6001\uFF0C\u505C\u7528 B**\uFF08\u63A8\u8350\uFF1AA \u66F4\u65B0\uFF09` : `- [ ] \u2705 **A is current \u2014 retire B** (recommended: A is newer)`
       );
-      pairLines.push(zh2 ? `- [ ] \u21A9\uFE0F B \u662F\u5F53\u524D\u72B6\u6001\uFF0C\u505C\u7528 A` : `- [ ] \u21A9\uFE0F B is current \u2014 retire A`);
-      pairLines.push(zh2 ? `- [ ] \u{1F91D} \u4E24\u8005\u90FD\u6210\u7ACB\uFF08\u8BEF\u5224\uFF09` : `- [ ] \u{1F91D} Both hold \u2014 not a contradiction`);
+      pairLines.push(zh ? `- [ ] \u21A9\uFE0F B \u662F\u5F53\u524D\u72B6\u6001\uFF0C\u505C\u7528 A` : `- [ ] \u21A9\uFE0F B is current \u2014 retire A`);
+      pairLines.push(zh ? `- [ ] \u{1F91D} \u4E24\u8005\u90FD\u6210\u7ACB\uFF08\u8BEF\u5224\uFF09` : `- [ ] \u{1F91D} Both hold \u2014 not a contradiction`);
       pairLines.push("");
       pairLines.push("---");
       pairLines.push("");
     }
   }
   if (pairLines.length > 0) {
-    lines.push(LOCALE2 === "zh" ? "## \u51B2\u7A81\uFF08\u6210\u5BF9\uFF0C\u4E00\u4E2A\u51B2\u7A81\u4E00\u4E2A\u51B3\u5B9A\uFF09" : "## Conflicts (paired \u2014 one decision each)");
+    lines.push(LOCALE === "zh" ? "## \u51B2\u7A81\uFF08\u6210\u5BF9\uFF0C\u4E00\u4E2A\u51B2\u7A81\u4E00\u4E2A\u51B3\u5B9A\uFF09" : "## Conflicts (paired \u2014 one decision each)");
     lines.push("");
     lines.push(...pairLines);
-    lines.push(LOCALE2 === "zh" ? "## \u5176\u4F59\u6761\u76EE" : "## Other items");
+    lines.push(LOCALE === "zh" ? "## \u5176\u4F59\u6761\u76EE" : "## Other items");
     lines.push("");
   }
   for (let i = 0; i < items.length; i++) {
     const { note, reasons } = items[i];
     const badge = severityBadge(reasons);
     const reasonStr = reasons.map(reasonLabel).join("\u3001");
-    const issueLabel = LOCALE2 === "zh" ? "\u95EE\u9898" : "Issue";
-    const contentLabel = LOCALE2 === "zh" ? "\u5185\u5BB9" : "Content";
-    const kwLabel = LOCALE2 === "zh" ? "\u5173\u952E\u8BCD" : "Keywords";
-    const tagLabel = LOCALE2 === "zh" ? "\u6807\u7B7E" : "Tags";
-    const keepLabel = LOCALE2 === "zh" ? "\u4FDD\u7559" : "Keep";
-    const rewriteLabel = LOCALE2 === "zh" ? "\u6539\u5199" : "Rewrite";
-    const deleteLabel = LOCALE2 === "zh" ? "\u5220\u9664" : "Delete";
+    const issueLabel = LOCALE === "zh" ? "\u95EE\u9898" : "Issue";
+    const contentLabel = LOCALE === "zh" ? "\u5185\u5BB9" : "Content";
+    const kwLabel = LOCALE === "zh" ? "\u5173\u952E\u8BCD" : "Keywords";
+    const tagLabel = LOCALE === "zh" ? "\u6807\u7B7E" : "Tags";
+    const keepLabel = LOCALE === "zh" ? "\u4FDD\u7559" : "Keep";
+    const rewriteLabel = LOCALE === "zh" ? "\u6539\u5199" : "Rewrite";
+    const deleteLabel = LOCALE === "zh" ? "\u5220\u9664" : "Delete";
     lines.push(`### [${i + 1}] ${badge} | ${note.category || "General"}`);
     lines.push(`\`${note.id}\``);
     lines.push("");
@@ -2186,89 +218,11 @@ async function generateReviewBatch(agentId, outputPath) {
     lines.push("---");
     lines.push("");
   }
-  fs3.mkdirSync(path4.dirname(filePath), { recursive: true });
-  fs3.writeFileSync(filePath, lines.join("\n"), "utf8");
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, lines.join("\n"), "utf8");
   return filePath;
 }
 
-// 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, sourceDim, targetDim, model, dryRun: true };
-  }
-  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 existingCount = await countPointsRaw(to);
-    if (existingCount > 0) {
-      throw new Error(`migrate: target "${to}" already holds ${existingCount} point(s); use an empty collection`);
-    }
-  }
-  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 (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] ${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} migrated, ${refreshed} re-extracted. "${from}" is untouched \u2014 switch with AMEM_COLLECTION=${to}, and keep the old one until you are satisfied.`
-  );
-  return { total: notes.length, missingDerived, refreshed, migrated, sourceDim, targetDim, model, dryRun: false };
-}
-
 // src/crud-guard.ts
 var DEFAULT_CRUD_UPDATE_MIN_SIM = 0.35;
 function resolveCrudUpdateMinSim(override) {
@@ -2286,6 +240,11 @@ export {
   DEFAULT_CRUD_UPDATE_MIN_SIM,
   DEFAULT_EMBEDDING_MODEL,
   EmbeddingDimensionMismatchError,
+  EmbeddingModelMismatchError,
+  LEGACY_DEFAULT_DIM,
+  LEGACY_DEFAULT_EMBEDDING_MODEL,
+  MixedEmbeddingModelsError,
+  SYSTEM_ACTOR,
   addEpisodic,
   addMemory,
   canRead,
@@ -2300,7 +259,9 @@ export {
   encode,
   ensureCollection,
   generateReviewBatch,
+  getEmbeddingDevice,
   getEmbeddingDim,
+  getEmbeddingDtype,
   getEmbeddingModel,
   getEmbeddingPooling,
   getNote,
@@ -2318,6 +279,7 @@ export {
   resolveCrudUpdateMinSim,
   scanLowQuality,
   searchMemory,
+  switchToMigrated,
   updateNote
 };
 //# sourceMappingURL=index.js.map