@prmichaelsen/remember-mcp 3.16.0 → 3.17.0

package/dist/server-factory.js

@@ -1458,6 +1458,18 @@ function unsafeStringify(arr, offset = 0) {
   return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
 }
 
+// node_modules/@prmichaelsen/remember-core/node_modules/uuid/dist/esm/rng.js
+import { randomFillSync } from "crypto";
+var rnds8Pool = new Uint8Array(256);
+var poolPtr = rnds8Pool.length;
+function rng() {
+  if (poolPtr > rnds8Pool.length - 16) {
+    randomFillSync(rnds8Pool);
+    poolPtr = 0;
+  }
+  return rnds8Pool.slice(poolPtr, poolPtr += 16);
+}
+
 // node_modules/@prmichaelsen/remember-core/node_modules/uuid/dist/esm/v35.js
 function stringToBytes(str) {
   str = unescape(encodeURIComponent(str));
@@ -1494,6 +1506,36 @@ function v35(version, hash, value, namespace, buf, offset) {
   return unsafeStringify(bytes);
 }
 
+// node_modules/@prmichaelsen/remember-core/node_modules/uuid/dist/esm/native.js
+import { randomUUID } from "crypto";
+var native_default = { randomUUID };
+
+// node_modules/@prmichaelsen/remember-core/node_modules/uuid/dist/esm/v4.js
+function v4(options, buf, offset) {
+  if (native_default.randomUUID && !buf && !options) {
+    return native_default.randomUUID();
+  }
+  options = options || {};
+  const rnds = options.random ?? options.rng?.() ?? rng();
+  if (rnds.length < 16) {
+    throw new Error("Random bytes length must be >= 16");
+  }
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    if (offset < 0 || offset + 16 > buf.length) {
+      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+    }
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+var v4_default = v4;
+
 // node_modules/@prmichaelsen/remember-core/node_modules/uuid/dist/esm/sha1.js
 import { createHash } from "crypto";
 function sha1(bytes) {
@@ -1712,6 +1754,9 @@ function buildDocTypeFilters(collection, docType, filters) {
   if (filters?.tags && filters.tags.length > 0) {
     filterList.push(collection.filter.byProperty("tags").containsAny(filters.tags));
   }
+  if (filters?.is_user_organized !== void 0) {
+    filterList.push(collection.filter.byProperty("is_user_organized").equal(filters.is_user_organized));
+  }
   if (filters?.memory_ids && filters.memory_ids.length > 0) {
     filterList.push(collection.filter.byId().containsAny(filters.memory_ids));
   }
@@ -1871,6 +1916,7 @@ var COMMON_MEMORY_PROPERTIES = [
   { name: "relationships", dataType: configure.dataType.TEXT_ARRAY },
   { name: "memory_ids", dataType: configure.dataType.TEXT_ARRAY },
   { name: "relationship_count", dataType: configure.dataType.INT },
+  { name: "member_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 },
@@ -1931,7 +1977,15 @@ var COMMON_MEMORY_PROPERTIES = [
   { name: "total_significance", dataType: configure.dataType.NUMBER },
   // REM metadata
   { name: "rem_touched_at", dataType: configure.dataType.TEXT },
-  { name: "rem_visits", dataType: configure.dataType.INT }
+  { name: "rem_visits", dataType: configure.dataType.INT },
+  // User organization (M64)
+  { name: "is_user_organized", dataType: configure.dataType.BOOLEAN },
+  // Curation scoring (M36)
+  { name: "curated_score", dataType: configure.dataType.NUMBER },
+  { name: "editorial_score", dataType: configure.dataType.NUMBER },
+  { name: "click_count", dataType: configure.dataType.INT },
+  { name: "share_count", dataType: configure.dataType.INT },
+  { name: "comment_count", dataType: configure.dataType.INT }
 ];
 var PUBLISHED_MEMORY_PROPERTIES = [
   // Publication metadata
@@ -2286,7 +2340,7 @@ var PreferencesDatabaseService = class {
 };
 
 // node_modules/@prmichaelsen/remember-core/dist/services/confirmation-token.service.js
-var randomUUID = () => globalThis.crypto.randomUUID();
+var randomUUID2 = () => globalThis.crypto.randomUUID();
 var ConfirmationTokenService = class {
   EXPIRY_MINUTES = 5;
   logger;
@@ -2298,7 +2352,7 @@ var ConfirmationTokenService = class {
    */
   async createRequest(userId, action, payload, targetCollection) {
     try {
-      const token = randomUUID();
+      const token = randomUUID2();
       const now = /* @__PURE__ */ new Date();
       const expiresAt = new Date(now.getTime() + this.EXPIRY_MINUTES * 60 * 1e3);
       const request = {
@@ -2582,7 +2636,13 @@ var ALL_MEMORY_PROPERTIES = [
   "functional_significance",
   "total_significance",
   "rem_touched_at",
-  "rem_visits"
+  "rem_visits",
+  // Curation scoring (M36)
+  "curated_score",
+  "editorial_score",
+  "click_count",
+  "share_count",
+  "comment_count"
 ];
 async function fetchMemoryWithAllProperties(collection, memoryId) {
   try {
@@ -2823,6 +2883,7 @@ var MemoryService = class {
       thread_root_id: input.thread_root_id ?? null,
       moderation_flags: input.moderation_flags ?? [],
       follow_up_at: input.follow_up_at || null,
+      is_user_organized: input.is_user_organized ?? false,
       space_ids: [],
       group_ids: []
     };
@@ -3358,6 +3419,99 @@ var MemoryService = class {
       total_pool_size: totalPoolSize
     };
   }
+  // ── By Curated (composite quality score) ──────────────────────────
+  async byCurated(input) {
+    const limit = input.limit ?? 50;
+    const offset = input.offset ?? 0;
+    const direction = input.direction ?? "desc";
+    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 && !input.filters?.types?.includes("ghost")) {
+      ghostFilters.push(this.collection.filter.byProperty("content_type").notEqual("ghost"));
+    }
+    if (!input.filters?.types?.includes("rem")) {
+      ghostFilters.push(this.collection.filter.byProperty("content_type").notEqual("rem"));
+    }
+    const hasQuery = input.query?.trim();
+    const fetchLimit = (limit + offset) * 2;
+    const executeScoredQuery = async (useDeletedFilter) => {
+      const deletedFilter = useDeletedFilter ? buildDeletedFilter(this.collection, input.deleted_filter || "exclude") : null;
+      const scoredFilter = this.collection.filter.byProperty("curated_score").greaterThan(0);
+      const combined = combineFiltersWithAnd([deletedFilter, memoryFilters, scoredFilter, ...ghostFilters].filter((f) => f !== null));
+      if (hasQuery) {
+        const queryOptions2 = {
+          limit: fetchLimit,
+          alpha: 0.7,
+          query: hasQuery
+        };
+        if (combined)
+          queryOptions2.filters = combined;
+        return this.collection.query.hybrid(hasQuery, queryOptions2);
+      }
+      const queryOptions = {
+        limit: fetchLimit,
+        sort: this.collection.sort.byProperty("curated_score", direction === "asc")
+      };
+      if (combined)
+        queryOptions.filters = combined;
+      return this.collection.query.fetchObjects(queryOptions);
+    };
+    const executeUnscoredQuery = async (useDeletedFilter) => {
+      const deletedFilter = useDeletedFilter ? buildDeletedFilter(this.collection, input.deleted_filter || "exclude") : null;
+      const unscoredFilters = [];
+      const combined = combineFiltersWithAnd([deletedFilter, memoryFilters, ...ghostFilters].filter((f) => f !== null));
+      const queryOptions = {
+        limit: Math.ceil(fetchLimit / 4),
+        sort: this.collection.sort.byProperty("created_at", false)
+        // newest first
+      };
+      if (combined)
+        queryOptions.filters = combined;
+      return this.collection.query.fetchObjects(queryOptions);
+    };
+    const scoredResults = await this.retryWithoutDeletedFilter(executeScoredQuery);
+    const unscoredResults = await this.retryWithoutDeletedFilter(executeUnscoredQuery);
+    const scored = [];
+    for (const obj of scoredResults.objects) {
+      const doc = normalizeDoc({ id: obj.uuid, ...obj.properties });
+      if (doc.doc_type === "memory" && doc.curated_score > 0) {
+        scored.push(doc);
+      }
+    }
+    if (hasQuery) {
+      scored.sort((a, b) => {
+        const aScore = a.curated_score ?? 0;
+        const bScore = b.curated_score ?? 0;
+        return direction === "asc" ? aScore - bScore : bScore - aScore;
+      });
+    }
+    const unscored = [];
+    for (const obj of unscoredResults.objects) {
+      const doc = normalizeDoc({ id: obj.uuid, ...obj.properties });
+      if (doc.doc_type === "memory" && !doc.curated_score) {
+        unscored.push(doc);
+      }
+    }
+    const interleaved = interleaveDiscovery({
+      rated: scored,
+      discovery: unscored,
+      offset,
+      limit
+    });
+    const memories = interleaved.map((item) => ({
+      ...item.item,
+      ...item.is_discovery ? { is_discovery: true } : {}
+    }));
+    return {
+      memories,
+      total: memories.length,
+      offset,
+      limit
+    };
+  }
   // ── Find Similar (vector) ──────────────────────────────────────────
   async findSimilar(input) {
     if (!input.memory_id && !input.text)
@@ -3374,6 +3528,7 @@ var MemoryService = class {
       ghostFilters.push(this.collection.filter.byProperty("content_type").notEqual("ghost"));
     }
     ghostFilters.push(this.collection.filter.byProperty("content_type").notEqual("rem"));
+    ghostFilters.push(this.collection.filter.byProperty("content_type").notEqual("comment"));
     let memoryObj = null;
     if (input.memory_id) {
       memoryObj = await this.collection.query.fetchObjectById(input.memory_id, {
@@ -3507,6 +3662,10 @@ var MemoryService = class {
       updates.moderation_flags = input.moderation_flags;
       updatedFields.push("moderation_flags");
     }
+    if (input.is_user_organized !== void 0) {
+      updates.is_user_organized = input.is_user_organized;
+      updatedFields.push("is_user_organized");
+    }
     if (updatedFields.length === 0)
       throw new Error("No fields provided for update");
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -3565,6 +3724,28 @@ var MemoryService = class {
       orphaned_relationship_ids: orphanedIds
     };
   }
+  // ── Engagement Counters ───────────────────────────────────────────
+  async incrementClick(memoryId) {
+    await this.incrementCounter(memoryId, "click_count");
+  }
+  async incrementShare(memoryId) {
+    await this.incrementCounter(memoryId, "share_count");
+  }
+  async incrementComment(memoryId) {
+    await this.incrementCounter(memoryId, "comment_count");
+  }
+  async incrementCounter(memoryId, field) {
+    const existing = await this.collection.query.fetchObjectById(memoryId, {
+      returnProperties: [field]
+    });
+    if (!existing)
+      throw new Error(`Memory not found: ${memoryId}`);
+    const current = existing.properties?.[field] ?? 0;
+    await this.collection.data.update({
+      id: memoryId,
+      properties: { [field]: current + 1 }
+    });
+  }
 };
 
 // node_modules/@prmichaelsen/remember-core/dist/services/relationship.service.js
@@ -3617,6 +3798,7 @@ var RelationshipService = class {
         "confidence",
         "source",
         "tags",
+        "member_count",
         "created_at",
         "updated_at",
         "version"
@@ -3663,6 +3845,7 @@ var RelationshipService = class {
       strength: input.strength ?? 0.5,
       confidence: input.confidence ?? 0.8,
       source: input.source ?? "user",
+      member_count: input.memory_ids.length,
       created_at: now,
       updated_at: now,
       version: 1,
@@ -3766,6 +3949,9 @@ var RelationshipService = class {
     const opts = { alpha: 1, limit: limit + offset };
     if (combinedFilters)
       opts.filters = combinedFilters;
+    if (input.sort_by) {
+      opts.sort = this.collection.sort.byProperty(input.sort_by, input.sort_direction === "asc");
+    }
     const results = await this.collection.query.hybrid(input.query, opts);
     const paginated = results.objects.slice(offset, offset + limit);
     const relationships = paginated.map((obj) => ({
@@ -3802,6 +3988,7 @@ var RelationshipService = class {
         "confidence",
         "source",
         "tags",
+        "member_count",
         "created_at",
         "updated_at",
         "version"
@@ -3895,6 +4082,7 @@ var SpaceService = class {
   moderationClient;
   memoryIndex;
   recommendationService;
+  eventBus;
   constructor(weaviateClient, userCollection, userId, confirmationTokenService, logger2, memoryIndexService2, options) {
     this.weaviateClient = weaviateClient;
     this.userCollection = userCollection;
@@ -3904,6 +4092,7 @@ var SpaceService = class {
     this.memoryIndexService = memoryIndexService2;
     this.moderationClient = options?.moderationClient;
     this.recommendationService = options?.recommendationService;
+    this.eventBus = options?.eventBus;
     this.memoryIndex = memoryIndexService2;
   }
   // ── Content moderation helper ────────────────────────────────────────
@@ -3918,6 +4107,46 @@ var SpaceService = class {
       });
     }
   }
+  // ── Resolve composite UUID to original memory ──────────────────────
+  /**
+   * Looks up a memory in the user's collection. If not found, checks whether
+   * the ID is a composite UUID from a published copy and resolves to the
+   * original memory via composite_id or original_memory_id.
+   */
+  async resolveToOriginalMemory(memoryId) {
+    let memory = await fetchMemoryWithAllProperties(this.userCollection, memoryId);
+    if (memory) {
+      if (memory.properties.user_id !== this.userId)
+        throw new ForbiddenError("Permission denied: not memory owner");
+      return { resolvedId: memoryId, memory };
+    }
+    const collectionName = await this.memoryIndex.lookup(memoryId);
+    if (collectionName && collectionName !== this.userCollection.name) {
+      const publishedCollection = this.weaviateClient.collections.get(collectionName);
+      const published = await fetchMemoryWithAllProperties(publishedCollection, memoryId);
+      if (published) {
+        let originalId;
+        if (published.properties.original_memory_id) {
+          originalId = published.properties.original_memory_id;
+        } else if (published.properties.composite_id) {
+          try {
+            const parsed = parseCompositeId(published.properties.composite_id);
+            originalId = parsed.memoryId;
+          } catch {
+          }
+        }
+        if (originalId) {
+          memory = await fetchMemoryWithAllProperties(this.userCollection, originalId);
+          if (memory) {
+            if (memory.properties.user_id !== this.userId)
+              throw new ForbiddenError("Permission denied: not memory owner");
+            return { resolvedId: originalId, memory };
+          }
+        }
+      }
+    }
+    throw new NotFoundError("Memory", memoryId);
+  }
   // ── Publish (phase 1: generate confirmation token) ──────────────────
   async publish(input) {
     const spaces = input.spaces || [];
@@ -3937,11 +4166,7 @@ var SpaceService = class {
         throw new ValidationError("Group IDs cannot be empty or contain dots");
       }
     }
-    const memory = await fetchMemoryWithAllProperties(this.userCollection, input.memory_id);
-    if (!memory)
-      throw new NotFoundError("Memory", input.memory_id);
-    if (memory.properties.user_id !== this.userId)
-      throw new ForbiddenError("Permission denied: not memory owner");
+    const { resolvedId: resolvedMemoryId, memory } = await this.resolveToOriginalMemory(input.memory_id);
     if (memory.properties.doc_type !== "memory")
       throw new ValidationError("Only memories can be published");
     const memoryContentType = memory.properties.content_type;
@@ -3953,14 +4178,14 @@ var SpaceService = class {
     }
     await this.checkModeration(memory.properties.content);
     const { token } = await this.confirmationTokenService.createRequest(this.userId, "publish_memory", {
-      memory_id: input.memory_id,
+      memory_id: resolvedMemoryId,
       spaces,
       groups,
       additional_tags: input.additional_tags || []
     });
     this.logger.info("Publish confirmation created", {
       userId: this.userId,
-      memoryId: input.memory_id,
+      memoryId: resolvedMemoryId,
       spaces,
       groups
     });
@@ -3979,11 +4204,7 @@ var SpaceService = class {
         throw new ValidationError(`Group IDs cannot contain dots: ${invalidGroups.join(", ")}`);
       }
     }
-    const memory = await fetchMemoryWithAllProperties(this.userCollection, input.memory_id);
-    if (!memory)
-      throw new NotFoundError("Memory", input.memory_id);
-    if (memory.properties.user_id !== this.userId)
-      throw new ForbiddenError("Permission denied: not memory owner");
+    const { resolvedId: resolvedMemoryId, memory } = await this.resolveToOriginalMemory(input.memory_id);
     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));
@@ -3992,7 +4213,7 @@ var SpaceService = class {
       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,
+      memory_id: resolvedMemoryId,
       spaces,
       groups,
       current_space_ids: currentSpaceIds,
@@ -4000,7 +4221,7 @@ var SpaceService = class {
     });
     this.logger.info("Retract confirmation created", {
       userId: this.userId,
-      memoryId: input.memory_id,
+      memoryId: resolvedMemoryId,
       spaces,
       groups
     });
@@ -4254,6 +4475,22 @@ var SpaceService = class {
       total: memories.length
     };
   }
+  // ── Private: Dedupe Check ──────────────────────────────────────────
+  /**
+   * Check that the given original_memory_id is not already published to the
+   * target collection by a different user.  If the same user re-publishes
+   * (same weaviateId) this is fine — the caller handles update vs insert.
+   */
+  async checkOriginalMemoryNotPublished(collection, originalMemoryId, expectedWeaviateId) {
+    const filter = collection.filter.byProperty("original_memory_id").equal(originalMemoryId);
+    const result = await collection.query.fetchObjects({ filters: filter, limit: 1 });
+    if (result.objects.length > 0) {
+      const existing = result.objects[0];
+      if (existing.uuid === expectedWeaviateId)
+        return;
+      throw new ValidationError(`This memory is already published by another user`);
+    }
+  }
   // ── Private: Execute Publish ────────────────────────────────────────
   async executePublish(request) {
     const spaces = request.payload.spaces || [];
@@ -4278,6 +4515,7 @@ var SpaceService = class {
     if (spaces.length > 0) {
       try {
         const publicCollection = await ensurePublicCollection(this.weaviateClient);
+        await this.checkOriginalMemoryNotPublished(publicCollection, request.payload.memory_id, weaviateId);
         let existingSpaceMemory = null;
         try {
           existingSpaceMemory = await fetchMemoryWithAllProperties(publicCollection, weaviateId);
@@ -4327,6 +4565,7 @@ var SpaceService = class {
       try {
         await ensureGroupCollection(this.weaviateClient, groupId);
         const groupCollection = this.weaviateClient.collections.get(groupCollectionName);
+        await this.checkOriginalMemoryNotPublished(groupCollection, request.payload.memory_id, weaviateId);
         let existingGroupMemory = null;
         try {
           existingGroupMemory = await fetchMemoryWithAllProperties(groupCollection, weaviateId);
@@ -4385,6 +4624,35 @@ var SpaceService = class {
       published: successfulPublications,
       failed: failedPublications
     });
+    if (this.eventBus) {
+      const title = String(originalMemory.properties.title ?? "");
+      const actor = { type: "user", id: this.userId };
+      const isComment = originalMemory.properties.content_type === "comment";
+      if (isComment) {
+        const parentId = String(originalMemory.properties.parent_id ?? "");
+        const threadRootId = String(originalMemory.properties.thread_root_id ?? parentId);
+        const contentPreview = String(originalMemory.properties.content ?? "").slice(0, 200);
+        if (successfulPublications.some((p) => p.startsWith("spaces:"))) {
+          for (const spaceId of spaces) {
+            this.eventBus.emit({ type: "comment.published_to_space", memory_id: request.payload.memory_id, parent_id: parentId, thread_root_id: threadRootId, content_preview: contentPreview, space_id: spaceId, owner_id: this.userId }, actor);
+          }
+        }
+        const publishedGroups = groups.filter((g) => successfulPublications.some((p) => p === `group: ${g}`));
+        for (const groupId of publishedGroups) {
+          this.eventBus.emit({ type: "comment.published_to_group", memory_id: request.payload.memory_id, parent_id: parentId, thread_root_id: threadRootId, content_preview: contentPreview, group_id: groupId, owner_id: this.userId }, actor);
+        }
+      } else {
+        if (successfulPublications.some((p) => p.startsWith("spaces:"))) {
+          for (const spaceId of spaces) {
+            this.eventBus.emit({ type: "memory.published_to_space", memory_id: request.payload.memory_id, title, space_id: spaceId, owner_id: this.userId }, actor);
+          }
+        }
+        const publishedGroups = groups.filter((g) => successfulPublications.some((p) => p === `group: ${g}`));
+        for (const groupId of publishedGroups) {
+          this.eventBus.emit({ type: "memory.published_to_group", memory_id: request.payload.memory_id, title, group_id: groupId, owner_id: this.userId }, actor);
+        }
+      }
+    }
     return {
       action: "publish_memory",
       success: true,
@@ -4466,6 +4734,21 @@ var SpaceService = class {
       retracted: successfulRetractions,
       failed: failedRetractions
     });
+    if (this.eventBus && successfulRetractions.length > 0) {
+      const targets = [];
+      if (successfulRetractions.some((r) => r.startsWith("spaces:"))) {
+        for (const spaceId of spaces) {
+          targets.push({ kind: "space", id: spaceId });
+        }
+      }
+      const retractedGroups = groups.filter((g) => successfulRetractions.some((r) => r === `group: ${g}`));
+      for (const groupId of retractedGroups) {
+        targets.push({ kind: "group", id: groupId });
+      }
+      if (targets.length > 0) {
+        this.eventBus.emit({ type: "memory.retracted", memory_id: request.payload.memory_id, owner_id: this.userId, targets }, { type: "user", id: this.userId });
+      }
+    }
     return {
       action: "retract_memory",
       success: true,
@@ -5006,6 +5289,42 @@ var SpaceService = class {
     });
     return { spaces_searched: spacesSearched, groups_searched: groupsSearched, results, total_pool_size: totalPoolSize };
   }
+  // ── By Curated (composite quality score) ──────────────────────────
+  async byCurated(input, authContext) {
+    const spaces = input.spaces || [];
+    const groups = input.groups || [];
+    const limit = input.limit ?? 50;
+    const offset = input.offset ?? 0;
+    const direction = input.direction ?? "desc";
+    this.validateSpaceGroupInput(spaces, groups, input.moderation_filter || "approved", authContext);
+    const fetchLimit = (limit + offset) * 2;
+    const hasQuery = input.query?.trim();
+    const { allResults, spacesSearched, groupsSearched } = await this.fetchAcrossCollections(input, spaces, groups, async (collection, baseFilters) => {
+      const combined = baseFilters.length > 0 ? Filters4.and(...baseFilters) : void 0;
+      if (hasQuery) {
+        const opts2 = { limit: fetchLimit, alpha: 0.7, query: hasQuery };
+        if (combined)
+          opts2.filters = combined;
+        return (await collection.query.hybrid(hasQuery, opts2)).objects;
+      }
+      const opts = {
+        limit: fetchLimit,
+        sort: collection.sort.byProperty("curated_score", direction === "asc")
+      };
+      if (combined)
+        opts.filters = combined;
+      return (await collection.query.fetchObjects(opts)).objects;
+    });
+    const deduped = dedupeBySourceId(allResults, input.dedupe);
+    deduped.sort((a, b) => {
+      const aVal = a.properties?.curated_score ?? 0;
+      const bVal = b.properties?.curated_score ?? 0;
+      return direction === "desc" ? bVal - aVal : aVal - bVal;
+    });
+    const paginated = deduped.slice(offset, offset + limit);
+    const memories = paginated.filter((obj) => obj.properties?.doc_type === "memory").map((obj) => ({ id: obj.uuid, ...obj.properties }));
+    return { spaces_searched: spacesSearched, groups_searched: groupsSearched, memories, total: memories.length, offset, limit };
+  }
   // ── Private: Validate Space/Group Input ───────────────────────────
   validateSpaceGroupInput(spaces, groups, moderationFilter, authContext) {
     if (spaces.length > 0) {
@@ -5150,6 +5469,18 @@ 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/rem.service.js
+import { Filters as Filters9 } from "weaviate-client";
+
+// node_modules/@prmichaelsen/remember-core/dist/services/scoring-context.service.js
+import { Filters as Filters6 } from "weaviate-client";
+
+// node_modules/@prmichaelsen/remember-core/dist/services/rem.pruning.js
+import { Filters as Filters7 } from "weaviate-client";
+
+// node_modules/@prmichaelsen/remember-core/dist/services/rem.reconciliation.js
+import { Filters as Filters8 } from "weaviate-client";
+
 // node_modules/@prmichaelsen/remember-core/dist/services/classification.service.js
 var GENRES = [
   "short_story",
@@ -5347,6 +5678,132 @@ var INITIAL_PERCEPTION = {
   last_updated: (/* @__PURE__ */ new Date()).toISOString()
 };
 
+// node_modules/@prmichaelsen/remember-core/dist/webhooks/signing.js
+import { createHmac } from "node:crypto";
+function signWebhookPayload(webhookId, timestamp, body, secret) {
+  const content = `${webhookId}.${timestamp}.${body}`;
+  const hmac = createHmac("sha256", secret).update(content).digest("base64");
+  return `v1,${hmac}`;
+}
+
+// node_modules/@prmichaelsen/remember-core/dist/webhooks/batched-webhook.service.js
+var DEFAULT_MAX_BATCH_SIZE = 20;
+var DEFAULT_FLUSH_INTERVAL_MS = 1e3;
+var DEFAULT_TIMEOUT_MS = 5e3;
+var SOURCE = "remember-core";
+var API_VERSION = "1";
+var BatchedWebhookService = class {
+  logger;
+  resolveEndpoint;
+  maxBatchSize;
+  flushIntervalMs;
+  timeoutMs;
+  onError;
+  buffers = /* @__PURE__ */ new Map();
+  constructor(logger2, config2) {
+    this.logger = logger2;
+    this.resolveEndpoint = config2.resolveEndpoint;
+    this.maxBatchSize = config2.maxBatchSize ?? DEFAULT_MAX_BATCH_SIZE;
+    this.flushIntervalMs = config2.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS;
+    this.timeoutMs = config2.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.onError = config2.onError;
+  }
+  emit(event, actor) {
+    const ownerId = event.owner_id;
+    const endpoints = this.resolveEndpoint(ownerId);
+    if (endpoints.length === 0) {
+      this.logger.debug?.("[BatchedWebhookService] no endpoints for owner, dropping event", {
+        owner_id: ownerId,
+        type: event.type
+      });
+      return;
+    }
+    const envelope = this.buildEnvelope(event, actor);
+    for (const endpoint of endpoints) {
+      const url = endpoint.url;
+      let buffer = this.buffers.get(url);
+      if (!buffer) {
+        buffer = { endpoint, envelopes: [], timer: null };
+        this.buffers.set(url, buffer);
+      }
+      buffer.envelopes.push(envelope);
+      if (buffer.envelopes.length >= this.maxBatchSize) {
+        this.flush(url);
+      } else if (!buffer.timer) {
+        buffer.timer = setTimeout(() => this.flush(url), this.flushIntervalMs);
+      }
+    }
+  }
+  flush(url) {
+    const buffer = this.buffers.get(url);
+    if (!buffer || buffer.envelopes.length === 0)
+      return;
+    const envelopes = buffer.envelopes;
+    const endpoint = buffer.endpoint;
+    if (buffer.timer) {
+      clearTimeout(buffer.timer);
+    }
+    buffer.envelopes = [];
+    buffer.timer = null;
+    this.sendBatch(url, endpoint, envelopes).catch((err2) => {
+      this.logger.error?.("[BatchedWebhookService] batch delivery failed", {
+        error: err2,
+        url,
+        count: envelopes.length
+      });
+      this.onError?.(err2, envelopes);
+    });
+  }
+  dispose() {
+    for (const url of this.buffers.keys()) {
+      this.flush(url);
+    }
+  }
+  async sendBatch(url, endpoint, envelopes) {
+    const batchId = v4_default();
+    const batchTimestamp = Math.floor(Date.now() / 1e3);
+    const body = JSON.stringify(envelopes);
+    const signature = signWebhookPayload(batchId, batchTimestamp, body, endpoint.signingSecret);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "webhook-id": batchId,
+          "webhook-timestamp": String(batchTimestamp),
+          "webhook-signature": signature,
+          "x-webhook-batch": "true"
+        },
+        body,
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`Webhook batch delivery failed: HTTP ${response.status}`);
+      }
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  buildEnvelope(event, actor) {
+    return {
+      id: v4_default(),
+      timestamp: Math.floor(Date.now() / 1e3),
+      source: SOURCE,
+      api_version: API_VERSION,
+      type: event.type,
+      actor,
+      data: event
+    };
+  }
+};
+
+// node_modules/@prmichaelsen/remember-core/dist/webhooks/create.js
+function createBatchedWebhookService(logger2, config2) {
+  return new BatchedWebhookService(logger2, config2);
+}
+
 // src/weaviate/schema.ts
 init_logger();
 
@@ -5465,6 +5922,15 @@ 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 eventBus = (() => {
+  const url = process.env.REMEMBER_WEBHOOK_URL;
+  const secret = process.env.REMEMBER_WEBHOOK_SECRET;
+  if (!url || !secret)
+    return void 0;
+  return createBatchedWebhookService(coreLogger, {
+    resolveEndpoint: () => [{ url, signingSecret: secret }]
+  });
+})();
 var coreServicesCache = /* @__PURE__ */ new Map();
 function createCoreServices(userId) {
   const cached = coreServicesCache.get(userId);
@@ -5478,7 +5944,7 @@ function createCoreServices(userId) {
       weaviateClient
     }),
     relationship: new RelationshipService(collection, userId, coreLogger),
-    space: new SpaceService(weaviateClient, collection, userId, tokenService, coreLogger, memoryIndexService, { moderationClient }),
+    space: new SpaceService(weaviateClient, collection, userId, tokenService, coreLogger, memoryIndexService, { moderationClient, eventBus }),
     preferences: preferencesService,
     token: tokenService
   };
@@ -7437,7 +7903,7 @@ async function handleDeny(args, userId, authContext) {
 }
 
 // src/tools/search-space.ts
-import { Filters as Filters6 } from "weaviate-client";
+import { Filters as Filters10 } from "weaviate-client";
 var searchSpaceTool = {
   name: "remember_search_space",
   description: `Search shared spaces and/or groups to discover memories from other users.