@anuma/sdk 4.2.0 → 5.0.0

package/dist/react/{chunk-BS7C4CUW.mjs → chunk-KTBOHRRE.mjs}

@@ -13,8 +13,21 @@ import { v7 as uuidv72 } from "uuid";
 
 // src/react/useEncryption.ts
 var SIGN_MESSAGE = "The app is asking you to sign this message to generate a key, which will be used to encrypt data.";
+var EncryptionKeyMissingError = class extends Error {
+  constructor(address, version) {
+    super(
+      `Encryption key (${version}) not found for ${address}. Please sign a message to generate your encryption key.`
+    );
+    this.name = "EncryptionKeyMissingError";
+    this.address = address;
+    this.version = version;
+  }
+};
 var encryptionKeyStore = /* @__PURE__ */ new Map();
 var pendingKeyRequests = /* @__PURE__ */ new Map();
+var pendingCandidateDerives = /* @__PURE__ */ new Map();
+var refreshCandidatesByAddress = /* @__PURE__ */ new Map();
+var divergentDeriveAddresses = /* @__PURE__ */ new Set();
 var sessionEpoch = 0;
 var cryptoKeyCache = /* @__PURE__ */ new Map();
 var keyAvailableCallbacks = /* @__PURE__ */ new Map();
@@ -57,14 +70,11 @@ function notifyKeyAvailable(address) {
   }
 }
 var keyPairStore = /* @__PURE__ */ new Map();
-function getStoredKey(address) {
-  const keys = encryptionKeyStore.get(address);
-  return keys?.current ?? null;
-}
 function getStoredKeyByVersion(address, version) {
   const keys = encryptionKeyStore.get(address);
   if (!keys) return null;
-  return version === "v2" ? keys.legacy : keys.current;
+  const value = version === "v2" ? keys.legacy : keys.current;
+  return value ?? null;
 }
 function setStoredKey(address, keys) {
   encryptionKeyStore.set(address, keys);
@@ -73,6 +83,8 @@ function clearEncryptionKey(address) {
   encryptionKeyStore.delete(address);
   cryptoKeyCache.delete(`${address}:v2`);
   cryptoKeyCache.delete(`${address}:v3`);
+  refreshCandidatesByAddress.delete(address);
+  divergentDeriveAddresses.delete(address);
 }
 function clearAllEncryptionState() {
   sessionEpoch += 1;
@@ -80,6 +92,9 @@ function clearAllEncryptionState() {
   cryptoKeyCache.clear();
   keyAvailableCallbacks.clear();
   pendingKeyRequests.clear();
+  pendingCandidateDerives.clear();
+  refreshCandidatesByAddress.clear();
+  divergentDeriveAddresses.clear();
   clearAllKeyPairs();
   for (const cb of clearAllEncryptionStateCallbacks) {
     try {
@@ -265,9 +280,7 @@ async function getEncryptionKey(address, version = "v3") {
   }
   const keyHex = getStoredKeyByVersion(address, version);
   if (!keyHex) {
-    throw new Error(
-      "Encryption key not found. Please sign a message to generate your encryption key."
-    );
+    throw new EncryptionKeyMissingError(address, version);
   }
   const keyBytes = hexToBytes(keyHex);
   const cryptoKey = await crypto.subtle.importKey(
@@ -331,8 +344,43 @@ async function decryptDataBytesFromBytes(encrypted, address, version = "v3") {
   );
   return new Uint8Array(decryptedData);
 }
-function hasEncryptionKey(address) {
-  return getStoredKey(address) !== null;
+function hasEncryptionKey(address, version) {
+  return getStoredKeyByVersion(address, version ?? "v3") !== null;
+}
+function seedEncryptionKeys(address, keys) {
+  if (!isValidWalletAddress(address)) {
+    throw new Error(
+      `Invalid wallet address: ${address}. Address must start with 0x and be 42 characters (0x + 40 hex characters).`
+    );
+  }
+  if (!keys.legacy && !keys.current) {
+    throw new Error("seedEncryptionKeys: at least one of legacy or current is required");
+  }
+  if (keys.legacy !== void 0) {
+    assertAes256KeyHex("legacy", keys.legacy);
+  }
+  if (keys.current !== void 0) {
+    assertAes256KeyHex("current", keys.current);
+  }
+  const existing = encryptionKeyStore.get(address);
+  const next = {
+    legacy: keys.legacy ?? existing?.legacy,
+    current: keys.current ?? existing?.current
+  };
+  setStoredKey(address, next);
+  if (keys.legacy !== void 0) cryptoKeyCache.delete(`${address}:v2`);
+  if (keys.current !== void 0) cryptoKeyCache.delete(`${address}:v3`);
+  refreshCandidatesByAddress.delete(address);
+  divergentDeriveAddresses.delete(address);
+  notifyKeyAvailable(address);
+}
+var AES_256_KEY_HEX = /^[0-9a-fA-F]{64}$/;
+function assertAes256KeyHex(field, value) {
+  if (!AES_256_KEY_HEX.test(value)) {
+    throw new Error(
+      `seedEncryptionKeys: ${field} must be 64 hex characters (32-byte AES key), got length ${value.length}`
+    );
+  }
 }
 async function encryptBytesWithKey(plaintext, key) {
   const plaintextBytes = typeof plaintext === "string" ? SHARED_TEXT_ENCODER.encode(plaintext) : plaintext;
@@ -381,20 +429,23 @@ async function decryptDataBatch(encryptedValues, address) {
   const key = await getEncryptionKey(address);
   return Promise.all(encryptedValues.map((value) => decryptDataWithKey(value, key)));
 }
-async function requestEncryptionKey(walletAddress, signMessage, embeddedWalletSigner) {
+async function requestEncryptionKey(walletAddress, signMessage, embeddedWalletSigner, options) {
   if (!isValidWalletAddress(walletAddress)) {
     throw new Error(
       `Invalid wallet address: ${walletAddress}. Address must start with 0x and be 42 characters (0x + 40 hex characters).`
     );
   }
-  const existingKey = getStoredKey(walletAddress);
-  if (existingKey) {
-    return;
+  if (!options?.force && getStoredKeyByVersion(walletAddress, "v3") && getStoredKeyByVersion(walletAddress, "v2")) {
+    return true;
   }
-  const pending = pendingKeyRequests.get(walletAddress);
-  if (pending) {
-    await pending;
-    return;
+  if (!options?.force && divergentDeriveAddresses.has(walletAddress)) {
+    return false;
+  }
+  if (!options?.force) {
+    const pending = pendingKeyRequests.get(walletAddress);
+    if (pending) {
+      return pending;
+    }
   }
   const startEpoch = sessionEpoch;
   const promise = (async () => {
@@ -422,20 +473,143 @@ async function requestEncryptionKey(walletAddress, signMessage, embeddedWalletSi
       deriveKeyFromSignatureV3(signature)
     ]);
     if (sessionEpoch !== startEpoch) {
-      return;
+      return false;
+    }
+    const existing = encryptionKeyStore.get(walletAddress);
+    if (!options?.force && existing && (existing.legacy || existing.current)) {
+      const matchesCurrent = Boolean(existing.current && existing.current === currentKey);
+      const matchesLegacy = Boolean(existing.legacy && existing.legacy === legacyKey);
+      if (!matchesCurrent && !matchesLegacy) {
+        getLogger().warn(
+          "requestEncryptionKey: derived keys do not match existing store; leaving unchanged"
+        );
+        divergentDeriveAddresses.add(walletAddress);
+        return false;
+      }
+      setStoredKey(walletAddress, {
+        legacy: existing.legacy ?? legacyKey,
+        current: existing.current ?? currentKey
+      });
+    } else {
+      setStoredKey(walletAddress, { legacy: legacyKey, current: currentKey });
     }
-    setStoredKey(walletAddress, { legacy: legacyKey, current: currentKey });
+    cryptoKeyCache.delete(`${walletAddress}:v2`);
+    cryptoKeyCache.delete(`${walletAddress}:v3`);
+    refreshCandidatesByAddress.delete(walletAddress);
+    divergentDeriveAddresses.delete(walletAddress);
     notifyKeyAvailable(walletAddress);
+    return true;
   })();
   pendingKeyRequests.set(walletAddress, promise);
   try {
-    await promise;
+    return await promise;
   } finally {
     if (pendingKeyRequests.get(walletAddress) === promise) {
       pendingKeyRequests.delete(walletAddress);
     }
   }
 }
+async function refreshEncryptionKeyIfMatches(walletAddress, probeCiphertext, signMessage, embeddedWalletSigner) {
+  if (!isValidWalletAddress(walletAddress)) {
+    throw new Error(
+      `Invalid wallet address: ${walletAddress}. Address must start with 0x and be 42 characters (0x + 40 hex characters).`
+    );
+  }
+  const parsed = parsePrefixedCiphertext(probeCiphertext);
+  if (!parsed) {
+    return false;
+  }
+  const cached = refreshCandidatesByAddress.get(walletAddress);
+  if (cached) {
+    return tryCommitCandidatesIfProbeMatches(walletAddress, parsed, cached);
+  }
+  let derivePromise = pendingCandidateDerives.get(walletAddress);
+  if (!derivePromise) {
+    derivePromise = (async () => {
+      const candidates2 = await deriveRefreshCandidates(signMessage, embeddedWalletSigner);
+      if (candidates2) {
+        refreshCandidatesByAddress.set(walletAddress, candidates2);
+      }
+      return candidates2;
+    })().finally(() => {
+      if (pendingCandidateDerives.get(walletAddress) === derivePromise) {
+        pendingCandidateDerives.delete(walletAddress);
+      }
+    });
+    pendingCandidateDerives.set(walletAddress, derivePromise);
+  }
+  const candidates = await derivePromise;
+  if (!candidates) {
+    return false;
+  }
+  return tryCommitCandidatesIfProbeMatches(walletAddress, parsed, candidates);
+}
+function parsePrefixedCiphertext(probeCiphertext) {
+  const version = probeCiphertext.startsWith("enc:v3:") ? "v3" : probeCiphertext.startsWith("enc:v2:") ? "v2" : null;
+  if (!version) return null;
+  const encryptedData = probeCiphertext.slice(
+    version === "v3" ? "enc:v3:".length : "enc:v2:".length
+  );
+  if (encryptedData.length < 56 || !/^[0-9a-f]+$/i.test(encryptedData)) {
+    return null;
+  }
+  return { version, encryptedData };
+}
+async function deriveRefreshCandidates(signMessage, embeddedWalletSigner) {
+  const startEpoch = sessionEpoch;
+  const signOptions = { showWalletUIs: false };
+  let signature;
+  try {
+    if (embeddedWalletSigner) {
+      signature = await embeddedWalletSigner(SIGN_MESSAGE, signOptions);
+    } else {
+      signature = await signMessage(SIGN_MESSAGE, signOptions);
+    }
+  } catch (error) {
+    if (embeddedWalletSigner && error instanceof Error) {
+      getLogger().warn(
+        "Embedded wallet signing failed during key refresh, falling back to standard signMessage:",
+        error.message
+      );
+      signature = await signMessage(SIGN_MESSAGE, signOptions);
+    } else {
+      throw error;
+    }
+  }
+  const [legacyKey, currentKey] = await Promise.all([
+    deriveKeyFromSignature(signature),
+    deriveKeyFromSignatureV3(signature)
+  ]);
+  if (sessionEpoch !== startEpoch) {
+    return null;
+  }
+  return { legacy: legacyKey, current: currentKey };
+}
+async function tryCommitCandidatesIfProbeMatches(walletAddress, parsed, candidates) {
+  const candidateHex = parsed.version === "v2" ? candidates.legacy : candidates.current;
+  const keyBytes = hexToBytes(candidateHex);
+  const candidateCryptoKey = await crypto.subtle.importKey(
+    "raw",
+    keyBytes.buffer,
+    { name: "AES-GCM" },
+    false,
+    ["encrypt", "decrypt"]
+  );
+  try {
+    await decryptDataWithKey(parsed.encryptedData, candidateCryptoKey);
+  } catch {
+    getLogger().warn(
+      "refreshEncryptionKeyIfMatches: candidate keys failed to decrypt probe; leaving store unchanged"
+    );
+    return false;
+  }
+  setStoredKey(walletAddress, { legacy: candidates.legacy, current: candidates.current });
+  cryptoKeyCache.delete(`${walletAddress}:v2`);
+  cryptoKeyCache.delete(`${walletAddress}:v3`);
+  divergentDeriveAddresses.delete(walletAddress);
+  notifyKeyAvailable(walletAddress);
+  return true;
+}
 var KEYPAIR_STORAGE_PREFIX = "ecdh_keypair_";
 async function persistKeyPair(address, startEpoch) {
   if (typeof window === "undefined") {
@@ -715,20 +889,29 @@ async function encryptField(value, address, signMessage, embeddedWalletSigner, s
   const encrypted = await encryptData(value, address);
   return `${ENCRYPTION_PREFIX}${encrypted}`;
 }
-async function decryptField(value, address) {
-  if (!value) return value;
+async function decryptFieldDetailed(value, address) {
+  if (!value) return { status: "plaintext", value };
   const detected = detectEncryptionVersion(value);
-  if (!detected) return value;
+  if (!detected) return { status: "plaintext", value };
   if (detected.encryptedData.length < 56 || !/^[0-9a-f]+$/i.test(detected.encryptedData)) {
-    return value;
+    return { status: "invalid_payload", value, version: detected.version };
   }
   try {
-    return await decryptData(detected.encryptedData, address, detected.version);
+    const plaintext = await decryptData(detected.encryptedData, address, detected.version);
+    return { status: "ok", value: plaintext, version: detected.version };
   } catch (error) {
-    getLogger().warn("Failed to decrypt field, returning as-is:", error);
-    return value;
+    if (error instanceof EncryptionKeyMissingError) {
+      getLogger().warn("Failed to decrypt field (key missing for version):", error.message);
+      return { status: "key_missing", value, version: detected.version };
+    }
+    getLogger().warn("Failed to decrypt field (auth mismatch or crypto error):", error);
+    return { status: "auth_mismatch", value, version: detected.version };
   }
 }
+async function decryptField(value, address) {
+  const result = await decryptFieldDetailed(value, address);
+  return result.value;
+}
 async function encryptJsonField(value, address, signMessage, embeddedWalletSigner, skipKeyRequest) {
   if (!value) return void 0;
   const jsonString = JSON.stringify(value);
@@ -828,20 +1011,40 @@ async function encryptMessageFields(message, address, signMessage, embeddedWalle
     throw error;
   }
 }
-async function decryptMaybeJsonField(value, address) {
-  if (value === void 0) return void 0;
-  if (value === null) return value;
+async function decryptMaybeJsonFieldDetailed(value, address) {
+  if (value === void 0) return { value: void 0, status: "plaintext" };
+  if (value === null) return { value, status: "plaintext" };
   if (typeof value === "string") {
     if (isEncrypted(value)) {
-      return await decryptJsonField(value, address);
+      const detailed = await decryptFieldDetailed(value, address);
+      if (detailed.status !== "ok") {
+        return { value: void 0, status: detailed.status, probe: value };
+      }
+      try {
+        return { value: JSON.parse(detailed.value), status: "ok" };
+      } catch (error) {
+        getLogger().warn("Failed to parse decrypted JSON field:", error);
+        return { value: void 0, status: "invalid_payload", probe: value };
+      }
     }
     try {
-      return JSON.parse(value);
+      return { value: JSON.parse(value), status: "plaintext" };
     } catch {
-      return void 0;
+      return { value: void 0, status: "plaintext" };
     }
   }
-  return value;
+  return { value, status: "plaintext" };
+}
+function worseDecryptStatus(a, b) {
+  if (b === "ok" || b === "plaintext") return a;
+  if (!a || a === "ok" || a === "plaintext") return b;
+  const rank = (s) => {
+    if (s === "auth_mismatch") return 3;
+    if (s === "key_missing") return 2;
+    if (s === "invalid_payload") return 1;
+    return 0;
+  };
+  return rank(b) >= rank(a) ? b : a;
 }
 async function decryptMessageFields(message, address, signMessage, embeddedWalletSigner) {
   if (!address) {
@@ -854,33 +1057,82 @@ async function decryptMessageFields(message, address, signMessage, embeddedWalle
       getLogger().warn("Failed to request encryption key for decryption:", error);
     }
   }
-  const decryptedContent = await decryptField(message.content, address);
-  const decryptedThinking = message.thinking ? await decryptField(message.thinking, address) : message.thinking;
-  const decryptedVector = await decryptMaybeJsonField(
+  let assembled = await assembleDecryptedMessage(message, address);
+  const needsRefresh = assembled.decryptionStatus === "auth_mismatch" || assembled.decryptionStatus === "key_missing";
+  if (needsRefresh && signMessage && assembled.refreshProbe) {
+    try {
+      const refreshed = await refreshEncryptionKeyIfMatches(
+        address,
+        assembled.refreshProbe,
+        signMessage,
+        embeddedWalletSigner
+      );
+      if (refreshed) {
+        assembled = await assembleDecryptedMessage(message, address);
+      }
+    } catch (error) {
+      getLogger().warn("Failed to refresh encryption key after decrypt failure:", error);
+    }
+  }
+  const { refreshProbe: _probe, ...result } = assembled;
+  return result;
+}
+async function assembleDecryptedMessage(message, address) {
+  const contentResult = await decryptFieldDetailed(message.content, address);
+  const thinkingResult = message.thinking ? await decryptFieldDetailed(message.thinking, address) : null;
+  const vectorResult = await decryptMaybeJsonFieldDetailed(
     message.vector,
     address
   );
-  const decryptedChunks = await decryptMaybeJsonField(
+  const chunksResult = await decryptMaybeJsonFieldDetailed(
     message.chunks,
     address
   );
-  const decryptedSources = await decryptMaybeJsonField(
+  const sourcesResult = await decryptMaybeJsonFieldDetailed(
     message.sources,
     address
   );
-  const decryptedThoughtProcess = await decryptMaybeJsonField(
+  const thoughtProcessResult = await decryptMaybeJsonFieldDetailed(
     message.thoughtProcess,
     address
   );
-  return {
+  let decryptionStatus;
+  let refreshProbe;
+  const consider = (status, probe) => {
+    decryptionStatus = worseDecryptStatus(decryptionStatus, status);
+    if (!refreshProbe && probe && (status === "auth_mismatch" || status === "key_missing")) {
+      refreshProbe = probe;
+    }
+  };
+  consider(contentResult.status, isEncrypted(message.content) ? message.content : void 0);
+  if (thinkingResult && message.thinking && typeof message.thinking === "string") {
+    consider(thinkingResult.status, isEncrypted(message.thinking) ? message.thinking : void 0);
+  }
+  if (vectorResult.probe) consider(vectorResult.status, vectorResult.probe);
+  if (chunksResult.probe) consider(chunksResult.status, chunksResult.probe);
+  if (sourcesResult.probe) consider(sourcesResult.status, sourcesResult.probe);
+  if (thoughtProcessResult.probe) {
+    consider(thoughtProcessResult.status, thoughtProcessResult.probe);
+  }
+  const statusForConsumer = decryptionStatus === "ok" || decryptionStatus === "plaintext" || !decryptionStatus ? void 0 : decryptionStatus;
+  const result = {
     ...message,
-    content: decryptedContent,
-    thinking: decryptedThinking,
-    vector: decryptedVector,
-    chunks: decryptedChunks,
-    sources: decryptedSources,
-    thoughtProcess: decryptedThoughtProcess
+    content: contentResult.value,
+    thinking: thinkingResult ? thinkingResult.value : message.thinking,
+    vector: vectorResult.value,
+    chunks: chunksResult.value,
+    sources: sourcesResult.value,
+    thoughtProcess: thoughtProcessResult.value
   };
+  if (statusForConsumer) {
+    result.decryptionStatus = statusForConsumer;
+  } else {
+    delete result.decryptionStatus;
+  }
+  if (refreshProbe) {
+    result.refreshProbe = refreshProbe;
+  }
+  return result;
 }
 
 // src/lib/db/chat/types.ts
@@ -4779,6 +5031,107 @@ async function chunkAndEmbedAllMessages(ctx, options, filter) {
   return embeddedCount;
 }
 
+// src/lib/memoryVault/decomposeQuery.ts
+var DEFAULT_MODEL = "inclusionai/ling-2.6-flash";
+var MAX_SUB_QUERIES = 5;
+var SYSTEM_PROMPT = `You classify a memory query and, if needed, decompose it into concrete sub-queries.
+
+CLASSIFICATION RULES \u2014 be strict:
+- "specific": asks for one fact OR a list of items in ONE category (one dimension).
+  Examples: a name, a date, a preference, a location, an ID, a value, "what hobbies",
+  "which conferences", "what open source projects", "what does X do for exercise".
+  Even when the answer is a list, if all items belong to one dimension, it is specific.
+- "composite": asks about a person, system, or setup MULTI-DIMENSIONALLY \u2014 a summary,
+  an overview, a profile, "tell me about X", "what is my X setup", "describe the team's
+  X". The answer must span multiple distinct fact dimensions (e.g. for a "tech stack":
+  language + database + framework + tools \u2014 four different dimensions).
+
+When in doubt, prefer "specific". Mis-classifying a single-dimension list as composite
+hurts retrieval more than the reverse.
+
+SUB-QUERY RULES (composite only, 3\u20135 questions):
+- Each sub-query targets a DIFFERENT fact dimension.
+- Use SHORT parenthetical examples \u2014 2\u20134 concrete options that anchor the
+  embedding to likely memory content. Examples must be terms a user would
+  actually have in their notes (e.g., "Postgres" not "PostgreSQL 15.2 with
+  read replicas"). No verbose qualifiers like "and versions" or "and any
+  relevant configuration details".
+- 8\u201314 words including the parenthetical. Like a human asking a follow-up.
+
+Examples:
+  "What is my dog's name?" \u2192 {"mode":"specific","subQueries":["What is my dog's name?"]}
+  "What does the user do for exercise?" \u2192 {"mode":"specific","subQueries":["What does the user do for exercise?"]}
+  "What conferences has the user attended?" \u2192 {"mode":"specific","subQueries":["What conferences has the user attended?"]}
+  "What did I do last Tuesday?" \u2192 {"mode":"specific","subQueries":["What did I do last Tuesday?"]}
+  "Tell me about the user as a person" \u2192 {"mode":"composite","subQueries":["What is the user's name?","Where does the user live?","What does the user do for work?","Any health conditions or allergies?","What are the user's hobbies (sports, music, games)?"]}
+  "What is the user's tech stack?" \u2192 {"mode":"composite","subQueries":["What programming languages does the user use (Python, Go, TypeScript)?","What database does the user use (Postgres, MySQL, Mongo)?","What framework or ORM (React, Django, Prisma)?","What infrastructure (AWS, Docker, K8s)?","What testing tools (Jest, pytest, Cypress)?"]}
+  "Describe the user's development environment" \u2192 {"mode":"composite","subQueries":["What operating system does the user use (macOS, Linux, Windows)?","What editor or IDE (VS Code, Vim, IntelliJ)?","What shell or terminal setup (zsh, bash, tmux)?","What keyboard or display setup (mechanical, vertical monitor)?","Any UI preferences (dark mode, font, vim keybindings)?"]}
+
+Output strict JSON. No prose.`;
+async function decomposeQuery(query, options) {
+  const fallback = { mode: "specific", subQueries: [query] };
+  const trimmed = query.trim();
+  if (trimmed.length === 0) return fallback;
+  let parsed;
+  try {
+    parsed = await callPortalJsonCompletion({
+      ...options.apiKey !== void 0 && { apiKey: options.apiKey },
+      ...options.getToken !== void 0 && { getToken: options.getToken },
+      ...options.baseUrl !== void 0 && { baseUrl: options.baseUrl },
+      model: options.model ?? DEFAULT_MODEL,
+      systemPrompt: SYSTEM_PROMPT,
+      // Wrap the bare query in a task framing so the model treats it as
+      // input to classify, not as a question to answer conversationally.
+      // Bare-query inputs caused Anthropic models to respond with prose
+      // like "Do you mean...?" before this wrap.
+      userMessage: `Classify the following memory query and decompose if composite. Respond with JSON only \u2014 do not answer the question, do not ask for clarification.
+
+Query: ${trimmed}`,
+      // Decompose runs ahead of recall in the tool layer — tighter than the
+      // portalLlm default (consolidate/extract can wait longer).
+      timeoutMs: 2e4,
+      // No internal retry: a failure degrades to the safe `{specific,[query]}`
+      // fallback below. The agent/tool loop is the retry surface (719/B4).
+      maxAttempts: 1,
+      tag: "memory/decompose",
+      ...options.fetchFn && { fetchFn: options.fetchFn }
+    });
+  } catch (err) {
+    getLogger().warn("memoryVault/decompose: portal call failed, falling back to specific", err);
+    return fallback;
+  }
+  if (parsed === null) return fallback;
+  return validate(parsed, trimmed) ?? fallback;
+}
+function normalizeSubQueries(raw) {
+  if (!raw || raw.length === 0) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const s of raw) {
+    if (typeof s !== "string") continue;
+    const t = s.trim();
+    if (t.length === 0) continue;
+    const key = t.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(t);
+    if (out.length >= MAX_SUB_QUERIES) break;
+  }
+  return out;
+}
+function validate(parsed, originalQuery) {
+  if (typeof parsed !== "object" || parsed === null) return null;
+  const obj = parsed;
+  const mode = obj.mode === "composite" ? "composite" : "specific";
+  if (!Array.isArray(obj.subQueries)) return null;
+  const subQueries = normalizeSubQueries(obj.subQueries);
+  if (subQueries.length === 0) return null;
+  if (mode === "specific") {
+    return { mode: "specific", subQueries: [originalQuery] };
+  }
+  return { mode, subQueries };
+}
+
 // src/lib/memory/mmr.ts
 function applyMMR(candidates, k, lambda = 0.5) {
   if (candidates.length === 0 || k <= 0) return [];
@@ -5156,91 +5509,6 @@ function scoreBM25(query, items) {
   return scoreBM25Prepared(query, prepareBM25Corpus(items));
 }
 
-// src/lib/memoryVault/decomposeQuery.ts
-var DEFAULT_MODEL = "inclusionai/ling-2.6-flash";
-var MAX_SUB_QUERIES = 5;
-var SYSTEM_PROMPT = `You classify a memory query and, if needed, decompose it into concrete sub-queries.
-
-CLASSIFICATION RULES \u2014 be strict:
-- "specific": asks for one fact OR a list of items in ONE category (one dimension).
-  Examples: a name, a date, a preference, a location, an ID, a value, "what hobbies",
-  "which conferences", "what open source projects", "what does X do for exercise".
-  Even when the answer is a list, if all items belong to one dimension, it is specific.
-- "composite": asks about a person, system, or setup MULTI-DIMENSIONALLY \u2014 a summary,
-  an overview, a profile, "tell me about X", "what is my X setup", "describe the team's
-  X". The answer must span multiple distinct fact dimensions (e.g. for a "tech stack":
-  language + database + framework + tools \u2014 four different dimensions).
-
-When in doubt, prefer "specific". Mis-classifying a single-dimension list as composite
-hurts retrieval more than the reverse.
-
-SUB-QUERY RULES (composite only, 3\u20135 questions):
-- Each sub-query targets a DIFFERENT fact dimension.
-- Use SHORT parenthetical examples \u2014 2\u20134 concrete options that anchor the
-  embedding to likely memory content. Examples must be terms a user would
-  actually have in their notes (e.g., "Postgres" not "PostgreSQL 15.2 with
-  read replicas"). No verbose qualifiers like "and versions" or "and any
-  relevant configuration details".
-- 8\u201314 words including the parenthetical. Like a human asking a follow-up.
-
-Examples:
-  "What is my dog's name?" \u2192 {"mode":"specific","subQueries":["What is my dog's name?"]}
-  "What does the user do for exercise?" \u2192 {"mode":"specific","subQueries":["What does the user do for exercise?"]}
-  "What conferences has the user attended?" \u2192 {"mode":"specific","subQueries":["What conferences has the user attended?"]}
-  "What did I do last Tuesday?" \u2192 {"mode":"specific","subQueries":["What did I do last Tuesday?"]}
-  "Tell me about the user as a person" \u2192 {"mode":"composite","subQueries":["What is the user's name?","Where does the user live?","What does the user do for work?","Any health conditions or allergies?","What are the user's hobbies (sports, music, games)?"]}
-  "What is the user's tech stack?" \u2192 {"mode":"composite","subQueries":["What programming languages does the user use (Python, Go, TypeScript)?","What database does the user use (Postgres, MySQL, Mongo)?","What framework or ORM (React, Django, Prisma)?","What infrastructure (AWS, Docker, K8s)?","What testing tools (Jest, pytest, Cypress)?"]}
-  "Describe the user's development environment" \u2192 {"mode":"composite","subQueries":["What operating system does the user use (macOS, Linux, Windows)?","What editor or IDE (VS Code, Vim, IntelliJ)?","What shell or terminal setup (zsh, bash, tmux)?","What keyboard or display setup (mechanical, vertical monitor)?","Any UI preferences (dark mode, font, vim keybindings)?"]}
-
-Output strict JSON. No prose.`;
-async function decomposeQuery(query, options) {
-  const fallback = { mode: "specific", subQueries: [query] };
-  const trimmed = query.trim();
-  if (trimmed.length === 0) return fallback;
-  let parsed;
-  try {
-    parsed = await callPortalJsonCompletion({
-      ...options.apiKey !== void 0 && { apiKey: options.apiKey },
-      ...options.getToken !== void 0 && { getToken: options.getToken },
-      ...options.baseUrl !== void 0 && { baseUrl: options.baseUrl },
-      model: options.model ?? DEFAULT_MODEL,
-      systemPrompt: SYSTEM_PROMPT,
-      // Wrap the bare query in a task framing so the model treats it as
-      // input to classify, not as a question to answer conversationally.
-      // Bare-query inputs caused Anthropic models to respond with prose
-      // like "Do you mean...?" before this wrap.
-      userMessage: `Classify the following memory query and decompose if composite. Respond with JSON only \u2014 do not answer the question, do not ask for clarification.
-
-Query: ${trimmed}`,
-      // Decompose runs on the recall hot path — tighter than the
-      // portalLlm default (consolidate/extract can wait longer).
-      timeoutMs: 2e4,
-      // No internal retry: a failure degrades to the safe `{specific,[query]}`
-      // fallback below, so retrying would only add latency on the hot path.
-      maxAttempts: 1,
-      tag: "memory/decompose",
-      ...options.fetchFn && { fetchFn: options.fetchFn }
-    });
-  } catch (err) {
-    getLogger().warn("memoryVault/decompose: portal call failed, falling back to specific", err);
-    return fallback;
-  }
-  if (parsed === null) return fallback;
-  return validate(parsed, trimmed) ?? fallback;
-}
-function validate(parsed, originalQuery) {
-  if (typeof parsed !== "object" || parsed === null) return null;
-  const obj = parsed;
-  const mode = obj.mode === "composite" ? "composite" : "specific";
-  if (!Array.isArray(obj.subQueries)) return null;
-  const subQueries = obj.subQueries.filter((s) => typeof s === "string").map((s) => s.trim()).filter((s) => s.length > 0).slice(0, MAX_SUB_QUERIES);
-  if (subQueries.length === 0) return null;
-  if (mode === "specific") {
-    return { mode: "specific", subQueries: [originalQuery] };
-  }
-  return { mode, subQueries };
-}
-
 // src/lib/memoryVault/lruCache.ts
 var DEFAULT_VAULT_CACHE_SIZE = 5e3;
 var LRUCache = class extends Map {
@@ -5274,6 +5542,7 @@ function createVaultEmbeddingCache(maxSize = DEFAULT_VAULT_CACHE_SIZE) {
 }
 
 // src/lib/memoryVault/searchTool.ts
+var warnedProgrammaticDecomposeIgnored = false;
 function normalizeEventTimeKind(kind) {
   return kind === "point" || kind === "range" || kind === "ongoing" ? kind : null;
 }
@@ -6208,52 +6477,51 @@ async function rankPreparedVaultCandidates(query, prepared, embeddingOptions, se
     ...searchOptions?.rrfK !== void 0 && { rrfK: searchOptions.rrfK },
     ...searchOptions?.factTypeWeights && { factTypeWeights: searchOptions.factTypeWeights }
   };
-  if (useFusion && !embeddingsUnavailable && searchOptions?.decompose === "llm" && searchOptions.decomposeOptions) {
-    const decomp = await decomposeQuery(query, searchOptions.decomposeOptions);
-    if (decomp.mode === "composite") {
-      let subEmbeddings;
-      try {
-        subEmbeddings = await generateEmbeddings(decomp.subQueries, embeddingOptions);
-      } catch (err) {
-        getLogger().warn(
-          "memoryVault: sub-query embedding failed \u2014 falling back to single-query ranking: " + (err instanceof Error ? err.message : String(err))
-        );
-        subEmbeddings = [];
-      }
-      const subEmbeddingsUsable = decomp.subQueries.length > 0 && subEmbeddings.length === decomp.subQueries.length && subEmbeddings.every((v) => v.length > 0 && v.length === queryEmbedding.length);
-      if (subEmbeddings.length > 0 && !subEmbeddingsUsable) {
-        getLogger().warn(
-          `memoryVault: sub-query embedding returned ${subEmbeddings.length} vectors (dims ${subEmbeddings.map((v) => v.length).join(",")}) for ${decomp.subQueries.length} sub-queries against a ${queryEmbedding.length}-dim query \u2014 falling back to single-query ranking`
-        );
-      }
-      if (subEmbeddingsUsable) {
-        const subQueries = decomp.subQueries.map((sq, i) => ({
-          query: sq,
-          embedding: subEmbeddings[i]
-        }));
-        const v2HeadStats = { hadResults: false };
-        const composite = await rankComposite(query, queryEmbedding, subQueries, embeddedItems, {
-          limit,
-          minSimilarity,
-          rerank: !!searchOptions.rerank,
-          ...searchOptions.rerankTopN !== void 0 && {
-            rerankTopN: searchOptions.rerankTopN
-          },
-          ...searchOptions.ceWeight !== void 0 && { ceWeight: searchOptions.ceWeight },
-          ...searchOptions.mmr !== void 0 && { mmr: searchOptions.mmr },
-          ...tuning,
-          ...searchOptions.entityRanking && { entityRanking: searchOptions.entityRanking },
-          ...searchOptions.temporalRanking && { temporalRanking: searchOptions.temporalRanking },
-          rerankStats,
-          v2HeadStats
-        });
-        return stampTimestamps({
-          results: composite,
-          vaultSize,
-          reranked: rerankStats.applied,
-          hadV2Head: v2HeadStats.hadResults
-        });
-      }
+  const normalizedFacets = normalizeSubQueries(searchOptions?.subQueries);
+  const facetQueries = normalizedFacets.length >= 2 ? normalizedFacets : void 0;
+  if (useFusion && !embeddingsUnavailable && facetQueries) {
+    let subEmbeddings;
+    try {
+      subEmbeddings = await generateEmbeddings(facetQueries, embeddingOptions);
+    } catch (err) {
+      getLogger().warn(
+        "memoryVault: sub-query embedding failed \u2014 falling back to single-query ranking: " + (err instanceof Error ? err.message : String(err))
+      );
+      subEmbeddings = [];
+    }
+    const subEmbeddingsUsable = facetQueries.length > 0 && subEmbeddings.length === facetQueries.length && subEmbeddings.every((v) => v.length > 0 && v.length === queryEmbedding.length);
+    if (subEmbeddings.length > 0 && !subEmbeddingsUsable) {
+      getLogger().warn(
+        `memoryVault: sub-query embedding returned ${subEmbeddings.length} vectors (dims ${subEmbeddings.map((v) => v.length).join(",")}) for ${facetQueries.length} sub-queries against a ${queryEmbedding.length}-dim query \u2014 falling back to single-query ranking`
+      );
+    }
+    if (subEmbeddingsUsable) {
+      const subQueries = facetQueries.map((sq, i) => ({
+        query: sq,
+        embedding: subEmbeddings[i]
+      }));
+      const v2HeadStats = { hadResults: false };
+      const composite = await rankComposite(query, queryEmbedding, subQueries, embeddedItems, {
+        limit,
+        minSimilarity,
+        rerank: !!searchOptions?.rerank,
+        ...searchOptions?.rerankTopN !== void 0 && {
+          rerankTopN: searchOptions.rerankTopN
+        },
+        ...searchOptions?.ceWeight !== void 0 && { ceWeight: searchOptions.ceWeight },
+        ...searchOptions?.mmr !== void 0 && { mmr: searchOptions.mmr },
+        ...tuning,
+        ...searchOptions?.entityRanking && { entityRanking: searchOptions.entityRanking },
+        ...searchOptions?.temporalRanking && { temporalRanking: searchOptions.temporalRanking },
+        rerankStats,
+        v2HeadStats
+      });
+      return stampTimestamps({
+        results: composite,
+        vaultSize,
+        reranked: rerankStats.applied,
+        hadV2Head: v2HeadStats.hadResults
+      });
     }
   }
   if (useFusion && searchOptions?.rerank) {
@@ -6313,6 +6581,12 @@ async function searchVaultMemoriesWithSize(query, vaultCtx, embeddingOptions, ca
       rankedOnCosine: false
     };
   }
+  if (searchOptions?.decompose === "llm" && normalizeSubQueries(searchOptions.subQueries).length < 2 && !warnedProgrammaticDecomposeIgnored) {
+    warnedProgrammaticDecomposeIgnored = true;
+    getLogger().warn(
+      'memoryVault: decompose:"llm" is ignored by searchVaultMemories \u2014 pass subQueries or use createMemoryVaultSearchTool / createRecallTool (719/B4)'
+    );
+  }
   const prepared = await prepareVaultCandidates(
     query,
     vaultCtx,
@@ -6418,7 +6692,8 @@ function createMemoryVaultSearchTool(vaultCtx, embeddingOptions, cache, searchOp
         return "Error: A search query is required.";
       }
       try {
-        const budget = searchOptions?.decompose === "llm" && searchOptions.decomposeOptions ? "high" : searchOptions?.rerank ? "mid" : "low";
+        const wantsDecompose = searchOptions?.decompose === "llm" && !!searchOptions.decomposeOptions;
+        const budget = wantsDecompose ? "high" : searchOptions?.rerank ? "mid" : "low";
         const folderId = searchOptions?.folderId ?? argFolderId;
         if (searchOptions?.useFusion === false) {
           const { results: legacy, embeddingsUnavailable } = await searchVaultMemoriesWithSize(
@@ -6442,7 +6717,14 @@ function createMemoryVaultSearchTool(vaultCtx, embeddingOptions, cache, searchOp
             legacy.map((r) => ({ id: r.uniqueId, content: r.content, score: r.similarity }))
           );
         }
-        const { recall: recall2 } = await import("./recall-WXCZHXHZ.mjs");
+        let subQueries;
+        if (wantsDecompose && searchOptions?.decomposeOptions) {
+          const decomp = await decomposeQuery(query, searchOptions.decomposeOptions);
+          if (decomp.mode === "composite" && decomp.subQueries.length >= 2) {
+            subQueries = decomp.subQueries;
+          }
+        }
+        const { recall: recall2 } = await import("./recall-DVX4W2UD.mjs");
         let recallDegraded = [];
         const result = await recall2(
           query,
@@ -6458,9 +6740,7 @@ function createMemoryVaultSearchTool(vaultCtx, embeddingOptions, cache, searchOp
             ...tuningForward,
             ...folderId !== void 0 && { folderId },
             ...searchOptions?.scopes && { scopes: searchOptions.scopes },
-            ...searchOptions?.decompose === "llm" && searchOptions.decomposeOptions && {
-              decomposeOptions: searchOptions.decomposeOptions
-            }
+            ...subQueries && { subQueries }
           }
         );
         if (result.vaultSize === 0) {
@@ -6988,12 +7268,12 @@ var DEFAULT_CHUNK_MIN_SCORE = 0.5;
 function flagsForBudget(budget) {
   switch (budget) {
     case "high":
-      return { rerank: true, decompose: true, traverse: true };
+      return { rerank: true, traverse: true };
     case "mid":
-      return { rerank: true, decompose: false, traverse: false };
+      return { rerank: true, traverse: false };
     case "low":
     default:
-      return { rerank: false, decompose: false, traverse: false };
+      return { rerank: false, traverse: false };
   }
 }
 function dedupeBy(items, ...keys) {
@@ -7012,10 +7292,10 @@ function dedupeBy(items, ...keys) {
 async function recall(query, ctx, options = {}) {
   const types = options.types ?? ["fact"];
   const limit = options.limit ?? DEFAULT_LIMIT;
-  const requestedBudget = options.budget ?? DEFAULT_BUDGET;
-  const flags = flagsForBudget(requestedBudget);
-  const decomposeAvailable = flags.decompose && !!options.decomposeOptions;
-  const usedBudget = requestedBudget === "high" && !decomposeAvailable ? "mid" : requestedBudget;
+  const usedBudget = options.budget ?? DEFAULT_BUDGET;
+  const flags = flagsForBudget(usedBudget);
+  const normalizedFacets = normalizeSubQueries(options.subQueries);
+  const subQueries = normalizedFacets.length >= 2 ? normalizedFacets : void 0;
   const t0 = nowMs();
   let prepMs = 0;
   let factLaneMs = 0;
@@ -7036,7 +7316,9 @@ async function recall(query, ctx, options = {}) {
     if (flags.rerank && factResults.length > 0 && hadV2Head && !didRerank) {
       degraded.push("rerank-unavailable");
     }
-    if (flags.decompose && !decomposeAvailable) degraded.push("decompose-unavailable");
+    if (usedBudget === "high" && options.decomposeOptions && !subQueries && !options.graphRefine) {
+      degraded.push("decompose-moved");
+    }
     if (embeddingsUnavailable) degraded.push("embeddings-unavailable");
     const diagnostics = {
       usedBudget,
@@ -7149,10 +7431,8 @@ async function recall(query, ctx, options = {}) {
         },
         ...options.rrfK !== void 0 && { rrfK: options.rrfK },
         ...options.decryptLast !== void 0 && { decryptLast: options.decryptLast },
-        ...decomposeAvailable && {
-          decompose: "llm",
-          decomposeOptions: options.decomposeOptions
-        },
+        // 719/B4 — composite facets arrive pre-built; no LLM call here.
+        ...subQueries && { subQueries },
         ...options.scopes && { scopes: options.scopes },
         ...options.folderId !== void 0 && { folderId: options.folderId },
         ...options.factTypes?.length && { factTypes: options.factTypes },
@@ -7382,6 +7662,7 @@ function toChunkMemory(r) {
 
 export {
   createSseClient,
+  EncryptionKeyMissingError,
   onClearAllEncryptionState,
   onKeyAvailable,
   clearEncryptionKey,
@@ -7394,11 +7675,13 @@ export {
   decryptDataBytes,
   decryptDataBytesFromBytes,
   hasEncryptionKey,
+  seedEncryptionKeys,
   encryptDataWithKey,
   decryptDataWithKey,
   encryptDataBatch,
   decryptDataBatch,
   requestEncryptionKey,
+  refreshEncryptionKeyIfMatches,
   requestKeyPair,
   exportPublicKey,
   hasKeyPair,
@@ -7522,6 +7805,7 @@ export {
   EMBEDDINGS_DEGRADED_EMPTY,
   RerankerUnavailableError,
   isRerankerAvailable,
+  decomposeQuery,
   DEFAULT_VAULT_CACHE_SIZE,
   LRUCache,
   createVaultEmbeddingCache,