@prmichaelsen/remember-mcp 3.16.2 → 3.17.1

package/CHANGELOG.md

@@ -5,6 +5,28 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.17.1] - 2026-03-09
+
+### Fixed
+
+- Move `server-factory.spec.ts` to `server-factory.e2e.ts` — test requires live Weaviate and was crashing CI workers
+- Revert CI test command to `npm test` (OOM was a symptom of the Weaviate connection failure, not memory)
+
+## [3.17.0] - 2026-03-09
+
+### Added
+
+- Webhook event bus integration — `SpaceService` now emits `memory.published_to_group`, `memory.published_to_space`, `comment.published_to_group`, and `comment.published_to_space` events via `BatchedWebhookService`
+- `REMEMBER_WEBHOOK_URL` and `REMEMBER_WEBHOOK_SECRET` env vars configure outbound webhook delivery
+
+### Changed
+
+- Bump `@prmichaelsen/remember-core` to 0.54.0 (fan-out webhooks, comment events, publish dedupe)
+
+### Fixed
+
+- CI OOM crash in `server-factory.spec.ts` — add `maxWorkers: '50%'` to jest config
+
 ## [3.16.0] - 2026-03-08
 
 ### Added

package/dist/server-factory.e2e.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=server-factory.e2e.d.ts.map

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 },
@@ -1932,6 +1978,8 @@ var COMMON_MEMORY_PROPERTIES = [
   // REM metadata
   { name: "rem_touched_at", dataType: configure.dataType.TEXT },
   { 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 },
@@ -2292,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;
@@ -2304,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 = {
@@ -2835,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: []
     };
@@ -3613,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();
@@ -3745,6 +3798,7 @@ var RelationshipService = class {
         "confidence",
         "source",
         "tags",
+        "member_count",
         "created_at",
         "updated_at",
         "version"
@@ -3791,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,
@@ -3894,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) => ({
@@ -3930,6 +3988,7 @@ var RelationshipService = class {
         "confidence",
         "source",
         "tags",
+        "member_count",
         "created_at",
         "updated_at",
         "version"
@@ -4023,6 +4082,7 @@ var SpaceService = class {
   moderationClient;
   memoryIndex;
   recommendationService;
+  eventBus;
   constructor(weaviateClient, userCollection, userId, confirmationTokenService, logger2, memoryIndexService2, options) {
     this.weaviateClient = weaviateClient;
     this.userCollection = userCollection;
@@ -4032,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 ────────────────────────────────────────
@@ -4046,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 || [];
@@ -4065,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;
@@ -4081,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
     });
@@ -4107,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));
@@ -4120,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,
@@ -4128,7 +4221,7 @@ var SpaceService = class {
     });
     this.logger.info("Retract confirmation created", {
       userId: this.userId,
-      memoryId: input.memory_id,
+      memoryId: resolvedMemoryId,
       spaces,
       groups
     });
@@ -4382,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 || [];
@@ -4406,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);
@@ -4455,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);
@@ -4513,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,
@@ -4594,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,
@@ -5523,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();
 
@@ -5641,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);
@@ -5654,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
   };

package/dist/server.js

@@ -1462,6 +1462,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));
@@ -1498,6 +1510,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) {
@@ -1716,6 +1758,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));
   }
@@ -1875,6 +1920,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 },
@@ -1936,6 +1982,8 @@ var COMMON_MEMORY_PROPERTIES = [
   // REM metadata
   { name: "rem_touched_at", dataType: configure.dataType.TEXT },
   { 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 },
@@ -2296,7 +2344,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;
@@ -2308,7 +2356,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 = {
@@ -2839,6 +2887,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: []
     };
@@ -3617,6 +3666,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();
@@ -3749,6 +3802,7 @@ var RelationshipService = class {
         "confidence",
         "source",
         "tags",
+        "member_count",
         "created_at",
         "updated_at",
         "version"
@@ -3795,6 +3849,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,
@@ -3898,6 +3953,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) => ({
@@ -3934,6 +3992,7 @@ var RelationshipService = class {
         "confidence",
         "source",
         "tags",
+        "member_count",
         "created_at",
         "updated_at",
         "version"
@@ -4027,6 +4086,7 @@ var SpaceService = class {
   moderationClient;
   memoryIndex;
   recommendationService;
+  eventBus;
   constructor(weaviateClient, userCollection, userId, confirmationTokenService, logger2, memoryIndexService2, options) {
     this.weaviateClient = weaviateClient;
     this.userCollection = userCollection;
@@ -4036,6 +4096,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 ────────────────────────────────────────
@@ -4050,6 +4111,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 || [];
@@ -4069,11 +4170,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;
@@ -4085,14 +4182,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
     });
@@ -4111,11 +4208,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));
@@ -4124,7 +4217,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,
@@ -4132,7 +4225,7 @@ var SpaceService = class {
     });
     this.logger.info("Retract confirmation created", {
       userId: this.userId,
-      memoryId: input.memory_id,
+      memoryId: resolvedMemoryId,
       spaces,
       groups
     });
@@ -4386,6 +4479,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 || [];
@@ -4410,6 +4519,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);
@@ -4459,6 +4569,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);
@@ -4517,6 +4628,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,
@@ -4598,6 +4738,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,
@@ -5527,6 +5682,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, config3) {
+    this.logger = logger2;
+    this.resolveEndpoint = config3.resolveEndpoint;
+    this.maxBatchSize = config3.maxBatchSize ?? DEFAULT_MAX_BATCH_SIZE;
+    this.flushIntervalMs = config3.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS;
+    this.timeoutMs = config3.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.onError = config3.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, config3) {
+  return new BatchedWebhookService(logger2, config3);
+}
+
 // src/weaviate/schema.ts
 init_logger();
 
@@ -5645,6 +5926,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);
@@ -5658,7 +5948,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
   };

package/jest.config.js

@@ -2,6 +2,7 @@ export default {
   preset: 'ts-jest/presets/default-esm',
   testEnvironment: 'node',
   extensionsToTreatAsEsm: ['.ts'],
+  maxWorkers: '50%',
   roots: ['<rootDir>/src'],
   testMatch: ['**/*.spec.ts'],
   moduleFileExtensions: ['ts', 'js'],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prmichaelsen/remember-mcp",
-  "version": "3.16.2",
+  "version": "3.17.1",
   "description": "Multi-tenant memory system MCP server with vector search and relationships",
   "main": "dist/server.js",
   "type": "module",
@@ -51,7 +51,7 @@
     "@google-cloud/vision": "^5.3.4",
     "@modelcontextprotocol/sdk": "^1.0.4",
     "@prmichaelsen/firebase-admin-sdk-v8": "^2.2.0",
-    "@prmichaelsen/remember-core": "^0.49.16",
+    "@prmichaelsen/remember-core": "^0.54.0",
     "dotenv": "^16.4.5",
     "uuid": "^13.0.0",
     "weaviate-client": "^3.2.0"

package/src/core-services.ts

@@ -14,8 +14,9 @@ import {
   ConfirmationTokenService,
   createLogger,
   createModerationClient,
+  createBatchedWebhookService,
 } from '@prmichaelsen/remember-core';
-import type { Logger, ModerationClient } from '@prmichaelsen/remember-core';
+import type { Logger, ModerationClient, EventBus } from '@prmichaelsen/remember-core';
 import { getWeaviateClient } from './weaviate/client.js';
 import { getMemoryCollection } from './weaviate/schema.js';
 
@@ -36,6 +37,16 @@ const moderationClient: ModerationClient | undefined = process.env.ANTHROPIC_API
   : undefined;
 const memoryIndexService = new MemoryIndexService(coreLogger);
 
+// Webhook event bus — fans out events to all configured endpoints
+const eventBus: EventBus | undefined = (() => {
+  const url = process.env.REMEMBER_WEBHOOK_URL;
+  const secret = process.env.REMEMBER_WEBHOOK_SECRET;
+  if (!url || !secret) return undefined;
+  return createBatchedWebhookService(coreLogger, {
+    resolveEndpoint: () => [{ url, signingSecret: secret }],
+  });
+})();
+
 /** Cached CoreServices per userId — avoids re-instantiation on every tool call */
 const coreServicesCache = new Map<string, CoreServices>();
 
@@ -56,7 +67,7 @@ export function createCoreServices(userId: string): CoreServices {
       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,
   };

package/dist/server-factory.spec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=server-factory.spec.d.ts.map