@prmichaelsen/remember-mcp 3.15.2 → 3.15.4

package/dist/server-factory.js

@@ -1397,6 +1397,24 @@ var ValidationError = class extends AppError {
     this.fields = fields;
   }
 };
+var NotFoundError = class extends AppError {
+  resource;
+  id;
+  kind = "not_found";
+  constructor(resource, id) {
+    super(`${resource} not found: ${id}`, { resource, id });
+    this.resource = resource;
+    this.id = id;
+  }
+};
+var ForbiddenError = class extends AppError {
+  requiredRole;
+  kind = "forbidden";
+  constructor(message = "Access denied", requiredRole) {
+    super(message, { requiredRole });
+    this.requiredRole = requiredRole;
+  }
+};
 
 // node_modules/@prmichaelsen/remember-core/node_modules/uuid/dist/esm/regex.js
 var regex_default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;
@@ -2313,6 +2331,38 @@ async function getSpaceConfig(id, type, logger2) {
 // node_modules/@prmichaelsen/remember-core/dist/services/memory.service.js
 import { Filters as Filters2 } from "weaviate-client";
 
+// node_modules/@prmichaelsen/remember-core/dist/services/discovery.js
+var DISCOVERY_RATIO = 4;
+var DISCOVERY_THRESHOLD = 5;
+function interleaveDiscovery(options) {
+  const { rated, discovery, ratio = DISCOVERY_RATIO, offset = 0, limit } = options;
+  const totalAvailable = rated.length + discovery.length;
+  if (totalAvailable === 0)
+    return [];
+  const merged = [];
+  let ratedIdx = 0;
+  let discoveryIdx = 0;
+  for (let pos = 0; pos < totalAvailable; pos++) {
+    const isDiscoverySlot = (pos + 1) % (ratio + 1) === 0;
+    if (isDiscoverySlot) {
+      if (discoveryIdx < discovery.length) {
+        merged.push({ item: discovery[discoveryIdx++], is_discovery: true });
+      } else if (ratedIdx < rated.length) {
+        merged.push({ item: rated[ratedIdx++], is_discovery: false });
+      }
+    } else {
+      if (ratedIdx < rated.length) {
+        merged.push({ item: rated[ratedIdx++], is_discovery: false });
+      } else if (discoveryIdx < discovery.length) {
+        merged.push({ item: discovery[discoveryIdx++], is_discovery: true });
+      }
+    }
+  }
+  const start = Math.min(offset, merged.length);
+  const end = limit !== void 0 ? Math.min(start + limit, merged.length) : merged.length;
+  return merged.slice(start, end);
+}
+
 // node_modules/@prmichaelsen/remember-core/dist/database/weaviate/client.js
 import weaviate2 from "weaviate-client";
 var ALL_MEMORY_PROPERTIES = [
@@ -2693,6 +2743,72 @@ var MemoryService = class {
       limit
     };
   }
+  // ── By Discovery (interleaved rated + unrated) ────────────────────
+  async byDiscovery(input) {
+    const limit = input.limit ?? 50;
+    const offset = input.offset ?? 0;
+    const memoryFilters = buildMemoryOnlyFilters(this.collection, input.filters);
+    const ghostFilters = [];
+    if (input.ghost_context) {
+      ghostFilters.push(buildTrustFilter(this.collection, input.ghost_context.accessor_trust_level));
+    }
+    if (!input.ghost_context?.include_ghost_content) {
+      ghostFilters.push(this.collection.filter.byProperty("content_type").notEqual("ghost"));
+    }
+    const buildBaseFilters = (useDeletedFilter) => {
+      const deletedFilter = useDeletedFilter ? buildDeletedFilter(this.collection, input.deleted_filter || "exclude") : null;
+      return [deletedFilter, memoryFilters, ...ghostFilters].filter((f) => f !== null);
+    };
+    const fetchLimit = (limit + offset) * 2;
+    const executeRated = async (useDeletedFilter) => {
+      const base = buildBaseFilters(useDeletedFilter);
+      base.push(this.collection.filter.byProperty("rating_count").greaterOrEqual(RATING_MIN_THRESHOLD));
+      const combinedFilters = combineFiltersWithAnd(base);
+      const queryOptions = {
+        limit: fetchLimit,
+        sort: this.collection.sort.byProperty("rating_bayesian", false)
+      };
+      if (combinedFilters)
+        queryOptions.filters = combinedFilters;
+      return this.collection.query.fetchObjects(queryOptions);
+    };
+    const executeDiscovery = async (useDeletedFilter) => {
+      const base = buildBaseFilters(useDeletedFilter);
+      base.push(this.collection.filter.byProperty("rating_count").lessThan(RATING_MIN_THRESHOLD));
+      const combinedFilters = combineFiltersWithAnd(base);
+      const queryOptions = {
+        limit: fetchLimit,
+        sort: this.collection.sort.byProperty("created_at", false)
+      };
+      if (combinedFilters)
+        queryOptions.filters = combinedFilters;
+      return this.collection.query.fetchObjects(queryOptions);
+    };
+    const [ratedResults, discoveryResults] = await Promise.all([
+      this.retryWithoutDeletedFilter(executeRated),
+      this.retryWithoutDeletedFilter(executeDiscovery)
+    ]);
+    const toDoc = (obj) => normalizeDoc({ id: obj.uuid, ...obj.properties });
+    const ratedDocs = ratedResults.objects.map(toDoc).filter((d) => d.doc_type === "memory");
+    const discoveryDocs = discoveryResults.objects.map(toDoc).filter((d) => d.doc_type === "memory");
+    const interleaved = interleaveDiscovery({
+      rated: ratedDocs,
+      discovery: discoveryDocs,
+      ratio: DISCOVERY_RATIO,
+      offset,
+      limit
+    });
+    const memories = interleaved.map((item) => {
+      const doc = item.item;
+      return Object.assign({}, doc, { is_discovery: item.is_discovery });
+    });
+    return {
+      memories,
+      total: memories.length,
+      offset,
+      limit
+    };
+  }
   // ── Find Similar (vector) ──────────────────────────────────────────
   async findSimilar(input) {
     if (!input.memory_id && !input.text)
@@ -3272,32 +3388,32 @@ var SpaceService = class {
     const spaces = input.spaces || [];
     const groups = input.groups || [];
     if (spaces.length === 0 && groups.length === 0) {
-      throw new Error("Must specify at least one space or group to publish to");
+      throw new ValidationError("Must specify at least one space or group to publish to");
     }
     if (spaces.length > 0) {
       const invalidSpaces = spaces.filter((s) => !isValidSpaceId(s));
       if (invalidSpaces.length > 0) {
-        throw new Error(`Invalid space IDs: ${invalidSpaces.join(", ")}`);
+        throw new ValidationError(`Invalid space IDs: ${invalidSpaces.join(", ")}`, { spaces: invalidSpaces });
       }
     }
     if (groups.length > 0) {
       const invalidGroups = groups.filter((g) => !g || g.includes(".") || g.trim() === "");
       if (invalidGroups.length > 0) {
-        throw new Error("Group IDs cannot be empty or contain dots");
+        throw new ValidationError("Group IDs cannot be empty or contain dots");
       }
     }
     const memory = await fetchMemoryWithAllProperties(this.userCollection, input.memory_id);
     if (!memory)
-      throw new Error(`Memory not found: ${input.memory_id}`);
+      throw new NotFoundError("Memory", input.memory_id);
     if (memory.properties.user_id !== this.userId)
-      throw new Error("Permission denied: not memory owner");
+      throw new ForbiddenError("Permission denied: not memory owner");
     if (memory.properties.doc_type !== "memory")
-      throw new Error("Only memories can be published");
+      throw new ValidationError("Only memories can be published");
     const memoryContentType = memory.properties.content_type;
     for (const spaceId of spaces) {
       const requiredType = SPACE_CONTENT_TYPE_RESTRICTIONS[spaceId];
       if (requiredType && memoryContentType !== requiredType) {
-        throw new Error(`Space '${spaceId}' only accepts content_type '${requiredType}', got '${memoryContentType ?? "undefined"}'`);
+        throw new ValidationError(`Space '${spaceId}' only accepts content_type '${requiredType}', got '${memoryContentType ?? "undefined"}'`);
       }
     }
     await this.checkModeration(memory.properties.content);
@@ -3320,25 +3436,25 @@ var SpaceService = class {
     const spaces = input.spaces || [];
     const groups = input.groups || [];
     if (spaces.length === 0 && groups.length === 0) {
-      throw new Error("Must specify at least one space or group to retract from");
+      throw new ValidationError("Must specify at least one space or group to retract from");
     }
     if (groups.length > 0) {
       const invalidGroups = groups.filter((g) => g.includes("."));
       if (invalidGroups.length > 0) {
-        throw new Error(`Group IDs cannot contain dots: ${invalidGroups.join(", ")}`);
+        throw new ValidationError(`Group IDs cannot contain dots: ${invalidGroups.join(", ")}`);
       }
     }
     const memory = await fetchMemoryWithAllProperties(this.userCollection, input.memory_id);
     if (!memory)
-      throw new Error(`Memory not found: ${input.memory_id}`);
+      throw new NotFoundError("Memory", input.memory_id);
     if (memory.properties.user_id !== this.userId)
-      throw new Error("Permission denied: not memory owner");
+      throw new ForbiddenError("Permission denied: not memory owner");
     const currentSpaceIds = Array.isArray(memory.properties.space_ids) ? memory.properties.space_ids : [];
     const currentGroupIds = Array.isArray(memory.properties.group_ids) ? memory.properties.group_ids : [];
     const notPublishedSpaces = spaces.filter((s) => !currentSpaceIds.includes(s));
     const notPublishedGroups = groups.filter((g) => !currentGroupIds.includes(g));
     if (notPublishedSpaces.length > 0 || notPublishedGroups.length > 0) {
-      throw new Error(`Memory is not published to some destinations. Not in spaces: [${notPublishedSpaces.join(", ")}], Not in groups: [${notPublishedGroups.join(", ")}]`);
+      throw new ValidationError(`Memory is not published to some destinations. Not in spaces: [${notPublishedSpaces.join(", ")}], Not in groups: [${notPublishedGroups.join(", ")}]`);
     }
     const { token } = await this.confirmationTokenService.createRequest(this.userId, "retract_memory", {
       memory_id: input.memory_id,
@@ -3359,13 +3475,13 @@ var SpaceService = class {
   async revise(input) {
     const memory = await fetchMemoryWithAllProperties(this.userCollection, input.memory_id);
     if (!memory)
-      throw new Error(`Memory not found: ${input.memory_id}`);
+      throw new NotFoundError("Memory", input.memory_id);
     if (memory.properties.user_id !== this.userId)
-      throw new Error("Permission denied: not memory owner");
+      throw new ForbiddenError("Permission denied: not memory owner");
     const spaceIds = Array.isArray(memory.properties.space_ids) ? memory.properties.space_ids : [];
     const groupIds = Array.isArray(memory.properties.group_ids) ? memory.properties.group_ids : [];
     if (spaceIds.length === 0 && groupIds.length === 0) {
-      throw new Error("Memory has no published copies to revise. Publish first with publish().");
+      throw new ValidationError("Memory has no published copies to revise. Publish first with publish().");
     }
     await this.checkModeration(memory.properties.content);
     const { token } = await this.confirmationTokenService.createRequest(this.userId, "revise_memory", {
@@ -3385,7 +3501,7 @@ var SpaceService = class {
   async confirm(input) {
     const request = await this.confirmationTokenService.confirmRequest(this.userId, input.token);
     if (!request) {
-      throw new Error("Invalid or expired confirmation token");
+      throw new ValidationError("Invalid or expired confirmation token");
     }
     if (request.action === "publish_memory") {
       return this.executePublish(request);
@@ -3396,31 +3512,31 @@ var SpaceService = class {
     if (request.action === "revise_memory") {
       return this.executeRevise(request);
     }
-    throw new Error(`Unknown action type: ${request.action}`);
+    throw new ValidationError(`Unknown action type: ${request.action}`);
   }
   // ── Deny ────────────────────────────────────────────────────────────
   async deny(input) {
     const success = await this.confirmationTokenService.denyRequest(this.userId, input.token);
     if (!success) {
-      throw new Error("Token not found or already used");
+      throw new NotFoundError("Token", input.token);
     }
     return { success: true };
   }
   // ── Moderate ────────────────────────────────────────────────────────
   async moderate(input, authContext) {
     if (!input.space_id && !input.group_id) {
-      throw new Error("Must specify either space_id or group_id");
+      throw new ValidationError("Must specify either space_id or group_id");
     }
     if (!ACTION_TO_STATUS[input.action]) {
-      throw new Error(`Invalid action: ${input.action}. Must be approve, reject, or remove`);
+      throw new ValidationError(`Invalid action: ${input.action}. Must be approve, reject, or remove`);
     }
     if (input.group_id) {
       if (!canModerate(authContext, input.group_id)) {
-        throw new Error(`Moderator access required for group ${input.group_id}`);
+        throw new ForbiddenError(`Moderator access required for group ${input.group_id}`);
       }
     } else if (input.space_id) {
       if (!canModerateAny(authContext)) {
-        throw new Error("Moderator access required to moderate memories in spaces");
+        throw new ForbiddenError("Moderator access required to moderate memories in spaces");
       }
     }
     let collection;
@@ -3432,8 +3548,7 @@ var SpaceService = class {
     }
     const memory = await fetchMemoryWithAllProperties(collection, input.memory_id);
     if (!memory) {
-      const location2 = input.group_id ? `group ${input.group_id}` : `space ${input.space_id}`;
-      throw new Error(`Published memory ${input.memory_id} not found in ${location2}`);
+      throw new NotFoundError("Published memory", input.memory_id);
     }
     const newStatus = ACTION_TO_STATUS[input.action];
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -3472,24 +3587,24 @@ var SpaceService = class {
     if (spaces.length > 0) {
       const invalidSpaces = spaces.filter((s) => !isValidSpaceId(s));
       if (invalidSpaces.length > 0) {
-        throw new Error(`Invalid space IDs: ${invalidSpaces.join(", ")}`);
+        throw new ValidationError(`Invalid space IDs: ${invalidSpaces.join(", ")}`, { spaces: invalidSpaces });
       }
     }
     if (groups.length > 0) {
       const invalidGroups = groups.filter((g) => !g || g.includes(".") || g.trim() === "");
       if (invalidGroups.length > 0) {
-        throw new Error("Group IDs cannot be empty or contain dots");
+        throw new ValidationError("Group IDs cannot be empty or contain dots");
       }
     }
     const moderationFilter = input.moderation_filter || "approved";
     if (moderationFilter !== "approved") {
       for (const groupId of groups) {
         if (!canModerate(authContext, groupId)) {
-          throw new Error(`Moderator access required to view ${moderationFilter} memories in group ${groupId}`);
+          throw new ForbiddenError(`Moderator access required to view ${moderationFilter} memories in group ${groupId}`);
         }
       }
       if ((spaces.length > 0 || groups.length === 0) && !canModerateAny(authContext)) {
-        throw new Error(`Moderator access required to view ${moderationFilter} memories in spaces`);
+        throw new ForbiddenError(`Moderator access required to view ${moderationFilter} memories in spaces`);
       }
     }
     const fetchLimit = (limit + offset) * Math.max(1, groups.length + (spaces.length > 0 || groups.length === 0 ? 1 : 0));
@@ -3549,16 +3664,16 @@ var SpaceService = class {
   // ── Query Space ─────────────────────────────────────────────────────
   async query(input, authContext) {
     if (!input.question?.trim())
-      throw new Error("Question cannot be empty");
+      throw new ValidationError("Question cannot be empty");
     if (input.spaces.length === 0)
-      throw new Error("Must specify at least one space to query");
+      throw new ValidationError("Must specify at least one space to query");
     const invalidSpaces = input.spaces.filter((s) => !isValidSpaceId(s));
     if (invalidSpaces.length > 0) {
-      throw new Error(`Invalid space IDs: ${invalidSpaces.join(", ")}`);
+      throw new ValidationError(`Invalid space IDs: ${invalidSpaces.join(", ")}`, { spaces: invalidSpaces });
     }
     const moderationFilterValue = input.moderation_filter || "approved";
     if (moderationFilterValue !== "approved" && !canModerateAny(authContext)) {
-      throw new Error(`Moderator access required to view ${moderationFilterValue} memories in spaces`);
+      throw new ForbiddenError(`Moderator access required to view ${moderationFilterValue} memories in spaces`);
     }
     const publicCollection = await ensurePublicCollection(this.weaviateClient);
     const filterList = [];
@@ -3609,13 +3724,13 @@ var SpaceService = class {
     const spaces = request.payload.spaces || [];
     const groups = request.payload.groups || [];
     if (spaces.length === 0 && groups.length === 0) {
-      throw new Error("No destinations in publish request");
+      throw new ValidationError("No destinations in publish request");
     }
     const originalMemory = await fetchMemoryWithAllProperties(this.userCollection, request.payload.memory_id);
     if (!originalMemory)
-      throw new Error(`Memory ${request.payload.memory_id} no longer exists`);
+      throw new NotFoundError("Memory", request.payload.memory_id);
     if (originalMemory.properties.user_id !== this.userId)
-      throw new Error("Permission denied");
+      throw new ForbiddenError("Permission denied");
     const compositeId = generateCompositeId(this.userId, request.payload.memory_id);
     const weaviateId = compositeIdToUuid(compositeId);
     const existingSpaceIds = Array.isArray(originalMemory.properties.space_ids) ? originalMemory.properties.space_ids : [];
@@ -3751,7 +3866,7 @@ var SpaceService = class {
     const groups = request.payload.groups || [];
     const sourceMemory = await fetchMemoryWithAllProperties(this.userCollection, request.payload.memory_id);
     if (!sourceMemory)
-      throw new Error(`Source memory ${request.payload.memory_id} no longer exists`);
+      throw new NotFoundError("Memory", request.payload.memory_id);
     const currentSpaceIds = Array.isArray(sourceMemory.properties.space_ids) ? sourceMemory.properties.space_ids : [];
     const currentGroupIds = Array.isArray(sourceMemory.properties.group_ids) ? sourceMemory.properties.group_ids : [];
     const compositeId = generateCompositeId(this.userId, request.payload.memory_id);
@@ -3831,9 +3946,9 @@ var SpaceService = class {
     const { memory_id, space_ids = [], group_ids = [] } = request.payload;
     const sourceMemory = await fetchMemoryWithAllProperties(this.userCollection, memory_id);
     if (!sourceMemory)
-      throw new Error(`Source memory ${memory_id} no longer exists`);
+      throw new NotFoundError("Memory", memory_id);
     if (sourceMemory.properties.user_id !== this.userId)
-      throw new Error("Permission denied");
+      throw new ForbiddenError("Permission denied");
     const newContent = String(sourceMemory.properties.content ?? "");
     const revisedAt = (/* @__PURE__ */ new Date()).toISOString();
     const compositeId = generateCompositeId(this.userId, memory_id);
@@ -3891,6 +4006,135 @@ var SpaceService = class {
       results
     };
   }
+  // ── By Discovery (interleaved rated + unrated for spaces/groups) ────
+  async byDiscovery(input, authContext) {
+    const spaces = input.spaces || [];
+    const groups = input.groups || [];
+    const limit = input.limit ?? 10;
+    const offset = input.offset ?? 0;
+    if (spaces.length > 0) {
+      const invalidSpaces = spaces.filter((s) => !isValidSpaceId(s));
+      if (invalidSpaces.length > 0) {
+        throw new ValidationError(`Invalid space IDs: ${invalidSpaces.join(", ")}`, { spaces: invalidSpaces });
+      }
+    }
+    if (groups.length > 0) {
+      const invalidGroups = groups.filter((g) => !g || g.includes(".") || g.trim() === "");
+      if (invalidGroups.length > 0) {
+        throw new ValidationError("Group IDs cannot be empty or contain dots");
+      }
+    }
+    const moderationFilter = input.moderation_filter || "approved";
+    if (moderationFilter !== "approved") {
+      for (const groupId of groups) {
+        if (!canModerate(authContext, groupId)) {
+          throw new ForbiddenError(`Moderator access required to view ${moderationFilter} memories in group ${groupId}`);
+        }
+      }
+      if ((spaces.length > 0 || groups.length === 0) && !canModerateAny(authContext)) {
+        throw new ForbiddenError(`Moderator access required to view ${moderationFilter} memories in spaces`);
+      }
+    }
+    const fetchLimit = (limit + offset) * 2;
+    const fetchPool = async (collection, baseFilters, ratingFilter, sortProp) => {
+      const allFilters = [...baseFilters, ratingFilter];
+      const combined = allFilters.length > 0 ? Filters4.and(...allFilters) : void 0;
+      const queryOptions = {
+        limit: fetchLimit,
+        sort: collection.sort.byProperty(sortProp, false)
+      };
+      if (combined)
+        queryOptions.filters = combined;
+      return (await collection.query.fetchObjects(queryOptions)).objects;
+    };
+    const searchInput = {
+      query: "",
+      // not used for filter building
+      spaces: input.spaces,
+      groups: input.groups,
+      content_type: input.content_type,
+      tags: input.tags,
+      min_weight: input.min_weight,
+      max_weight: input.max_weight,
+      date_from: input.date_from,
+      date_to: input.date_to,
+      moderation_filter: input.moderation_filter,
+      include_comments: input.include_comments
+    };
+    const allRated = [];
+    const allDiscovery = [];
+    if (spaces.length > 0 || groups.length === 0) {
+      await ensurePublicCollection(this.weaviateClient);
+      const spacesCollectionName = getCollectionName(CollectionType.SPACES);
+      const spacesCollection = this.weaviateClient.collections.get(spacesCollectionName);
+      const baseFilters = this.buildBaseFilters(spacesCollection, searchInput);
+      if (spaces.length > 0) {
+        baseFilters.push(spacesCollection.filter.byProperty("space_ids").containsAny(spaces));
+      }
+      const ratedFilter = spacesCollection.filter.byProperty("rating_count").greaterOrEqual(DISCOVERY_THRESHOLD);
+      const discoveryFilter = spacesCollection.filter.byProperty("rating_count").lessThan(DISCOVERY_THRESHOLD);
+      const [rated, discovery] = await Promise.all([
+        fetchPool(spacesCollection, baseFilters, ratedFilter, "rating_bayesian"),
+        fetchPool(spacesCollection, baseFilters, discoveryFilter, "created_at")
+      ]);
+      allRated.push(...tagWithSource(rated, spacesCollectionName));
+      allDiscovery.push(...tagWithSource(discovery, spacesCollectionName));
+    }
+    for (const groupId of groups) {
+      const groupCollectionName = getCollectionName(CollectionType.GROUPS, groupId);
+      const exists = await this.weaviateClient.collections.exists(groupCollectionName);
+      if (!exists)
+        continue;
+      const groupCollection = this.weaviateClient.collections.get(groupCollectionName);
+      const baseFilters = this.buildBaseFilters(groupCollection, searchInput);
+      const ratedFilter = groupCollection.filter.byProperty("rating_count").greaterOrEqual(DISCOVERY_THRESHOLD);
+      const discoveryFilter = groupCollection.filter.byProperty("rating_count").lessThan(DISCOVERY_THRESHOLD);
+      const [rated, discovery] = await Promise.all([
+        fetchPool(groupCollection, baseFilters, ratedFilter, "rating_bayesian"),
+        fetchPool(groupCollection, baseFilters, discoveryFilter, "created_at")
+      ]);
+      allRated.push(...tagWithSource(rated, groupCollectionName));
+      allDiscovery.push(...tagWithSource(discovery, groupCollectionName));
+    }
+    const dedupePool = (pool) => {
+      const seen = /* @__PURE__ */ new Set();
+      return pool.filter((obj) => {
+        if (seen.has(obj.uuid))
+          return false;
+        seen.add(obj.uuid);
+        return true;
+      });
+    };
+    const ratedDeduped = dedupeBySourceId(dedupePool(allRated), input.dedupe);
+    const discoveryDeduped = dedupeBySourceId(dedupePool(allDiscovery), input.dedupe);
+    const toDoc = (obj) => ({
+      id: obj.uuid,
+      ...obj.properties,
+      ...obj._also_in?.length ? { also_in: obj._also_in } : {}
+    });
+    const ratedDocs = ratedDeduped.map(toDoc);
+    const discoveryDocs = discoveryDeduped.map(toDoc);
+    const interleaved = interleaveDiscovery({
+      rated: ratedDocs,
+      discovery: discoveryDocs,
+      ratio: DISCOVERY_RATIO,
+      offset,
+      limit
+    });
+    const memories = interleaved.map((item) => {
+      const doc = item.item;
+      return Object.assign({}, doc, { is_discovery: item.is_discovery });
+    });
+    const isAllPublic = spaces.length === 0 && groups.length === 0;
+    return {
+      spaces_searched: isAllPublic ? "all_public" : spaces,
+      groups_searched: groups,
+      memories,
+      total: memories.length,
+      offset,
+      limit
+    };
+  }
   // ── Private: Build Base Filters ─────────────────────────────────────
   buildBaseFilters(collection, input) {
     const filterList = [];
@@ -3928,6 +4172,10 @@ var SpaceService = class {
     const opts = { limit };
     if (filters)
       opts.filters = filters;
+    const isWildcard = !query.trim() || query === "*";
+    if (isWildcard) {
+      return (await collection.query.bm25("*", opts)).objects;
+    }
     switch (searchType) {
       case "bm25":
         return (await collection.query.bm25(query, opts)).objects;
@@ -4030,10 +4278,13 @@ Content to evaluate:
 ${content}
 ---
 
-Respond with ONLY valid JSON:
-{"pass":true}
-OR
-{"pass":false,"reason":"<specific, human-friendly explanation of why this was blocked>","category":"<hate_speech|extremism|violence_incitement|csam|self_harm_encouragement>"}`;
+\u{1F6A8} CRITICAL \u{1F6A8}:
+Respond with ONLY a single JSON object on one line \u2014 no markdown, no explanation, no code fences.
+
+If the content passes: {"pass":true,"reason":"<brief reason>"}
+If the content fails: {"pass":false,"reason":"<specific explanation>","category":"<hate_speech|extremism|violence_incitement|csam|self_harm_encouragement>"}
+
+Your entire response must be parseable by JSON.parse(). Do not include any other text.`;
 }
 var DEFAULT_CACHE_MAX = 1e3;
 function hashContent(content) {
@@ -4060,14 +4311,21 @@ function createModerationClient(options) {
           body: JSON.stringify({
             model,
             max_tokens: 256,
-            messages: [{ role: "user", content: buildModerationPrompt(content) }]
+            temperature: 0,
+            messages: [
+              { role: "user", content: buildModerationPrompt(content) },
+              { role: "assistant", content: "{" }
+            ]
           })
         });
         if (!response.ok) {
+          const errorBody = await response.text().catch(() => "");
+          console.error(`[moderation] Anthropic API error: ${response.status} ${response.statusText}`, errorBody);
           return { pass: false, reason: "Content moderation unavailable. Please try again later." };
         }
         const data = await response.json();
-        const text = data.content?.[0]?.text ?? "";
+        const rawText = data.content?.[0]?.text ?? "";
+        const text = ("{" + rawText).replace(/^```(?:json)?\s*\n?/i, "").replace(/\n?```\s*$/i, "").trim();
         const parsed = JSON.parse(text);
         const result = {
           pass: parsed.pass === true,
@@ -4080,7 +4338,8 @@ function createModerationClient(options) {
         }
         cache.set(hash, result);
         return result;
-      } catch {
+      } catch (err2) {
+        console.error("[moderation] Unexpected error:", err2);
         return { pass: false, reason: "Content moderation unavailable. Please try again later." };
       }
     }

package/dist/server.js

@@ -1401,6 +1401,24 @@ var ValidationError = class extends AppError {
     this.fields = fields;
   }
 };
+var NotFoundError = class extends AppError {
+  resource;
+  id;
+  kind = "not_found";
+  constructor(resource, id) {
+    super(`${resource} not found: ${id}`, { resource, id });
+    this.resource = resource;
+    this.id = id;
+  }
+};
+var ForbiddenError = class extends AppError {
+  requiredRole;
+  kind = "forbidden";
+  constructor(message = "Access denied", requiredRole) {
+    super(message, { requiredRole });
+    this.requiredRole = requiredRole;
+  }
+};
 
 // node_modules/@prmichaelsen/remember-core/node_modules/uuid/dist/esm/regex.js
 var regex_default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;
@@ -2317,6 +2335,38 @@ async function getSpaceConfig(id, type, logger2) {
 // node_modules/@prmichaelsen/remember-core/dist/services/memory.service.js
 import { Filters as Filters2 } from "weaviate-client";
 
+// node_modules/@prmichaelsen/remember-core/dist/services/discovery.js
+var DISCOVERY_RATIO = 4;
+var DISCOVERY_THRESHOLD = 5;
+function interleaveDiscovery(options) {
+  const { rated, discovery, ratio = DISCOVERY_RATIO, offset = 0, limit } = options;
+  const totalAvailable = rated.length + discovery.length;
+  if (totalAvailable === 0)
+    return [];
+  const merged = [];
+  let ratedIdx = 0;
+  let discoveryIdx = 0;
+  for (let pos = 0; pos < totalAvailable; pos++) {
+    const isDiscoverySlot = (pos + 1) % (ratio + 1) === 0;
+    if (isDiscoverySlot) {
+      if (discoveryIdx < discovery.length) {
+        merged.push({ item: discovery[discoveryIdx++], is_discovery: true });
+      } else if (ratedIdx < rated.length) {
+        merged.push({ item: rated[ratedIdx++], is_discovery: false });
+      }
+    } else {
+      if (ratedIdx < rated.length) {
+        merged.push({ item: rated[ratedIdx++], is_discovery: false });
+      } else if (discoveryIdx < discovery.length) {
+        merged.push({ item: discovery[discoveryIdx++], is_discovery: true });
+      }
+    }
+  }
+  const start = Math.min(offset, merged.length);
+  const end = limit !== void 0 ? Math.min(start + limit, merged.length) : merged.length;
+  return merged.slice(start, end);
+}
+
 // node_modules/@prmichaelsen/remember-core/dist/database/weaviate/client.js
 import weaviate2 from "weaviate-client";
 var ALL_MEMORY_PROPERTIES = [
@@ -2697,6 +2747,72 @@ var MemoryService = class {
       limit
     };
   }
+  // ── By Discovery (interleaved rated + unrated) ────────────────────
+  async byDiscovery(input) {
+    const limit = input.limit ?? 50;
+    const offset = input.offset ?? 0;
+    const memoryFilters = buildMemoryOnlyFilters(this.collection, input.filters);
+    const ghostFilters = [];
+    if (input.ghost_context) {
+      ghostFilters.push(buildTrustFilter(this.collection, input.ghost_context.accessor_trust_level));
+    }
+    if (!input.ghost_context?.include_ghost_content) {
+      ghostFilters.push(this.collection.filter.byProperty("content_type").notEqual("ghost"));
+    }
+    const buildBaseFilters = (useDeletedFilter) => {
+      const deletedFilter = useDeletedFilter ? buildDeletedFilter(this.collection, input.deleted_filter || "exclude") : null;
+      return [deletedFilter, memoryFilters, ...ghostFilters].filter((f) => f !== null);
+    };
+    const fetchLimit = (limit + offset) * 2;
+    const executeRated = async (useDeletedFilter) => {
+      const base = buildBaseFilters(useDeletedFilter);
+      base.push(this.collection.filter.byProperty("rating_count").greaterOrEqual(RATING_MIN_THRESHOLD));
+      const combinedFilters = combineFiltersWithAnd(base);
+      const queryOptions = {
+        limit: fetchLimit,
+        sort: this.collection.sort.byProperty("rating_bayesian", false)
+      };
+      if (combinedFilters)
+        queryOptions.filters = combinedFilters;
+      return this.collection.query.fetchObjects(queryOptions);
+    };
+    const executeDiscovery = async (useDeletedFilter) => {
+      const base = buildBaseFilters(useDeletedFilter);
+      base.push(this.collection.filter.byProperty("rating_count").lessThan(RATING_MIN_THRESHOLD));
+      const combinedFilters = combineFiltersWithAnd(base);
+      const queryOptions = {
+        limit: fetchLimit,
+        sort: this.collection.sort.byProperty("created_at", false)
+      };
+      if (combinedFilters)
+        queryOptions.filters = combinedFilters;
+      return this.collection.query.fetchObjects(queryOptions);
+    };
+    const [ratedResults, discoveryResults] = await Promise.all([
+      this.retryWithoutDeletedFilter(executeRated),
+      this.retryWithoutDeletedFilter(executeDiscovery)
+    ]);
+    const toDoc = (obj) => normalizeDoc({ id: obj.uuid, ...obj.properties });
+    const ratedDocs = ratedResults.objects.map(toDoc).filter((d) => d.doc_type === "memory");
+    const discoveryDocs = discoveryResults.objects.map(toDoc).filter((d) => d.doc_type === "memory");
+    const interleaved = interleaveDiscovery({
+      rated: ratedDocs,
+      discovery: discoveryDocs,
+      ratio: DISCOVERY_RATIO,
+      offset,
+      limit
+    });
+    const memories = interleaved.map((item) => {
+      const doc = item.item;
+      return Object.assign({}, doc, { is_discovery: item.is_discovery });
+    });
+    return {
+      memories,
+      total: memories.length,
+      offset,
+      limit
+    };
+  }
   // ── Find Similar (vector) ──────────────────────────────────────────
   async findSimilar(input) {
     if (!input.memory_id && !input.text)
@@ -3276,32 +3392,32 @@ var SpaceService = class {
     const spaces = input.spaces || [];
     const groups = input.groups || [];
     if (spaces.length === 0 && groups.length === 0) {
-      throw new Error("Must specify at least one space or group to publish to");
+      throw new ValidationError("Must specify at least one space or group to publish to");
     }
     if (spaces.length > 0) {
       const invalidSpaces = spaces.filter((s) => !isValidSpaceId(s));
       if (invalidSpaces.length > 0) {
-        throw new Error(`Invalid space IDs: ${invalidSpaces.join(", ")}`);
+        throw new ValidationError(`Invalid space IDs: ${invalidSpaces.join(", ")}`, { spaces: invalidSpaces });
       }
     }
     if (groups.length > 0) {
       const invalidGroups = groups.filter((g) => !g || g.includes(".") || g.trim() === "");
       if (invalidGroups.length > 0) {
-        throw new Error("Group IDs cannot be empty or contain dots");
+        throw new ValidationError("Group IDs cannot be empty or contain dots");
       }
     }
     const memory = await fetchMemoryWithAllProperties(this.userCollection, input.memory_id);
     if (!memory)
-      throw new Error(`Memory not found: ${input.memory_id}`);
+      throw new NotFoundError("Memory", input.memory_id);
     if (memory.properties.user_id !== this.userId)
-      throw new Error("Permission denied: not memory owner");
+      throw new ForbiddenError("Permission denied: not memory owner");
     if (memory.properties.doc_type !== "memory")
-      throw new Error("Only memories can be published");
+      throw new ValidationError("Only memories can be published");
     const memoryContentType = memory.properties.content_type;
     for (const spaceId of spaces) {
       const requiredType = SPACE_CONTENT_TYPE_RESTRICTIONS[spaceId];
       if (requiredType && memoryContentType !== requiredType) {
-        throw new Error(`Space '${spaceId}' only accepts content_type '${requiredType}', got '${memoryContentType ?? "undefined"}'`);
+        throw new ValidationError(`Space '${spaceId}' only accepts content_type '${requiredType}', got '${memoryContentType ?? "undefined"}'`);
       }
     }
     await this.checkModeration(memory.properties.content);
@@ -3324,25 +3440,25 @@ var SpaceService = class {
     const spaces = input.spaces || [];
     const groups = input.groups || [];
     if (spaces.length === 0 && groups.length === 0) {
-      throw new Error("Must specify at least one space or group to retract from");
+      throw new ValidationError("Must specify at least one space or group to retract from");
     }
     if (groups.length > 0) {
       const invalidGroups = groups.filter((g) => g.includes("."));
       if (invalidGroups.length > 0) {
-        throw new Error(`Group IDs cannot contain dots: ${invalidGroups.join(", ")}`);
+        throw new ValidationError(`Group IDs cannot contain dots: ${invalidGroups.join(", ")}`);
       }
     }
     const memory = await fetchMemoryWithAllProperties(this.userCollection, input.memory_id);
     if (!memory)
-      throw new Error(`Memory not found: ${input.memory_id}`);
+      throw new NotFoundError("Memory", input.memory_id);
     if (memory.properties.user_id !== this.userId)
-      throw new Error("Permission denied: not memory owner");
+      throw new ForbiddenError("Permission denied: not memory owner");
     const currentSpaceIds = Array.isArray(memory.properties.space_ids) ? memory.properties.space_ids : [];
     const currentGroupIds = Array.isArray(memory.properties.group_ids) ? memory.properties.group_ids : [];
     const notPublishedSpaces = spaces.filter((s) => !currentSpaceIds.includes(s));
     const notPublishedGroups = groups.filter((g) => !currentGroupIds.includes(g));
     if (notPublishedSpaces.length > 0 || notPublishedGroups.length > 0) {
-      throw new Error(`Memory is not published to some destinations. Not in spaces: [${notPublishedSpaces.join(", ")}], Not in groups: [${notPublishedGroups.join(", ")}]`);
+      throw new ValidationError(`Memory is not published to some destinations. Not in spaces: [${notPublishedSpaces.join(", ")}], Not in groups: [${notPublishedGroups.join(", ")}]`);
     }
     const { token } = await this.confirmationTokenService.createRequest(this.userId, "retract_memory", {
       memory_id: input.memory_id,
@@ -3363,13 +3479,13 @@ var SpaceService = class {
   async revise(input) {
     const memory = await fetchMemoryWithAllProperties(this.userCollection, input.memory_id);
     if (!memory)
-      throw new Error(`Memory not found: ${input.memory_id}`);
+      throw new NotFoundError("Memory", input.memory_id);
     if (memory.properties.user_id !== this.userId)
-      throw new Error("Permission denied: not memory owner");
+      throw new ForbiddenError("Permission denied: not memory owner");
     const spaceIds = Array.isArray(memory.properties.space_ids) ? memory.properties.space_ids : [];
     const groupIds = Array.isArray(memory.properties.group_ids) ? memory.properties.group_ids : [];
     if (spaceIds.length === 0 && groupIds.length === 0) {
-      throw new Error("Memory has no published copies to revise. Publish first with publish().");
+      throw new ValidationError("Memory has no published copies to revise. Publish first with publish().");
     }
     await this.checkModeration(memory.properties.content);
     const { token } = await this.confirmationTokenService.createRequest(this.userId, "revise_memory", {
@@ -3389,7 +3505,7 @@ var SpaceService = class {
   async confirm(input) {
     const request = await this.confirmationTokenService.confirmRequest(this.userId, input.token);
     if (!request) {
-      throw new Error("Invalid or expired confirmation token");
+      throw new ValidationError("Invalid or expired confirmation token");
     }
     if (request.action === "publish_memory") {
       return this.executePublish(request);
@@ -3400,31 +3516,31 @@ var SpaceService = class {
     if (request.action === "revise_memory") {
       return this.executeRevise(request);
     }
-    throw new Error(`Unknown action type: ${request.action}`);
+    throw new ValidationError(`Unknown action type: ${request.action}`);
   }
   // ── Deny ────────────────────────────────────────────────────────────
   async deny(input) {
     const success = await this.confirmationTokenService.denyRequest(this.userId, input.token);
     if (!success) {
-      throw new Error("Token not found or already used");
+      throw new NotFoundError("Token", input.token);
     }
     return { success: true };
   }
   // ── Moderate ────────────────────────────────────────────────────────
   async moderate(input, authContext) {
     if (!input.space_id && !input.group_id) {
-      throw new Error("Must specify either space_id or group_id");
+      throw new ValidationError("Must specify either space_id or group_id");
     }
     if (!ACTION_TO_STATUS[input.action]) {
-      throw new Error(`Invalid action: ${input.action}. Must be approve, reject, or remove`);
+      throw new ValidationError(`Invalid action: ${input.action}. Must be approve, reject, or remove`);
     }
     if (input.group_id) {
       if (!canModerate(authContext, input.group_id)) {
-        throw new Error(`Moderator access required for group ${input.group_id}`);
+        throw new ForbiddenError(`Moderator access required for group ${input.group_id}`);
       }
     } else if (input.space_id) {
       if (!canModerateAny(authContext)) {
-        throw new Error("Moderator access required to moderate memories in spaces");
+        throw new ForbiddenError("Moderator access required to moderate memories in spaces");
       }
     }
     let collection;
@@ -3436,8 +3552,7 @@ var SpaceService = class {
     }
     const memory = await fetchMemoryWithAllProperties(collection, input.memory_id);
     if (!memory) {
-      const location2 = input.group_id ? `group ${input.group_id}` : `space ${input.space_id}`;
-      throw new Error(`Published memory ${input.memory_id} not found in ${location2}`);
+      throw new NotFoundError("Published memory", input.memory_id);
     }
     const newStatus = ACTION_TO_STATUS[input.action];
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -3476,24 +3591,24 @@ var SpaceService = class {
     if (spaces.length > 0) {
       const invalidSpaces = spaces.filter((s) => !isValidSpaceId(s));
       if (invalidSpaces.length > 0) {
-        throw new Error(`Invalid space IDs: ${invalidSpaces.join(", ")}`);
+        throw new ValidationError(`Invalid space IDs: ${invalidSpaces.join(", ")}`, { spaces: invalidSpaces });
       }
     }
     if (groups.length > 0) {
       const invalidGroups = groups.filter((g) => !g || g.includes(".") || g.trim() === "");
       if (invalidGroups.length > 0) {
-        throw new Error("Group IDs cannot be empty or contain dots");
+        throw new ValidationError("Group IDs cannot be empty or contain dots");
       }
     }
     const moderationFilter = input.moderation_filter || "approved";
     if (moderationFilter !== "approved") {
       for (const groupId of groups) {
         if (!canModerate(authContext, groupId)) {
-          throw new Error(`Moderator access required to view ${moderationFilter} memories in group ${groupId}`);
+          throw new ForbiddenError(`Moderator access required to view ${moderationFilter} memories in group ${groupId}`);
         }
       }
       if ((spaces.length > 0 || groups.length === 0) && !canModerateAny(authContext)) {
-        throw new Error(`Moderator access required to view ${moderationFilter} memories in spaces`);
+        throw new ForbiddenError(`Moderator access required to view ${moderationFilter} memories in spaces`);
       }
     }
     const fetchLimit = (limit + offset) * Math.max(1, groups.length + (spaces.length > 0 || groups.length === 0 ? 1 : 0));
@@ -3553,16 +3668,16 @@ var SpaceService = class {
   // ── Query Space ─────────────────────────────────────────────────────
   async query(input, authContext) {
     if (!input.question?.trim())
-      throw new Error("Question cannot be empty");
+      throw new ValidationError("Question cannot be empty");
     if (input.spaces.length === 0)
-      throw new Error("Must specify at least one space to query");
+      throw new ValidationError("Must specify at least one space to query");
     const invalidSpaces = input.spaces.filter((s) => !isValidSpaceId(s));
     if (invalidSpaces.length > 0) {
-      throw new Error(`Invalid space IDs: ${invalidSpaces.join(", ")}`);
+      throw new ValidationError(`Invalid space IDs: ${invalidSpaces.join(", ")}`, { spaces: invalidSpaces });
     }
     const moderationFilterValue = input.moderation_filter || "approved";
     if (moderationFilterValue !== "approved" && !canModerateAny(authContext)) {
-      throw new Error(`Moderator access required to view ${moderationFilterValue} memories in spaces`);
+      throw new ForbiddenError(`Moderator access required to view ${moderationFilterValue} memories in spaces`);
     }
     const publicCollection = await ensurePublicCollection(this.weaviateClient);
     const filterList = [];
@@ -3613,13 +3728,13 @@ var SpaceService = class {
     const spaces = request.payload.spaces || [];
     const groups = request.payload.groups || [];
     if (spaces.length === 0 && groups.length === 0) {
-      throw new Error("No destinations in publish request");
+      throw new ValidationError("No destinations in publish request");
     }
     const originalMemory = await fetchMemoryWithAllProperties(this.userCollection, request.payload.memory_id);
     if (!originalMemory)
-      throw new Error(`Memory ${request.payload.memory_id} no longer exists`);
+      throw new NotFoundError("Memory", request.payload.memory_id);
     if (originalMemory.properties.user_id !== this.userId)
-      throw new Error("Permission denied");
+      throw new ForbiddenError("Permission denied");
     const compositeId = generateCompositeId(this.userId, request.payload.memory_id);
     const weaviateId = compositeIdToUuid(compositeId);
     const existingSpaceIds = Array.isArray(originalMemory.properties.space_ids) ? originalMemory.properties.space_ids : [];
@@ -3755,7 +3870,7 @@ var SpaceService = class {
     const groups = request.payload.groups || [];
     const sourceMemory = await fetchMemoryWithAllProperties(this.userCollection, request.payload.memory_id);
     if (!sourceMemory)
-      throw new Error(`Source memory ${request.payload.memory_id} no longer exists`);
+      throw new NotFoundError("Memory", request.payload.memory_id);
     const currentSpaceIds = Array.isArray(sourceMemory.properties.space_ids) ? sourceMemory.properties.space_ids : [];
     const currentGroupIds = Array.isArray(sourceMemory.properties.group_ids) ? sourceMemory.properties.group_ids : [];
     const compositeId = generateCompositeId(this.userId, request.payload.memory_id);
@@ -3835,9 +3950,9 @@ var SpaceService = class {
     const { memory_id, space_ids = [], group_ids = [] } = request.payload;
     const sourceMemory = await fetchMemoryWithAllProperties(this.userCollection, memory_id);
     if (!sourceMemory)
-      throw new Error(`Source memory ${memory_id} no longer exists`);
+      throw new NotFoundError("Memory", memory_id);
     if (sourceMemory.properties.user_id !== this.userId)
-      throw new Error("Permission denied");
+      throw new ForbiddenError("Permission denied");
     const newContent = String(sourceMemory.properties.content ?? "");
     const revisedAt = (/* @__PURE__ */ new Date()).toISOString();
     const compositeId = generateCompositeId(this.userId, memory_id);
@@ -3895,6 +4010,135 @@ var SpaceService = class {
       results
     };
   }
+  // ── By Discovery (interleaved rated + unrated for spaces/groups) ────
+  async byDiscovery(input, authContext) {
+    const spaces = input.spaces || [];
+    const groups = input.groups || [];
+    const limit = input.limit ?? 10;
+    const offset = input.offset ?? 0;
+    if (spaces.length > 0) {
+      const invalidSpaces = spaces.filter((s) => !isValidSpaceId(s));
+      if (invalidSpaces.length > 0) {
+        throw new ValidationError(`Invalid space IDs: ${invalidSpaces.join(", ")}`, { spaces: invalidSpaces });
+      }
+    }
+    if (groups.length > 0) {
+      const invalidGroups = groups.filter((g) => !g || g.includes(".") || g.trim() === "");
+      if (invalidGroups.length > 0) {
+        throw new ValidationError("Group IDs cannot be empty or contain dots");
+      }
+    }
+    const moderationFilter = input.moderation_filter || "approved";
+    if (moderationFilter !== "approved") {
+      for (const groupId of groups) {
+        if (!canModerate(authContext, groupId)) {
+          throw new ForbiddenError(`Moderator access required to view ${moderationFilter} memories in group ${groupId}`);
+        }
+      }
+      if ((spaces.length > 0 || groups.length === 0) && !canModerateAny(authContext)) {
+        throw new ForbiddenError(`Moderator access required to view ${moderationFilter} memories in spaces`);
+      }
+    }
+    const fetchLimit = (limit + offset) * 2;
+    const fetchPool = async (collection, baseFilters, ratingFilter, sortProp) => {
+      const allFilters = [...baseFilters, ratingFilter];
+      const combined = allFilters.length > 0 ? Filters4.and(...allFilters) : void 0;
+      const queryOptions = {
+        limit: fetchLimit,
+        sort: collection.sort.byProperty(sortProp, false)
+      };
+      if (combined)
+        queryOptions.filters = combined;
+      return (await collection.query.fetchObjects(queryOptions)).objects;
+    };
+    const searchInput = {
+      query: "",
+      // not used for filter building
+      spaces: input.spaces,
+      groups: input.groups,
+      content_type: input.content_type,
+      tags: input.tags,
+      min_weight: input.min_weight,
+      max_weight: input.max_weight,
+      date_from: input.date_from,
+      date_to: input.date_to,
+      moderation_filter: input.moderation_filter,
+      include_comments: input.include_comments
+    };
+    const allRated = [];
+    const allDiscovery = [];
+    if (spaces.length > 0 || groups.length === 0) {
+      await ensurePublicCollection(this.weaviateClient);
+      const spacesCollectionName = getCollectionName(CollectionType.SPACES);
+      const spacesCollection = this.weaviateClient.collections.get(spacesCollectionName);
+      const baseFilters = this.buildBaseFilters(spacesCollection, searchInput);
+      if (spaces.length > 0) {
+        baseFilters.push(spacesCollection.filter.byProperty("space_ids").containsAny(spaces));
+      }
+      const ratedFilter = spacesCollection.filter.byProperty("rating_count").greaterOrEqual(DISCOVERY_THRESHOLD);
+      const discoveryFilter = spacesCollection.filter.byProperty("rating_count").lessThan(DISCOVERY_THRESHOLD);
+      const [rated, discovery] = await Promise.all([
+        fetchPool(spacesCollection, baseFilters, ratedFilter, "rating_bayesian"),
+        fetchPool(spacesCollection, baseFilters, discoveryFilter, "created_at")
+      ]);
+      allRated.push(...tagWithSource(rated, spacesCollectionName));
+      allDiscovery.push(...tagWithSource(discovery, spacesCollectionName));
+    }
+    for (const groupId of groups) {
+      const groupCollectionName = getCollectionName(CollectionType.GROUPS, groupId);
+      const exists = await this.weaviateClient.collections.exists(groupCollectionName);
+      if (!exists)
+        continue;
+      const groupCollection = this.weaviateClient.collections.get(groupCollectionName);
+      const baseFilters = this.buildBaseFilters(groupCollection, searchInput);
+      const ratedFilter = groupCollection.filter.byProperty("rating_count").greaterOrEqual(DISCOVERY_THRESHOLD);
+      const discoveryFilter = groupCollection.filter.byProperty("rating_count").lessThan(DISCOVERY_THRESHOLD);
+      const [rated, discovery] = await Promise.all([
+        fetchPool(groupCollection, baseFilters, ratedFilter, "rating_bayesian"),
+        fetchPool(groupCollection, baseFilters, discoveryFilter, "created_at")
+      ]);
+      allRated.push(...tagWithSource(rated, groupCollectionName));
+      allDiscovery.push(...tagWithSource(discovery, groupCollectionName));
+    }
+    const dedupePool = (pool) => {
+      const seen = /* @__PURE__ */ new Set();
+      return pool.filter((obj) => {
+        if (seen.has(obj.uuid))
+          return false;
+        seen.add(obj.uuid);
+        return true;
+      });
+    };
+    const ratedDeduped = dedupeBySourceId(dedupePool(allRated), input.dedupe);
+    const discoveryDeduped = dedupeBySourceId(dedupePool(allDiscovery), input.dedupe);
+    const toDoc = (obj) => ({
+      id: obj.uuid,
+      ...obj.properties,
+      ...obj._also_in?.length ? { also_in: obj._also_in } : {}
+    });
+    const ratedDocs = ratedDeduped.map(toDoc);
+    const discoveryDocs = discoveryDeduped.map(toDoc);
+    const interleaved = interleaveDiscovery({
+      rated: ratedDocs,
+      discovery: discoveryDocs,
+      ratio: DISCOVERY_RATIO,
+      offset,
+      limit
+    });
+    const memories = interleaved.map((item) => {
+      const doc = item.item;
+      return Object.assign({}, doc, { is_discovery: item.is_discovery });
+    });
+    const isAllPublic = spaces.length === 0 && groups.length === 0;
+    return {
+      spaces_searched: isAllPublic ? "all_public" : spaces,
+      groups_searched: groups,
+      memories,
+      total: memories.length,
+      offset,
+      limit
+    };
+  }
   // ── Private: Build Base Filters ─────────────────────────────────────
   buildBaseFilters(collection, input) {
     const filterList = [];
@@ -3932,6 +4176,10 @@ var SpaceService = class {
     const opts = { limit };
     if (filters)
       opts.filters = filters;
+    const isWildcard = !query.trim() || query === "*";
+    if (isWildcard) {
+      return (await collection.query.bm25("*", opts)).objects;
+    }
     switch (searchType) {
       case "bm25":
         return (await collection.query.bm25(query, opts)).objects;
@@ -4034,10 +4282,13 @@ Content to evaluate:
 ${content}
 ---
 
-Respond with ONLY valid JSON:
-{"pass":true}
-OR
-{"pass":false,"reason":"<specific, human-friendly explanation of why this was blocked>","category":"<hate_speech|extremism|violence_incitement|csam|self_harm_encouragement>"}`;
+\u{1F6A8} CRITICAL \u{1F6A8}:
+Respond with ONLY a single JSON object on one line \u2014 no markdown, no explanation, no code fences.
+
+If the content passes: {"pass":true,"reason":"<brief reason>"}
+If the content fails: {"pass":false,"reason":"<specific explanation>","category":"<hate_speech|extremism|violence_incitement|csam|self_harm_encouragement>"}
+
+Your entire response must be parseable by JSON.parse(). Do not include any other text.`;
 }
 var DEFAULT_CACHE_MAX = 1e3;
 function hashContent(content) {
@@ -4064,14 +4315,21 @@ function createModerationClient(options) {
           body: JSON.stringify({
             model,
             max_tokens: 256,
-            messages: [{ role: "user", content: buildModerationPrompt(content) }]
+            temperature: 0,
+            messages: [
+              { role: "user", content: buildModerationPrompt(content) },
+              { role: "assistant", content: "{" }
+            ]
           })
         });
         if (!response.ok) {
+          const errorBody = await response.text().catch(() => "");
+          console.error(`[moderation] Anthropic API error: ${response.status} ${response.statusText}`, errorBody);
           return { pass: false, reason: "Content moderation unavailable. Please try again later." };
         }
         const data = await response.json();
-        const text = data.content?.[0]?.text ?? "";
+        const rawText = data.content?.[0]?.text ?? "";
+        const text = ("{" + rawText).replace(/^```(?:json)?\s*\n?/i, "").replace(/\n?```\s*$/i, "").trim();
         const parsed = JSON.parse(text);
         const result = {
           pass: parsed.pass === true,
@@ -4084,7 +4342,8 @@ function createModerationClient(options) {
         }
         cache.set(hash, result);
         return result;
-      } catch {
+      } catch (err2) {
+        console.error("[moderation] Unexpected error:", err2);
         return { pass: false, reason: "Content moderation unavailable. Please try again later." };
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prmichaelsen/remember-mcp",
-  "version": "3.15.2",
+  "version": "3.15.4",
   "description": "Multi-tenant memory system MCP server with vector search and relationships",
   "main": "dist/server.js",
   "type": "module",
@@ -52,7 +52,7 @@
     "@modelcontextprotocol/sdk": "^1.0.4",
     "@prmichaelsen/firebase-admin-sdk-v8": "^2.2.0",
     "@prmichaelsen/mcp-auth": "^7.0.4",
-    "@prmichaelsen/remember-core": "^0.34.12",
+    "@prmichaelsen/remember-core": "^0.35.2",
     "dotenv": "^16.4.5",
     "uuid": "^13.0.0",
     "weaviate-client": "^3.2.0"