@prmichaelsen/remember-mcp 3.15.3 → 3.15.4

package/dist/server-factory.js

@@ -2331,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 = [
@@ -2711,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)
@@ -3908,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 = [];
@@ -3945,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;
@@ -4047,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) {
@@ -4077,18 +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(() => "");
-          const msg = `[moderation] Anthropic API error: ${response.status} ${response.statusText} ${errorBody}`;
-          console.error(msg);
-          return { pass: false, reason: msg };
+          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 rawText = data.content?.[0]?.text ?? "";
-        const text = rawText.replace(/^```(?:json)?\s*\n?/i, "").replace(/\n?```\s*$/i, "").trim();
+        const text = ("{" + rawText).replace(/^```(?:json)?\s*\n?/i, "").replace(/\n?```\s*$/i, "").trim();
         const parsed = JSON.parse(text);
         const result = {
           pass: parsed.pass === true,
@@ -4102,9 +4339,8 @@ function createModerationClient(options) {
         cache.set(hash, result);
         return result;
       } catch (err2) {
-        const msg = `[moderation] Unexpected error: ${err2 instanceof Error ? err2.message : String(err2)}`;
-        console.error(msg, err2);
-        return { pass: false, reason: msg };
+        console.error("[moderation] Unexpected error:", err2);
+        return { pass: false, reason: "Content moderation unavailable. Please try again later." };
       }
     }
   };

package/dist/server.js

@@ -2335,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 = [
@@ -2715,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)
@@ -3912,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 = [];
@@ -3949,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;
@@ -4051,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) {
@@ -4081,18 +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(() => "");
-          const msg = `[moderation] Anthropic API error: ${response.status} ${response.statusText} ${errorBody}`;
-          console.error(msg);
-          return { pass: false, reason: msg };
+          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 rawText = data.content?.[0]?.text ?? "";
-        const text = rawText.replace(/^```(?:json)?\s*\n?/i, "").replace(/\n?```\s*$/i, "").trim();
+        const text = ("{" + rawText).replace(/^```(?:json)?\s*\n?/i, "").replace(/\n?```\s*$/i, "").trim();
         const parsed = JSON.parse(text);
         const result = {
           pass: parsed.pass === true,
@@ -4106,9 +4343,8 @@ function createModerationClient(options) {
         cache.set(hash, result);
         return result;
       } catch (err2) {
-        const msg = `[moderation] Unexpected error: ${err2 instanceof Error ? err2.message : String(err2)}`;
-        console.error(msg, err2);
-        return { pass: false, reason: msg };
+        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.3",
+  "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.14",
+    "@prmichaelsen/remember-core": "^0.35.2",
     "dotenv": "^16.4.5",
     "uuid": "^13.0.0",
     "weaviate-client": "^3.2.0"