@amemhq/core 1.0.1 → 2.0.0

package/dist/cli-migrate.cjs

@@ -0,0 +1,1086 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cli-migrate.ts
+var cli_migrate_exports = {};
+__export(cli_migrate_exports, {
+  carried: () => carried,
+  deriveTarget: () => deriveTarget,
+  parseArgs: () => parseArgs
+});
+module.exports = __toCommonJS(cli_migrate_exports);
+
+// src/embedding.ts
+var pipeline = null;
+var extractor = null;
+var loadedKey = null;
+var cachedDim = null;
+var DEFAULT_EMBEDDING_MODEL = "Xenova/bge-m3";
+var DEFAULT_MODEL_DTYPE = "fp16";
+var pinnedModel = null;
+function getEmbeddingModel() {
+  return process.env.AMEM_EMBED_MODEL?.trim() || pinnedModel || DEFAULT_EMBEDDING_MODEL;
+}
+var CLS_POOLED_MODELS = /* @__PURE__ */ new Set([
+  "bge-m3",
+  "bge-base-zh-v1.5",
+  "bge-small-zh-v1.5",
+  "bge-base-en-v1.5",
+  "bge-small-en-v1.5",
+  "bge-large-en-v1.5",
+  "gte-multilingual-base",
+  "gte-modernbert-base",
+  "gte-large-en-v1.5",
+  "snowflake-arctic-embed-m",
+  "snowflake-arctic-embed-l"
+]);
+function getEmbeddingPooling() {
+  const explicit = process.env.AMEM_EMBED_POOLING?.trim().toLowerCase();
+  if (explicit === "mean" || explicit === "cls") return explicit;
+  const basename = getEmbeddingModel().split("/").pop()?.toLowerCase() ?? "";
+  return CLS_POOLED_MODELS.has(basename) ? "cls" : "mean";
+}
+function getEmbeddingDevice() {
+  return process.env.AMEM_EMBED_DEVICE?.trim() || void 0;
+}
+function getEmbeddingDtype() {
+  const explicit = process.env.AMEM_EMBED_DTYPE?.trim();
+  if (explicit) return explicit;
+  return getEmbeddingModel() === DEFAULT_EMBEDDING_MODEL ? DEFAULT_MODEL_DTYPE : void 0;
+}
+function extractorKey() {
+  return `${getEmbeddingModel()}|${getEmbeddingDevice() ?? ""}|${getEmbeddingDtype() ?? ""}`;
+}
+async function getExtractor() {
+  const wanted = extractorKey();
+  if (extractor && loadedKey === wanted) return extractor;
+  if (!pipeline) {
+    const mod = await import("@huggingface/transformers");
+    pipeline = mod.pipeline;
+  }
+  const device = getEmbeddingDevice();
+  const dtype = getEmbeddingDtype();
+  extractor = await pipeline("feature-extraction", getEmbeddingModel(), {
+    revision: "main",
+    // Omitted entirely when unset, so an unconfigured install gets exactly the
+    // library defaults it got before these existed.
+    ...device ? { device } : {},
+    ...dtype ? { dtype } : {}
+  });
+  loadedKey = wanted;
+  cachedDim = null;
+  return extractor;
+}
+async function getEmbeddingDim() {
+  if (cachedDim !== null && loadedKey === extractorKey()) return cachedDim;
+  const probe = await encode("dimension probe");
+  cachedDim = probe.length;
+  return cachedDim;
+}
+function poolNormalize(output, attentionMask, mode) {
+  const seqLen = output.length;
+  const dim = output[0].length;
+  const pooled = new Array(dim).fill(0);
+  if (mode === "cls") {
+    for (let j = 0; j < dim; j++) pooled[j] = output[0][j];
+  } else {
+    let maskSum = 0;
+    for (let i = 0; i < seqLen; i++) {
+      const m = attentionMask[i];
+      maskSum += m;
+      for (let j = 0; j < dim; j++) {
+        pooled[j] += output[i][j] * m;
+      }
+    }
+    for (let j = 0; j < dim; j++) {
+      pooled[j] /= Math.max(maskSum, 1e-9);
+    }
+  }
+  let norm = 0;
+  for (const v of pooled) norm += v * v;
+  norm = Math.sqrt(norm);
+  return pooled.map((v) => v / Math.max(norm, 1e-9));
+}
+async function encode(text) {
+  const ext = await getExtractor();
+  const pooling = getEmbeddingPooling();
+  const result = await ext(text, { pooling, normalize: true });
+  if (result && result.data) {
+    return Array.from(result.data);
+  }
+  const tensor = result;
+  if (tensor.dims && tensor.dims.length === 3) {
+    const seqLen = tensor.dims[1];
+    const dim = tensor.dims[2];
+    const raw = [];
+    for (let i = 0; i < seqLen; i++) {
+      const row = [];
+      for (let j = 0; j < dim; j++) {
+        row.push(tensor.data[i * dim + j]);
+      }
+      raw.push(row);
+    }
+    return poolNormalize(raw, new Array(seqLen).fill(1), pooling);
+  }
+  throw new Error("Unexpected embedding output shape");
+}
+
+// src/storage.ts
+var QDRANT_URL = "http://localhost:6333";
+var getCollection = () => process.env.AMEM_COLLECTION || "amem_notes";
+async function recordCollectionModel(collection, model) {
+  try {
+    await qdrant("PATCH", `/collections/${collection}`, { metadata: { embedding_model: model } });
+  } catch {
+  }
+}
+async function qdrant(method, path2, body) {
+  const res = await fetch(`${QDRANT_URL}${path2}`, {
+    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} ${path2} failed: ${data.error || JSON.stringify(data)}`);
+  }
+  return data.result;
+}
+async function scrollAllRaw(collection, limit = 1e4) {
+  const out = [];
+  let offset = void 0;
+  for (; ; ) {
+    const body = { with_payload: true, with_vector: true, limit };
+    if (offset !== void 0 && offset !== null) body.offset = offset;
+    const res = await qdrant("POST", `/collections/${collection}/points/scroll`, body);
+    out.push(...res.points);
+    offset = res.next_page_offset;
+    if (offset === void 0 || offset === null || res.points.length === 0) break;
+  }
+  return out;
+}
+async function countPointsRaw(collection) {
+  const res = await qdrant("POST", `/collections/${collection}/points/count`, { exact: true });
+  return res.count;
+}
+async function collectionDimRaw(collection) {
+  try {
+    const info = await qdrant("GET", `/collections/${collection}`);
+    return info.config?.params?.vectors?.size ?? null;
+  } catch {
+    return null;
+  }
+}
+async function createCollectionRaw(collection, size) {
+  await qdrant("PUT", `/collections/${collection}`, { vectors: { size, distance: "Cosine" } });
+  await recordCollectionModel(collection, getEmbeddingModel());
+  for (const field_name of ["agent_id", "hash", "topics", "subjects"]) {
+    await qdrant("PUT", `/collections/${collection}/index`, { field_name, field_schema: "keyword" });
+  }
+}
+async function upsertPointsRaw(collection, points) {
+  await qdrant("PUT", `/collections/${collection}/points?wait=true`, { points });
+}
+async function scrollIdsRaw(collection, limit = 1e4) {
+  const ids = /* @__PURE__ */ new Set();
+  let offset = void 0;
+  for (; ; ) {
+    const body = { with_payload: false, with_vector: false, limit };
+    if (offset !== void 0 && offset !== null) body.offset = offset;
+    const res = await qdrant("POST", `/collections/${collection}/points/scroll`, body);
+    for (const p of res.points) ids.add(String(p.id));
+    offset = res.next_page_offset;
+    if (offset === void 0 || offset === null || res.points.length === 0) break;
+  }
+  return ids;
+}
+async function deleteCollectionRaw(collection) {
+  await qdrant("DELETE", `/collections/${collection}`);
+}
+async function resolveAliasRaw(alias) {
+  try {
+    const res = await qdrant("GET", `/aliases`);
+    return res.aliases.find((a) => a.alias_name === alias)?.collection_name ?? null;
+  } catch {
+    return null;
+  }
+}
+async function createAliasRaw(alias, collection) {
+  await qdrant("POST", `/collections/aliases`, {
+    actions: [{ create_alias: { collection_name: collection, alias_name: alias } }]
+  });
+}
+async function setAliasRaw(alias, collection) {
+  await qdrant("POST", `/collections/aliases`, {
+    actions: [
+      { delete_alias: { alias_name: alias } },
+      { create_alias: { collection_name: collection, alias_name: alias } }
+    ]
+  });
+}
+function noteToPoint(note) {
+  return {
+    id: note.id,
+    vector: note.embedding,
+    payload: {
+      content: note.content,
+      keywords: note.keywords,
+      tags: note.tags,
+      context: note.context,
+      links: note.links,
+      timestamp: note.timestamp,
+      agent_id: note.agent_id,
+      hash: note.hash,
+      // 13-A
+      retrieval_count: note.retrieval_count ?? 0,
+      last_accessed: note.last_accessed || note.timestamp,
+      // 13-B: stored as JSON string (Qdrant payload can't handle nested array-of-objects)
+      evolution_history: JSON.stringify(note.evolution_history ?? []),
+      // 13-E
+      category: note.category || "General",
+      is_active: note.is_active !== false,
+      // 26B
+      topics: note.topics ?? [],
+      // 26A
+      note_type: note.note_type || "memory",
+      // 29
+      pending_merge: note.pending_merge ?? false,
+      // 30
+      evolution_type: note.evolution_type || "",
+      conflict: note.conflict ?? false,
+      conflicts_with: note.conflicts_with ?? [],
+      conflict_reason: note.conflict_reason ?? "",
+      conflict_scanned_at: note.conflict_scanned_at ?? "",
+      subjects: note.subjects ?? [],
+      // 31
+      ephemeral: note.ephemeral ?? false,
+      low_quality: note.low_quality ?? false,
+      // 32
+      owner: note.owner || note.agent_id,
+      readers: note.readers ?? [note.agent_id],
+      writers: note.writers ?? [note.agent_id]
+    }
+  };
+}
+function pointToNote(point) {
+  const p = point.payload;
+  const timestamp = p.timestamp || "";
+  let evolutionHistory = [];
+  try {
+    const raw = p.evolution_history;
+    if (typeof raw === "string" && raw.length > 0) {
+      evolutionHistory = JSON.parse(raw);
+    } else if (Array.isArray(raw)) {
+      evolutionHistory = raw;
+    }
+  } catch {
+    evolutionHistory = [];
+  }
+  return {
+    id: String(point.id),
+    content: p.content || "",
+    keywords: p.keywords || [],
+    tags: p.tags || [],
+    context: p.context || "",
+    links: p.links || [],
+    timestamp,
+    agent_id: p.agent_id || "main",
+    embedding: point.vector || [],
+    hash: p.hash || "",
+    // 13-A
+    retrieval_count: typeof p.retrieval_count === "number" ? p.retrieval_count : 0,
+    last_accessed: p.last_accessed || timestamp,
+    // 13-B
+    evolution_history: evolutionHistory,
+    // 13-E
+    category: p.category || "General",
+    is_active: p.is_active !== false,
+    // 26A
+    note_type: p.note_type === "knowledge" ? "knowledge" : "memory",
+    // 26B
+    topics: Array.isArray(p.topics) ? p.topics : [],
+    // 29
+    pending_merge: p.pending_merge === true,
+    // 30
+    evolution_type: typeof p.evolution_type === "string" && ["EVOLVE", "CONFLICT", "EXPAND", "NEW"].includes(p.evolution_type) ? p.evolution_type : void 0,
+    conflict: p.conflict === true,
+    conflicts_with: Array.isArray(p.conflicts_with) ? p.conflicts_with.filter((v) => typeof v === "string") : [],
+    conflict_reason: typeof p.conflict_reason === "string" ? p.conflict_reason : "",
+    conflict_scanned_at: typeof p.conflict_scanned_at === "string" ? p.conflict_scanned_at : "",
+    subjects: Array.isArray(p.subjects) ? p.subjects.filter((v) => typeof v === "string") : [],
+    // 31
+    ephemeral: p.ephemeral === true,
+    low_quality: p.low_quality === true,
+    // 32
+    owner: p.owner || p.agent_id || "main",
+    readers: Array.isArray(p.readers) ? p.readers : [p.agent_id || "main"],
+    writers: Array.isArray(p.writers) ? p.writers : [p.agent_id || "main"]
+  };
+}
+
+// src/llm.ts
+var import_sdk = __toESM(require("@anthropic-ai/sdk"), 1);
+var import_openai = __toESM(require("openai"), 1);
+
+// 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 = {};
+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;
+}
+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 import_sdk.default({
+      ...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 import_openai.default({
+      // 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"
+    };
+  }
+}
+
+// src/memory.ts
+var import_uuid = require("uuid");
+
+// src/config.ts
+var os = __toESM(require("os"), 1);
+var path = __toESM(require("path"), 1);
+var _dataDir = process.env.AMEM_DATA_DIR || path.join(os.homedir(), ".amem");
+
+// src/memory.ts
+var import_jieba = require("@node-rs/jieba");
+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;
+}
+
+// src/migrate.ts
+function missingDerivedFields(n) {
+  return n.keywords.length === 0 || n.tags.length === 0;
+}
+async function migrateCollection(opts) {
+  const { from, to } = opts;
+  const refreshFields = opts.refreshFields !== false;
+  const dryRun = opts.dryRun !== false;
+  const log = opts.logger?.info ?? ((m) => console.log(m));
+  const warn = opts.logger?.warn ?? ((m) => console.warn(m));
+  if (from === to) throw new Error(`migrate: source and target are the same collection ("${from}")`);
+  const model = getEmbeddingModel();
+  const targetDim = await getEmbeddingDim();
+  const sourceDim = await collectionDimRaw(from);
+  if (sourceDim === null) throw new Error(`migrate: source collection "${from}" does not exist`);
+  const points = await scrollAllRaw(from);
+  const notes = points.map(pointToNote);
+  const missingDerived = notes.filter(missingDerivedFields).length;
+  log(
+    `[migrate] ${from} (${sourceDim}d, ${notes.length} notes) \u2192 ${to} (${targetDim}d, ${model}); ${missingDerived} note(s) missing keywords/tags`
+  );
+  if (dryRun) {
+    log("[migrate] dry run \u2014 nothing written. Pass dryRun: false to apply.");
+    return {
+      total: notes.length,
+      missingDerived,
+      refreshed: 0,
+      migrated: 0,
+      skipped: 0,
+      sourceDim,
+      targetDim,
+      model,
+      dryRun: true
+    };
+  }
+  let alreadyDone = /* @__PURE__ */ new Set();
+  const existingTargetDim = await collectionDimRaw(to);
+  if (existingTargetDim === null) {
+    await createCollectionRaw(to, targetDim);
+    log(`[migrate] created ${to} at ${targetDim}d`);
+  } else {
+    if (existingTargetDim !== targetDim) {
+      throw new Error(`migrate: target "${to}" exists at ${existingTargetDim}d but the model produces ${targetDim}d`);
+    }
+    const present = await scrollIdsRaw(to);
+    if (present.size > 0) {
+      const sourceIds = new Set(notes.map((n) => n.id));
+      const foreign = [...present].filter((id) => !sourceIds.has(id));
+      if (foreign.length > 0) {
+        throw new Error(
+          `migrate: target "${to}" holds ${foreign.length} point(s) that are not in "${from}" (e.g. ${foreign[0]}). That is not an interrupted migration \u2014 use a different target.`
+        );
+      }
+      alreadyDone = present;
+      log(`[migrate] resuming: ${present.size} of ${notes.length} already in ${to}`);
+    }
+  }
+  let refreshed = 0;
+  let migrated = 0;
+  const BATCH = 64;
+  let buffer = [];
+  const flush = async () => {
+    if (!buffer.length) return;
+    await upsertPointsRaw(to, buffer);
+    migrated += buffer.length;
+    buffer = [];
+  };
+  for (const note of notes) {
+    if (alreadyDone.has(note.id)) continue;
+    if (refreshFields && missingDerivedFields(note)) {
+      try {
+        const built = await llmConstructNote(note.content);
+        if (note.keywords.length === 0) note.keywords = built.keywords;
+        if (note.tags.length === 0) note.tags = built.tags;
+        if (!note.context) note.context = built.context;
+        refreshed++;
+      } catch (e) {
+        warn(`[migrate] re-extract failed for ${note.id.slice(0, 8)} \u2014 keeping as-is: ${e.message}`);
+      }
+    }
+    const point = noteToPoint({ ...note, embedding: await encode(buildEmbedText(note)) });
+    buffer.push(point);
+    if (buffer.length >= BATCH) {
+      await flush();
+      log(`[migrate] ${alreadyDone.size + migrated}/${notes.length}`);
+    }
+  }
+  await flush();
+  const finalCount = await countPointsRaw(to);
+  if (finalCount !== notes.length) {
+    warn(`[migrate] target holds ${finalCount} point(s) but the source had ${notes.length} \u2014 check before switching`);
+  }
+  log(`[migrate] done: ${migrated} written, ${alreadyDone.size} already present, ${refreshed} re-extracted.`);
+  return {
+    total: notes.length,
+    missingDerived,
+    refreshed,
+    migrated,
+    skipped: alreadyDone.size,
+    sourceDim,
+    targetDim,
+    model,
+    dryRun: false
+  };
+}
+async function switchToMigrated(opts) {
+  const { name, to } = opts;
+  const log = opts.logger?.info ?? ((m) => console.log(m));
+  if (name === to) throw new Error(`switch: "${name}" and "${to}" are the same collection`);
+  const already = await resolveAliasRaw(name);
+  if (already === to) {
+    log(`[switch] "${name}" already points at "${to}" \u2014 nothing to do`);
+    return { name, to, moved: await countPointsRaw(to) };
+  }
+  const targetCount = await countPointsRaw(to);
+  if (targetCount === 0) throw new Error(`switch: "${to}" is empty \u2014 migrate into it first`);
+  if (already === null) {
+    const sourceCount = await countPointsRaw(name);
+    if (targetCount < sourceCount) {
+      throw new Error(
+        `switch: "${to}" holds ${targetCount} point(s) but "${name}" still holds ${sourceCount}. The migration is not finished \u2014 run it again before switching.`
+      );
+    }
+    log(`[switch] verified ${targetCount} in "${to}" against ${sourceCount} in "${name}"`);
+    await deleteCollectionRaw(name);
+    log(`[switch] dropped "${name}"`);
+    await createAliasRaw(name, to);
+  } else {
+    await setAliasRaw(name, to);
+  }
+  log(`[switch] "${name}" now resolves to "${to}"`);
+  return { name, to, moved: targetCount };
+}
+
+// src/cli-migrate.ts
+var USAGE = `amem-migrate \u2014 move a memory store onto a different embedding model
+
+  amem-migrate              what state the store is in, and what comes next
+  amem-migrate --apply      do the next step; safe to interrupt and re-run
+  amem-migrate --switch     put the new store behind the old name (irreversible)
+
+Options
+  --from-collection <name>  the store to migrate. Defaults to AMEM_COLLECTION.
+  --to-collection <name>    where to build it. Derived from the source if omitted.
+  --no-refresh-fields       skip re-extracting keywords for notes that never had
+                            them. Makes the run completely offline.
+  -h, --help
+
+Migrates onto amem's current default unless AMEM_EMBED_MODEL says otherwise:
+
+  AMEM_EMBED_MODEL=Alibaba-NLP/gte-multilingual-base amem-migrate --apply
+
+Nothing before --switch touches the original. If a run looks wrong, delete the
+target and start again.`;
+function parseArgs(argv) {
+  const value = (flag) => {
+    const i = argv.indexOf(flag);
+    return i === -1 ? void 0 : argv[i + 1];
+  };
+  return {
+    help: argv.includes("-h") || argv.includes("--help"),
+    apply: argv.includes("--apply"),
+    switchOver: argv.includes("--switch"),
+    from: value("--from-collection"),
+    to: value("--to-collection"),
+    refreshFields: !argv.includes("--no-refresh-fields")
+  };
+}
+function deriveTarget(source) {
+  const m = source.match(/^(.*)_v(\d+)$/);
+  return m ? `${m[1]}_v${Number(m[2]) + 1}` : `${source}_v2`;
+}
+function carried(args) {
+  return (args.from ? ` --from-collection ${args.from}` : "") + (args.to ? ` --to-collection ${args.to}` : "");
+}
+async function detect(from, to) {
+  const alias = await resolveAliasRaw(from);
+  if (alias !== null) return { kind: "switched", points: await countPointsRaw(from) };
+  const sourceDim = await collectionDimRaw(from);
+  if (sourceDim === null) return { kind: "no-source" };
+  const modelDim = await getEmbeddingDim();
+  if (sourceDim === modelDim) return { kind: "already-current", model: getEmbeddingModel() };
+  const notes = await countPointsRaw(from);
+  const targetDim = await collectionDimRaw(to);
+  if (targetDim === null) return { kind: "not-started", notes };
+  const done = (await scrollIdsRaw(to)).size;
+  return done >= notes ? { kind: "ready-to-switch", notes } : { kind: "partial", done, notes };
+}
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    console.log(USAGE);
+    return;
+  }
+  const from = args.from ?? getCollection();
+  const to = args.to ?? deriveTarget(from);
+  const flags = carried(args);
+  const phase = await detect(from, to);
+  console.log(`store:  ${from}`);
+  console.log(`model:  ${getEmbeddingModel()}`);
+  switch (phase.kind) {
+    case "no-source":
+      console.error(`
+No collection named "${from}". Nothing to migrate.`);
+      process.exitCode = 1;
+      return;
+    case "switched":
+      console.log(`
+"${from}" is already an alias \u2014 ${phase.points} notes, nothing to do.`);
+      return;
+    case "already-current":
+      console.log(`
+Already on ${phase.model}. Nothing to migrate.`);
+      return;
+    case "not-started":
+      if (!args.apply) {
+        console.log(`
+${phase.notes} notes to rebuild into "${to}".`);
+        console.log(`Run "amem-migrate${flags} --apply" to start. "${from}" is only read.`);
+        return;
+      }
+      break;
+    case "partial":
+      if (!args.apply) {
+        console.log(`
+${phase.done} of ${phase.notes} rebuilt into "${to}".`);
+        console.log(`Run "amem-migrate${flags} --apply" to carry on from there.`);
+        return;
+      }
+      break;
+    case "ready-to-switch":
+      if (!args.switchOver) {
+        console.log(`
+All ${phase.notes} notes are in "${to}". "${from}" is untouched.`);
+        console.log(`Check it, then run "amem-migrate${flags} --switch" to put "${to}" behind the name "${from}".`);
+        console.log(`That drops "${from}" and cannot be undone.`);
+        return;
+      }
+      await switchToMigrated({ name: from, to });
+      console.log(`
+Done. Nothing to change in your config \u2014 "${from}" now resolves to "${to}".`);
+      return;
+  }
+  if (args.switchOver) {
+    console.error(`
+Not finished yet \u2014 run "amem-migrate${flags} --apply" until it is before switching.`);
+    process.exitCode = 1;
+    return;
+  }
+  const result = await migrateCollection({ from, to, dryRun: false, refreshFields: args.refreshFields });
+  console.log(`
+${result.migrated + result.skipped} of ${result.total} rebuilt.`);
+  if (result.migrated + result.skipped >= result.total) {
+    console.log(`Check "${to}", then run "amem-migrate${flags} --switch".`);
+  } else {
+    console.log(`Run "amem-migrate${flags} --apply" again to carry on.`);
+  }
+}
+main().catch((err) => {
+  console.error(`amem-migrate: ${err instanceof Error ? err.message : String(err)}`);
+  process.exitCode = 1;
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  carried,
+  deriveTarget,
+  parseArgs
+});
+//# sourceMappingURL=cli-migrate.cjs.map