@melandlabs/memory-store 0.3.1 → 1.1.0

package/dist/index.js

@@ -1,9 +1,14 @@
+import { vsaNormalizeVector, vsaAssertSameDim } from '@melandlabs/contracts';
 import '@melandlabs/ai/memory';
 import { ChromaVectorStore } from '@melandlabs/rag';
 import { mkdirSync } from 'fs';
 import { dirname } from 'path';
 import { getOpenContextPath } from '@melandlabs/env-config';
-import { SQLiteRawMessageManager } from '@melandlabs/sqlite';
+import { SQLiteRawMessageManager, getSQLiteVsaStore } from '@melandlabs/sqlite';
+export { closeSQLiteVsaStore, getSQLiteVsaStore } from '@melandlabs/sqlite';
+import { applyReflectedConsolidationPlan } from '@melandlabs/memory-consolidation';
+import { superpose, bind, unbind, cleanup, cosineSimilarity } from '@melandlabs/vsa';
+import { createRawMessageMemoryGraphStore } from '@melandlabs/indexeddb';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -14,8 +19,6 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-
-// src/contracts.ts
 var init_contracts = __esm({
   "src/contracts.ts"() {
   }
@@ -376,6 +379,416 @@ function isRawMemorySemanticResult(result) {
   const item = result;
   return typeof item.id === "string" && typeof item.content === "string" && typeof item.similarity === "number" && Boolean(item.metadata) && typeof item.metadata === "object";
 }
+async function resolveScopePeer(input) {
+  const peers = input.peerFilter ?? [];
+  if (peers.length === 0) {
+    return { peers: [], warnings: [] };
+  }
+  if (typeof input.scopeCheck !== "function") {
+    return { peers, warnings: [] };
+  }
+  const retained = [];
+  const dropped = [];
+  for (const peer of peers) {
+    const ok = await input.scopeCheck({ userId: input.userId, peers: [peer] });
+    if (ok) {
+      retained.push(peer);
+    } else {
+      dropped.push(peer);
+    }
+  }
+  if (dropped.length === 0) {
+    return { peers, warnings: [] };
+  }
+  if (retained.length === 0) {
+    return {
+      peers: [],
+      warnings: [
+        {
+          source: "memory",
+          code: "peer_filter_outside_user_scope",
+          message: `${dropped.map((peer) => `${peer.kind}:${peer.id}`).join(",")} ignored; falling back to userId scope`
+        }
+      ]
+    };
+  }
+  return {
+    peers: retained,
+    warnings: [
+      {
+        source: "memory",
+        code: "peer_filter_outside_user_scope",
+        message: `${dropped.map((peer) => `${peer.kind}:${peer.id}`).join(",")} ignored because they fall outside userId ${input.userId}`
+      }
+    ]
+  };
+}
+
+// src/search/apply-reflect.ts
+var DEFAULT_TIERS = ["summary", "raw", "insight", "knowledge"];
+function reflectTierToEvidenceTier(source) {
+  switch (source) {
+    case "raw":
+      return "short";
+    case "summary":
+      return "long";
+    default:
+      return "mid";
+  }
+}
+function toMemoryEvidenceRecord(input, fallbackUserId) {
+  const tier = reflectTierToEvidenceTier(input.source);
+  const timestamp = input.timestamp ?? Date.now();
+  return {
+    id: input.id,
+    userId: fallbackUserId,
+    timestamp,
+    tier,
+    text: input.snippet,
+    metadata: {
+      source: input.source,
+      score: input.score,
+      ...input.timestamp !== void 0 ? { originalTimestamp: input.timestamp } : {}
+    }
+  };
+}
+async function applyReflectedPlan(deps, store, input, _logger) {
+  const query = input.query.trim();
+  const warnings = [];
+  const limit = clampUnifiedMemorySearchLimit(input.limit);
+  const threshold = clampUnifiedMemorySearchThreshold(input.threshold);
+  const tiers = input.tiers && input.tiers.length > 0 ? input.tiers : DEFAULT_TIERS;
+  const searchInput = {
+    userId: input.userId,
+    query,
+    botIds: input.botIds,
+    dateFrom: input.dateFrom,
+    dateTo: input.dateTo,
+    tiers,
+    limit,
+    threshold,
+    authToken: input.authToken,
+    peerFilter: input.peerFilter,
+    synthesize: true
+  };
+  const search = createUnifiedSearch(deps);
+  const result = await search.search(searchInput);
+  warnings.push(...result.warnings);
+  const evidence = result.evidence.map((item) => ({
+    id: item.id,
+    source: item.source ?? "raw",
+    snippet: item.snippet,
+    score: item.score,
+    timestamp: item.timestamp
+  }));
+  const records = evidence.map((item) => toMemoryEvidenceRecord(item, input.userId));
+  const applyInput = {
+    userId: input.userId,
+    ownerScope: input.ownerScope,
+    records,
+    plan: input.plan,
+    dryRun: input.dryRun,
+    expectedVersion: input.expectedVersion,
+    getClusterKey: input.getClusterKey ?? defaultClusterKey,
+    llmReview: deps.reasoning?.complete ? {
+      complete: deps.reasoning.complete,
+      maxTokens: input.llmPlanReview?.maxTokens
+    } : void 0,
+    graphStore: input.graphStore ?? store.graphStore,
+    storage: input.storage ?? store.storage
+  };
+  const applyOutput = await applyReflectedConsolidationPlan(applyInput);
+  for (const warning of applyOutput.warnings) {
+    warnings.push({
+      source: "memory",
+      code: warning.code,
+      message: warning.message
+    });
+  }
+  const summaryAnswer = makePlanSummary(applyOutput.plan);
+  return {
+    answer: result.answer ? `${result.answer}
+
+Plan summary:
+${summaryAnswer}` : summaryAnswer,
+    plan: applyOutput.plan,
+    persistenceResult: applyOutput.persistenceResult,
+    deprecationCounts: applyOutput.deprecationCounts,
+    warnings,
+    applied: applyOutput.applied,
+    evidence
+  };
+}
+function defaultClusterKey(record) {
+  return record.text ?? record.id;
+}
+function makePlanSummary(plan) {
+  const lines = [];
+  const counts = {
+    preserve: plan.actions.preserve.length,
+    observe: plan.actions.observe.length,
+    decay: plan.actions.decay.length,
+    deprecate: plan.actions.deprecate.length
+  };
+  lines.push(
+    `- preserve=${counts.preserve} observe=${counts.observe} decay=${counts.decay} deprecate=${counts.deprecate}`
+  );
+  for (const entry of plan.actions.deprecate.slice(0, 5)) {
+    lines.push(
+      `  deprecate ${entry.recordIds.length} record(s) from cluster ${entry.clusterKey} -> ${entry.supersededBySummaryId ?? entry.winningClusterKey}`
+    );
+  }
+  return lines.join("\n");
+}
+
+// src/search/reranker.ts
+async function applyReranker(reranker, query, results) {
+  if (!reranker || results.length === 0) {
+    return results;
+  }
+  const scores = await reranker.rerank({
+    query,
+    candidates: results.map((result) => ({
+      id: result.id,
+      content: result.content,
+      metadata: result.metadata
+    }))
+  });
+  if (scores.length === 0) {
+    return results;
+  }
+  const byId = new Map(results.map((result) => [result.id, result]));
+  const reordered = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const { id, score } of scores) {
+    const hit = byId.get(id);
+    if (!hit || seen.has(id)) {
+      continue;
+    }
+    seen.add(id);
+    reordered.push({ ...hit, metadata: { ...hit.metadata, rerankerScore: score } });
+  }
+  for (const hit of results) {
+    if (!seen.has(hit.id)) {
+      reordered.push(hit);
+    }
+  }
+  return reordered;
+}
+
+// src/search/gather-evidence.ts
+var DEFAULT_TIERS2 = ["summary", "raw", "insight", "knowledge"];
+var MAX_EVIDENCE_CHARS = 600;
+function toSummaryResult(row) {
+  const start = typeof row.startTimestamp === "number" ? row.startTimestamp : void 0;
+  const end = typeof row.endTimestamp === "number" ? row.endTimestamp : void 0;
+  return {
+    type: "memory",
+    id: row.summaryId,
+    content: row.summaryText,
+    similarity: 1,
+    metadata: {
+      tier: "summary",
+      summaryTier: row.summaryTier,
+      keywords: row.keywords,
+      startTimestamp: start,
+      endTimestamp: end
+    }
+  };
+}
+async function gatherSummaries(deps, input, limit, threshold, logger, peerPeers) {
+  if (typeof deps.searchSummaries !== "function") {
+    return { hits: [], warnings: [] };
+  }
+  const keywords = input.query.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((token) => token.length >= 2).slice(0, 16);
+  try {
+    const rows = await deps.searchSummaries({
+      userId: input.userId,
+      query: input.query,
+      keywords,
+      limit,
+      threshold,
+      authToken: input.authToken,
+      ...peerPeers.length > 0 ? { peers: peerPeers } : {}
+    });
+    const hits = rows.map(toSummaryResult);
+    return { hits, warnings: [] };
+  } catch (error) {
+    logger.warn?.("[memory-store] gather-evidence: summary search failed:", error);
+    return {
+      hits: [],
+      warnings: [
+        {
+          source: "memory",
+          code: "reflect_summaries_failed",
+          message: error.message ?? "reflect_summaries_failed"
+        }
+      ]
+    };
+  }
+}
+function truncate(input, max = MAX_EVIDENCE_CHARS) {
+  if (input.length <= max) {
+    return input;
+  }
+  return `${input.slice(0, max - 1)}\u2026`;
+}
+function buildSynthesisPrompt(input) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const item of input.evidence) {
+    const bucket = grouped.get(item.source) ?? [];
+    bucket.push(item);
+    grouped.set(item.source, bucket);
+  }
+  const sections = [];
+  for (const tier of DEFAULT_TIERS2) {
+    const items = grouped.get(tier) ?? [];
+    if (items.length === 0) {
+      continue;
+    }
+    const lines = items.map(
+      (item, index) => `  [${index + 1}] (${item.id}, score=${item.score.toFixed(4)}) ${item.snippet}`
+    );
+    sections.push(`## ${tier}
+${lines.join("\n")}`);
+  }
+  const schemaDirective = input.responseSchema ? `
+Respond with a JSON object that conforms to the following schema:
+${JSON.stringify(input.responseSchema, null, 2)}
+Wrap your JSON in a single fenced \`\`\`json code block; do not add any prose outside the code block.` : "\nRespond in plain prose. Be concise; cite evidence by its [n] number.";
+  if (sections.length === 0) {
+    return `You are a reflection assistant.
+
+Question: ${input.query}
+
+No evidence was found across any tier. State that explicitly.${schemaDirective}`;
+  }
+  return `You are a reflection assistant. Synthesise the user's question using only the evidence below. Do not invent facts.
+
+Question: ${input.query}
+
+Evidence (grouped by tier):
+${sections.join("\n\n")}${schemaDirective}`;
+}
+function extractJsonPayload(text) {
+  const fenced = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
+  if (fenced?.[1]) {
+    return fenced[1];
+  }
+  const start = text.indexOf("{");
+  if (start === -1) {
+    return void 0;
+  }
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = start; i < text.length; i += 1) {
+    const ch = text[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (inString) {
+      if (ch === "\\") {
+        escaped = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+    } else if (ch === "{") {
+      depth += 1;
+    } else if (ch === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        return text.slice(start, i + 1);
+      }
+    }
+  }
+  return void 0;
+}
+function coerceAnswer(text, schema) {
+  if (!schema) {
+    return text;
+  }
+  const payload = extractJsonPayload(text);
+  if (!payload) {
+    return text;
+  }
+  try {
+    const parsed = JSON.parse(payload);
+    if (parsed && typeof parsed === "object") {
+      const answer = parsed.answer;
+      if (typeof answer === "string") {
+        return answer;
+      }
+    }
+  } catch {
+  }
+  return text;
+}
+async function synthesizeAnswer(input) {
+  const { query, hits, responseSchema, deps, logger } = input;
+  const evidence = hits.map((hit) => ({
+    id: hit.id,
+    source: mapHitToTier(hit),
+    snippet: truncate(hit.content),
+    score: hit.similarity
+  }));
+  const warnings = [];
+  const complete = deps.reasoning?.complete;
+  if (!complete) {
+    warnings.push({
+      source: "memory",
+      code: "reflect_llm_not_configured",
+      message: "No `reasoning.complete` callback is configured; search() returned evidence without an LLM synthesis."
+    });
+    return { answer: "", warnings };
+  }
+  const prompt = buildSynthesisPrompt({ query, evidence, responseSchema });
+  try {
+    const raw = await complete(prompt);
+    const answer = coerceAnswer(raw, responseSchema);
+    logger.log?.("[memory-store] search synthesis completed", {
+      evidenceCount: evidence.length,
+      answerChars: answer.length
+    });
+    return { answer, warnings };
+  } catch (error) {
+    logger.warn?.("[memory-store] search synthesis failed:", error);
+    warnings.push({
+      source: "memory",
+      code: "reflect_llm_failed",
+      message: error.message ?? "reflect_llm_failed"
+    });
+    return { answer: "", warnings };
+  }
+}
+function mapHitToTier(hit) {
+  const tierMarker = hit.metadata?.tier;
+  if (tierMarker === "summary") {
+    return "summary";
+  }
+  if (hit.type === "memory") {
+    return "raw";
+  }
+  if (hit.type === "insight") {
+    return "insight";
+  }
+  if (hit.type === "knowledge") {
+    return "knowledge";
+  }
+  return hit.type;
+}
+async function resolveSearchScopePeers(input) {
+  return resolveScopePeer({
+    userId: input.userId,
+    peerFilter: input.peerFilter,
+    scopeCheck: input.deps.peerScopeCheck
+  });
+}
 
 // src/search/unified-search.ts
 function deriveLexicalKeywords(query) {
@@ -447,7 +860,7 @@ async function embedQueryVariant(embedQuery, input, query) {
     authToken: input.authToken
   });
 }
-async function runSemanticSearchForEmbedding(deps, input, queryEmbedding, limit, threshold, logger) {
+async function runSemanticSearchForEmbedding(deps, input, queryEmbedding, limit, threshold, logger, peerPeers = []) {
   const filters = input.botIds && input.botIds.length > 0 ? input.botIds.map((botId) => ({ botId })) : [{}];
   let semantic = [];
   if (isRawMessageChromaEnabled()) {
@@ -477,6 +890,7 @@ async function runSemanticSearchForEmbedding(deps, input, queryEmbedding, limit,
     }
   } else if (typeof deps.searchRawMessagesAnn === "function") {
     const searchRawMessagesAnn = deps.searchRawMessagesAnn;
+    const factTypes = input.factTypes?.length ? input.factTypes : void 0;
     semantic = (await Promise.all(
       filters.map(
         (filter) => searchRawMessagesAnn({
@@ -484,7 +898,9 @@ async function runSemanticSearchForEmbedding(deps, input, queryEmbedding, limit,
           queryEmbedding,
           limit,
           threshold,
-          botId: "botId" in filter ? filter.botId : void 0
+          botId: "botId" in filter ? filter.botId : void 0,
+          ...peerPeers.length > 0 ? { peers: peerPeers } : {},
+          ...factTypes ? { factTypes } : {}
         })
       )
     )).flat().filter(isRawMemorySemanticResult).map(toMemoryResult);
@@ -494,11 +910,14 @@ async function runSemanticSearchForEmbedding(deps, input, queryEmbedding, limit,
       const { getRawMessageManager: getRawMessageManager2 } = await Promise.resolve().then(() => (init_raw_message_store(), raw_message_store_exports));
       const manager2 = await getRawMessageManager2();
       if (typeof manager2.searchMessagesSemantically === "function") {
+        const factTypes = input.factTypes?.length ? input.factTypes : void 0;
         const results = await manager2.searchMessagesSemantically({
           userId: input.userId,
           queryEmbedding,
           limit,
-          threshold
+          threshold,
+          ...peerPeers.length > 0 ? { peers: peerPeers } : {},
+          ...factTypes ? { factTypes } : {}
         });
         semantic = results.map((r) => ({
           type: "memory",
@@ -534,7 +953,7 @@ function toIterativeRecallCandidate(hit) {
     metadata: hit.metadata
   };
 }
-async function runLexicalSearchForKeywords(deps, input, keywords, limit, logger) {
+async function runLexicalSearchForKeywords(deps, input, keywords, limit, logger, peerPeers = []) {
   if (keywords.length === 0) {
     return [];
   }
@@ -542,13 +961,16 @@ async function runLexicalSearchForKeywords(deps, input, keywords, limit, logger)
     try {
       const filters = input.botIds && input.botIds.length > 0 ? input.botIds : [void 0];
       const searchRawMessagesLexical = deps.searchRawMessagesLexical;
+      const factTypes = input.factTypes?.length ? input.factTypes : void 0;
       return (await Promise.all(
         filters.map(
           (botId) => searchRawMessagesLexical({
             userId: input.userId,
             keywords,
             limit: Math.ceil(limit / filters.length),
-            botId
+            botId,
+            ...peerPeers.length > 0 ? { peers: peerPeers } : {},
+            ...factTypes ? { factTypes } : {}
           })
         )
       )).flat().filter(isRawMemorySemanticResult).map((hit) => ({
@@ -562,13 +984,15 @@ async function runLexicalSearchForKeywords(deps, input, keywords, limit, logger)
   try {
     const { lexicalSearchRawMessages: lexicalSearchRawMessages2 } = await Promise.resolve().then(() => (init_sqlite_raw_message_store(), sqlite_raw_message_store_exports));
     const filters = input.botIds && input.botIds.length > 0 ? input.botIds : [void 0];
+    const factTypes = input.factTypes?.length ? input.factTypes : void 0;
     return (await Promise.all(
       filters.map(
         (botId) => lexicalSearchRawMessages2({
           userId: input.userId,
           keywords,
           limit: Math.ceil(limit / filters.length),
-          botId
+          botId,
+          ...factTypes ? { factTypes } : {}
         })
       )
     )).flat().filter(Boolean).map(
@@ -581,6 +1005,42 @@ async function runLexicalSearchForKeywords(deps, input, keywords, limit, logger)
   }
   return [];
 }
+function searchInputToUnified(input) {
+  return {
+    userId: input.userId,
+    query: input.query,
+    sources: input.sources ? [...input.sources] : void 0,
+    limit: input.limit,
+    threshold: input.threshold,
+    authToken: input.authToken,
+    includeArchivedInsights: input.includeArchivedInsights,
+    botIds: input.botIds,
+    documentIds: input.documentIds,
+    asOf: input.asOf,
+    dateFrom: input.dateFrom,
+    dateTo: input.dateTo,
+    mergeStrategy: input.mergeStrategy,
+    peerFilter: input.peerFilter,
+    reasoningStrategy: input.reasoningStrategy,
+    factTypes: input.factTypes
+  };
+}
+function mapHitToEvidenceSource(hit) {
+  const tierMarker = hit.metadata?.tier;
+  if (tierMarker === "summary") {
+    return "summary";
+  }
+  if (hit.type === "memory") {
+    return "raw";
+  }
+  if (hit.type === "insight") {
+    return "insight";
+  }
+  if (hit.type === "knowledge") {
+    return "knowledge";
+  }
+  return hit.type;
+}
 function createUnifiedSearch(deps = {}) {
   const logger = deps.logger ?? console;
   function resolveReasoningStrategy(input) {
@@ -590,130 +1050,7 @@ function createUnifiedSearch(deps = {}) {
     }
     return normalizeUnifiedMemoryReasoningStrategy(deps.reasoning?.defaultStrategy, "none");
   }
-  async function searchUnifiedMemory(input) {
-    const query = input.query.trim();
-    const sources = normalizeUnifiedMemorySearchSources(input.sources);
-    const limit = clampUnifiedMemorySearchLimit(input.limit);
-    const threshold = clampUnifiedMemorySearchThreshold(input.threshold);
-    const mergeStrategy = normalizeUnifiedMemoryMergeStrategy(input.mergeStrategy);
-    const reasoningStrategy = resolveReasoningStrategy(input);
-    const warnings = [];
-    if (!query) {
-      return {
-        query,
-        sources,
-        results: [],
-        count: 0,
-        warnings
-      };
-    }
-    let memorySubs;
-    const reasoningInfo = { strategy: reasoningStrategy };
-    if (input.dateFrom || input.dateTo) {
-      reasoningInfo.dateRange = { from: input.dateFrom, to: input.dateTo };
-    }
-    if (sources.includes("memory")) {
-      if (isRawMessageStorageAvailable()) {
-        try {
-          memorySubs = await runMemorySource(
-            input,
-            limit,
-            threshold,
-            warnings,
-            reasoningStrategy,
-            reasoningInfo
-          );
-        } catch (error) {
-          logger.warn?.("[memory-store] memory source failed:", error);
-          warnings.push({
-            source: "memory",
-            code: "memory_search_failed",
-            message: `Memory search failed: ${error.message ?? "Unknown error"}. Using keyword search fallback.`
-          });
-        }
-      } else {
-        warnings.push({
-          source: "memory",
-          code: "raw_message_storage_unavailable",
-          message: "Raw memory storage is not available in this environment."
-        });
-      }
-    }
-    const insightHits = [];
-    if (sources.includes("insights") && typeof deps.searchInsights === "function") {
-      try {
-        const hits = await deps.searchInsights({
-          userId: input.userId,
-          query: input.query,
-          limit,
-          threshold,
-          botIds: input.botIds,
-          includeArchived: input.includeArchivedInsights,
-          authToken: input.authToken
-        });
-        for (const hit of hits) {
-          insightHits.push({
-            type: "insight",
-            id: hit.id,
-            content: hit.content,
-            similarity: hit.similarity,
-            metadata: hit.metadata
-          });
-        }
-      } catch (error) {
-        logger.warn?.("[memory-store] insights source failed:", error);
-        warnings.push({
-          source: "insights",
-          code: "insights_search_failed",
-          message: error.message ?? "insights_search_failed"
-        });
-      }
-    } else if (sources.includes("insights")) ;
-    const knowledgeHits = [];
-    if (sources.includes("knowledge") && typeof deps.searchKnowledge === "function") {
-      try {
-        const hits = await deps.searchKnowledge({
-          userId: input.userId,
-          query: input.query,
-          options: {
-            limit,
-            threshold,
-            documentIds: input.documentIds
-          },
-          authToken: input.authToken
-        });
-        for (const hit of hits) {
-          knowledgeHits.push(toKnowledgeResult(hit));
-        }
-      } catch (error) {
-        logger.warn?.("[memory-store] knowledge source failed:", error);
-        warnings.push({
-          source: "knowledge",
-          code: "knowledge_search_failed",
-          message: error.message ?? "knowledge_search_failed"
-        });
-      }
-    } else if (sources.includes("knowledge")) ;
-    const merged = mergeAcrossSources({
-      memorySubs,
-      insightHits,
-      knowledgeHits,
-      limit,
-      strategy: mergeStrategy
-    });
-    const output = {
-      query: input.query,
-      sources,
-      results: merged,
-      count: merged.length,
-      warnings
-    };
-    if (reasoningInfo && (reasoningInfo.strategy !== "none" || reasoningInfo.dateRange !== void 0)) {
-      output.reasoning = reasoningInfo;
-    }
-    return output;
-  }
-  async function runMemorySource(input, limit, threshold, warnings, reasoningStrategy = "none", reasoningInfo) {
+  async function runMemorySource(input, limit, threshold, warnings, reasoningStrategy = "none", reasoningInfo, peerPeers = []) {
     if (reasoningStrategy === "iterative" && !deps.reasoning?.iterativePlanner) {
       warnings.push({
         source: "memory",
@@ -739,7 +1076,14 @@ function createUnifiedSearch(deps = {}) {
         executor: {
           search: async (request) => {
             const keywords2 = request.keywords.length > 0 ? request.keywords : deriveLexicalKeywords(input.query);
-            const lexicalHits = await runLexicalSearchForKeywords(deps, input, keywords2, limit, logger);
+            const lexicalHits = await runLexicalSearchForKeywords(
+              deps,
+              input,
+              keywords2,
+              limit,
+              logger,
+              peerPeers
+            );
             let semanticHits = [];
             if (typeof deps.embedQuery === "function") {
               try {
@@ -751,7 +1095,8 @@ function createUnifiedSearch(deps = {}) {
                   queryEmbedding,
                   limit,
                   threshold,
-                  logger
+                  logger,
+                  peerPeers
                 );
               } catch (error) {
                 logger.warn?.(
@@ -796,7 +1141,7 @@ function createUnifiedSearch(deps = {}) {
       });
       const keywords2 = deriveLexicalKeywords(input.query);
       const lexical2 = filterByDateRange(
-        await runLexicalSearchForKeywords(deps, input, keywords2, limit, logger),
+        await runLexicalSearchForKeywords(deps, input, keywords2, limit, logger, peerPeers),
         input.dateFrom,
         input.dateTo
       );
@@ -822,7 +1167,7 @@ function createUnifiedSearch(deps = {}) {
         );
         const lists = await Promise.all(
           embeddings.map(
-            (embedding) => runSemanticSearchForEmbedding(deps, input, embedding, limit, threshold, logger)
+            (embedding) => runSemanticSearchForEmbedding(deps, input, embedding, limit, threshold, logger, peerPeers)
           )
         );
         semantic = mergeByMaxScore(lists);
@@ -838,7 +1183,15 @@ function createUnifiedSearch(deps = {}) {
     }
     if (semantic.length === 0) {
       const queryEmbedding = await embedQueryVariant(embedQuery, input, input.query);
-      semantic = await runSemanticSearchForEmbedding(deps, input, queryEmbedding, limit, threshold, logger);
+      semantic = await runSemanticSearchForEmbedding(
+        deps,
+        input,
+        queryEmbedding,
+        limit,
+        threshold,
+        logger,
+        peerPeers
+      );
     }
     let lexical = [];
     const keywords = deriveLexicalKeywords(input.query);
@@ -847,13 +1200,16 @@ function createUnifiedSearch(deps = {}) {
         try {
           const lexFilters = input.botIds && input.botIds.length > 0 ? input.botIds : [void 0];
           const searchRawMessagesLexical = deps.searchRawMessagesLexical;
+          const factTypes = input.factTypes?.length ? input.factTypes : void 0;
           lexical = (await Promise.all(
             lexFilters.map(
               (botId) => searchRawMessagesLexical({
                 userId: input.userId,
                 keywords,
                 limit,
-                botId
+                botId,
+                ...peerPeers.length > 0 ? { peers: peerPeers } : {},
+                ...factTypes ? { factTypes } : {}
               })
             )
           )).flat().filter(isRawMemorySemanticResult).map((hit) => ({
@@ -881,20 +1237,272 @@ function createUnifiedSearch(deps = {}) {
       lexical: filterByDateRange(lexical, input.dateFrom, input.dateTo)
     };
   }
+  async function searchUnifiedMemory(input) {
+    const query = input.query.trim();
+    const sources = normalizeUnifiedMemorySearchSources(input.sources);
+    const limit = clampUnifiedMemorySearchLimit(input.limit);
+    const threshold = clampUnifiedMemorySearchThreshold(input.threshold);
+    const mergeStrategy = normalizeUnifiedMemoryMergeStrategy(
+      input.mergeStrategy ?? deps.reasoning?.defaultMergeStrategy ?? "rrf"
+    );
+    const reasoningStrategy = resolveReasoningStrategy(input);
+    const warnings = [];
+    const peerScope = input.peerFilter && input.peerFilter.length > 0 ? await resolveScopePeer({
+      userId: input.userId,
+      peerFilter: input.peerFilter,
+      scopeCheck: deps.peerScopeCheck
+    }) : { peers: [], warnings: [] };
+    warnings.push(...peerScope.warnings);
+    const peerPeers = peerScope.peers;
+    if (!query) {
+      return {
+        query,
+        sources,
+        results: [],
+        count: 0,
+        warnings
+      };
+    }
+    let memorySubs;
+    const reasoningInfo = { strategy: reasoningStrategy };
+    if (input.dateFrom || input.dateTo) {
+      reasoningInfo.dateRange = { from: input.dateFrom, to: input.dateTo };
+    }
+    if (sources.includes("memory")) {
+      const hasRawProviders = typeof deps.searchRawMessagesAnn === "function" || typeof deps.searchRawMessagesLexical === "function";
+      if (isRawMessageStorageAvailable() || hasRawProviders) {
+        try {
+          memorySubs = await runMemorySource(
+            input,
+            limit,
+            threshold,
+            warnings,
+            reasoningStrategy,
+            reasoningInfo,
+            peerPeers
+          );
+        } catch (error) {
+          logger.warn?.("[memory-store] memory source failed:", error);
+          warnings.push({
+            source: "memory",
+            code: "memory_search_failed",
+            message: `Memory search failed: ${error.message ?? "Unknown error"}. Using keyword search fallback.`
+          });
+        }
+      } else {
+        warnings.push({
+          source: "memory",
+          code: "raw_message_storage_unavailable",
+          message: "Raw memory storage is not available in this environment."
+        });
+      }
+    }
+    const insightHits = [];
+    if (sources.includes("insights") && typeof deps.searchInsights === "function") {
+      try {
+        const hits = await deps.searchInsights({
+          userId: input.userId,
+          query: input.query,
+          limit,
+          threshold,
+          botIds: input.botIds,
+          includeArchived: input.includeArchivedInsights,
+          authToken: input.authToken,
+          ...peerPeers.length > 0 ? { peers: peerPeers } : {}
+        });
+        for (const hit of hits) {
+          insightHits.push({
+            type: "insight",
+            id: hit.id,
+            content: hit.content,
+            similarity: hit.similarity,
+            metadata: hit.metadata
+          });
+        }
+      } catch (error) {
+        logger.warn?.("[memory-store] insights source failed:", error);
+        warnings.push({
+          source: "insights",
+          code: "insights_search_failed",
+          message: error.message ?? "insights_search_failed"
+        });
+      }
+    } else if (sources.includes("insights")) ;
+    const knowledgeHits = [];
+    if (sources.includes("knowledge") && typeof deps.searchKnowledge === "function") {
+      try {
+        const hits = await deps.searchKnowledge({
+          userId: input.userId,
+          query: input.query,
+          options: {
+            limit,
+            threshold,
+            documentIds: input.documentIds
+          },
+          authToken: input.authToken,
+          ...peerPeers.length > 0 ? { peers: peerPeers } : {}
+        });
+        for (const hit of hits) {
+          knowledgeHits.push(toKnowledgeResult(hit));
+        }
+      } catch (error) {
+        logger.warn?.("[memory-store] knowledge source failed:", error);
+        warnings.push({
+          source: "knowledge",
+          code: "knowledge_search_failed",
+          message: error.message ?? "knowledge_search_failed"
+        });
+      }
+    } else if (sources.includes("knowledge")) ;
+    const merged = mergeAcrossSources({
+      memorySubs,
+      insightHits,
+      knowledgeHits,
+      limit,
+      strategy: mergeStrategy
+    });
+    const ranked = await applyReranker(deps.reranker, input.query, merged);
+    const output = {
+      query: input.query,
+      sources,
+      results: ranked,
+      count: ranked.length,
+      warnings
+    };
+    if (reasoningInfo && (reasoningInfo.strategy !== "none" || reasoningInfo.dateRange !== void 0)) {
+      output.reasoning = reasoningInfo;
+    }
+    return output;
+  }
   async function searchRawMemorySemantically(input) {
     const limit = clampUnifiedMemorySearchLimit(input.limit);
     const threshold = clampUnifiedMemorySearchThreshold(input.threshold);
     const reasoningStrategy = resolveReasoningStrategy(input);
+    const mergeStrategy = normalizeUnifiedMemoryMergeStrategy(
+      input.mergeStrategy ?? deps.reasoning?.defaultMergeStrategy ?? "rrf"
+    );
     const sub = await runMemorySource(input, limit, threshold, [], reasoningStrategy);
     return mergeAcrossSources({
       memorySubs: sub,
       insightHits: [],
       knowledgeHits: [],
       limit,
-      strategy: normalizeUnifiedMemoryMergeStrategy(input.mergeStrategy)
+      strategy: mergeStrategy
+    });
+  }
+  async function search(input) {
+    const query = input.query.trim();
+    const wantsSynthesis = typeof input.synthesize === "boolean" ? input.synthesize : typeof input.synthesize === "object" && input.synthesize !== null;
+    const synthesisSchema = typeof input.synthesize === "object" && input.synthesize !== null ? input.synthesize.responseSchema ?? input.responseSchema : input.responseSchema;
+    const peerScope = await resolveSearchScopePeers({
+      deps,
+      userId: input.userId,
+      peerFilter: input.peerFilter
+    });
+    if (!query) {
+      const empty = {
+        query,
+        sources: input.sources ? [...input.sources] : [],
+        results: [],
+        evidence: [],
+        count: 0,
+        warnings: peerScope.warnings,
+        answer: ""
+      };
+      return empty;
+    }
+    const tiers = input.tiers ? [...input.tiers] : wantsSynthesis ? ["summary", "raw", "insight", "knowledge"] : ["raw", "insight", "knowledge"];
+    const wantsSummaryTier = tiers.includes("summary");
+    const wantsRawTier = tiers.includes("raw");
+    const wantsInsightTier = tiers.includes("insight");
+    const wantsKnowledgeTier = tiers.includes("knowledge");
+    const warnings = [...peerScope.warnings];
+    const limit = clampUnifiedMemorySearchLimit(input.limit);
+    const threshold = clampUnifiedMemorySearchThreshold(input.threshold);
+    let unifiedHits = [];
+    let sources = input.sources ? [...input.sources] : [];
+    let unifiedReasoning;
+    if (wantsRawTier || wantsInsightTier || wantsKnowledgeTier) {
+      const inferredSources = sources.length > 0 ? sources : [
+        ...wantsRawTier ? ["memory"] : [],
+        ...wantsInsightTier ? ["insights"] : [],
+        ...wantsKnowledgeTier ? ["knowledge"] : []
+      ];
+      const unified = await searchUnifiedMemory({
+        ...searchInputToUnified(input),
+        sources: inferredSources.length > 0 ? inferredSources : void 0
+      });
+      unifiedHits = unified.results;
+      sources = unified.sources;
+      unifiedReasoning = unified.reasoning;
+      warnings.push(...unified.warnings);
+    }
+    let summaryHits = [];
+    if (wantsSummaryTier && typeof deps.searchSummaries === "function") {
+      const summaryBucket = await gatherSummaries(
+        deps,
+        { userId: input.userId, query: input.query, authToken: input.authToken },
+        limit,
+        threshold,
+        logger,
+        peerScope.peers
+      );
+      warnings.push(...summaryBucket.warnings);
+      summaryHits = summaryBucket.hits;
+    }
+    const tierLists = [];
+    if (unifiedHits.length > 0) {
+      tierLists.push({ name: "memory", hits: unifiedHits });
+    }
+    if (summaryHits.length > 0) {
+      tierLists.push({ name: "summary", hits: summaryHits });
+    }
+    let hits;
+    if (tierLists.length === 0) {
+      hits = [];
+    } else if (tierLists.length === 1) {
+      hits = tierLists[0].hits.slice(0, limit);
+    } else {
+      hits = mergeUnifiedMemorySearchResultsRrf(tierLists, limit);
+    }
+    const evidence = hits.map((hit) => ({
+      id: hit.id,
+      source: mapHitToEvidenceSource(hit),
+      snippet: hit.content,
+      score: hit.similarity,
+      timestamp: getCandidateTimestamp(hit.metadata)
+    }));
+    const base = {
+      query,
+      sources,
+      results: hits,
+      evidence,
+      count: hits.length,
+      warnings
+    };
+    if (unifiedReasoning) {
+      base.reasoning = unifiedReasoning;
+    }
+    if (!wantsSynthesis) {
+      return base;
+    }
+    const { answer, warnings: synthWarnings } = await synthesizeAnswer({
+      query,
+      hits,
+      responseSchema: synthesisSchema,
+      deps,
+      logger
     });
+    base.answer = answer;
+    base.warnings = [...base.warnings, ...synthWarnings];
+    return base;
   }
-  return { searchUnifiedMemory, searchRawMemorySemantically };
+  return {
+    search,
+    searchUnifiedMemory,
+    searchRawMemorySemantically,
+    consolidate: (input) => applyReflectedPlan(deps, {}, input)
+  };
 }
 function mergeAcrossSources(input) {
   const memorySubs = input.memorySubs ?? { semantic: [], lexical: [] };
@@ -925,11 +1533,185 @@ function mergeAcrossSources(input) {
   }
   return mergeUnifiedMemorySearchResultsRrf(lists, input.limit);
 }
+var DEFAULT_MAX_FACTS = 1e3;
+var LOW_CONFIDENCE_THRESHOLD = 0.1;
+function toHRR(data) {
+  const arr = data instanceof Float32Array ? data : new Float32Array(data);
+  return { dim: arr.length, data: arr };
+}
+function generateFactId() {
+  const stamp = Date.now().toString(36);
+  const rand = Math.random().toString(36).slice(2, 10);
+  return `vsa-${stamp}-${rand}`;
+}
+function createVsaRecall(storage) {
+  return {
+    async storeFact(input) {
+      const roleVector = vsaNormalizeVector(input.roleVector, "roleVector");
+      const fillerVector = vsaNormalizeVector(input.fillerVector, "fillerVector");
+      vsaAssertSameDim(roleVector, fillerVector, "storeFact");
+      const dim = input.dim ?? roleVector.length;
+      if (roleVector.length !== dim) {
+        throw new Error(`storeFact: roleVector.length (${roleVector.length}) must equal dim (${dim})`);
+      }
+      const now = Date.now();
+      const fact = {
+        factId: input.factId ?? generateFactId(),
+        userId: input.userId,
+        roleLabel: input.roleLabel,
+        fillerLabel: input.fillerLabel,
+        roleVector,
+        fillerVector,
+        dim,
+        scopeTag: input.scopeTag ?? "default",
+        botId: input.botId,
+        createdAt: now
+      };
+      await storage.storeFact(fact);
+      return { factId: fact.factId, createdAt: now };
+    },
+    async recall(input) {
+      const roleVector = vsaNormalizeVector(input.roleVector, "roleVector");
+      const scopeTag = input.scopeTag ?? "default";
+      const maxFacts = input.maxFacts ?? DEFAULT_MAX_FACTS;
+      if (input.vocabulary.length === 0) {
+        throw new Error("vsaRecall: vocabulary must contain at least one entry");
+      }
+      const facts = await storage.queryFacts({
+        userId: input.userId,
+        scopeTag,
+        botId: input.botId,
+        includeDeprecated: false,
+        limit: maxFacts
+      });
+      const warnings = [];
+      if (facts.length === 0) {
+        warnings.push({
+          code: "vsa_no_facts",
+          message: `No VSA facts for userId=${input.userId} scopeTag=${scopeTag}`
+        });
+        return {
+          fillerLabel: "",
+          score: 0,
+          allScores: [],
+          factCount: 0,
+          warnings
+        };
+      }
+      const refDim = facts[0].dim;
+      const dimMatchedFacts = facts.filter((fact) => {
+        if (fact.dim === refDim) return true;
+        warnings.push({
+          code: "vsa_dim_mismatch",
+          message: `Fact ${fact.factId} has dim=${fact.dim}, expected ${refDim}; skipping`
+        });
+        return false;
+      });
+      if (roleVector.length !== refDim) {
+        throw new Error(
+          `vsaRecall: roleVector dim (${roleVector.length}) must match stored fact dim (${refDim})`
+        );
+      }
+      if (dimMatchedFacts.length === 0) {
+        warnings.push({
+          code: "vsa_no_facts",
+          message: `All stored facts for userId=${input.userId} scopeTag=${scopeTag} had a non-matching dim`
+        });
+        return {
+          fillerLabel: "",
+          score: 0,
+          allScores: [],
+          factCount: 0,
+          warnings
+        };
+      }
+      const memoryVec = superpose(
+        dimMatchedFacts.map((fact) => bind(toHRR(fact.roleVector), toHRR(fact.fillerVector)))
+      );
+      const candidate = unbind(memoryVec, toHRR(roleVector));
+      const vocabVecs = input.vocabulary.map(
+        (entry) => toHRR(vsaNormalizeVector(entry.vector, `vocabulary[${entry.label}].vector`))
+      );
+      const bestVec = cleanup(candidate, vocabVecs);
+      const bestIdx = vocabVecs.indexOf(bestVec);
+      const allScores = input.vocabulary.map((entry, idx) => ({
+        label: entry.label,
+        score: cosineSimilarity(candidate, vocabVecs[idx])
+      }));
+      allScores.sort((a, b) => b.score - a.score);
+      const fillerLabel = bestIdx >= 0 ? input.vocabulary[bestIdx].label : "";
+      const score = allScores[0]?.score ?? 0;
+      if (score < LOW_CONFIDENCE_THRESHOLD) {
+        warnings.push({
+          code: "vsa_low_confidence",
+          message: `Best match "${fillerLabel}" score ${score.toFixed(3)} below ${LOW_CONFIDENCE_THRESHOLD}`
+        });
+      }
+      if (facts.length >= maxFacts) {
+        warnings.push({
+          code: "vsa_fact_limit_reached",
+          message: `Loaded ${facts.length} facts (cap=${maxFacts}); recall may degrade with more`
+        });
+      }
+      return {
+        fillerLabel,
+        score,
+        allScores,
+        factCount: facts.length,
+        warnings
+      };
+    },
+    async listFacts(input) {
+      const facts = await storage.queryFacts({
+        userId: input.userId,
+        scopeTag: input.scopeTag,
+        botId: input.botId,
+        includeDeprecated: input.includeDeprecated
+      });
+      return facts.map((fact) => ({
+        factId: fact.factId,
+        userId: fact.userId,
+        roleLabel: fact.roleLabel,
+        fillerLabel: fact.fillerLabel,
+        scopeTag: fact.scopeTag,
+        botId: fact.botId,
+        createdAt: fact.createdAt,
+        deprecatedAt: fact.deprecatedAt
+      }));
+    },
+    async forget(input) {
+      const result = await storage.deprecateFacts({
+        userId: input.userId,
+        factIds: input.factIds,
+        reason: input.reason
+      });
+      return { deprecatedCount: result.deprecatedCount };
+    }
+  };
+}
 
 // src/index.ts
 init_raw_message_store();
+init_sqlite_raw_message_store();
 init_raw_message_store();
 init_postgres_raw_message_factory();
+function attachMemoryGraphStore(store, input) {
+  const logger = input.logger ?? console;
+  if (typeof input.storage.compareAndSwapGraphLedger !== "function") {
+    logger.warn?.(
+      "[memory-store] attachMemoryGraphStore: storage is missing `compareAndSwapGraphLedger`; no graph store attached."
+    );
+    return store;
+  }
+  const graphStore = createRawMessageMemoryGraphStore({
+    storage: input.storage,
+    ownerScope: input.ownerScope,
+    botId: input.botId,
+    now: input.now
+  });
+  store.graphStore = graphStore;
+  return store;
+}
 
 // src/search/query-rewriter.ts
 var SYSTEM_PROMPT = `You are a memory retrieval assistant.
@@ -1285,19 +2067,173 @@ function createIdentityIterativePlanner() {
   };
 }
 
-// src/index.ts
+// src/search/peer-profile.ts
+var DEFAULT_PROFILE_LIMIT = 20;
+var DEFAULT_RELATIONSHIP_LIMIT = 5;
+var DEFAULT_PROFILE_THRESHOLD = 0.1;
+var DEFAULT_RELATIONSHIP_THRESHOLD = 0.1;
+function indexKnownPeers(peers) {
+  const map = /* @__PURE__ */ new Map();
+  for (const peer of peers) {
+    map.set(peer.id, peer);
+  }
+  return map;
+}
+function resolvePeerFromMap(peerId, known, resolvePeer) {
+  if (resolvePeer) {
+    const explicit = resolvePeer(peerId);
+    if (explicit) return explicit;
+  }
+  return known.get(peerId);
+}
+function buildProfilePrompt(peerId) {
+  return `Summarize ${peerId}'s role, interests, and recent activity based on the evidence below.`;
+}
+function buildRelationshipPrompt(fromId, toId) {
+  return `How do ${fromId} and ${toId} interact? Describe the relationship.`;
+}
+async function collectMentions(postings) {
+  if (!postings) return [];
+  const result = postings();
+  if (Array.isArray(result)) {
+    return result;
+  }
+  return await result;
+}
+function collectCoMentions(postings, targetId) {
+  const coCounts = /* @__PURE__ */ new Map();
+  for (const posting of postings) {
+    const mentionIds = posting.mentionedPeers?.map((p) => p.id) ?? posting.mentionedIds ?? [];
+    const involvesTarget = posting.authorId === targetId || mentionIds.includes(targetId) || (posting.mentionedPeers ?? []).some((p) => p.id === targetId);
+    if (!involvesTarget) {
+      continue;
+    }
+    if (posting.authorId !== targetId) {
+      const entry = coCounts.get(posting.authorId) ?? { count: 0, evidenceIds: [] };
+      entry.count += 1;
+      entry.evidenceIds.push(posting.id);
+      coCounts.set(posting.authorId, entry);
+    }
+    for (const otherId of mentionIds) {
+      if (otherId === targetId) continue;
+      const entry = coCounts.get(otherId) ?? { count: 0, evidenceIds: [] };
+      entry.count += 1;
+      entry.evidenceIds.push(posting.id);
+      coCounts.set(otherId, entry);
+    }
+  }
+  return coCounts;
+}
+function createPeerProfile(deps) {
+  const { search, userId, resolvePeer, listKnownPeers } = deps;
+  return {
+    getKnownPeers() {
+      return listKnownPeers();
+    },
+    async getProfile(peerId) {
+      const known = indexKnownPeers(listKnownPeers());
+      const peer = resolvePeerFromMap(peerId, known, resolvePeer);
+      if (!peer) {
+        throw new Error(`peer_profile: unknown peerId "${peerId}"`);
+      }
+      const out = await search.search({
+        userId,
+        query: buildProfilePrompt(peer.id),
+        peerFilter: [peer],
+        tiers: ["raw"],
+        limit: DEFAULT_PROFILE_LIMIT,
+        threshold: deps.profileThreshold ?? DEFAULT_PROFILE_THRESHOLD,
+        synthesize: {
+          responseSchema: { answer: "string", confidence: "number" }
+        }
+      });
+      return {
+        peer,
+        answer: out.answer ?? "",
+        evidenceIds: out.evidence.map((item) => item.id),
+        warnings: out.warnings.map((warning) => warning.code)
+      };
+    },
+    async getRelationships(peerId) {
+      const known = indexKnownPeers(listKnownPeers());
+      const peer = resolvePeerFromMap(peerId, known, resolvePeer);
+      if (!peer) {
+        throw new Error(`peer_profile: unknown peerId "${peerId}"`);
+      }
+      const postings = await collectMentions(deps.listPeerMentions);
+      const coCounts = collectCoMentions(postings, peer.id);
+      if (coCounts.size === 0) {
+        return [];
+      }
+      const results = [];
+      for (const [otherId, info] of coCounts) {
+        const other = resolvePeerFromMap(otherId, known, resolvePeer);
+        if (!other) continue;
+        const confirmation = await search.search({
+          userId,
+          query: buildRelationshipPrompt(peer.id, other.id),
+          peerFilter: [peer, other],
+          sources: ["memory"],
+          limit: DEFAULT_RELATIONSHIP_LIMIT,
+          threshold: deps.relationshipThreshold ?? DEFAULT_RELATIONSHIP_THRESHOLD,
+          mergeStrategy: "rrf"
+        });
+        const evidenceIds = confirmation.results.map((hit) => hit.id);
+        results.push({
+          from: peer,
+          to: other,
+          summary: confirmation.results.length > 0 ? `${confirmation.results.length} cross-mention${confirmation.results.length === 1 ? "" : "s"} between ${peer.id} and ${other.id}` : "no cross-mentions found",
+          evidenceIds,
+          strength: info.count
+        });
+      }
+      return results.sort((a, b) => b.strength - a.strength);
+    }
+  };
+}
 async function createMemoryStore(config = {}) {
   const dbPath = config.dbPath ?? (config.db && "path" in config.db ? config.db.path : void 0);
   const raw = createRawMessageStore({ env: config.env, dbPath });
-  const search = createUnifiedSearch(config.unified);
+  const search = createUnifiedSearch({ ...config.unified, logger: config.logger });
   configureRawMessageStore(config);
-  return {
+  const wiring = {
+    graphStore: config.graphStore,
+    storage: config.storage
+  };
+  const vsaDbPath = config.dbPath ?? (config.db && "path" in config.db ? config.db.path : void 0) ?? resolveSQLiteRawMessageDbPath();
+  const vsaStorage = await getSQLiteVsaStore({
+    dbPath: vsaDbPath
+  });
+  const vsa = createVsaRecall(vsaStorage);
+  const applyConsolidate = (input) => search.consolidate({
+    ...input,
+    graphStore: input.graphStore ?? wiring.graphStore,
+    storage: input.storage ?? wiring.storage
+  });
+  const store = {
     raw,
-    search,
+    // Flat search verb — `search({ synthesize: true })` opts into the
+    // read-only LLM synthesis path.
+    search: search.search,
+    vsa,
     getRawMessageManager,
     searchUnifiedMemory: search.searchUnifiedMemory,
-    searchRawMemorySemantically: search.searchRawMemorySemantically
+    searchRawMemorySemantically: search.searchRawMemorySemantically,
+    consolidate: applyConsolidate,
+    get graphStore() {
+      return wiring.graphStore;
+    },
+    set graphStore(value) {
+      wiring.graphStore = value;
+    },
+    get storage() {
+      return wiring.storage;
+    },
+    set storage(value) {
+      wiring.storage = value;
+    }
   };
+  return store;
 }
 
-export { clampUnifiedMemorySearchLimit, clampUnifiedMemorySearchThreshold, clearPostgresFactory, closeRawMessageStore, createIdentityIterativePlanner, createIdentityRewriter, createIterativeRecallPlanner, createMemoryStore, createRawMessageStore, createUnifiedSearch, createUserVoiceRewriter, getRawMessageManager, getRawMessageStorageBackend, hasPostgresFactory, isRawMemorySemanticResult, isRawMessageStorageAvailable, mergeUnifiedMemorySearchResults, normalizeUnifiedMemoryReasoningStrategy, normalizeUnifiedMemorySearchSources, registerPostgresFactory, resolvePostgresFactory, toKnowledgeResult, toMemoryResult };
+export { applyReflectedPlan, attachMemoryGraphStore, clampUnifiedMemorySearchLimit, clampUnifiedMemorySearchThreshold, clearPostgresFactory, closeRawMessageStore, createIdentityIterativePlanner, createIdentityRewriter, createIterativeRecallPlanner, createMemoryStore, createPeerProfile, createRawMessageStore, createUnifiedSearch, createUserVoiceRewriter, createVsaRecall, getRawMessageManager, getRawMessageStorageBackend, hasPostgresFactory, isRawMemorySemanticResult, isRawMessageStorageAvailable, mergeUnifiedMemorySearchResults, mergeUnifiedMemorySearchResultsRrf, normalizeUnifiedMemoryReasoningStrategy, normalizeUnifiedMemorySearchSources, registerPostgresFactory, resolvePostgresFactory, toKnowledgeResult, toMemoryResult };