@prmichaelsen/remember-mcp 3.14.21 → 3.15.1

package/dist/server.js

@@ -1730,6 +1730,9 @@ function canModerateAny(authContext) {
   return authContext.credentials.group_memberships.some((m) => m.permissions.can_moderate);
 }
 
+// node_modules/@prmichaelsen/remember-core/dist/database/weaviate/v2-collections.js
+import { configure } from "weaviate-client";
+
 // node_modules/@prmichaelsen/remember-core/dist/database/firestore/init.js
 import { initializeApp as initializeApp2 } from "@prmichaelsen/firebase-admin-sdk-v8";
 import { getDocument as getDocument2, setDocument as setDocument2, addDocument as addDocument2, updateDocument as updateDocument2, deleteDocument as deleteDocument2, queryDocuments as queryDocuments2, batchWrite as batchWrite2, FieldValue as FieldValue2, verifyIdToken as verifyIdToken2 } from "@prmichaelsen/firebase-admin-sdk-v8";
@@ -1758,6 +1761,313 @@ function getUserPreferencesPath(userId) {
 function getCollectionRegistryPath() {
   return `${BASE}.collection_registry`;
 }
+function getMemoryIndexPath() {
+  return `${BASE}.memory_index`;
+}
+
+// node_modules/@prmichaelsen/remember-core/dist/database/collection-registry.js
+async function registerCollection(entry) {
+  const path = getCollectionRegistryPath();
+  await setDocument2(path, entry.collection_name, entry);
+}
+
+// node_modules/@prmichaelsen/remember-core/dist/database/weaviate/v2-collections.js
+var collectionCache = /* @__PURE__ */ new Map();
+var COLLECTION_CACHE_TTL_MS = 6e4;
+function isCollectionCached(collectionName) {
+  const expiresAt = collectionCache.get(collectionName);
+  if (expiresAt !== void 0 && Date.now() < expiresAt)
+    return true;
+  collectionCache.delete(collectionName);
+  return false;
+}
+function cacheCollection(collectionName) {
+  collectionCache.set(collectionName, Date.now() + COLLECTION_CACHE_TTL_MS);
+}
+var COMMON_MEMORY_PROPERTIES = [
+  // Core content
+  { name: "content", dataType: configure.dataType.TEXT },
+  { name: "content_type", dataType: configure.dataType.TEXT },
+  { name: "title", dataType: configure.dataType.TEXT },
+  { name: "summary", dataType: configure.dataType.TEXT },
+  { name: "type", dataType: configure.dataType.TEXT },
+  // v1 compat (v2: content_type)
+  // Tracking arrays (v2 feature)
+  { name: "space_ids", dataType: configure.dataType.TEXT_ARRAY },
+  { name: "group_ids", dataType: configure.dataType.TEXT_ARRAY },
+  // Metadata
+  { name: "created_at", dataType: configure.dataType.DATE },
+  { name: "updated_at", dataType: configure.dataType.DATE },
+  { name: "version", dataType: configure.dataType.INT },
+  // User context
+  { name: "user_id", dataType: configure.dataType.TEXT },
+  // Document type (memory, relationship, comment)
+  { name: "doc_type", dataType: configure.dataType.TEXT },
+  // Memory-specific fields
+  { name: "tags", dataType: configure.dataType.TEXT_ARRAY },
+  { name: "weight", dataType: configure.dataType.NUMBER },
+  { name: "trust_score", dataType: configure.dataType.NUMBER },
+  { name: "trust", dataType: configure.dataType.NUMBER },
+  // v1 compat (v2: trust_score)
+  { name: "base_weight", dataType: configure.dataType.NUMBER },
+  { name: "computed_weight", dataType: configure.dataType.NUMBER },
+  { name: "confidence", dataType: configure.dataType.NUMBER },
+  { name: "strength", dataType: configure.dataType.NUMBER },
+  // Location data (v2 names)
+  { name: "location_name", dataType: configure.dataType.TEXT },
+  { name: "location_lat", dataType: configure.dataType.NUMBER },
+  { name: "location_lon", dataType: configure.dataType.NUMBER },
+  // Location data (v1 compat)
+  { name: "location_gps_lat", dataType: configure.dataType.NUMBER },
+  { name: "location_gps_lng", dataType: configure.dataType.NUMBER },
+  { name: "location_address", dataType: configure.dataType.TEXT },
+  { name: "location_city", dataType: configure.dataType.TEXT },
+  { name: "location_country", dataType: configure.dataType.TEXT },
+  { name: "location_source", dataType: configure.dataType.TEXT },
+  // Locale
+  { name: "locale_language", dataType: configure.dataType.TEXT },
+  { name: "locale_timezone", dataType: configure.dataType.TEXT },
+  // Context
+  { name: "context_app", dataType: configure.dataType.TEXT },
+  { name: "context_url", dataType: configure.dataType.TEXT },
+  { name: "context_conversation_id", dataType: configure.dataType.TEXT },
+  { name: "context_summary", dataType: configure.dataType.TEXT },
+  { name: "context_timestamp", dataType: configure.dataType.DATE },
+  // Relationships (v2 names)
+  { name: "relationship_ids", dataType: configure.dataType.TEXT_ARRAY },
+  { name: "relationship_type", dataType: configure.dataType.TEXT },
+  { name: "related_memory_ids", dataType: configure.dataType.TEXT_ARRAY },
+  { name: "observation", dataType: configure.dataType.TEXT },
+  { name: "source", dataType: configure.dataType.TEXT },
+  // Relationships (v1 compat)
+  { name: "relationships", dataType: configure.dataType.TEXT_ARRAY },
+  { name: "memory_ids", dataType: configure.dataType.TEXT_ARRAY },
+  { name: "relationship_count", dataType: configure.dataType.INT },
+  // Rating aggregates (denormalized from Firestore individual ratings)
+  { name: "rating_sum", dataType: configure.dataType.INT },
+  { name: "rating_count", dataType: configure.dataType.INT },
+  { name: "rating_bayesian", dataType: configure.dataType.NUMBER },
+  // Access tracking
+  { name: "access_count", dataType: configure.dataType.NUMBER },
+  { name: "last_accessed_at", dataType: configure.dataType.DATE },
+  // References & templates
+  { name: "references", dataType: configure.dataType.TEXT_ARRAY },
+  { name: "template_id", dataType: configure.dataType.TEXT },
+  // Comments (Phase 1)
+  { name: "parent_id", dataType: configure.dataType.TEXT },
+  { name: "thread_root_id", dataType: configure.dataType.TEXT },
+  { name: "moderation_flags", dataType: configure.dataType.TEXT_ARRAY },
+  // Agent follow-up tracking
+  { name: "follow_up_at", dataType: configure.dataType.DATE },
+  // Soft delete
+  { name: "deleted_at", dataType: configure.dataType.DATE },
+  { name: "deleted_by", dataType: configure.dataType.TEXT },
+  { name: "deletion_reason", dataType: configure.dataType.TEXT }
+];
+var PUBLISHED_MEMORY_PROPERTIES = [
+  // Publication metadata
+  { name: "published_at", dataType: configure.dataType.DATE },
+  { name: "revised_at", dataType: configure.dataType.DATE },
+  // Attribution
+  { name: "author_id", dataType: configure.dataType.TEXT },
+  { name: "ghost_id", dataType: configure.dataType.TEXT },
+  { name: "attribution", dataType: configure.dataType.TEXT },
+  // Discovery
+  { name: "discovery_count", dataType: configure.dataType.INT },
+  // Revision tracking
+  { name: "revision_count", dataType: configure.dataType.INT },
+  { name: "original_memory_id", dataType: configure.dataType.TEXT },
+  // Moderation (nullable — null defaults to approved)
+  { name: "moderation_status", dataType: configure.dataType.TEXT },
+  { name: "moderated_by", dataType: configure.dataType.TEXT },
+  { name: "moderated_at", dataType: configure.dataType.DATE },
+  // Memory-level ACL (nullable — null defaults to owner_only semantics)
+  { name: "write_mode", dataType: configure.dataType.TEXT },
+  { name: "owner_id", dataType: configure.dataType.TEXT },
+  { name: "overwrite_allowed_ids", dataType: configure.dataType.TEXT_ARRAY },
+  { name: "last_revised_by", dataType: configure.dataType.TEXT },
+  // Legacy compatibility (deprecated but kept for migration)
+  { name: "spaces", dataType: configure.dataType.TEXT_ARRAY },
+  { name: "space_id", dataType: configure.dataType.TEXT },
+  { name: "space_memory_id", dataType: configure.dataType.TEXT }
+];
+function createSpaceCollectionSchema() {
+  const collectionName = "Memory_spaces_public";
+  return {
+    name: collectionName,
+    description: "Shared memory collection for all public spaces",
+    vectorizers: configure.vectorizer.text2VecOpenAI({
+      model: "text-embedding-3-small",
+      dimensions: 1536,
+      vectorizeCollectionName: false
+    }),
+    properties: [
+      ...COMMON_MEMORY_PROPERTIES,
+      ...PUBLISHED_MEMORY_PROPERTIES
+    ],
+    invertedIndex: configure.invertedIndex({
+      indexNullState: true,
+      indexPropertyLength: true,
+      indexTimestamps: true
+    })
+  };
+}
+function createGroupCollectionSchema(groupId) {
+  const collectionName = `Memory_groups_${groupId}`;
+  return {
+    name: collectionName,
+    description: `Group memory collection for group: ${groupId}`,
+    vectorizers: configure.vectorizer.text2VecOpenAI({
+      model: "text-embedding-3-small",
+      dimensions: 1536,
+      vectorizeCollectionName: false
+    }),
+    properties: [
+      ...COMMON_MEMORY_PROPERTIES,
+      ...PUBLISHED_MEMORY_PROPERTIES
+    ],
+    invertedIndex: configure.invertedIndex({
+      indexNullState: true,
+      indexPropertyLength: true,
+      indexTimestamps: true
+    })
+  };
+}
+async function reconcileCollectionProperties(client2, collectionName, expectedProperties) {
+  const collection = client2.collections.get(collectionName);
+  const config3 = await collection.config.get();
+  const existingNames = new Set(config3.properties.map((p) => p.name));
+  let added = 0;
+  for (const prop of expectedProperties) {
+    if (!existingNames.has(prop.name)) {
+      await collection.config.addProperty(prop);
+      added++;
+    }
+  }
+  return added;
+}
+async function ensureGroupCollection(client2, groupId) {
+  const collectionName = `Memory_groups_${groupId}`;
+  if (isCollectionCached(collectionName))
+    return false;
+  const exists = await client2.collections.exists(collectionName);
+  if (exists) {
+    await reconcileCollectionProperties(client2, collectionName, [...COMMON_MEMORY_PROPERTIES, ...PUBLISHED_MEMORY_PROPERTIES]);
+    cacheCollection(collectionName);
+    return false;
+  }
+  const schema = createGroupCollectionSchema(groupId);
+  await client2.collections.create(schema);
+  await registerCollection({
+    collection_name: collectionName,
+    collection_type: "groups",
+    owner_id: groupId,
+    created_at: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  cacheCollection(collectionName);
+  return true;
+}
+function getCollectionType(collectionName) {
+  if (collectionName.startsWith("Memory_users_"))
+    return "users";
+  if (collectionName === "Memory_spaces_public")
+    return "spaces";
+  if (collectionName.startsWith("Memory_groups_"))
+    return "groups";
+  throw new Error(`Unknown collection type for: ${collectionName}`);
+}
+
+// node_modules/@prmichaelsen/remember-core/dist/utils/dedupe.js
+function tagWithSource(objects, collectionName) {
+  return objects.map((obj) => ({ ...obj, _collectionName: collectionName }));
+}
+function getTier(collectionName) {
+  try {
+    const type = getCollectionType(collectionName);
+    switch (type) {
+      case "spaces":
+        return 1;
+      case "groups":
+        return 2;
+      case "users":
+        return 3;
+    }
+  } catch {
+    return 4;
+  }
+}
+function extractGroupId(collectionName) {
+  if (collectionName.startsWith("Memory_groups_")) {
+    return collectionName.replace("Memory_groups_", "");
+  }
+  return null;
+}
+function shouldPrefer(aCollection, bCollection, viewingGroupId) {
+  const aTier = getTier(aCollection);
+  const bTier = getTier(bCollection);
+  if (aTier !== bTier)
+    return aTier < bTier;
+  if (viewingGroupId) {
+    const aGroup = extractGroupId(aCollection);
+    const bGroup = extractGroupId(bCollection);
+    if (aGroup === viewingGroupId && bGroup !== viewingGroupId)
+      return true;
+    if (bGroup === viewingGroupId && aGroup !== viewingGroupId)
+      return false;
+  }
+  return aCollection <= bCollection;
+}
+function dedupeBySourceId(objects, options = {}) {
+  if (options.enabled === false)
+    return objects;
+  const sourceMap = /* @__PURE__ */ new Map();
+  const results = [];
+  const deduped = /* @__PURE__ */ new Set();
+  for (let i = 0; i < objects.length; i++) {
+    const obj = objects[i];
+    const sourceId = obj.properties.original_memory_id;
+    if (!sourceId) {
+      results.push({ obj, index: i });
+      continue;
+    }
+    const existing = sourceMap.get(sourceId);
+    if (!existing) {
+      const tagged = { ...obj, _also_in: [] };
+      sourceMap.set(sourceId, { winner: tagged, index: i });
+      results.push({ obj: tagged, index: i });
+      continue;
+    }
+    if (shouldPrefer(obj._collectionName, existing.winner._collectionName, options.viewingGroupId)) {
+      existing.winner._also_in.push({
+        source: obj._collectionName,
+        id: obj.uuid
+      });
+      const loser = existing.winner;
+      const newWinner = {
+        ...obj,
+        _also_in: [
+          ...existing.winner._also_in.filter((a) => a.id !== obj.uuid),
+          { source: loser._collectionName, id: loser.uuid }
+        ]
+      };
+      deduped.add(loser.uuid);
+      deduped.delete(obj.uuid);
+      sourceMap.set(sourceId, { winner: newWinner, index: i });
+      const oldSlot = results.find((r) => r.obj.uuid === loser.uuid);
+      if (oldSlot) {
+        oldSlot.obj = newWinner;
+        oldSlot.index = i;
+      }
+    } else {
+      existing.winner._also_in.push({
+        source: obj._collectionName,
+        id: obj.uuid
+      });
+      deduped.add(obj.uuid);
+    }
+  }
+  return results.filter((r) => !deduped.has(r.obj.uuid)).map((r) => r.obj);
+}
 
 // node_modules/@prmichaelsen/remember-core/dist/services/preferences.service.js
 var PreferencesDatabaseService = class {
@@ -2147,20 +2457,18 @@ var MemoryService = class {
    * Requires `memoryIndex` and `weaviateClient` in constructor options.
    */
   async resolveById(memoryId) {
-    if (!this.options?.weaviateClient) {
+    if (!this.options.weaviateClient) {
       throw new Error("resolveById requires weaviateClient in options");
     }
-    if (this.options?.memoryIndex) {
-      const collectionName = await this.options.memoryIndex.lookup(memoryId);
-      if (collectionName) {
-        const col = this.options.weaviateClient.collections.get(collectionName);
-        const memory = await fetchMemoryWithAllProperties(col, memoryId);
-        if (memory?.properties) {
-          return {
-            memory: normalizeDoc({ id: memory.uuid, ...memory.properties }),
-            collectionName
-          };
-        }
+    const collectionName = await this.options.memoryIndex.lookup(memoryId);
+    if (collectionName) {
+      const col = this.options.weaviateClient.collections.get(collectionName);
+      const memory = await fetchMemoryWithAllProperties(col, memoryId);
+      if (memory?.properties) {
+        return {
+          memory: normalizeDoc({ id: memory.uuid, ...memory.properties }),
+          collectionName
+        };
       }
     }
     return { memory: null, collectionName: null };
@@ -2206,13 +2514,11 @@ var MemoryService = class {
     };
     const memoryId = await this.collection.data.insert({ properties });
     this.logger.info("Memory created", { memoryId, userId: this.userId });
-    if (this.options?.memoryIndex) {
-      try {
-        const collectionName = this.collection.name;
-        await this.options.memoryIndex.index(memoryId, collectionName);
-      } catch (err2) {
-        this.logger.warn?.(`[MemoryService] Index write failed for ${memoryId}: ${err2}`);
-      }
+    try {
+      const collectionName = this.collection.name;
+      await this.options.memoryIndex.index(memoryId, collectionName);
+    } catch (err2) {
+      this.logger.warn?.(`[MemoryService] Index write failed for ${memoryId}: ${err2}`);
     }
     return { memory_id: memoryId, created_at: now };
   }
@@ -2885,212 +3191,6 @@ var RelationshipService = class {
 // node_modules/@prmichaelsen/remember-core/dist/services/space.service.js
 import { Filters as Filters4 } from "weaviate-client";
 
-// node_modules/@prmichaelsen/remember-core/dist/database/weaviate/v2-collections.js
-import { configure } from "weaviate-client";
-
-// node_modules/@prmichaelsen/remember-core/dist/database/collection-registry.js
-async function registerCollection(entry) {
-  const path = getCollectionRegistryPath();
-  await setDocument2(path, entry.collection_name, entry);
-}
-
-// node_modules/@prmichaelsen/remember-core/dist/database/weaviate/v2-collections.js
-var collectionCache = /* @__PURE__ */ new Map();
-var COLLECTION_CACHE_TTL_MS = 6e4;
-function isCollectionCached(collectionName) {
-  const expiresAt = collectionCache.get(collectionName);
-  if (expiresAt !== void 0 && Date.now() < expiresAt)
-    return true;
-  collectionCache.delete(collectionName);
-  return false;
-}
-function cacheCollection(collectionName) {
-  collectionCache.set(collectionName, Date.now() + COLLECTION_CACHE_TTL_MS);
-}
-var COMMON_MEMORY_PROPERTIES = [
-  // Core content
-  { name: "content", dataType: configure.dataType.TEXT },
-  { name: "content_type", dataType: configure.dataType.TEXT },
-  { name: "title", dataType: configure.dataType.TEXT },
-  { name: "summary", dataType: configure.dataType.TEXT },
-  { name: "type", dataType: configure.dataType.TEXT },
-  // v1 compat (v2: content_type)
-  // Tracking arrays (v2 feature)
-  { name: "space_ids", dataType: configure.dataType.TEXT_ARRAY },
-  { name: "group_ids", dataType: configure.dataType.TEXT_ARRAY },
-  // Metadata
-  { name: "created_at", dataType: configure.dataType.DATE },
-  { name: "updated_at", dataType: configure.dataType.DATE },
-  { name: "version", dataType: configure.dataType.INT },
-  // User context
-  { name: "user_id", dataType: configure.dataType.TEXT },
-  // Document type (memory, relationship, comment)
-  { name: "doc_type", dataType: configure.dataType.TEXT },
-  // Memory-specific fields
-  { name: "tags", dataType: configure.dataType.TEXT_ARRAY },
-  { name: "weight", dataType: configure.dataType.NUMBER },
-  { name: "trust_score", dataType: configure.dataType.NUMBER },
-  { name: "trust", dataType: configure.dataType.NUMBER },
-  // v1 compat (v2: trust_score)
-  { name: "base_weight", dataType: configure.dataType.NUMBER },
-  { name: "computed_weight", dataType: configure.dataType.NUMBER },
-  { name: "confidence", dataType: configure.dataType.NUMBER },
-  { name: "strength", dataType: configure.dataType.NUMBER },
-  // Location data (v2 names)
-  { name: "location_name", dataType: configure.dataType.TEXT },
-  { name: "location_lat", dataType: configure.dataType.NUMBER },
-  { name: "location_lon", dataType: configure.dataType.NUMBER },
-  // Location data (v1 compat)
-  { name: "location_gps_lat", dataType: configure.dataType.NUMBER },
-  { name: "location_gps_lng", dataType: configure.dataType.NUMBER },
-  { name: "location_address", dataType: configure.dataType.TEXT },
-  { name: "location_city", dataType: configure.dataType.TEXT },
-  { name: "location_country", dataType: configure.dataType.TEXT },
-  { name: "location_source", dataType: configure.dataType.TEXT },
-  // Locale
-  { name: "locale_language", dataType: configure.dataType.TEXT },
-  { name: "locale_timezone", dataType: configure.dataType.TEXT },
-  // Context
-  { name: "context_app", dataType: configure.dataType.TEXT },
-  { name: "context_url", dataType: configure.dataType.TEXT },
-  { name: "context_conversation_id", dataType: configure.dataType.TEXT },
-  { name: "context_summary", dataType: configure.dataType.TEXT },
-  { name: "context_timestamp", dataType: configure.dataType.DATE },
-  // Relationships (v2 names)
-  { name: "relationship_ids", dataType: configure.dataType.TEXT_ARRAY },
-  { name: "relationship_type", dataType: configure.dataType.TEXT },
-  { name: "related_memory_ids", dataType: configure.dataType.TEXT_ARRAY },
-  { name: "observation", dataType: configure.dataType.TEXT },
-  { name: "source", dataType: configure.dataType.TEXT },
-  // Relationships (v1 compat)
-  { name: "relationships", dataType: configure.dataType.TEXT_ARRAY },
-  { name: "memory_ids", dataType: configure.dataType.TEXT_ARRAY },
-  { name: "relationship_count", dataType: configure.dataType.INT },
-  // Rating aggregates (denormalized from Firestore individual ratings)
-  { name: "rating_sum", dataType: configure.dataType.INT },
-  { name: "rating_count", dataType: configure.dataType.INT },
-  { name: "rating_bayesian", dataType: configure.dataType.NUMBER },
-  // Access tracking
-  { name: "access_count", dataType: configure.dataType.NUMBER },
-  { name: "last_accessed_at", dataType: configure.dataType.DATE },
-  // References & templates
-  { name: "references", dataType: configure.dataType.TEXT_ARRAY },
-  { name: "template_id", dataType: configure.dataType.TEXT },
-  // Comments (Phase 1)
-  { name: "parent_id", dataType: configure.dataType.TEXT },
-  { name: "thread_root_id", dataType: configure.dataType.TEXT },
-  { name: "moderation_flags", dataType: configure.dataType.TEXT_ARRAY },
-  // Agent follow-up tracking
-  { name: "follow_up_at", dataType: configure.dataType.DATE },
-  // Soft delete
-  { name: "deleted_at", dataType: configure.dataType.DATE },
-  { name: "deleted_by", dataType: configure.dataType.TEXT },
-  { name: "deletion_reason", dataType: configure.dataType.TEXT }
-];
-var PUBLISHED_MEMORY_PROPERTIES = [
-  // Publication metadata
-  { name: "published_at", dataType: configure.dataType.DATE },
-  { name: "revised_at", dataType: configure.dataType.DATE },
-  // Attribution
-  { name: "author_id", dataType: configure.dataType.TEXT },
-  { name: "ghost_id", dataType: configure.dataType.TEXT },
-  { name: "attribution", dataType: configure.dataType.TEXT },
-  // Discovery
-  { name: "discovery_count", dataType: configure.dataType.INT },
-  // Revision tracking
-  { name: "revision_count", dataType: configure.dataType.INT },
-  { name: "original_memory_id", dataType: configure.dataType.TEXT },
-  // Moderation (nullable — null defaults to approved)
-  { name: "moderation_status", dataType: configure.dataType.TEXT },
-  { name: "moderated_by", dataType: configure.dataType.TEXT },
-  { name: "moderated_at", dataType: configure.dataType.DATE },
-  // Memory-level ACL (nullable — null defaults to owner_only semantics)
-  { name: "write_mode", dataType: configure.dataType.TEXT },
-  { name: "owner_id", dataType: configure.dataType.TEXT },
-  { name: "overwrite_allowed_ids", dataType: configure.dataType.TEXT_ARRAY },
-  { name: "last_revised_by", dataType: configure.dataType.TEXT },
-  // Legacy compatibility (deprecated but kept for migration)
-  { name: "spaces", dataType: configure.dataType.TEXT_ARRAY },
-  { name: "space_id", dataType: configure.dataType.TEXT },
-  { name: "space_memory_id", dataType: configure.dataType.TEXT }
-];
-function createSpaceCollectionSchema() {
-  const collectionName = "Memory_spaces_public";
-  return {
-    name: collectionName,
-    description: "Shared memory collection for all public spaces",
-    vectorizers: configure.vectorizer.text2VecOpenAI({
-      model: "text-embedding-3-small",
-      dimensions: 1536,
-      vectorizeCollectionName: false
-    }),
-    properties: [
-      ...COMMON_MEMORY_PROPERTIES,
-      ...PUBLISHED_MEMORY_PROPERTIES
-    ],
-    invertedIndex: configure.invertedIndex({
-      indexNullState: true,
-      indexPropertyLength: true,
-      indexTimestamps: true
-    })
-  };
-}
-function createGroupCollectionSchema(groupId) {
-  const collectionName = `Memory_groups_${groupId}`;
-  return {
-    name: collectionName,
-    description: `Group memory collection for group: ${groupId}`,
-    vectorizers: configure.vectorizer.text2VecOpenAI({
-      model: "text-embedding-3-small",
-      dimensions: 1536,
-      vectorizeCollectionName: false
-    }),
-    properties: [
-      ...COMMON_MEMORY_PROPERTIES,
-      ...PUBLISHED_MEMORY_PROPERTIES
-    ],
-    invertedIndex: configure.invertedIndex({
-      indexNullState: true,
-      indexPropertyLength: true,
-      indexTimestamps: true
-    })
-  };
-}
-async function reconcileCollectionProperties(client2, collectionName, expectedProperties) {
-  const collection = client2.collections.get(collectionName);
-  const config3 = await collection.config.get();
-  const existingNames = new Set(config3.properties.map((p) => p.name));
-  let added = 0;
-  for (const prop of expectedProperties) {
-    if (!existingNames.has(prop.name)) {
-      await collection.config.addProperty(prop);
-      added++;
-    }
-  }
-  return added;
-}
-async function ensureGroupCollection(client2, groupId) {
-  const collectionName = `Memory_groups_${groupId}`;
-  if (isCollectionCached(collectionName))
-    return false;
-  const exists = await client2.collections.exists(collectionName);
-  if (exists) {
-    await reconcileCollectionProperties(client2, collectionName, [...COMMON_MEMORY_PROPERTIES, ...PUBLISHED_MEMORY_PROPERTIES]);
-    cacheCollection(collectionName);
-    return false;
-  }
-  const schema = createGroupCollectionSchema(groupId);
-  await client2.collections.create(schema);
-  await registerCollection({
-    collection_name: collectionName,
-    collection_type: "groups",
-    owner_id: groupId,
-    created_at: (/* @__PURE__ */ new Date()).toISOString()
-  });
-  cacheCollection(collectionName);
-  return true;
-}
-
 // node_modules/@prmichaelsen/remember-core/dist/database/weaviate/space-schema.js
 var PUBLIC_COLLECTION_NAME = "Memory_spaces_public";
 function isValidSpaceId(spaceId) {
@@ -3146,14 +3246,18 @@ var SpaceService = class {
   userId;
   confirmationTokenService;
   logger;
+  memoryIndexService;
   moderationClient;
-  constructor(weaviateClient, userCollection, userId, confirmationTokenService, logger2, options) {
+  memoryIndex;
+  constructor(weaviateClient, userCollection, userId, confirmationTokenService, logger2, memoryIndexService2, options) {
     this.weaviateClient = weaviateClient;
     this.userCollection = userCollection;
     this.userId = userId;
     this.confirmationTokenService = confirmationTokenService;
     this.logger = logger2;
+    this.memoryIndexService = memoryIndexService2;
     this.moderationClient = options?.moderationClient;
+    this.memoryIndex = memoryIndexService2;
   }
   // ── Content moderation helper ────────────────────────────────────────
   async checkModeration(content) {
@@ -3404,7 +3508,7 @@ var SpaceService = class {
       }
       const combinedFilters = filterList.length > 0 ? Filters4.and(...filterList) : void 0;
       const spaceObjects = await this.executeSearch(spacesCollection, input.query, searchType, combinedFilters, fetchLimit);
-      allObjects.push(...spaceObjects);
+      allObjects.push(...tagWithSource(spaceObjects, spacesCollectionName));
     }
     for (const groupId of groups) {
       const groupCollectionName = getCollectionName(CollectionType.GROUPS, groupId);
@@ -3415,24 +3519,26 @@ var SpaceService = class {
       const filterList = this.buildBaseFilters(groupCollection, input);
       const combinedFilters = filterList.length > 0 ? Filters4.and(...filterList) : void 0;
       const groupObjects = await this.executeSearch(groupCollection, input.query, searchType, combinedFilters, fetchLimit);
-      allObjects.push(...groupObjects);
+      allObjects.push(...tagWithSource(groupObjects, groupCollectionName));
     }
     const seen = /* @__PURE__ */ new Set();
-    const deduplicated = allObjects.filter((obj) => {
+    const uuidDeduped = allObjects.filter((obj) => {
       if (seen.has(obj.uuid))
         return false;
       seen.add(obj.uuid);
       return true;
     });
-    deduplicated.sort((a, b) => {
+    const contentDeduped = dedupeBySourceId(uuidDeduped, input.dedupe);
+    contentDeduped.sort((a, b) => {
       const scoreA = a.metadata?.score ?? 0;
       const scoreB = b.metadata?.score ?? 0;
       return scoreB - scoreA;
     });
-    const paginated = deduplicated.slice(offset, offset + limit);
+    const paginated = contentDeduped.slice(offset, offset + limit);
     const memories = paginated.map((obj) => ({
       id: obj.uuid,
-      ...obj.properties
+      ...obj.properties,
+      ...obj._also_in?.length ? { also_in: obj._also_in } : {}
     }));
     const isAllPublic = spaces.length === 0 && groups.length === 0;
     return {
@@ -3551,7 +3657,8 @@ var SpaceService = class {
           discovery_count: 0,
           attribution: "user",
           moderation_status: spaceModerationStatus,
-          tags: mergedTags
+          tags: mergedTags,
+          original_memory_id: request.payload.memory_id
         };
         delete publishedMemory._additional;
         if (existingSpaceMemory) {
@@ -3559,6 +3666,11 @@ var SpaceService = class {
         } else {
           await publicCollection.data.insert({ id: weaviateId, properties: publishedMemory });
         }
+        try {
+          await this.memoryIndex.index(weaviateId, "Memory_spaces_public");
+        } catch (err2) {
+          this.logger.warn?.(`[SpaceService] Index write failed for ${weaviateId}: ${err2}`);
+        }
         successfulPublications.push(`spaces: ${spaces.join(", ")}`);
       } catch (err2) {
         failedPublications.push(`spaces: ${err2 instanceof Error ? err2.message : String(err2)}`);
@@ -3587,7 +3699,8 @@ var SpaceService = class {
           discovery_count: 0,
           attribution: "user",
           moderation_status: groupModerationStatus,
-          tags: mergedTags
+          tags: mergedTags,
+          original_memory_id: request.payload.memory_id
         };
         delete groupMemory._additional;
         if (existingGroupMemory) {
@@ -3595,6 +3708,11 @@ var SpaceService = class {
         } else {
           await groupCollection.data.insert({ id: weaviateId, properties: groupMemory });
         }
+        try {
+          await this.memoryIndex.index(weaviateId, groupCollectionName);
+        } catch (err2) {
+          this.logger.warn?.(`[SpaceService] Index write failed for ${weaviateId} in ${groupCollectionName}: ${err2}`);
+        }
         successfulPublications.push(`group: ${groupId}`);
       } catch (err2) {
         failedPublications.push(`group ${groupId}: ${err2 instanceof Error ? err2.message : String(err2)}`);
@@ -3835,6 +3953,39 @@ var REM_STATE_COLLECTION = `${BASE}.rem_state`;
 // node_modules/@prmichaelsen/remember-core/dist/services/rem.clustering.js
 import { Filters as Filters5 } from "weaviate-client";
 
+// node_modules/@prmichaelsen/remember-core/dist/services/memory-index.service.js
+var MemoryIndexService = class {
+  logger;
+  collectionPath;
+  constructor(logger2) {
+    this.logger = logger2;
+    this.collectionPath = getMemoryIndexPath();
+  }
+  /**
+   * Index a memory UUID → collection name mapping.
+   * Uses set() for idempotency (safe to re-index).
+   */
+  async index(memoryUuid, collectionName) {
+    const entry = {
+      collection_name: collectionName,
+      created_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await setDocument2(this.collectionPath, memoryUuid, entry);
+    this.logger.debug?.(`[MemoryIndex] Indexed ${memoryUuid} \u2192 ${collectionName}`);
+  }
+  /**
+   * Look up the collection name for a memory UUID.
+   * Returns null if the memory is not indexed.
+   */
+  async lookup(memoryUuid) {
+    const doc = await getDocument2(this.collectionPath, memoryUuid);
+    if (!doc)
+      return null;
+    const entry = doc;
+    return entry.collection_name ?? null;
+  }
+};
+
 // node_modules/@prmichaelsen/remember-core/dist/services/moderation.service.js
 import { createHash as createHash2 } from "crypto";
 function buildModerationPrompt(content) {
@@ -4057,6 +4208,7 @@ var coreLogger = createLogger("info");
 var tokenService = new ConfirmationTokenService(coreLogger);
 var preferencesService = new PreferencesDatabaseService(coreLogger);
 var moderationClient = process.env.ANTHROPIC_API_KEY ? createModerationClient({ apiKey: process.env.ANTHROPIC_API_KEY }) : void 0;
+var memoryIndexService = new MemoryIndexService(coreLogger);
 var coreServicesCache = /* @__PURE__ */ new Map();
 function createCoreServices(userId) {
   const cached = coreServicesCache.get(userId);
@@ -4065,9 +4217,12 @@ function createCoreServices(userId) {
   const collection = getMemoryCollection(userId);
   const weaviateClient = getWeaviateClient();
   const services = {
-    memory: new MemoryService(collection, userId, coreLogger),
+    memory: new MemoryService(collection, userId, coreLogger, {
+      memoryIndex: memoryIndexService,
+      weaviateClient
+    }),
     relationship: new RelationshipService(collection, userId, coreLogger),
-    space: new SpaceService(weaviateClient, collection, userId, tokenService, coreLogger, { moderationClient }),
+    space: new SpaceService(weaviateClient, collection, userId, tokenService, coreLogger, memoryIndexService, { moderationClient }),
     preferences: preferencesService,
     token: tokenService
   };