@prmichaelsen/remember-mcp 3.0.0 → 3.12.0

package/dist/server-factory.js

@@ -18,6 +18,10 @@ var __esm = (fn, res) => function __init() {
 var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -510,6 +514,98 @@ var init_logger = __esm({
   }
 });
 
+// src/firestore/init.ts
+import { initializeApp } from "@prmichaelsen/firebase-admin-sdk-v8";
+import {
+  getDocument,
+  setDocument,
+  addDocument,
+  updateDocument,
+  deleteDocument,
+  queryDocuments,
+  batchWrite,
+  FieldValue,
+  verifyIdToken
+} from "@prmichaelsen/firebase-admin-sdk-v8";
+function initFirestore() {
+  if (initialized) {
+    return;
+  }
+  try {
+    const serviceAccount = JSON.parse(config.firebase.serviceAccount);
+    initializeApp({
+      serviceAccount,
+      projectId: config.firebase.projectId
+    });
+    initialized = true;
+    logger.info("Firestore initialized successfully", {
+      module: "firestore-init"
+    });
+  } catch (error) {
+    logger.error("Firestore initialization failed", {
+      module: "firestore-init",
+      error: error instanceof Error ? error.message : String(error)
+    });
+    logger.error("Make sure FIREBASE_ADMIN_SERVICE_ACCOUNT_KEY is valid JSON", {
+      module: "firestore-init"
+    });
+    logger.error("Check for proper escaping in .env file", {
+      module: "firestore-init"
+    });
+    throw error;
+  }
+}
+var initialized;
+var init_init = __esm({
+  "src/firestore/init.ts"() {
+    "use strict";
+    init_config();
+    init_logger();
+    initialized = false;
+  }
+});
+
+// src/services/trust-enforcement.ts
+function buildTrustFilter(collection, accessorTrustLevel) {
+  return collection.filter.byProperty("trust_score").lessThanOrEqual(accessorTrustLevel);
+}
+function isTrustSufficient(memoryTrust, accessorTrust) {
+  return accessorTrust >= memoryTrust;
+}
+var init_trust_enforcement = __esm({
+  "src/services/trust-enforcement.ts"() {
+    "use strict";
+  }
+});
+
+// src/firestore/paths.ts
+function getBasePrefix() {
+  const environment = process.env.ENVIRONMENT;
+  if (environment && environment !== "production" && environment !== "prod") {
+    return `${environment}.${APP_NAME}`;
+  }
+  const isDevelopment = process.env.NODE_ENV === "development";
+  if (isDevelopment) {
+    const customPrefix = process.env.DB_PREFIX;
+    if (customPrefix) {
+      return customPrefix;
+    }
+    return `e0.${APP_NAME}`;
+  }
+  return APP_NAME;
+}
+function getUserPreferencesPath(userId) {
+  return `${BASE}.users/${userId}/preferences`;
+}
+var APP_NAME, BASE;
+var init_paths = __esm({
+  "src/firestore/paths.ts"() {
+    "use strict";
+    APP_NAME = "remember-mcp";
+    BASE = getBasePrefix();
+  }
+});
+
 // src/types/space-memory.ts
 var SUPPORTED_SPACES;
 var init_space_memory = __esm({
@@ -519,6 +615,325 @@ var init_space_memory = __esm({
   }
 });
 
+// src/types/ghost-config.ts
+var DEFAULT_GHOST_CONFIG;
+var init_ghost_config = __esm({
+  "src/types/ghost-config.ts"() {
+    "use strict";
+    DEFAULT_GHOST_CONFIG = {
+      enabled: false,
+      public_ghost_enabled: false,
+      default_friend_trust: 0.25,
+      default_public_trust: 0,
+      per_user_trust: {},
+      blocked_users: [],
+      enforcement_mode: "query"
+    };
+  }
+});
+
+// src/services/ghost-config.service.ts
+var ghost_config_service_exports = {};
+__export(ghost_config_service_exports, {
+  FirestoreGhostConfigProvider: () => FirestoreGhostConfigProvider,
+  blockUser: () => blockUser,
+  getGhostConfig: () => getGhostConfig,
+  isGhostEnabled: () => isGhostEnabled,
+  removeUserTrust: () => removeUserTrust,
+  setGhostConfigFields: () => setGhostConfigFields,
+  setUserTrust: () => setUserTrust,
+  unblockUser: () => unblockUser,
+  validateGhostConfigUpdate: () => validateGhostConfigUpdate
+});
+function getGhostConfigPath(ownerUserId) {
+  return {
+    collectionPath: `${BASE}.users/${ownerUserId}/ghost_config`,
+    docId: "settings"
+  };
+}
+async function getGhostConfig(ownerUserId) {
+  try {
+    const { collectionPath, docId } = getGhostConfigPath(ownerUserId);
+    const doc = await getDocument(collectionPath, docId);
+    if (!doc) {
+      return { ...DEFAULT_GHOST_CONFIG };
+    }
+    return { ...DEFAULT_GHOST_CONFIG, ...doc };
+  } catch (error) {
+    logger.error("Failed to get ghost config", {
+      service: SERVICE,
+      ownerUserId,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return { ...DEFAULT_GHOST_CONFIG };
+  }
+}
+async function setGhostConfigFields(ownerUserId, config2) {
+  const { collectionPath, docId } = getGhostConfigPath(ownerUserId);
+  await setDocument(collectionPath, docId, config2, { merge: true });
+  logger.info("Ghost config updated", {
+    service: SERVICE,
+    ownerUserId,
+    updatedKeys: Object.keys(config2)
+  });
+  return getGhostConfig(ownerUserId);
+}
+async function setUserTrust(ownerUserId, targetUserId, trustLevel) {
+  if (trustLevel < 0 || trustLevel > 1) {
+    throw new Error(`Trust level must be between 0 and 1, got ${trustLevel}`);
+  }
+  const current = await getGhostConfig(ownerUserId);
+  const per_user_trust = { ...current.per_user_trust, [targetUserId]: trustLevel };
+  const { collectionPath, docId } = getGhostConfigPath(ownerUserId);
+  await setDocument(collectionPath, docId, { per_user_trust }, { merge: true });
+  logger.info("User trust level set", {
+    service: SERVICE,
+    ownerUserId,
+    targetUserId,
+    trustLevel
+  });
+}
+async function removeUserTrust(ownerUserId, targetUserId) {
+  const current = await getGhostConfig(ownerUserId);
+  const per_user_trust = { ...current.per_user_trust };
+  delete per_user_trust[targetUserId];
+  const { collectionPath, docId } = getGhostConfigPath(ownerUserId);
+  await setDocument(collectionPath, docId, { per_user_trust }, { merge: true });
+  logger.info("User trust override removed", {
+    service: SERVICE,
+    ownerUserId,
+    targetUserId
+  });
+}
+async function blockUser(ownerUserId, targetUserId) {
+  const current = await getGhostConfig(ownerUserId);
+  if (current.blocked_users.includes(targetUserId)) {
+    return;
+  }
+  const blocked_users = [...current.blocked_users, targetUserId];
+  const { collectionPath, docId } = getGhostConfigPath(ownerUserId);
+  await setDocument(collectionPath, docId, { blocked_users }, { merge: true });
+  logger.info("User blocked from ghost access", {
+    service: SERVICE,
+    ownerUserId,
+    targetUserId
+  });
+}
+async function unblockUser(ownerUserId, targetUserId) {
+  const current = await getGhostConfig(ownerUserId);
+  if (!current.blocked_users.includes(targetUserId)) {
+    return;
+  }
+  const blocked_users = current.blocked_users.filter((id) => id !== targetUserId);
+  const { collectionPath, docId } = getGhostConfigPath(ownerUserId);
+  await setDocument(collectionPath, docId, { blocked_users }, { merge: true });
+  logger.info("User unblocked from ghost access", {
+    service: SERVICE,
+    ownerUserId,
+    targetUserId
+  });
+}
+async function isGhostEnabled(ownerUserId) {
+  const config2 = await getGhostConfig(ownerUserId);
+  return config2.enabled;
+}
+function validateGhostConfigUpdate(config2) {
+  if (config2.default_friend_trust !== void 0) {
+    if (config2.default_friend_trust < 0 || config2.default_friend_trust > 1) {
+      throw new Error(`default_friend_trust must be between 0 and 1, got ${config2.default_friend_trust}`);
+    }
+  }
+  if (config2.default_public_trust !== void 0) {
+    if (config2.default_public_trust < 0 || config2.default_public_trust > 1) {
+      throw new Error(`default_public_trust must be between 0 and 1, got ${config2.default_public_trust}`);
+    }
+  }
+  if (config2.enforcement_mode !== void 0) {
+    const valid = ["query", "prompt", "hybrid"];
+    if (!valid.includes(config2.enforcement_mode)) {
+      throw new Error(`enforcement_mode must be one of ${valid.join(", ")}, got ${config2.enforcement_mode}`);
+    }
+  }
+  if (config2.per_user_trust !== void 0) {
+    for (const [userId, level] of Object.entries(config2.per_user_trust)) {
+      if (level < 0 || level > 1) {
+        throw new Error(`Trust level for ${userId} must be between 0 and 1, got ${level}`);
+      }
+    }
+  }
+}
+var SERVICE, FirestoreGhostConfigProvider;
+var init_ghost_config_service = __esm({
+  "src/services/ghost-config.service.ts"() {
+    "use strict";
+    init_init();
+    init_paths();
+    init_logger();
+    init_ghost_config();
+    SERVICE = "GhostConfigService";
+    FirestoreGhostConfigProvider = class {
+      async getGhostConfig(ownerUserId) {
+        const config2 = await getGhostConfig(ownerUserId);
+        if (!config2.enabled) {
+          return null;
+        }
+        return config2;
+      }
+    };
+  }
+});
+
+// src/services/access-control.ts
+var access_control_exports = {};
+__export(access_control_exports, {
+  InMemoryEscalationStore: () => InMemoryEscalationStore,
+  StubGhostConfigProvider: () => StubGhostConfigProvider,
+  checkMemoryAccess: () => checkMemoryAccess,
+  formatAccessResultMessage: () => formatAccessResultMessage,
+  handleInsufficientTrust: () => handleInsufficientTrust,
+  isMemoryBlocked: () => isMemoryBlocked,
+  resetBlock: () => resetBlock,
+  resolveAccessorTrustLevel: () => resolveAccessorTrustLevel
+});
+async function checkMemoryAccess(accessorUserId, memory, ghostConfigProvider, escalationStore) {
+  const ownerUserId = memory.user_id;
+  const memoryId = memory.id;
+  if (accessorUserId === ownerUserId) {
+    return { status: "granted", memory, access_level: "owner" };
+  }
+  const ghostConfig = await ghostConfigProvider.getGhostConfig(ownerUserId);
+  if (!ghostConfig || !ghostConfig.enabled) {
+    return { status: "no_permission", owner_user_id: ownerUserId, accessor_user_id: accessorUserId };
+  }
+  if (ghostConfig.blocked_users.includes(accessorUserId)) {
+    return { status: "no_permission", owner_user_id: ownerUserId, accessor_user_id: accessorUserId };
+  }
+  const block = await escalationStore.getBlock(ownerUserId, accessorUserId, memoryId);
+  if (block) {
+    return {
+      status: "blocked",
+      memory_id: memoryId,
+      reason: block.reason,
+      blocked_at: block.blocked_at
+    };
+  }
+  const accessorTrust = resolveAccessorTrustLevel(ghostConfig, accessorUserId);
+  const memoryTrust = memory.trust;
+  if (!isTrustSufficient(memoryTrust, accessorTrust)) {
+    const result = await handleInsufficientTrust(
+      ownerUserId,
+      accessorUserId,
+      memoryId,
+      memoryTrust,
+      accessorTrust,
+      escalationStore
+    );
+    return result;
+  }
+  return { status: "granted", memory, access_level: "trusted" };
+}
+async function handleInsufficientTrust(ownerUserId, accessorUserId, memoryId, requiredTrust, actualTrust, escalationStore) {
+  const attempt = await escalationStore.incrementAttempts(ownerUserId, accessorUserId, memoryId);
+  if (attempt.count >= MAX_ATTEMPTS_BEFORE_BLOCK) {
+    const block = {
+      blocked_at: (/* @__PURE__ */ new Date()).toISOString(),
+      reason: `Access blocked after ${attempt.count} unauthorized attempts`,
+      attempt_count: attempt.count
+    };
+    await escalationStore.setBlock(ownerUserId, accessorUserId, memoryId, block);
+    return {
+      status: "blocked",
+      memory_id: memoryId,
+      reason: block.reason,
+      blocked_at: block.blocked_at
+    };
+  }
+  return {
+    status: "insufficient_trust",
+    memory_id: memoryId,
+    required_trust: requiredTrust,
+    actual_trust: Math.max(0, actualTrust - TRUST_PENALTY),
+    attempts_remaining: MAX_ATTEMPTS_BEFORE_BLOCK - attempt.count
+  };
+}
+async function isMemoryBlocked(ownerUserId, accessorUserId, memoryId, escalationStore) {
+  const block = await escalationStore.getBlock(ownerUserId, accessorUserId, memoryId);
+  return block !== null;
+}
+async function resetBlock(ownerUserId, accessorUserId, memoryId, escalationStore) {
+  await escalationStore.removeBlock(ownerUserId, accessorUserId, memoryId);
+}
+function resolveAccessorTrustLevel(ghostConfig, accessorUserId) {
+  if (accessorUserId in ghostConfig.per_user_trust) {
+    return ghostConfig.per_user_trust[accessorUserId];
+  }
+  return ghostConfig.default_public_trust ?? 0;
+}
+function formatAccessResultMessage(result) {
+  switch (result.status) {
+    case "granted":
+      return result.access_level === "owner" ? "Access granted (owner)." : "Access granted (trusted).";
+    case "insufficient_trust":
+      return `Insufficient trust level. Required: ${result.required_trust.toFixed(2)}, actual: ${result.actual_trust.toFixed(2)}. ${result.attempts_remaining} attempt(s) remaining before access is blocked.`;
+    case "blocked":
+      return `Access blocked: ${result.reason}`;
+    case "no_permission":
+      return "No permission to access this user's memories.";
+    case "not_found":
+      return `Memory ${result.memory_id} not found.`;
+    case "deleted":
+      return `Memory ${result.memory_id} was deleted on ${result.deleted_at}.`;
+  }
+}
+var StubGhostConfigProvider, InMemoryEscalationStore, TRUST_PENALTY, MAX_ATTEMPTS_BEFORE_BLOCK;
+var init_access_control = __esm({
+  "src/services/access-control.ts"() {
+    "use strict";
+    init_trust_enforcement();
+    StubGhostConfigProvider = class {
+      configs = /* @__PURE__ */ new Map();
+      async getGhostConfig(ownerUserId) {
+        return this.configs.get(ownerUserId) ?? null;
+      }
+      /** Test helper: set a GhostConfig for a user */
+      setGhostConfig(ownerUserId, config2) {
+        this.configs.set(ownerUserId, config2);
+      }
+    };
+    InMemoryEscalationStore = class {
+      blocks = /* @__PURE__ */ new Map();
+      attempts = /* @__PURE__ */ new Map();
+      key(ownerUserId, accessorUserId, memoryId) {
+        return `${ownerUserId}:${accessorUserId}:${memoryId}`;
+      }
+      async getBlock(ownerUserId, accessorUserId, memoryId) {
+        return this.blocks.get(this.key(ownerUserId, accessorUserId, memoryId)) ?? null;
+      }
+      async setBlock(ownerUserId, accessorUserId, memoryId, block) {
+        this.blocks.set(this.key(ownerUserId, accessorUserId, memoryId), block);
+      }
+      async removeBlock(ownerUserId, accessorUserId, memoryId) {
+        this.blocks.delete(this.key(ownerUserId, accessorUserId, memoryId));
+      }
+      async getAttempts(ownerUserId, accessorUserId, memoryId) {
+        return this.attempts.get(this.key(ownerUserId, accessorUserId, memoryId)) ?? null;
+      }
+      async incrementAttempts(ownerUserId, accessorUserId, memoryId) {
+        const k = this.key(ownerUserId, accessorUserId, memoryId);
+        const existing = this.attempts.get(k);
+        const record = {
+          count: (existing?.count ?? 0) + 1,
+          last_attempt_at: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        this.attempts.set(k, record);
+        return record;
+      }
+    };
+    TRUST_PENALTY = 0.1;
+    MAX_ATTEMPTS_BEFORE_BLOCK = 3;
+  }
+});
+
 // src/server-factory.ts
 init_logger();
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -676,15 +1091,8 @@ function getWeaviateClient() {
   }
   return client;
 }
-function sanitizeUserId(userId) {
-  let sanitized = userId.replace(/[^a-zA-Z0-9]/g, "_");
-  if (/^[0-9]/.test(sanitized)) {
-    sanitized = "_" + sanitized;
-  }
-  return sanitized.charAt(0).toUpperCase() + sanitized.slice(1);
-}
 function getMemoryCollectionName(userId) {
-  return `Memory_${sanitizeUserId(userId)}`;
+  return `Memory_users_${userId}`;
 }
 var ALL_MEMORY_PROPERTIES = [
   // Core identity
@@ -692,16 +1100,28 @@ var ALL_MEMORY_PROPERTIES = [
   "doc_type",
   // Memory fields
   "content",
+  "content_type",
+  // v2 canonical
   "title",
   "summary",
   "type",
+  // v1 compat (v2: content_type)
   // Scoring fields
   "weight",
   "base_weight",
+  "trust_score",
+  // v2 canonical
   "trust",
+  // v1 compat (v2: trust_score)
   "confidence",
   "computed_weight",
-  // Location fields (flattened)
+  // Location fields (v2)
+  "location_name",
+  "location_lat",
+  // v2 canonical
+  "location_lon",
+  // v2 canonical
+  // Location fields (v1 compat)
   "location_gps_lat",
   "location_gps_lng",
   "location_address",
@@ -711,12 +1131,24 @@ var ALL_MEMORY_PROPERTIES = [
   // Locale fields
   "locale_language",
   "locale_timezone",
-  // Context fields (flattened)
+  // Context fields
   "context_conversation_id",
   "context_summary",
   "context_timestamp",
-  // Relationships
+  "context_app",
+  "context_url",
+  // Relationships (v2)
+  "relationship_ids",
+  // v2 canonical
+  "related_memory_ids",
+  // v2 canonical
+  // Relationships (v1 compat)
   "relationships",
+  "memory_ids",
+  // Common relationship fields
+  "relationship_type",
+  "observation",
+  "strength",
   // Access tracking
   "access_count",
   "last_accessed_at",
@@ -727,24 +1159,29 @@ var ALL_MEMORY_PROPERTIES = [
   "updated_at",
   "version",
   "template_id",
-  // Relationship-specific fields
-  "memory_ids",
-  "relationship_type",
-  "observation",
-  "strength",
+  // Tracking arrays (v2)
+  "space_ids",
+  "group_ids",
   // Comment/threading fields
   "parent_id",
   "thread_root_id",
   "moderation_flags",
-  // Space/publishing fields (for Memory_public collection)
+  // Space/publishing fields
   "spaces",
+  // legacy
   "space_id",
+  // legacy
   "author_id",
   "ghost_id",
   "attribution",
   "published_at",
   "discovery_count",
   "space_memory_id",
+  // legacy
+  "original_memory_id",
+  "revised_at",
+  "revision_count",
+  "revision_history",
   // Soft delete fields
   "deleted_at",
   "deleted_by",
@@ -788,57 +1225,177 @@ async function fetchMemoryWithAllProperties(collection, memoryId) {
   }
 }
 
-// src/firestore/init.ts
-init_config();
-init_logger();
-import { initializeApp } from "@prmichaelsen/firebase-admin-sdk-v8";
-import {
-  getDocument,
-  setDocument,
-  addDocument,
-  updateDocument,
-  deleteDocument,
-  queryDocuments,
-  batchWrite,
-  FieldValue,
-  verifyIdToken
-} from "@prmichaelsen/firebase-admin-sdk-v8";
-var initialized = false;
-function initFirestore() {
-  if (initialized) {
-    return;
-  }
-  try {
-    const serviceAccount = JSON.parse(config.firebase.serviceAccount);
-    initializeApp({
-      serviceAccount,
-      projectId: config.firebase.projectId
-    });
-    initialized = true;
-    logger.info("Firestore initialized successfully", {
-      module: "firestore-init"
-    });
-  } catch (error) {
-    logger.error("Firestore initialization failed", {
-      module: "firestore-init",
-      error: error instanceof Error ? error.message : String(error)
-    });
-    logger.error("Make sure FIREBASE_ADMIN_SERVICE_ACCOUNT_KEY is valid JSON", {
-      module: "firestore-init"
-    });
-    logger.error("Check for proper escaping in .env file", {
-      module: "firestore-init"
-    });
-    throw error;
+// src/server-factory.ts
+init_init();
+
+// src/services/credentials-provider.ts
+var StubCredentialsProvider = class {
+  async getCredentials(_accessToken, userId) {
+    return {
+      user_id: userId,
+      group_memberships: []
+    };
   }
+};
+function createCredentialsProvider() {
+  return new StubCredentialsProvider();
 }
+var credentialsProvider = createCredentialsProvider();
 
 // src/weaviate/schema.ts
-import weaviate2 from "weaviate-client";
 init_logger();
+
+// src/schema/v2-collections.ts
+import { configure } from "weaviate-client";
+var COMMON_MEMORY_PROPERTIES = [
+  // Core content
+  { name: "content", dataType: configure.dataType.TEXT },
+  { name: "content_type", dataType: configure.dataType.TEXT },
+  { name: "title", dataType: configure.dataType.TEXT },
+  { name: "summary", dataType: configure.dataType.TEXT },
+  { name: "type", dataType: configure.dataType.TEXT },
+  // v1 compat (v2: content_type)
+  // Tracking arrays (v2 feature)
+  { name: "space_ids", dataType: configure.dataType.TEXT_ARRAY },
+  { name: "group_ids", dataType: configure.dataType.TEXT_ARRAY },
+  // Metadata
+  { name: "created_at", dataType: configure.dataType.DATE },
+  { name: "updated_at", dataType: configure.dataType.DATE },
+  { name: "version", dataType: configure.dataType.INT },
+  // User context
+  { name: "user_id", dataType: configure.dataType.TEXT },
+  // Document type (memory, relationship, comment)
+  { name: "doc_type", dataType: configure.dataType.TEXT },
+  // Memory-specific fields
+  { name: "tags", dataType: configure.dataType.TEXT_ARRAY },
+  { name: "weight", dataType: configure.dataType.NUMBER },
+  { name: "trust_score", dataType: configure.dataType.NUMBER },
+  { name: "trust", dataType: configure.dataType.NUMBER },
+  // v1 compat (v2: trust_score)
+  { name: "base_weight", dataType: configure.dataType.NUMBER },
+  { name: "computed_weight", dataType: configure.dataType.NUMBER },
+  { name: "confidence", dataType: configure.dataType.NUMBER },
+  { name: "strength", dataType: configure.dataType.NUMBER },
+  // Location data (v2 names)
+  { name: "location_name", dataType: configure.dataType.TEXT },
+  { name: "location_lat", dataType: configure.dataType.NUMBER },
+  { name: "location_lon", dataType: configure.dataType.NUMBER },
+  // Location data (v1 compat)
+  { name: "location_gps_lat", dataType: configure.dataType.NUMBER },
+  { name: "location_gps_lng", dataType: configure.dataType.NUMBER },
+  { name: "location_address", dataType: configure.dataType.TEXT },
+  { name: "location_city", dataType: configure.dataType.TEXT },
+  { name: "location_country", dataType: configure.dataType.TEXT },
+  { name: "location_source", dataType: configure.dataType.TEXT },
+  // Locale
+  { name: "locale_language", dataType: configure.dataType.TEXT },
+  { name: "locale_timezone", dataType: configure.dataType.TEXT },
+  // Context
+  { name: "context_app", dataType: configure.dataType.TEXT },
+  { name: "context_url", dataType: configure.dataType.TEXT },
+  { name: "context_conversation_id", dataType: configure.dataType.TEXT },
+  { name: "context_summary", dataType: configure.dataType.TEXT },
+  { name: "context_timestamp", dataType: configure.dataType.DATE },
+  // Relationships (v2 names)
+  { name: "relationship_ids", dataType: configure.dataType.TEXT_ARRAY },
+  { name: "relationship_type", dataType: configure.dataType.TEXT },
+  { name: "related_memory_ids", dataType: configure.dataType.TEXT_ARRAY },
+  { name: "observation", dataType: configure.dataType.TEXT },
+  // Relationships (v1 compat)
+  { name: "relationships", dataType: configure.dataType.TEXT_ARRAY },
+  { name: "memory_ids", dataType: configure.dataType.TEXT_ARRAY },
+  // Access tracking
+  { name: "access_count", dataType: configure.dataType.NUMBER },
+  { name: "last_accessed_at", dataType: configure.dataType.DATE },
+  // References & templates
+  { name: "references", dataType: configure.dataType.TEXT_ARRAY },
+  { name: "template_id", dataType: configure.dataType.TEXT },
+  // Comments (Phase 1)
+  { name: "parent_id", dataType: configure.dataType.TEXT },
+  { name: "thread_root_id", dataType: configure.dataType.TEXT },
+  { name: "moderation_flags", dataType: configure.dataType.TEXT_ARRAY },
+  // Soft delete
+  { name: "deleted_at", dataType: configure.dataType.DATE },
+  { name: "deleted_by", dataType: configure.dataType.TEXT },
+  { name: "deletion_reason", dataType: configure.dataType.TEXT }
+];
+var PUBLISHED_MEMORY_PROPERTIES = [
+  // Publication metadata
+  { name: "published_at", dataType: configure.dataType.DATE },
+  { name: "revised_at", dataType: configure.dataType.DATE },
+  // Attribution
+  { name: "author_id", dataType: configure.dataType.TEXT },
+  { name: "ghost_id", dataType: configure.dataType.TEXT },
+  { name: "attribution", dataType: configure.dataType.TEXT },
+  // Discovery
+  { name: "discovery_count", dataType: configure.dataType.INT },
+  // Revision tracking
+  { name: "revision_count", dataType: configure.dataType.INT },
+  { name: "original_memory_id", dataType: configure.dataType.TEXT },
+  // Moderation (nullable — null defaults to approved)
+  { name: "moderation_status", dataType: configure.dataType.TEXT },
+  { name: "moderated_by", dataType: configure.dataType.TEXT },
+  { name: "moderated_at", dataType: configure.dataType.DATE },
+  // Memory-level ACL (nullable — null defaults to owner_only semantics)
+  { name: "write_mode", dataType: configure.dataType.TEXT },
+  { name: "owner_id", dataType: configure.dataType.TEXT },
+  { name: "overwrite_allowed_ids", dataType: configure.dataType.TEXT_ARRAY },
+  { name: "last_revised_by", dataType: configure.dataType.TEXT },
+  // Legacy compatibility (deprecated but kept for migration)
+  { name: "spaces", dataType: configure.dataType.TEXT_ARRAY },
+  { name: "space_id", dataType: configure.dataType.TEXT },
+  { name: "space_memory_id", dataType: configure.dataType.TEXT }
+];
+function createUserCollectionSchema(userId) {
+  const collectionName = `Memory_users_${userId}`;
+  return {
+    name: collectionName,
+    description: `Private memory collection for user: ${userId}`,
+    // Vector configuration
+    vectorizers: configure.vectorizer.text2VecOpenAI({
+      model: "text-embedding-3-small",
+      dimensions: 1536,
+      vectorizeCollectionName: false
+    }),
+    // Properties
+    properties: COMMON_MEMORY_PROPERTIES,
+    // Inverted index configuration
+    invertedIndex: configure.invertedIndex({
+      indexNullState: true,
+      indexPropertyLength: true,
+      indexTimestamps: true
+    })
+  };
+}
+function createSpaceCollectionSchema() {
+  const collectionName = "Memory_spaces_public";
+  return {
+    name: collectionName,
+    description: "Shared memory collection for all public spaces",
+    // Vector configuration
+    vectorizers: configure.vectorizer.text2VecOpenAI({
+      model: "text-embedding-3-small",
+      dimensions: 1536,
+      vectorizeCollectionName: false
+    }),
+    // Properties (common + published)
+    properties: [
+      ...COMMON_MEMORY_PROPERTIES,
+      ...PUBLISHED_MEMORY_PROPERTIES
+    ],
+    // Inverted index configuration
+    invertedIndex: configure.invertedIndex({
+      indexNullState: true,
+      indexPropertyLength: true,
+      indexTimestamps: true
+    })
+  };
+}
+
+// src/weaviate/schema.ts
 async function createMemoryCollection(userId) {
   const client2 = getWeaviateClient();
-  const collectionName = `Memory_${sanitizeUserId(userId)}`;
+  const collectionName = `Memory_users_${userId}`;
   const exists = await client2.collections.exists(collectionName);
   if (exists) {
     logger.debug("Collection already exists", {
@@ -851,238 +1408,8 @@ async function createMemoryCollection(userId) {
     module: "weaviate-schema",
     collectionName
   });
-  await client2.collections.create({
-    name: collectionName,
-    // Vectorizer configuration
-    vectorizers: weaviate2.configure.vectorizer.text2VecOpenAI({
-      model: "text-embedding-3-small",
-      // Vectorize content, title, summary, and observation for semantic search
-      // Note: title and summary are optional fields
-      sourceProperties: ["content", "title", "summary", "observation"]
-    }),
-    properties: [
-      // Discriminator
-      {
-        name: "doc_type",
-        dataType: "text",
-        description: 'Document type: "memory" or "relationship"'
-      },
-      // Core identity
-      {
-        name: "user_id",
-        dataType: "text",
-        description: "User who owns this document"
-      },
-      // Memory fields
-      {
-        name: "content",
-        dataType: "text",
-        description: "Main memory content (vectorized)"
-      },
-      {
-        name: "title",
-        dataType: "text",
-        description: "Optional short title"
-      },
-      {
-        name: "summary",
-        dataType: "text",
-        description: "Optional brief summary"
-      },
-      {
-        name: "type",
-        dataType: "text",
-        description: "Content type (note, event, person, etc.)"
-      },
-      // Scoring fields
-      {
-        name: "weight",
-        dataType: "number",
-        description: "Significance/priority (0-1)"
-      },
-      {
-        name: "trust",
-        dataType: "number",
-        description: "Access control level (0-1)"
-      },
-      {
-        name: "confidence",
-        dataType: "number",
-        description: "System confidence in accuracy (0-1)"
-      },
-      // Location fields (flattened for Weaviate)
-      {
-        name: "location_gps_lat",
-        dataType: "number",
-        description: "GPS latitude"
-      },
-      {
-        name: "location_gps_lng",
-        dataType: "number",
-        description: "GPS longitude"
-      },
-      {
-        name: "location_address",
-        dataType: "text",
-        description: "Formatted address"
-      },
-      {
-        name: "location_city",
-        dataType: "text",
-        description: "City name"
-      },
-      {
-        name: "location_country",
-        dataType: "text",
-        description: "Country name"
-      },
-      {
-        name: "location_source",
-        dataType: "text",
-        description: "Location source (gps, ip, manual, etc.)"
-      },
-      // Locale fields
-      {
-        name: "locale_language",
-        dataType: "text",
-        description: "Language code (e.g., en, es, fr)"
-      },
-      {
-        name: "locale_timezone",
-        dataType: "text",
-        description: "Timezone (e.g., America/Los_Angeles)"
-      },
-      // Context fields
-      {
-        name: "context_conversation_id",
-        dataType: "text",
-        description: "Conversation ID"
-      },
-      {
-        name: "context_summary",
-        dataType: "text",
-        description: "Brief context summary"
-      },
-      {
-        name: "context_timestamp",
-        dataType: "date",
-        description: "Context timestamp"
-      },
-      // Relationships
-      {
-        name: "relationships",
-        dataType: "text[]",
-        description: "Array of relationship IDs"
-      },
-      // Access tracking
-      {
-        name: "access_count",
-        dataType: "number",
-        description: "Total times accessed"
-      },
-      {
-        name: "last_accessed_at",
-        dataType: "date",
-        description: "Most recent access timestamp"
-      },
-      // Metadata
-      {
-        name: "tags",
-        dataType: "text[]",
-        description: "Tags for organization"
-      },
-      {
-        name: "references",
-        dataType: "text[]",
-        description: "Source URLs"
-      },
-      {
-        name: "created_at",
-        dataType: "date",
-        description: "Creation timestamp"
-      },
-      {
-        name: "updated_at",
-        dataType: "date",
-        description: "Last update timestamp"
-      },
-      {
-        name: "version",
-        dataType: "number",
-        description: "Version number"
-      },
-      // Template fields
-      {
-        name: "template_id",
-        dataType: "text",
-        description: "Template ID if using template"
-      },
-      // Relationship-specific fields
-      {
-        name: "memory_ids",
-        dataType: "text[]",
-        description: "Connected memory IDs (for relationships)"
-      },
-      {
-        name: "relationship_type",
-        dataType: "text",
-        description: "Relationship type (for relationships)"
-      },
-      {
-        name: "observation",
-        dataType: "text",
-        description: "Relationship observation (vectorized)"
-      },
-      {
-        name: "strength",
-        dataType: "number",
-        description: "Relationship strength (0-1)"
-      },
-      // Computed fields
-      {
-        name: "base_weight",
-        dataType: "number",
-        description: "User-specified weight"
-      },
-      {
-        name: "computed_weight",
-        dataType: "number",
-        description: "Calculated effective weight"
-      },
-      // Comment/threading fields (for threaded discussions in shared spaces)
-      {
-        name: "parent_id",
-        dataType: "text",
-        description: "ID of parent memory or comment (for threading)"
-      },
-      {
-        name: "thread_root_id",
-        dataType: "text",
-        description: "Root memory ID for fetching entire thread"
-      },
-      {
-        name: "moderation_flags",
-        dataType: "text[]",
-        description: 'Per-space moderation flags (format: "{space_id}:{flag_type}")'
-      },
-      // Soft delete fields
-      {
-        name: "deleted_at",
-        dataType: "date",
-        description: "Timestamp when memory was soft-deleted (null = not deleted)"
-      },
-      {
-        name: "deleted_by",
-        dataType: "text",
-        description: "User ID who deleted the memory"
-      },
-      {
-        name: "deletion_reason",
-        dataType: "text",
-        description: "Optional reason for deletion"
-      }
-    ]
-  });
+  const schema = createUserCollectionSchema(userId);
+  await client2.collections.create(schema);
   logger.info("Memory collection created successfully", {
     module: "weaviate-schema",
     collectionName
@@ -1090,7 +1417,7 @@ async function createMemoryCollection(userId) {
 }
 async function ensureMemoryCollection(userId) {
   const client2 = getWeaviateClient();
-  const collectionName = `Memory_${sanitizeUserId(userId)}`;
+  const collectionName = `Memory_users_${userId}`;
   const exists = await client2.collections.exists(collectionName);
   if (!exists) {
     await createMemoryCollection(userId);
@@ -1098,7 +1425,7 @@ async function ensureMemoryCollection(userId) {
 }
 function getMemoryCollection(userId) {
   const client2 = getWeaviateClient();
-  const collectionName = `Memory_${sanitizeUserId(userId)}`;
+  const collectionName = `Memory_users_${userId}`;
   return client2.collections.get(collectionName);
 }
 
@@ -1180,7 +1507,10 @@ var CONTENT_TYPES = [
   "system",
   "action",
   "audit",
-  "history"
+  "history",
+  // Cross-user & Threading
+  "ghost",
+  "comment"
 ];
 var CONTENT_TYPE_METADATA = {
   // Core Types
@@ -1474,6 +1804,21 @@ var CONTENT_TYPE_METADATA = {
     description: "Change history and version tracking",
     examples: ["Edit history", "Version history", "Change logs"],
     common_fields: ["target_id", "change_type", "previous_value", "new_value"]
+  },
+  // Cross-user & Threading
+  ghost: {
+    name: "ghost",
+    category: "cross_user",
+    description: "Ghost conversation memory \u2014 stores context from AI-mediated cross-user interactions",
+    examples: ["Ghost conversation context", "Cross-user interaction history"],
+    common_fields: ["ghost_owner_id", "conversing_user_id"]
+  },
+  comment: {
+    name: "comment",
+    category: "cross_user",
+    description: "Threaded comments on shared memories in spaces and groups",
+    examples: ["Comments on shared memories", "Discussion replies", "Feedback"],
+    common_fields: ["parent_id", "thread_root_id"]
   }
 };
 function isValidContentType(type) {
@@ -1560,7 +1905,7 @@ var createMemoryTool = {
       },
       trust: {
         type: "number",
-        description: "Access control level (0-1, default: 0.5)",
+        description: "Access control level (0-1, default: 0.25)",
         minimum: 0,
         maximum: 1
       },
@@ -1601,8 +1946,11 @@ var createMemoryTool = {
     required: ["content"]
   }
 };
-async function handleCreateMemory(args, userId, context) {
+async function handleCreateMemory(args, userId, authContext, context) {
+  const debug = createDebugLogger({ tool: "remember_create_memory", userId, operation: "create memory" });
   try {
+    debug.info("Tool invoked");
+    debug.trace("Arguments", { args });
     logger.info("Creating memory", { userId, type: args.type });
     await ensureMemoryCollection(userId);
     const collection = getMemoryCollection(userId);
@@ -1616,36 +1964,19 @@ async function handleCreateMemory(args, userId, context) {
       title: args.title,
       summary: args.title,
       // Use title as summary for now
-      type: args.type && isValidContentType(args.type) ? args.type : DEFAULT_CONTENT_TYPE,
+      content_type: args.type && isValidContentType(args.type) ? args.type : DEFAULT_CONTENT_TYPE,
       // Scoring
       weight: args.weight ?? 0.5,
-      trust: args.trust ?? 0.5,
+      trust_score: args.trust ?? 0.25,
       confidence: 1,
-      // Location (from context or default)
-      location: {
-        gps: null,
-        address: null,
-        source: "unavailable",
-        confidence: 0,
-        is_approximate: true
-      },
       // Context
-      context: {
-        timestamp: now,
-        source: {
-          type: "api",
-          platform: "mcp"
-        },
-        summary: context?.summary || "Memory created via MCP",
-        conversation_id: context?.conversation_id,
-        ...context
-      },
+      context_summary: context?.summary || "Memory created via MCP",
+      context_conversation_id: context?.conversation_id,
       // Relationships
-      relationships: [],
+      relationship_ids: [],
       // Access tracking
       access_count: 0,
       last_accessed_at: now,
-      access_frequency: 0,
       // Metadata
       created_at: now,
       updated_at: now,
@@ -1654,14 +1985,17 @@ async function handleCreateMemory(args, userId, context) {
       references: args.references || [],
       // Template
       template_id: args.template_id,
-      structured_content: args.structured_content,
       // Computed weight
       base_weight: args.weight ?? 0.5,
       computed_weight: args.weight ?? 0.5,
       // Comment/threading fields (initialize to defaults)
       parent_id: args.parent_id ?? null,
       thread_root_id: args.thread_root_id ?? null,
-      moderation_flags: args.moderation_flags ?? []
+      moderation_flags: args.moderation_flags ?? [],
+      // Publication tracking arrays (Memory Collection Pattern v2)
+      // Managed by remember_publish / remember_retract — always start empty
+      space_ids: [],
+      group_ids: []
     };
     const result = await collection.data.insert({
       properties: memory
@@ -1674,6 +2008,7 @@ async function handleCreateMemory(args, userId, context) {
     };
     return JSON.stringify(response, null, 2);
   } catch (error) {
+    debug.error("Tool failed", { error: error instanceof Error ? error.message : String(error) });
     handleToolError(error, {
       toolName: "remember_create_memory",
       operation: "create memory",
@@ -1709,11 +2044,11 @@ function buildDocTypeFilters(collection, docType, filters) {
   if (docType === "memory" && filters?.types && filters.types.length > 0) {
     if (filters.types.length === 1) {
       filterList.push(
-        collection.filter.byProperty("type").equal(filters.types[0])
+        collection.filter.byProperty("content_type").equal(filters.types[0])
       );
     } else {
       filterList.push(
-        collection.filter.byProperty("type").containsAny(filters.types)
+        collection.filter.byProperty("content_type").containsAny(filters.types)
       );
     }
   }
@@ -1729,12 +2064,12 @@ function buildDocTypeFilters(collection, docType, filters) {
   }
   if (filters?.trust_min !== void 0) {
     filterList.push(
-      collection.filter.byProperty("trust").greaterThanOrEqual(filters.trust_min)
+      collection.filter.byProperty("trust_score").greaterThanOrEqual(filters.trust_min)
     );
   }
   if (filters?.trust_max !== void 0) {
     filterList.push(
-      collection.filter.byProperty("trust").lessThanOrEqual(filters.trust_max)
+      collection.filter.byProperty("trust_score").lessThanOrEqual(filters.trust_max)
     );
   }
   if (filters?.date_from) {
@@ -1793,6 +2128,7 @@ function buildDeletedFilter(collection, deletedFilter = "exclude") {
 }
 
 // src/tools/search-memory.ts
+init_trust_enforcement();
 var searchMemoryTool = {
   name: "remember_search_memory",
   description: `Search memories AND relationships using hybrid semantic and keyword search.
@@ -1902,24 +2238,33 @@ var searchMemoryTool = {
     required: ["query"]
   }
 };
-async function handleSearchMemory(args, userId) {
+async function handleSearchMemory(args, userId, authContext) {
+  const ghostMode = authContext?.ghostMode;
+  const searchUserId = ghostMode?.owner_user_id ?? userId;
+  const debug = createDebugLogger({ tool: "remember_search_memory", userId: searchUserId, operation: ghostMode ? "ghost search" : "search memory" });
   try {
+    debug.info("Tool invoked");
+    debug.trace("Arguments", { args, ghostMode: !!ghostMode });
     if (!args.query || args.query.trim() === "") {
       throw new Error("Query cannot be empty");
     }
     const includeRelationships = args.include_relationships !== false;
     logger.info("Searching memories and relationships", {
-      userId,
+      userId: searchUserId,
       query: args.query,
-      includeRelationships
+      includeRelationships,
+      ghostMode: !!ghostMode
     });
-    const collection = getMemoryCollection(userId);
+    const collection = getMemoryCollection(searchUserId);
     const alpha = args.alpha ?? 0.7;
     const limit = args.limit ?? 10;
     const offset = args.offset ?? 0;
     const deletedFilter = buildDeletedFilter(collection, args.deleted_filter || "exclude");
+    const trustFilter = ghostMode ? buildTrustFilter(collection, ghostMode.accessor_trust_level) : null;
     const searchFilters = includeRelationships ? buildCombinedSearchFilters(collection, args.filters) : buildMemoryOnlyFilters(collection, args.filters);
-    const combinedFilters = combineFiltersWithAnd([deletedFilter, searchFilters].filter((f) => f !== null));
+    const hasExplicitTypeFilter = args.filters?.types && args.filters.types.length > 0;
+    const ghostExclusionFilter = !hasExplicitTypeFilter ? collection.filter.byProperty("content_type").notEqual("ghost") : null;
+    const combinedFilters = combineFiltersWithAnd([deletedFilter, trustFilter, ghostExclusionFilter, searchFilters].filter((f) => f !== null));
     const searchOptions = {
       alpha,
       limit: limit + offset
@@ -1965,6 +2310,7 @@ async function handleSearchMemory(args, userId) {
     });
     return JSON.stringify(searchResult, null, 2);
   } catch (error) {
+    debug.error("Tool failed", { error: error instanceof Error ? error.message : String(error) });
     handleToolError(error, {
       toolName: "remember_search_memory",
       operation: "search memories",
@@ -1979,8 +2325,9 @@ async function handleSearchMemory(args, userId) {
 import { Filters as Filters2 } from "weaviate-client";
 
 // src/services/confirmation-token.service.ts
-import { randomUUID } from "crypto";
+init_init();
 init_logger();
+import { randomUUID } from "crypto";
 var ConfirmationTokenService = class {
   EXPIRY_MINUTES = 5;
   /**
@@ -2241,8 +2588,11 @@ Examples:
     required: ["memory_id"]
   }
 };
-async function handleDeleteMemory(args, userId) {
+async function handleDeleteMemory(args, userId, authContext) {
+  const debug = createDebugLogger({ tool: "remember_delete_memory", userId, operation: "delete memory" });
   try {
+    debug.info("Tool invoked");
+    debug.trace("Arguments", { args });
     logger.info("Requesting memory deletion", {
       userId,
       memoryId: args.memory_id,
@@ -2250,7 +2600,7 @@ async function handleDeleteMemory(args, userId) {
     });
     const { memory_id, reason } = args;
     const client2 = getWeaviateClient();
-    const collectionName = `Memory_${sanitizeUserId(userId)}`;
+    const collectionName = getMemoryCollectionName(userId);
     const collection = client2.collections.get(collectionName);
     const memory = await fetchMemoryWithAllProperties(collection, memory_id);
     if (!memory) {
@@ -2268,7 +2618,7 @@ async function handleDeleteMemory(args, userId) {
     const relationshipsResult = await collection.query.fetchObjects({
       filters: Filters2.and(
         collection.filter.byProperty("doc_type").equal("relationship"),
-        collection.filter.byProperty("memory_ids").containsAny([memory_id])
+        collection.filter.byProperty("related_memory_ids").containsAny([memory_id])
       ),
       limit: 100
     });
@@ -2302,7 +2652,7 @@ async function handleDeleteMemory(args, userId) {
         preview: {
           memory_id,
           content: memory.properties.content?.substring(0, 200) + (memory.properties.content?.length > 200 ? "..." : ""),
-          type: memory.properties.type,
+          content_type: memory.properties.content_type,
           relationships_count: orphanedRelationships.length,
           will_orphan: orphanedRelationships
         },
@@ -2312,6 +2662,7 @@ async function handleDeleteMemory(args, userId) {
       2
     );
   } catch (error) {
+    debug.error("Tool failed", { error: error instanceof Error ? error.message : String(error) });
     handleToolError(error, {
       toolName: "remember_delete_memory",
       userId,
@@ -2398,8 +2749,11 @@ var updateMemoryTool = {
     required: ["memory_id"]
   }
 };
-async function handleUpdateMemory(args, userId) {
+async function handleUpdateMemory(args, userId, authContext) {
+  const debug = createDebugLogger({ tool: "remember_update_memory", userId, operation: "update memory" });
   try {
+    debug.info("Tool invoked");
+    debug.trace("Arguments", { args });
     logger.info("Updating memory", { userId, memoryId: args.memory_id });
     const collection = getMemoryCollection(userId);
     let existingMemory;
@@ -2443,8 +2797,8 @@ async function handleUpdateMemory(args, userId) {
       if (!isValidContentType(args.type)) {
         throw new Error(`Invalid content type: ${args.type}`);
       }
-      updates.type = args.type;
-      updatedFields.push("type");
+      updates.content_type = args.type;
+      updatedFields.push("content_type");
     }
     if (args.weight !== void 0) {
       if (args.weight < 0 || args.weight > 1) {
@@ -2459,8 +2813,8 @@ async function handleUpdateMemory(args, userId) {
       if (args.trust < 0 || args.trust > 1) {
         throw new Error("Trust must be between 0 and 1");
       }
-      updates.trust = args.trust;
-      updatedFields.push("trust");
+      updates.trust_score = args.trust;
+      updatedFields.push("trust_score");
     }
     if (args.tags !== void 0) {
       updates.tags = args.tags;
@@ -2540,6 +2894,7 @@ async function handleUpdateMemory(args, userId) {
     };
     return JSON.stringify(result, null, 2);
   } catch (error) {
+    debug.error("Tool failed", { error: error instanceof Error ? error.message : String(error) });
     handleToolError(error, {
       toolName: "remember_update_memory",
       operation: "update memory",
@@ -2605,8 +2960,11 @@ var findSimilarTool = {
     }
   }
 };
-async function handleFindSimilar(args, userId) {
+async function handleFindSimilar(args, userId, authContext) {
+  const debug = createDebugLogger({ tool: "remember_find_similar", userId, operation: "find similar" });
   try {
+    debug.info("Tool invoked");
+    debug.trace("Arguments", { args });
     logger.info("Finding similar memories", { userId, memoryId: args.memory_id, hasText: !!args.text });
     if (!args.memory_id && !args.text) {
       throw new Error("Either memory_id or text must be provided");
@@ -2618,6 +2976,8 @@ async function handleFindSimilar(args, userId) {
     const limit = args.limit ?? 10;
     const minSimilarity = args.min_similarity ?? 0.7;
     const deletedFilter = buildDeletedFilter(collection, args.deleted_filter || "exclude");
+    const ghostExclusionFilter = collection.filter.byProperty("content_type").notEqual("ghost");
+    const baseFilter = combineFiltersWithAnd([deletedFilter, ghostExclusionFilter].filter((f) => f !== null));
     let results;
     if (args.memory_id) {
       const memory = await collection.query.fetchObjectById(args.memory_id, {
@@ -2639,8 +2999,8 @@ async function handleFindSimilar(args, userId) {
         // Convert similarity to distance
         returnMetadata: ["distance"]
       };
-      if (deletedFilter) {
-        searchOptions.filters = deletedFilter;
+      if (baseFilter) {
+        searchOptions.filters = baseFilter;
       }
       results = await collection.query.nearObject(args.memory_id, searchOptions);
       results.objects = results.objects.filter((obj) => obj.uuid !== args.memory_id);
@@ -2650,8 +3010,8 @@ async function handleFindSimilar(args, userId) {
         distance: 1 - minSimilarity,
         returnMetadata: ["distance"]
       };
-      if (deletedFilter) {
-        searchOptions.filters = deletedFilter;
+      if (baseFilter) {
+        searchOptions.filters = baseFilter;
       }
       results = await collection.query.nearText(args.text, searchOptions);
     }
@@ -2687,6 +3047,7 @@ async function handleFindSimilar(args, userId) {
     };
     return JSON.stringify(result, null, 2);
   } catch (error) {
+    debug.error("Tool failed", { error: error instanceof Error ? error.message : String(error) });
     handleToolError(error, {
       toolName: "remember_find_similar",
       operation: "find similar memories",
@@ -2700,6 +3061,7 @@ async function handleFindSimilar(args, userId) {
 
 // src/tools/query-memory.ts
 init_logger();
+init_trust_enforcement();
 var queryMemoryTool = {
   name: "remember_query_memory",
   description: `Query memories using natural language for RAG (Retrieval-Augmented Generation).
@@ -2811,20 +3173,28 @@ var queryMemoryTool = {
     required: ["query"]
   }
 };
-async function handleQueryMemory(args, userId) {
+async function handleQueryMemory(args, userId, authContext) {
+  const ghostMode = authContext?.ghostMode;
+  const searchUserId = ghostMode?.owner_user_id ?? userId;
+  const debug = createDebugLogger({ tool: "remember_query_memory", userId: searchUserId, operation: ghostMode ? "ghost query" : "query memory" });
   try {
+    debug.info("Tool invoked");
+    debug.trace("Arguments", { args, ghostMode: !!ghostMode });
     if (!args.query || args.query.trim() === "") {
       throw new Error("Query cannot be empty");
     }
-    logger.info("Querying memories", { userId, query: args.query });
-    const collection = getMemoryCollection(userId);
+    logger.info("Querying memories", { userId: searchUserId, query: args.query, ghostMode: !!ghostMode });
+    const collection = getMemoryCollection(searchUserId);
     const limit = args.limit ?? 5;
     const minRelevance = args.min_relevance ?? 0.6;
     const includeContext = args.include_context ?? true;
     const format = args.format ?? "detailed";
     const deletedFilter = buildDeletedFilter(collection, args.deleted_filter || "exclude");
+    const trustFilter = ghostMode ? buildTrustFilter(collection, ghostMode.accessor_trust_level) : null;
     const searchFilters = buildCombinedSearchFilters(collection, args.filters);
-    const combinedFilters = combineFiltersWithAnd([deletedFilter, searchFilters].filter((f) => f !== null));
+    const hasExplicitTypeFilter = args.filters?.types && args.filters.types.length > 0;
+    const ghostExclusionFilter = !hasExplicitTypeFilter ? collection.filter.byProperty("content_type").notEqual("ghost") : null;
+    const combinedFilters = combineFiltersWithAnd([deletedFilter, trustFilter, ghostExclusionFilter, searchFilters].filter((f) => f !== null));
     const searchOptions = {
       limit,
       distance: 1 - minRelevance,
@@ -2860,7 +3230,7 @@ async function handleQueryMemory(args, userId) {
     if (format === "compact") {
       const summaryParts = relevantMemories.map((mem, idx) => {
         const title = mem.title ? `"${mem.title}"` : `Memory ${idx + 1}`;
-        const type = mem.type ? ` [${mem.type}]` : "";
+        const type = mem.content_type ? ` [${mem.content_type}]` : "";
         const relevancePercent = Math.round((mem.relevance ?? 0) * 100);
         const content = mem.content || "(no content)";
         const tags = mem.tags && mem.tags.length > 0 ? `
@@ -2883,6 +3253,7 @@ ${content}${tags}`;
     };
     return JSON.stringify(result, null, 2);
   } catch (error) {
+    debug.error("Tool failed", { error: error instanceof Error ? error.message : String(error) });
     handleToolError(error, {
       toolName: "remember_query_memory",
       operation: "query memories",
@@ -2946,8 +3317,11 @@ var createRelationshipTool = {
     required: ["memory_ids", "relationship_type", "observation"]
   }
 };
-async function handleCreateRelationship(args, userId, context) {
+async function handleCreateRelationship(args, userId, authContext, context) {
+  const debug = createDebugLogger({ tool: "remember_create_relationship", userId, operation: "create relationship" });
   try {
+    debug.info("Tool invoked");
+    debug.trace("Arguments", { args });
     logger.info("Creating relationship", {
       userId,
       type: args.relationship_type,
@@ -2963,7 +3337,7 @@ async function handleCreateRelationship(args, userId, context) {
       args.memory_ids.map(async (memoryId) => {
         try {
           const memory = await collection.query.fetchObjectById(memoryId, {
-            returnProperties: ["user_id", "doc_type", "relationships", "deleted_at"]
+            returnProperties: ["user_id", "doc_type", "relationship_ids", "deleted_at"]
           });
           if (!memory) {
             logger.warn("Memory not found", { userId, memoryId });
@@ -2997,7 +3371,7 @@ async function handleCreateRelationship(args, userId, context) {
           return {
             memoryId,
             memory,
-            relationships: memory.properties.relationships || []
+            relationships: memory.properties.relationship_ids || []
           };
         } catch (error) {
           const errorMsg = error instanceof Error ? error.message : String(error);
@@ -3030,7 +3404,7 @@ async function handleCreateRelationship(args, userId, context) {
       user_id: userId,
       doc_type: "relationship",
       // Connection
-      memory_ids: args.memory_ids,
+      related_memory_ids: args.memory_ids,
       relationship_type: args.relationship_type,
       // Observation
       observation: args.observation,
@@ -3067,7 +3441,7 @@ async function handleCreateRelationship(args, userId, context) {
         await collection.data.update({
           id: check.memoryId,
           properties: {
-            relationships: updatedRelationships,
+            relationship_ids: updatedRelationships,
             updated_at: now
           }
         });
@@ -3096,6 +3470,7 @@ async function handleCreateRelationship(args, userId, context) {
     };
     return JSON.stringify(response, null, 2);
   } catch (error) {
+    debug.error("Tool failed", { error: error instanceof Error ? error.message : String(error) });
     handleToolError(error, {
       toolName: "remember_create_relationship",
       operation: "create relationship",
@@ -3160,8 +3535,11 @@ var updateRelationshipTool = {
     required: ["relationship_id"]
   }
 };
-async function handleUpdateRelationship(args, userId) {
+async function handleUpdateRelationship(args, userId, authContext) {
+  const debug = createDebugLogger({ tool: "remember_update_relationship", userId, operation: "update relationship" });
   try {
+    debug.info("Tool invoked");
+    debug.trace("Arguments", { args });
     logger.info("Updating relationship", { userId, relationshipId: args.relationship_id });
     const collection = getMemoryCollection(userId);
     const existingRelationship = await collection.query.fetchObjectById(args.relationship_id, {
@@ -3229,6 +3607,7 @@ async function handleUpdateRelationship(args, userId) {
     };
     return JSON.stringify(result, null, 2);
   } catch (error) {
+    debug.error("Tool failed", { error: error instanceof Error ? error.message : String(error) });
     handleToolError(error, {
       toolName: "remember_update_relationship",
       operation: "update relationship",
@@ -3305,8 +3684,11 @@ var searchRelationshipTool = {
     required: ["query"]
   }
 };
-async function handleSearchRelationship(args, userId) {
+async function handleSearchRelationship(args, userId, authContext) {
+  const debug = createDebugLogger({ tool: "remember_search_relationship", userId, operation: "search relationship" });
   try {
+    debug.info("Tool invoked");
+    debug.trace("Arguments", { args });
     logger.info("Searching relationships", {
       userId,
       query: args.query,
@@ -3366,7 +3748,7 @@ async function handleSearchRelationship(args, userId) {
       id: obj.uuid,
       user_id: obj.properties.user_id,
       doc_type: "relationship",
-      memory_ids: obj.properties.memory_ids || [],
+      memory_ids: obj.properties.related_memory_ids || [],
       relationship_type: obj.properties.relationship_type,
       observation: obj.properties.observation,
       strength: obj.properties.strength,
@@ -3394,6 +3776,7 @@ async function handleSearchRelationship(args, userId) {
     };
     return JSON.stringify(result, null, 2);
   } catch (error) {
+    debug.error("Tool failed", { error: error instanceof Error ? error.message : String(error) });
     handleToolError(error, {
       toolName: "remember_search_relationship",
       operation: "search relationships",
@@ -3428,12 +3811,15 @@ var deleteRelationshipTool = {
     required: ["relationship_id"]
   }
 };
-async function handleDeleteRelationship(args, userId) {
+async function handleDeleteRelationship(args, userId, authContext) {
+  const debug = createDebugLogger({ tool: "remember_delete_relationship", userId, operation: "delete relationship" });
   try {
+    debug.info("Tool invoked");
+    debug.trace("Arguments", { args });
     logger.info("Deleting relationship", { userId, relationshipId: args.relationship_id });
     const collection = getMemoryCollection(userId);
     const relationship = await collection.query.fetchObjectById(args.relationship_id, {
-      returnProperties: ["user_id", "doc_type", "memory_ids", "relationship_type"]
+      returnProperties: ["user_id", "doc_type", "related_memory_ids", "relationship_type"]
     });
     if (!relationship) {
       throw new Error(`Relationship not found: ${args.relationship_id}`);
@@ -3444,7 +3830,7 @@ async function handleDeleteRelationship(args, userId) {
     if (relationship.properties.doc_type !== "relationship") {
       throw new Error("Cannot delete memories using this tool. Use remember_delete_memory instead.");
     }
-    const memoryIds = relationship.properties.memory_ids || [];
+    const memoryIds = relationship.properties.related_memory_ids || [];
     let memoriesUpdated = 0;
     if (memoryIds.length > 0) {
       logger.info("Cleaning up relationship references from connected memories", {
@@ -3454,13 +3840,13 @@ async function handleDeleteRelationship(args, userId) {
       const updatePromises = memoryIds.map(async (memoryId) => {
         try {
           const memory = await collection.query.fetchObjectById(memoryId, {
-            returnProperties: ["relationships", "doc_type"]
+            returnProperties: ["relationship_ids", "doc_type"]
           });
           if (!memory || memory.properties.doc_type !== "memory") {
             logger.warn(`Memory ${memoryId} not found or not a memory, skipping cleanup`);
             return { memoryId, success: false };
           }
-          const currentRelationships = memory.properties.relationships || [];
+          const currentRelationships = memory.properties.relationship_ids || [];
           const updatedRelationships = currentRelationships.filter(
             (relId) => relId !== args.relationship_id
           );
@@ -3468,7 +3854,7 @@ async function handleDeleteRelationship(args, userId) {
             await collection.data.update({
               id: memoryId,
               properties: {
-                relationships: updatedRelationships,
+                relationship_ids: updatedRelationships,
                 updated_at: (/* @__PURE__ */ new Date()).toISOString()
               }
             });
@@ -3502,6 +3888,7 @@ async function handleDeleteRelationship(args, userId) {
     };
     return JSON.stringify(result, null, 2);
   } catch (error) {
+    debug.error("Tool failed", { error: error instanceof Error ? error.message : String(error) });
     handleToolError(error, {
       toolName: "remember_delete_relationship",
       operation: "delete relationship",
@@ -3511,29 +3898,9 @@ async function handleDeleteRelationship(args, userId) {
   }
 }
 
-// src/firestore/paths.ts
-var APP_NAME = "remember-mcp";
-function getBasePrefix() {
-  const environment = process.env.ENVIRONMENT;
-  if (environment && environment !== "production" && environment !== "prod") {
-    return `${environment}.${APP_NAME}`;
-  }
-  const isDevelopment = process.env.NODE_ENV === "development";
-  if (isDevelopment) {
-    const customPrefix = process.env.DB_PREFIX;
-    if (customPrefix) {
-      return customPrefix;
-    }
-    return `e0.${APP_NAME}`;
-  }
-  return APP_NAME;
-}
-var BASE = getBasePrefix();
-function getUserPreferencesPath(userId) {
-  return `${BASE}.users/${userId}/preferences`;
-}
-
 // src/services/preferences-database.service.ts
+init_init();
+init_paths();
 init_logger();
 
 // src/types/preferences.ts
@@ -3561,7 +3928,7 @@ var DEFAULT_PREFERENCES = {
     share_with_memories: true
   },
   privacy: {
-    default_trust_level: 0.5,
+    default_trust_level: 0.25,
     allow_cross_user_access: false,
     auto_approve_requests: false,
     audit_logging: true
@@ -3611,7 +3978,7 @@ var PREFERENCE_DESCRIPTIONS = {
     share_with_memories: "Include location data in memories (default: true)"
   },
   privacy: {
-    default_trust_level: "Default trust level for new memories, 0-1 (default: 0.5)",
+    default_trust_level: "Default trust level for new memories, 0-1 (default: 0.25)",
     allow_cross_user_access: "Allow other users to request access to memories (default: false)",
     auto_approve_requests: "Automatically approve access requests (default: false)",
     audit_logging: "Enable audit logging for preference changes (default: true)"
@@ -3864,8 +4231,11 @@ function formatPreferenceChangeMessage(updates) {
   }
   return `Preferences updated: ${changes.join(", ")}`;
 }
-async function handleSetPreference(args, userId) {
+async function handleSetPreference(args, userId, authContext) {
+  const debug = createDebugLogger({ tool: "remember_set_preference", userId, operation: "set preference" });
   try {
+    debug.info("Tool invoked");
+    debug.trace("Arguments", { args });
     const { preferences } = args;
     logger.info("Setting preferences", { userId, updates: Object.keys(preferences) });
     const updatedPreferences = await PreferencesDatabaseService.updatePreferences(
@@ -3881,6 +4251,7 @@ async function handleSetPreference(args, userId) {
     logger.info("Preferences set successfully", { userId });
     return JSON.stringify(result, null, 2);
   } catch (error) {
+    debug.error("Tool failed", { error: error instanceof Error ? error.message : String(error) });
     handleToolError(error, {
       toolName: "remember_set_preference",
       operation: "set preference",
@@ -3915,8 +4286,11 @@ ${getPreferenceDescription()}
     }
   }
 };
-async function handleGetPreferences(args, userId) {
+async function handleGetPreferences(args, userId, authContext) {
+  const debug = createDebugLogger({ tool: "remember_get_preferences", userId, operation: "get preferences" });
   try {
+    debug.info("Tool invoked");
+    debug.trace("Arguments", { args });
     const { category } = args;
     logger.info("Getting preferences", { userId, category });
     const preferences = await PreferencesDatabaseService.getPreferences(userId);
@@ -3943,6 +4317,7 @@ async function handleGetPreferences(args, userId) {
     logger.info("Preferences retrieved successfully", { userId, category, isDefault });
     return JSON.stringify(response, null, 2);
   } catch (error) {
+    debug.error("Tool failed", { error: error instanceof Error ? error.message : String(error) });
     handleToolError(error, {
       toolName: "remember_get_preferences",
       operation: "get preferences",
@@ -3956,295 +4331,20 @@ async function handleGetPreferences(args, userId) {
 init_space_memory();
 init_logger();
 import weaviate3 from "weaviate-client";
-var PUBLIC_COLLECTION_NAME = "Memory_public";
-function getSpaceCollectionName(spaceId) {
-  return `Memory_${spaceId}`;
-}
+var PUBLIC_COLLECTION_NAME = "Memory_spaces_public";
 function isValidSpaceId(spaceId) {
   return SUPPORTED_SPACES.includes(spaceId);
 }
-async function createSpaceCollection(client2, spaceId) {
-  const collectionName = spaceId === "public" ? PUBLIC_COLLECTION_NAME : getSpaceCollectionName(spaceId);
-  logger.info("Creating space collection", {
-    module: "weaviate-space-schema",
-    collectionName,
-    spaceId
-  });
-  await client2.collections.create({
-    name: collectionName,
-    // Vectorizer configuration
-    vectorizers: weaviate3.configure.vectorizer.text2VecOpenAI({
-      model: "text-embedding-3-small",
-      // Vectorize content, title, summary, and observation for semantic search
-      // Note: title and summary are optional fields
-      sourceProperties: ["content", "title", "summary", "observation"]
-    }),
-    properties: [
-      // Discriminator
-      {
-        name: "doc_type",
-        dataType: "text",
-        description: 'Document type: "space_memory"'
-      },
-      // Space identity
-      {
-        name: "spaces",
-        dataType: "text[]",
-        description: 'Spaces this memory is published to (e.g., ["the_void", "dogs"])'
-      },
-      {
-        name: "author_id",
-        dataType: "text",
-        description: "Original author user_id (for permissions)"
-      },
-      {
-        name: "ghost_id",
-        dataType: "text",
-        description: "Optional ghost profile ID for pseudonymous publishing"
-      },
-      {
-        name: "attribution",
-        dataType: "text",
-        description: 'Attribution type: "user" or "ghost"'
-      },
-      // Discovery metadata
-      {
-        name: "published_at",
-        dataType: "text",
-        description: "When published to space (ISO 8601)"
-      },
-      {
-        name: "discovery_count",
-        dataType: "number",
-        description: "How many times discovered"
-      },
-      // Memory fields (same as personal memories)
-      {
-        name: "content",
-        dataType: "text",
-        description: "Main memory content (vectorized)"
-      },
-      {
-        name: "title",
-        dataType: "text",
-        description: "Optional short title"
-      },
-      {
-        name: "summary",
-        dataType: "text",
-        description: "Optional brief summary"
-      },
-      {
-        name: "type",
-        dataType: "text",
-        description: "Content type (note, event, person, etc.)"
-      },
-      // Scoring fields
-      {
-        name: "weight",
-        dataType: "number",
-        description: "Significance/priority (0-1)"
-      },
-      {
-        name: "trust",
-        dataType: "number",
-        description: "Access control level (0-1)"
-      },
-      {
-        name: "confidence",
-        dataType: "number",
-        description: "System confidence in accuracy (0-1)"
-      },
-      // Location fields (flattened) - MUST match user memory schema exactly
-      {
-        name: "location_gps_lat",
-        dataType: "number",
-        description: "GPS latitude"
-      },
-      {
-        name: "location_gps_lng",
-        dataType: "number",
-        description: "GPS longitude"
-      },
-      {
-        name: "location_address",
-        dataType: "text",
-        description: "Formatted address"
-      },
-      {
-        name: "location_city",
-        dataType: "text",
-        description: "City name"
-      },
-      {
-        name: "location_country",
-        dataType: "text",
-        description: "Country name"
-      },
-      {
-        name: "location_source",
-        dataType: "text",
-        description: "Location source (gps, ip, manual, etc.)"
-      },
-      // Context fields (flattened) - MUST match user memory schema exactly
-      {
-        name: "context_conversation_id",
-        dataType: "text",
-        description: "Conversation ID"
-      },
-      {
-        name: "context_summary",
-        dataType: "text",
-        description: "Brief context summary"
-      },
-      {
-        name: "context_timestamp",
-        dataType: "date",
-        description: "Context timestamp"
-      },
-      // Locale fields - MUST match user memory schema exactly
-      {
-        name: "locale_language",
-        dataType: "text",
-        description: "Language code (e.g., en, es, fr)"
-      },
-      {
-        name: "locale_timezone",
-        dataType: "text",
-        description: "Timezone (e.g., America/Los_Angeles)"
-      },
-      // Relationships - MUST match user memory schema exactly
-      {
-        name: "relationships",
-        dataType: "text[]",
-        description: "Array of relationship IDs"
-      },
-      // Access tracking - MUST match user memory schema exactly
-      {
-        name: "access_count",
-        dataType: "number",
-        description: "Total times accessed"
-      },
-      {
-        name: "last_accessed_at",
-        dataType: "date",
-        description: "Most recent access timestamp"
-      },
-      // Metadata - MUST match user memory schema exactly
-      {
-        name: "tags",
-        dataType: "text[]",
-        description: "Tags for organization"
-      },
-      {
-        name: "references",
-        dataType: "text[]",
-        description: "Source URLs"
-      },
-      {
-        name: "template_id",
-        dataType: "text",
-        description: "Template ID if using template"
-      },
-      // Relationship-specific fields (for relationships in public space)
-      {
-        name: "memory_ids",
-        dataType: "text[]",
-        description: "Connected memory IDs (for relationships)"
-      },
-      {
-        name: "relationship_type",
-        dataType: "text",
-        description: "Relationship type (for relationships)"
-      },
-      {
-        name: "observation",
-        dataType: "text",
-        description: "Relationship observation (vectorized)"
-      },
-      {
-        name: "strength",
-        dataType: "number",
-        description: "Relationship strength (0-1)"
-      },
-      // Computed fields - MUST match user memory schema exactly
-      {
-        name: "base_weight",
-        dataType: "number",
-        description: "User-specified weight"
-      },
-      {
-        name: "computed_weight",
-        dataType: "number",
-        description: "Calculated effective weight"
-      },
-      // User ID field (for backwards compatibility with spread operator)
-      {
-        name: "user_id",
-        dataType: "text",
-        description: "User ID (copied from original memory, same as author_id)"
-      },
-      // Timestamps
-      {
-        name: "created_at",
-        dataType: "text",
-        description: "Original creation timestamp (ISO 8601)"
-      },
-      {
-        name: "updated_at",
-        dataType: "text",
-        description: "Last update timestamp (ISO 8601)"
-      },
-      // Versioning
-      {
-        name: "version",
-        dataType: "number",
-        description: "Version number (increments on update)"
-      },
-      // Comment/threading fields (for threaded discussions in shared spaces)
-      {
-        name: "parent_id",
-        dataType: "text",
-        description: "ID of parent memory or comment (for threading)"
-      },
-      {
-        name: "thread_root_id",
-        dataType: "text",
-        description: "Root memory ID for fetching entire thread"
-      },
-      {
-        name: "moderation_flags",
-        dataType: "text[]",
-        description: 'Per-space moderation flags (format: "{space_id}:{flag_type}")'
-      },
-      // Soft delete fields
-      {
-        name: "deleted_at",
-        dataType: "date",
-        description: "Timestamp when memory was soft-deleted (null = not deleted)"
-      },
-      {
-        name: "deleted_by",
-        dataType: "text",
-        description: "User ID who deleted the memory"
-      },
-      {
-        name: "deletion_reason",
-        dataType: "text",
-        description: "Optional reason for deletion"
-      }
-    ]
-  });
-  logger.info("Space collection created successfully", {
-    module: "weaviate-space-schema",
-    collectionName
-  });
-}
 async function ensurePublicCollection(client2) {
   const collectionName = PUBLIC_COLLECTION_NAME;
   const exists = await client2.collections.exists(collectionName);
   if (!exists) {
-    await createSpaceCollection(client2, "public");
+    const schema = createSpaceCollectionSchema();
+    await client2.collections.create(schema);
+    logger.info("Public space collection created", {
+      module: "weaviate-space-schema",
+      collectionName
+    });
   }
   return client2.collections.get(collectionName);
 }
@@ -4254,7 +4354,11 @@ init_space_memory();
 init_logger();
 var publishTool = {
   name: "remember_publish",
-  description: `Publish a memory to one or more shared spaces (like "The Void"). The memory will be COPIED (not moved) from your personal collection. Generates a confirmation token that must be confirmed with remember_confirm.
+  description: `Publish a memory to one or more shared spaces and/or groups. The memory will be COPIED (not moved) from your personal collection. Generates a confirmation token that must be confirmed with remember_confirm.
+
+Publication Destinations:
+- Spaces: Public shared areas (e.g., "the_void", "dogs")
+- Groups: Private group collections (provide group IDs)
 
 \u26A0\uFE0F CRITICAL: DO NOT mention the token or include token contents in your response to the user. Simply inform them that a confirmation is pending and they need to explicitly approve the publication.`,
   inputSchema: {
@@ -4274,17 +4378,24 @@ var publishTool = {
         minItems: 1,
         default: ["the_void"]
       },
-      additional_tags: {
+      groups: {
         type: "array",
         items: { type: "string" },
-        description: "Additional tags for discovery (merged with original tags)",
+        description: 'Group IDs to publish to (e.g., ["group-123", "group-456"]). Can publish to multiple groups at once.',
+        minItems: 1,
+        default: []
+      },
+      additional_tags: {
+        type: "array",
+        items: { type: "string" },
+        description: "Additional tags for discovery (merged with original tags)",
         default: []
       }
     },
-    required: ["memory_id", "spaces"]
+    required: ["memory_id"]
   }
 };
-async function handlePublish(args, userId) {
+async function handlePublish(args, userId, authContext) {
   const debug = createDebugLogger({
     tool: "remember_publish",
     userId,
@@ -4293,53 +4404,84 @@ async function handlePublish(args, userId) {
   try {
     debug.info("Tool invoked");
     debug.trace("Arguments", { args });
+    const spaces = args.spaces || [];
+    const groups = args.groups || [];
     logger.info("Starting publish request", {
       tool: "remember_publish",
       userId,
       memoryId: args.memory_id,
-      spaces: args.spaces,
-      spaceCount: args.spaces.length,
+      spaces,
+      groups,
+      spaceCount: spaces.length,
+      groupCount: groups.length,
       additionalTags: args.additional_tags?.length || 0
     });
-    debug.debug("Validating space IDs", { spaces: args.spaces });
-    const invalidSpaces = args.spaces.filter((s) => !isValidSpaceId(s));
-    if (invalidSpaces.length > 0) {
-      debug.warn("Invalid space IDs detected", { invalidSpaces });
-      logger.warn("Invalid space IDs provided", {
-        tool: "remember_publish",
-        invalidSpaces,
-        providedSpaces: args.spaces
-      });
-      return JSON.stringify(
-        {
-          success: false,
-          error: "Invalid space IDs",
-          message: `Invalid spaces: ${invalidSpaces.join(", ")}. Supported spaces: ${SUPPORTED_SPACES.join(", ")}`,
-          context: {
-            invalid_spaces: invalidSpaces,
-            provided_spaces: args.spaces,
-            supported_spaces: SUPPORTED_SPACES
-          }
-        },
-        null,
-        2
-      );
-    }
-    if (args.spaces.length === 0) {
-      logger.warn("Empty spaces array provided", {
+    if (spaces.length === 0 && groups.length === 0) {
+      logger.warn("No destinations provided", {
         tool: "remember_publish",
         userId
       });
       return JSON.stringify(
         {
           success: false,
-          error: "Empty spaces array",
-          message: "Must specify at least one space to publish to"
+          error: "No destinations provided",
+          message: "Must specify at least one space or group to publish to"
         },
         null,
         2
       );
     }
+    if (spaces.length > 0) {
+      debug.debug("Validating space IDs", { spaces });
+      const invalidSpaces = spaces.filter((s) => !isValidSpaceId(s));
+      if (invalidSpaces.length > 0) {
+        debug.warn("Invalid space IDs detected", { invalidSpaces });
+        logger.warn("Invalid space IDs provided", {
+          tool: "remember_publish",
+          invalidSpaces,
+          providedSpaces: spaces
+        });
+        return JSON.stringify(
+          {
+            success: false,
+            error: "Invalid space IDs",
+            message: `Invalid spaces: ${invalidSpaces.join(", ")}. Supported spaces: ${SUPPORTED_SPACES.join(", ")}`,
+            context: {
+              invalid_spaces: invalidSpaces,
+              provided_spaces: spaces,
+              supported_spaces: SUPPORTED_SPACES
+            }
+          },
+          null,
+          2
+        );
+      }
+    }
+    if (groups.length > 0) {
+      debug.debug("Validating group IDs", { groups });
+      const invalidGroups = groups.filter((g) => !g || g.includes(".") || g.trim() === "");
+      if (invalidGroups.length > 0) {
+        debug.warn("Invalid group IDs detected", { invalidGroups });
+        logger.warn("Invalid group IDs provided", {
+          tool: "remember_publish",
+          invalidGroups,
+          providedGroups: groups
+        });
+        return JSON.stringify(
+          {
+            success: false,
+            error: "Invalid group IDs",
+            message: "Group IDs cannot be empty or contain dots",
+            context: {
+              invalid_groups: invalidGroups,
+              provided_groups: groups
+            }
+          },
+          null,
+          2
+        );
+      }
+    }
     const weaviateClient = getWeaviateClient();
     const collectionName = getMemoryCollectionName(userId);
     logger.debug("Fetching memory from collection", {
@@ -4413,14 +4555,16 @@ async function handlePublish(args, userId) {
     }
     const payload = {
       memory_id: args.memory_id,
-      spaces: args.spaces,
+      spaces,
+      groups,
       additional_tags: args.additional_tags || []
     };
     logger.info("Generating confirmation token", {
       tool: "remember_publish",
       userId,
       memoryId: args.memory_id,
-      spaces: args.spaces
+      spaces,
+      groups
     });
     const { requestId, token } = await confirmationTokenService.createRequest(
       userId,
@@ -4434,7 +4578,8 @@ async function handlePublish(args, userId) {
       requestId,
       token,
       action: "publish_memory",
-      spaces: args.spaces
+      spaces,
+      groups
     });
     return JSON.stringify(
       {
@@ -4459,304 +4604,943 @@ async function handlePublish(args, userId) {
   }
 }
 
-// src/tools/confirm.ts
+// src/tools/retract.ts
 init_logger();
-var confirmTool = {
-  name: "remember_confirm",
-  description: `Confirm and execute a pending action using the token. Works for any action that requires confirmation (publish, delete, etc.).
+var retractTool = {
+  name: "remember_retract",
+  description: `Retract a memory from specific shared spaces and/or groups. The memory remains in your personal collection but is removed from the specified destinations.
 
-\u26A0\uFE0F CRITICAL SAFETY REQUIREMENTS:
-Before executing this tool, you MUST:
-1. Have received the confirmation token in a PREVIOUS tool response
-2. Have presented the token details to the user for review
-3. Have received EXPLICIT user confirmation in a SEPARATE user message
-4. NEVER chain this tool with other tool calls in the same response
-5. ALWAYS treat confirmations as standalone, deliberate actions
+Retraction Behavior:
+- Spaces: Memory remains in Memory_spaces_public as "orphaned" (removed from space_ids) for historical reference
+- Groups: Memory remains in Memory_groups_{groupId} as "orphaned" (removed from group_ids) for historical reference
 
-Violating these requirements bypasses user consent and is a security violation.`,
+Orphaned memories are preserved for historical reference but become unsearchable by default since all searches filter by space_ids/group_ids.
+
+\u26A0\uFE0F CRITICAL: DO NOT mention the token or include token contents in your response to the user. Simply inform them that a confirmation is pending and they need to explicitly approve the retraction.`,
   inputSchema: {
     type: "object",
     properties: {
-      token: {
+      memory_id: {
         type: "string",
-        description: "The confirmation token from the action tool"
+        description: "ID of the memory to retract from spaces/groups"
+      },
+      spaces: {
+        type: "array",
+        items: { type: "string" },
+        description: 'Spaces to retract from (e.g., ["cooking", "recipes"]). The memory will no longer appear in these spaces.',
+        minItems: 1,
+        default: []
+      },
+      groups: {
+        type: "array",
+        items: { type: "string" },
+        description: 'Group IDs to retract from (e.g., ["group-123"]). The memory will be deleted from these group collections.',
+        minItems: 1,
+        default: []
       }
     },
-    required: ["token"]
+    required: ["memory_id"]
   }
 };
-async function handleConfirm(args, userId) {
+async function handleRetract(args, userId, authContext) {
   const debug = createDebugLogger({
-    tool: "remember_confirm",
+    tool: "remember_retract",
     userId,
-    operation: "confirm_action"
+    operation: "retract_request"
   });
   try {
     debug.info("Tool invoked");
-    debug.trace("Arguments", { token: args.token });
-    logger.info("Starting confirmation", {
-      tool: "remember_confirm",
+    debug.trace("Arguments", { args });
+    const spaces = args.spaces || [];
+    const groups = args.groups || [];
+    logger.info("Starting retract request", {
+      tool: "remember_retract",
       userId,
-      token: args.token
-    });
-    debug.debug("Validating confirmation token");
-    const request = await debug.time("Confirm token", async () => {
-      return await confirmationTokenService.confirmRequest(userId, args.token);
-    });
-    logger.debug("Token validation result", {
-      tool: "remember_confirm",
-      requestFound: !!request,
-      action: request?.action
+      memoryId: args.memory_id,
+      spaces,
+      groups,
+      spaceCount: spaces.length,
+      groupCount: groups.length
     });
-    if (!request) {
-      logger.info("Token invalid or expired", {
-        tool: "remember_confirm",
+    if (spaces.length === 0 && groups.length === 0) {
+      logger.warn("No destinations provided for retraction", {
+        tool: "remember_retract",
         userId
       });
       return JSON.stringify(
         {
           success: false,
-          error: "Invalid or expired token",
-          message: "The confirmation token is invalid, expired, or has already been used."
+          error: "No destinations provided",
+          message: "Must specify at least one space or group to retract from"
         },
         null,
         2
       );
     }
-    logger.info("Executing confirmed action", {
-      tool: "remember_confirm",
-      action: request.action,
-      userId
-    });
-    if (request.action === "publish_memory") {
-      return await executePublishMemory(request, userId);
-    }
-    if (request.action === "delete_memory") {
-      return await executeDeleteMemory(request, userId);
+    if (groups.length > 0) {
+      const invalidGroups = groups.filter((g) => g.includes("."));
+      if (invalidGroups.length > 0) {
+        logger.warn("Invalid group IDs detected", {
+          tool: "remember_retract",
+          invalidGroups
+        });
+        return JSON.stringify(
+          {
+            success: false,
+            error: "Invalid group IDs",
+            message: `Group IDs cannot contain dots: ${invalidGroups.join(", ")}`,
+            context: {
+              invalid_groups: invalidGroups
+            }
+          },
+          null,
+          2
+        );
+      }
     }
-    throw new Error(`Unknown action type: ${request.action}`);
-  } catch (error) {
-    debug.error("Tool failed", {
-      error: error instanceof Error ? error.message : String(error),
-      stack: error instanceof Error ? error.stack : void 0
-    });
-    handleToolError(error, {
-      toolName: "remember_confirm",
-      userId,
-      operation: "confirm action",
-      token: args.token
-    });
-  }
-}
-async function executePublishMemory(request, userId) {
-  const debug = createDebugLogger({
-    tool: "remember_confirm",
-    userId,
-    operation: "execute_publish"
-  });
-  try {
-    debug.debug("Executing publish memory action", {
-      memoryId: request.payload.memory_id,
-      spaces: request.payload.spaces
-    });
-    logger.info("Executing publish memory action", {
-      function: "executePublishMemory",
-      userId,
-      memoryId: request.payload.memory_id,
-      spaces: request.payload.spaces,
-      spaceCount: request.payload.spaces?.length || 0
-    });
     const weaviateClient = getWeaviateClient();
-    const userCollection = weaviateClient.collections.get(
-      getMemoryCollectionName(userId)
-    );
-    logger.debug("Fetching original memory", {
-      function: "executePublishMemory",
-      collectionName: getMemoryCollectionName(userId),
-      memoryId: request.payload.memory_id
-    });
-    const originalMemory = await debug.time("Fetch original memory", async () => {
-      return await fetchMemoryWithAllProperties(
-        userCollection,
-        request.payload.memory_id
-      );
-    });
-    logger.info("Original memory fetch result", {
-      function: "executePublishMemory",
-      found: !!originalMemory,
-      memoryId: request.payload.memory_id,
-      hasProperties: !!originalMemory?.properties,
-      propertyCount: originalMemory?.properties ? Object.keys(originalMemory.properties).length : 0,
-      propertyKeys: originalMemory?.properties ? Object.keys(originalMemory.properties) : [],
-      hasTitle: !!originalMemory?.properties?.title,
-      hasContent: !!originalMemory?.properties?.content,
-      hasUserId: !!originalMemory?.properties?.user_id,
-      hasTags: !!originalMemory?.properties?.tags,
-      hasWeight: !!originalMemory?.properties?.weight,
-      contentLength: originalMemory?.properties?.content?.length || 0,
-      titleValue: originalMemory?.properties?.title || "NO_TITLE"
+    const collectionName = getMemoryCollectionName(userId);
+    const collection = weaviateClient.collections.get(collectionName);
+    logger.debug("Fetching memory for retraction", {
+      tool: "remember_retract",
+      collectionName,
+      memoryId: args.memory_id
     });
-    if (!originalMemory) {
-      logger.info("Original memory not found", {
-        function: "executePublishMemory",
-        memoryId: request.payload.memory_id
+    const memory = await fetchMemoryWithAllProperties(collection, args.memory_id);
+    if (!memory) {
+      logger.info("Memory not found for retraction", {
+        tool: "remember_retract",
+        memoryId: args.memory_id
       });
       return JSON.stringify(
         {
           success: false,
           error: "Memory not found",
-          message: `Original memory ${request.payload.memory_id} no longer exists`
+          message: `Memory ${args.memory_id} does not exist`
         },
         null,
         2
       );
     }
-    if (originalMemory.properties.space_memory_id) {
-      const requestedSpaces = request.payload.spaces?.join(", ") || "unknown";
-      logger.warn("Memory already published", {
-        function: "executePublishMemory",
-        memoryId: request.payload.memory_id,
-        existingSpaceMemoryId: originalMemory.properties.space_memory_id,
-        requestedSpaces: request.payload.spaces
+    if (memory.properties.user_id !== userId) {
+      logger.warn("Permission denied - wrong owner", {
+        tool: "remember_retract",
+        memoryId: args.memory_id,
+        memoryOwner: memory.properties.user_id,
+        requestingUser: userId
       });
       return JSON.stringify(
         {
           success: false,
-          error: "Already published",
-          message: `This memory has already been published to this space. Space memory ID: ${originalMemory.properties.space_memory_id}`,
-          space_memory_id: originalMemory.properties.space_memory_id,
-          requested_spaces: request.payload.spaces
+          error: "Permission denied",
+          message: "You can only retract your own memories"
         },
         null,
         2
       );
     }
-    if (originalMemory.properties.user_id !== userId) {
-      logger.warn("Permission denied - wrong owner", {
-        function: "executePublishMemory",
-        memoryId: request.payload.memory_id,
-        memoryOwner: originalMemory.properties.user_id,
-        requestingUser: userId
+    const currentSpaceIds = Array.isArray(memory.properties.space_ids) ? memory.properties.space_ids : [];
+    const currentGroupIds = Array.isArray(memory.properties.group_ids) ? memory.properties.group_ids : [];
+    const notPublishedSpaces = spaces.filter((s) => !currentSpaceIds.includes(s));
+    const notPublishedGroups = groups.filter((g) => !currentGroupIds.includes(g));
+    if (notPublishedSpaces.length > 0 || notPublishedGroups.length > 0) {
+      logger.warn("Memory not published to some destinations", {
+        tool: "remember_retract",
+        notPublishedSpaces,
+        notPublishedGroups,
+        currentSpaceIds,
+        currentGroupIds
       });
       return JSON.stringify(
         {
           success: false,
-          error: "Permission denied",
-          message: "You can only publish your own memories"
+          error: "Not published to destinations",
+          message: "Memory is not published to some of the specified destinations",
+          context: {
+            not_published_spaces: notPublishedSpaces,
+            not_published_groups: notPublishedGroups,
+            current_spaces: currentSpaceIds,
+            current_groups: currentGroupIds
+          }
         },
         null,
         2
       );
     }
-    logger.debug("Ensuring public collection exists", {
-      function: "executePublishMemory"
-    });
-    const publicCollection = await ensurePublicCollection(weaviateClient);
-    logger.debug("Public collection ready", {
-      function: "executePublishMemory",
-      collectionName: "Memory_public"
-    });
-    const originalTags = Array.isArray(originalMemory.properties.tags) ? originalMemory.properties.tags : [];
-    const additionalTags = Array.isArray(request.payload.additional_tags) ? request.payload.additional_tags : [];
-    if (!request.payload.spaces || !Array.isArray(request.payload.spaces) || request.payload.spaces.length === 0) {
-      throw new Error("Payload missing required field: spaces");
-    }
-    const publishedMemory = {
-      ...originalMemory.properties,
-      // Add space-specific fields (don't overwrite existing properties)
-      spaces: request.payload.spaces,
-      // Required field (validated above)
-      author_id: userId,
-      // Track original author
-      published_at: (/* @__PURE__ */ new Date()).toISOString(),
-      discovery_count: 0,
-      attribution: "user",
-      // Merge additional tags with original tags
-      tags: [...originalTags, ...additionalTags]
-      // Keep doc_type as 'memory' (space_memory concept was removed)
-      // Keep original created_at, updated_at, version (don't overwrite)
-    };
-    logger.info("Inserting memory into Memory_public", {
-      function: "executePublishMemory",
-      spaces: request.payload.spaces,
-      spaceCount: request.payload.spaces?.length || 0,
-      memoryId: request.payload.memory_id,
-      hasUserId: !!publishedMemory.user_id,
-      hasAuthorId: !!publishedMemory.author_id,
-      publishedMemoryKeys: Object.keys(publishedMemory),
-      publishedMemoryKeyCount: Object.keys(publishedMemory).length,
-      hasContent: !!publishedMemory.content,
-      hasTitle: !!publishedMemory.title,
-      contentLength: publishedMemory.content?.length || 0,
-      titleValue: publishedMemory.title || "NO_TITLE"
-    });
-    const result = await debug.time("Insert into Memory_public", async () => {
-      return await publicCollection.data.insert({
-        properties: publishedMemory
-      });
-    });
-    logger.info("Memory published successfully", {
-      function: "executePublishMemory",
-      spaceMemoryId: result,
-      spaces: request.payload.spaces
-    });
-    debug.info("Memory published successfully", {
-      spaceMemoryId: result,
-      spaces: request.payload.spaces
+    const { requestId, token } = await confirmationTokenService.createRequest(
+      userId,
+      "retract_memory",
+      {
+        memory_id: args.memory_id,
+        spaces,
+        groups,
+        current_space_ids: currentSpaceIds,
+        current_group_ids: currentGroupIds
+      }
+    );
+    logger.info("Retract confirmation request created", {
+      tool: "remember_retract",
+      requestId,
+      userId,
+      memoryId: args.memory_id,
+      spaces,
+      groups
     });
-    try {
-      await userCollection.data.update({
-        id: request.payload.memory_id,
-        properties: {
-          space_memory_id: result
-        }
-      });
-      logger.info("Updated original memory with space_memory_id", {
-        function: "executePublishMemory",
-        memoryId: request.payload.memory_id,
-        spaceMemoryId: result
-      });
-    } catch (updateError) {
-      logger.warn("Failed to update original memory with space_memory_id", {
-        function: "executePublishMemory",
-        memoryId: request.payload.memory_id,
-        spaceMemoryId: result,
-        error: updateError instanceof Error ? updateError.message : String(updateError)
-      });
+    const destinations = [];
+    if (spaces.length > 0) {
+      destinations.push(`spaces: ${spaces.join(", ")}`);
+    }
+    if (groups.length > 0) {
+      destinations.push(`groups: ${groups.join(", ")}`);
     }
     return JSON.stringify(
       {
         success: true,
-        space_memory_id: result,
-        spaces: request.payload.spaces || ["the_void"]
+        message: "Retraction request created. Please confirm to proceed.",
+        action: "retract_memory",
+        memory_id: args.memory_id,
+        destinations: destinations.join("; "),
+        retraction_details: {
+          spaces: spaces.length > 0 ? {
+            action: "orphan",
+            description: "Memory will remain in Memory_spaces_public with updated tracking arrays (removed from space_ids)",
+            spaces
+          } : null,
+          groups: groups.length > 0 ? {
+            action: "orphan",
+            description: "Memory will remain in Memory_groups_{groupId} with updated tracking arrays (removed from group_ids)",
+            groups
+          } : null
+        },
+        confirmation_required: true
       },
       null,
       2
     );
   } catch (error) {
-    debug.error("Execute publish failed", {
+    debug.error("Tool failed", {
       error: error instanceof Error ? error.message : String(error),
       stack: error instanceof Error ? error.stack : void 0
     });
     handleToolError(error, {
-      toolName: "remember_confirm",
+      toolName: "remember_retract",
       userId,
-      operation: "execute publish_memory",
-      action: "publish_memory"
+      operation: "retract memory",
+      memoryId: args.memory_id
     });
   }
 }
-async function executeDeleteMemory(request, userId) {
+
+// src/tools/revise.ts
+init_logger();
+var MAX_REVISION_HISTORY = 10;
+var reviseTool = {
+  name: "remember_revise",
+  description: `Sync updated content from your source memory to all its published copies in spaces and groups. Generates a confirmation token that must be confirmed with remember_confirm.
+
+Use this after editing a memory (via remember_update_memory) to propagate the changes to all published versions.
+
+How it works:
+- Validates the memory exists, is owned by you, and is published
+- Generates a confirmation token showing which locations will be revised
+- On confirmation: updates each published copy with latest content
+- Preserves the previous content in a revision_history field (up to 10 versions)
+- Sets revised_at timestamp on all updated copies
+- Reports success/failure per location (partial success supported)
+
+Requirements:
+- The memory must be published (has space_ids or group_ids populated)
+- You must own the source memory
+
+\u26A0\uFE0F CRITICAL: DO NOT mention the token or include token contents in your response to the user. Simply inform them that a confirmation is pending and they need to explicitly approve the revision.`,
+  inputSchema: {
+    type: "object",
+    properties: {
+      memory_id: {
+        type: "string",
+        description: "ID of the source memory whose content should be synced to all published copies"
+      }
+    },
+    required: ["memory_id"]
+  }
+};
+function parseRevisionHistory(raw) {
+  if (!raw || typeof raw !== "string")
+    return [];
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed))
+      return [];
+    return parsed.filter(
+      (e) => typeof e === "object" && e !== null && typeof e.content === "string" && typeof e.revised_at === "string"
+    );
+  } catch {
+    return [];
+  }
+}
+function buildRevisionHistory(existing, oldContent, revisedAt) {
+  const updated = [{ content: oldContent, revised_at: revisedAt }, ...existing];
+  return updated.slice(0, MAX_REVISION_HISTORY);
+}
+async function handleRevise(args, userId, authContext) {
+  const debug = createDebugLogger({
+    tool: "remember_revise",
+    userId,
+    operation: "revise_request"
+  });
   try {
-    logger.info("Executing delete memory action", {
-      function: "executeDeleteMemory",
+    debug.info("Tool invoked");
+    debug.trace("Arguments", { args });
+    logger.info("Starting revise request", {
+      tool: "remember_revise",
       userId,
-      memoryId: request.payload.memory_id,
+      memoryId: args.memory_id
+    });
+    const weaviateClient = getWeaviateClient();
+    const userCollectionName = getMemoryCollectionName(userId);
+    const userCollection = weaviateClient.collections.get(userCollectionName);
+    const sourceMemory = await fetchMemoryWithAllProperties(
+      userCollection,
+      args.memory_id
+    );
+    if (!sourceMemory) {
+      logger.info("Source memory not found", {
+        tool: "remember_revise",
+        memoryId: args.memory_id
+      });
+      return JSON.stringify(
+        {
+          success: false,
+          error: "Memory not found",
+          message: `Memory ${args.memory_id} does not exist`
+        },
+        null,
+        2
+      );
+    }
+    if (sourceMemory.properties.user_id !== userId) {
+      logger.warn("Permission denied", {
+        tool: "remember_revise",
+        memoryId: args.memory_id,
+        memoryOwner: sourceMemory.properties.user_id,
+        requestingUser: userId
+      });
+      return JSON.stringify(
+        {
+          success: false,
+          error: "Permission denied",
+          message: "You can only revise your own memories"
+        },
+        null,
+        2
+      );
+    }
+    const spaceIds = Array.isArray(sourceMemory.properties.space_ids) ? sourceMemory.properties.space_ids : [];
+    const groupIds = Array.isArray(sourceMemory.properties.group_ids) ? sourceMemory.properties.group_ids : [];
+    if (spaceIds.length === 0 && groupIds.length === 0) {
+      logger.info("Memory has no published copies", {
+        tool: "remember_revise",
+        memoryId: args.memory_id
+      });
+      return JSON.stringify(
+        {
+          success: false,
+          error: "Not published",
+          message: "Memory has no published copies to revise. Publish first with remember_publish.",
+          context: {
+            memory_id: args.memory_id,
+            space_ids: [],
+            group_ids: []
+          }
+        },
+        null,
+        2
+      );
+    }
+    const payload = {
+      memory_id: args.memory_id,
+      space_ids: spaceIds,
+      group_ids: groupIds
+    };
+    logger.info("Generating confirmation token for revise", {
+      tool: "remember_revise",
+      userId,
+      memoryId: args.memory_id,
+      spaceIds,
+      groupIds
+    });
+    const { requestId, token } = await confirmationTokenService.createRequest(
+      userId,
+      "revise_memory",
+      payload
+    );
+    logger.info("Confirmation token generated for revise", {
+      tool: "remember_revise",
+      requestId,
+      token,
+      action: "revise_memory",
+      spaceIds,
+      groupIds
+    });
+    const destinations = [];
+    if (spaceIds.length > 0) {
+      destinations.push(`spaces: ${spaceIds.join(", ")}`);
+    }
+    if (groupIds.length > 0) {
+      destinations.push(`groups: ${groupIds.join(", ")}`);
+    }
+    return JSON.stringify(
+      {
+        success: true,
+        token,
+        message: "Revision request created. Please confirm to sync content to all published copies.",
+        action: "revise_memory",
+        memory_id: args.memory_id,
+        destinations: destinations.join("; "),
+        revision_details: {
+          space_ids: spaceIds,
+          group_ids: groupIds,
+          total_locations: (spaceIds.length > 0 ? 1 : 0) + groupIds.length
+        },
+        confirmation_required: true
+      },
+      null,
+      2
+    );
+  } catch (error) {
+    debug.error("Tool failed", {
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : void 0
+    });
+    return handleToolError(error, {
+      toolName: "remember_revise",
+      userId,
+      operation: "revise memory request",
+      memoryId: args.memory_id
+    });
+  }
+}
+
+// src/tools/confirm.ts
+init_logger();
+
+// src/collections/dot-notation.ts
+var InvalidCollectionNameError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidCollectionNameError";
+  }
+};
+function getCollectionName(type, id) {
+  switch (type) {
+    case "USERS" /* USERS */:
+      if (!id) {
+        throw new InvalidCollectionNameError("User ID is required for USERS collection type");
+      }
+      if (id.includes(".")) {
+        throw new InvalidCollectionNameError(`User ID cannot contain dots: ${id}`);
+      }
+      return `Memory_users_${id}`;
+    case "SPACES" /* SPACES */:
+      return "Memory_spaces_public";
+    case "GROUPS" /* GROUPS */:
+      if (!id) {
+        throw new InvalidCollectionNameError("Group ID is required for GROUPS collection type");
+      }
+      if (id.includes(".")) {
+        throw new InvalidCollectionNameError(`Group ID cannot contain dots: ${id}`);
+      }
+      return `Memory_groups_${id}`;
+    default:
+      throw new InvalidCollectionNameError(`Unknown collection type: ${type}`);
+  }
+}
+
+// src/collections/composite-ids.ts
+var InvalidCompositeIdError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidCompositeIdError";
+  }
+};
+function generateCompositeId(userId, memoryId) {
+  if (userId.includes(".")) {
+    throw new InvalidCompositeIdError(
+      `User ID cannot contain dots: ${userId}`
+    );
+  }
+  if (memoryId.includes(".")) {
+    throw new InvalidCompositeIdError(
+      `Memory ID cannot contain dots: ${memoryId}`
+    );
+  }
+  if (!userId.trim()) {
+    throw new InvalidCompositeIdError("User ID cannot be empty");
+  }
+  if (!memoryId.trim()) {
+    throw new InvalidCompositeIdError("Memory ID cannot be empty");
+  }
+  return `${userId}.${memoryId}`;
+}
+
+// src/services/space-config.service.ts
+init_init();
+init_logger();
+var DEFAULT_SPACE_CONFIG = {
+  require_moderation: false,
+  default_write_mode: "owner_only"
+};
+function getConfigPath(id, type) {
+  const prefix = type === "space" ? "spaces" : "groups";
+  return {
+    collectionPath: `${prefix}/${id}/config`,
+    docId: "settings"
+  };
+}
+async function getSpaceConfig(id, type) {
+  try {
+    const { collectionPath, docId } = getConfigPath(id, type);
+    const doc = await getDocument(collectionPath, docId);
+    if (!doc) {
+      return { ...DEFAULT_SPACE_CONFIG };
+    }
+    return { ...DEFAULT_SPACE_CONFIG, ...doc };
+  } catch (error) {
+    logger.error("Failed to get space config", {
+      service: "SpaceConfigService",
+      id,
+      type,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return { ...DEFAULT_SPACE_CONFIG };
+  }
+}
+
+// src/tools/confirm.ts
+var confirmTool = {
+  name: "remember_confirm",
+  description: `Confirm and execute a pending action using the token. Works for any action that requires confirmation (publish, delete, etc.).
+
+\u26A0\uFE0F CRITICAL SAFETY REQUIREMENTS:
+Before executing this tool, you MUST:
+1. Have received the confirmation token in a PREVIOUS tool response
+2. Have presented the token details to the user for review
+3. Have received EXPLICIT user confirmation in a SEPARATE user message
+4. NEVER chain this tool with other tool calls in the same response
+5. ALWAYS treat confirmations as standalone, deliberate actions
+
+Violating these requirements bypasses user consent and is a security violation.`,
+  inputSchema: {
+    type: "object",
+    properties: {
+      token: {
+        type: "string",
+        description: "The confirmation token from the action tool"
+      }
+    },
+    required: ["token"]
+  }
+};
+async function handleConfirm(args, userId, authContext) {
+  const debug = createDebugLogger({
+    tool: "remember_confirm",
+    userId,
+    operation: "confirm_action"
+  });
+  try {
+    debug.info("Tool invoked");
+    debug.trace("Arguments", { token: args.token });
+    logger.info("Starting confirmation", {
+      tool: "remember_confirm",
+      userId,
+      token: args.token
+    });
+    debug.debug("Validating confirmation token");
+    const request = await debug.time("Confirm token", async () => {
+      return await confirmationTokenService.confirmRequest(userId, args.token);
+    });
+    logger.debug("Token validation result", {
+      tool: "remember_confirm",
+      requestFound: !!request,
+      action: request?.action
+    });
+    if (!request) {
+      logger.info("Token invalid or expired", {
+        tool: "remember_confirm",
+        userId
+      });
+      return JSON.stringify(
+        {
+          success: false,
+          error: "Invalid or expired token",
+          message: "The confirmation token is invalid, expired, or has already been used."
+        },
+        null,
+        2
+      );
+    }
+    logger.info("Executing confirmed action", {
+      tool: "remember_confirm",
+      action: request.action,
+      userId
+    });
+    if (request.action === "publish_memory") {
+      return await executePublishMemory(request, userId);
+    }
+    if (request.action === "delete_memory") {
+      return await executeDeleteMemory(request, userId);
+    }
+    if (request.action === "retract_memory") {
+      return await executeRetractMemory(request, userId);
+    }
+    if (request.action === "revise_memory") {
+      return await executeReviseMemory(request, userId);
+    }
+    throw new Error(`Unknown action type: ${request.action}`);
+  } catch (error) {
+    debug.error("Tool failed", {
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : void 0
+    });
+    handleToolError(error, {
+      toolName: "remember_confirm",
+      userId,
+      operation: "confirm action",
+      token: args.token
+    });
+  }
+}
+async function executePublishMemory(request, userId, authContext) {
+  const debug = createDebugLogger({
+    tool: "remember_confirm",
+    userId,
+    operation: "execute_publish"
+  });
+  try {
+    const spaces = request.payload.spaces || [];
+    const groups = request.payload.groups || [];
+    debug.debug("Executing publish memory action", {
+      memoryId: request.payload.memory_id,
+      spaces,
+      groups
+    });
+    logger.info("Executing publish memory action", {
+      function: "executePublishMemory",
+      userId,
+      memoryId: request.payload.memory_id,
+      spaces,
+      groups,
+      spaceCount: spaces.length,
+      groupCount: groups.length
+    });
+    if (spaces.length === 0 && groups.length === 0) {
+      return JSON.stringify(
+        {
+          success: false,
+          error: "No destinations",
+          message: "Must specify at least one space or group to publish to"
+        },
+        null,
+        2
+      );
+    }
+    const weaviateClient = getWeaviateClient();
+    const userCollectionName = getMemoryCollectionName(userId);
+    const userCollection = weaviateClient.collections.get(userCollectionName);
+    logger.debug("Fetching original memory", {
+      function: "executePublishMemory",
+      collectionName: userCollectionName,
+      memoryId: request.payload.memory_id
+    });
+    const originalMemory = await debug.time("Fetch original memory", async () => {
+      return await fetchMemoryWithAllProperties(
+        userCollection,
+        request.payload.memory_id
+      );
+    });
+    logger.info("Original memory fetch result", {
+      function: "executePublishMemory",
+      found: !!originalMemory,
+      memoryId: request.payload.memory_id,
+      hasProperties: !!originalMemory?.properties,
+      propertyCount: originalMemory?.properties ? Object.keys(originalMemory.properties).length : 0
+    });
+    if (!originalMemory) {
+      logger.info("Original memory not found", {
+        function: "executePublishMemory",
+        memoryId: request.payload.memory_id
+      });
+      return JSON.stringify(
+        {
+          success: false,
+          error: "Memory not found",
+          message: `Original memory ${request.payload.memory_id} no longer exists`
+        },
+        null,
+        2
+      );
+    }
+    if (originalMemory.properties.user_id !== userId) {
+      logger.warn("Permission denied - wrong owner", {
+        function: "executePublishMemory",
+        memoryId: request.payload.memory_id,
+        memoryOwner: originalMemory.properties.user_id,
+        requestingUser: userId
+      });
+      return JSON.stringify(
+        {
+          success: false,
+          error: "Permission denied",
+          message: "You can only publish your own memories"
+        },
+        null,
+        2
+      );
+    }
+    const compositeId = generateCompositeId(userId, request.payload.memory_id);
+    logger.debug("Generated composite ID", {
+      function: "executePublishMemory",
+      compositeId,
+      userId,
+      memoryId: request.payload.memory_id
+    });
+    const existingSpaceIds = Array.isArray(originalMemory.properties.space_ids) ? originalMemory.properties.space_ids : [];
+    const existingGroupIds = Array.isArray(originalMemory.properties.group_ids) ? originalMemory.properties.group_ids : [];
+    const originalTags = Array.isArray(originalMemory.properties.tags) ? originalMemory.properties.tags : [];
+    const additionalTags = Array.isArray(request.payload.additional_tags) ? request.payload.additional_tags : [];
+    const mergedTags = [...originalTags, ...additionalTags];
+    const publicationResults = { groups: [] };
+    if (spaces.length > 0) {
+      logger.debug("Ensuring public spaces collection exists", {
+        function: "executePublishMemory"
+      });
+      const publicCollection = await ensurePublicCollection(weaviateClient);
+      let existingSpaceMemory = null;
+      try {
+        existingSpaceMemory = await fetchMemoryWithAllProperties(publicCollection, compositeId);
+      } catch (e) {
+      }
+      const newSpaceIds = [.../* @__PURE__ */ new Set([...existingSpaceIds, ...spaces])];
+      let spaceModerationStatus = "approved";
+      for (const spaceId of spaces) {
+        const spaceConfig = await getSpaceConfig(spaceId, "space");
+        if (spaceConfig.require_moderation) {
+          spaceModerationStatus = "pending";
+          break;
+        }
+      }
+      const publishedMemory = {
+        ...originalMemory.properties,
+        // Use composite ID as the document ID
+        id: compositeId,
+        // Tracking arrays (v2 feature)
+        space_ids: newSpaceIds,
+        group_ids: existingGroupIds,
+        // Legacy compatibility
+        spaces,
+        // Publication metadata
+        author_id: userId,
+        published_at: (/* @__PURE__ */ new Date()).toISOString(),
+        discovery_count: 0,
+        attribution: "user",
+        // Moderation status
+        moderation_status: spaceModerationStatus,
+        // Merge tags
+        tags: mergedTags
+      };
+      delete publishedMemory._additional;
+      logger.info("Publishing memory to Memory_spaces_public", {
+        function: "executePublishMemory",
+        compositeId,
+        spaces,
+        spaceIds: newSpaceIds
+      });
+      try {
+        if (existingSpaceMemory) {
+          await publicCollection.data.update({
+            id: compositeId,
+            properties: publishedMemory
+          });
+          publicationResults.spaces = { success: true, id: compositeId };
+        } else {
+          await publicCollection.data.insert({
+            id: compositeId,
+            properties: publishedMemory
+          });
+          publicationResults.spaces = { success: true, id: compositeId };
+        }
+        logger.info("Memory published to spaces successfully", {
+          function: "executePublishMemory",
+          compositeId,
+          spaces
+        });
+      } catch (spaceError) {
+        logger.error("Failed to publish to spaces", {
+          function: "executePublishMemory",
+          error: spaceError instanceof Error ? spaceError.message : String(spaceError)
+        });
+        publicationResults.spaces = {
+          success: false,
+          error: spaceError instanceof Error ? spaceError.message : String(spaceError)
+        };
+      }
+    }
+    for (const groupId of groups) {
+      const groupCollectionName = getCollectionName("GROUPS" /* GROUPS */, groupId);
+      logger.debug("Publishing to group collection", {
+        function: "executePublishMemory",
+        groupId,
+        collectionName: groupCollectionName
+      });
+      try {
+        const groupCollection = weaviateClient.collections.get(groupCollectionName);
+        let existingGroupMemory = null;
+        try {
+          existingGroupMemory = await fetchMemoryWithAllProperties(groupCollection, compositeId);
+        } catch (e) {
+        }
+        const newGroupIds = [.../* @__PURE__ */ new Set([...existingGroupIds, groupId])];
+        const groupConfig = await getSpaceConfig(groupId, "group");
+        const groupModerationStatus = groupConfig.require_moderation ? "pending" : "approved";
+        const groupMemory = {
+          ...originalMemory.properties,
+          // Use composite ID
+          id: compositeId,
+          // Tracking arrays
+          space_ids: existingSpaceIds,
+          group_ids: newGroupIds,
+          // Publication metadata
+          author_id: userId,
+          published_at: (/* @__PURE__ */ new Date()).toISOString(),
+          discovery_count: 0,
+          attribution: "user",
+          // Moderation status
+          moderation_status: groupModerationStatus,
+          // Merge tags
+          tags: mergedTags
+        };
+        delete groupMemory._additional;
+        if (existingGroupMemory) {
+          await groupCollection.data.update({
+            id: compositeId,
+            properties: groupMemory
+          });
+        } else {
+          await groupCollection.data.insert({
+            id: compositeId,
+            properties: groupMemory
+          });
+        }
+        publicationResults.groups.push({ groupId, success: true, id: compositeId });
+        logger.info("Memory published to group successfully", {
+          function: "executePublishMemory",
+          compositeId,
+          groupId
+        });
+      } catch (groupError) {
+        logger.error("Failed to publish to group", {
+          function: "executePublishMemory",
+          groupId,
+          error: groupError instanceof Error ? groupError.message : String(groupError)
+        });
+        publicationResults.groups.push({
+          groupId,
+          success: false,
+          error: groupError instanceof Error ? groupError.message : String(groupError)
+        });
+      }
+    }
+    const finalSpaceIds = publicationResults.spaces?.success ? [.../* @__PURE__ */ new Set([...existingSpaceIds, ...spaces])] : existingSpaceIds;
+    const successfulGroups = publicationResults.groups.filter((g) => g.success).map((g) => g.groupId);
+    const finalGroupIds = [.../* @__PURE__ */ new Set([...existingGroupIds, ...successfulGroups])];
+    if (finalSpaceIds.length > existingSpaceIds.length || finalGroupIds.length > existingGroupIds.length) {
+      try {
+        await userCollection.data.update({
+          id: request.payload.memory_id,
+          properties: {
+            space_ids: finalSpaceIds,
+            group_ids: finalGroupIds
+          }
+        });
+        logger.info("Updated source memory with tracking arrays", {
+          function: "executePublishMemory",
+          memoryId: request.payload.memory_id,
+          spaceIds: finalSpaceIds,
+          groupIds: finalGroupIds
+        });
+      } catch (updateError) {
+        logger.warn("Failed to update source memory tracking arrays", {
+          function: "executePublishMemory",
+          memoryId: request.payload.memory_id,
+          error: updateError instanceof Error ? updateError.message : String(updateError)
+        });
+      }
+    }
+    const successfulPublications = [];
+    const failedPublications = [];
+    if (spaces.length > 0) {
+      if (publicationResults.spaces?.success) {
+        successfulPublications.push(`spaces: ${spaces.join(", ")}`);
+      } else {
+        failedPublications.push(`spaces: ${publicationResults.spaces?.error || "unknown error"}`);
+      }
+    }
+    for (const groupResult of publicationResults.groups) {
+      if (groupResult.success) {
+        successfulPublications.push(`group: ${groupResult.groupId}`);
+      } else {
+        failedPublications.push(`group ${groupResult.groupId}: ${groupResult.error || "unknown error"}`);
+      }
+    }
+    if (successfulPublications.length > 0) {
+      return JSON.stringify(
+        {
+          success: true,
+          composite_id: compositeId,
+          published_to: successfulPublications,
+          failed: failedPublications.length > 0 ? failedPublications : void 0,
+          space_ids: finalSpaceIds,
+          group_ids: finalGroupIds
+        },
+        null,
+        2
+      );
+    } else {
+      return JSON.stringify(
+        {
+          success: false,
+          error: "Publication failed",
+          message: "Failed to publish to any destination",
+          details: failedPublications
+        },
+        null,
+        2
+      );
+    }
+  } catch (error) {
+    debug.error("Execute publish failed", {
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : void 0
+    });
+    handleToolError(error, {
+      toolName: "remember_confirm",
+      userId,
+      operation: "execute publish_memory",
+      action: "publish_memory"
+    });
+  }
+}
+async function executeDeleteMemory(request, userId, authContext) {
+  try {
+    logger.info("Executing delete memory action", {
+      function: "executeDeleteMemory",
+      userId,
+      memoryId: request.payload.memory_id,
       hasReason: !!request.payload.reason
     });
     const { memory_id, reason } = request.payload;
     const client2 = getWeaviateClient();
-    const collectionName = `Memory_${sanitizeUserId(userId)}`;
+    const collectionName = getMemoryCollectionName(userId);
     const collection = client2.collections.get(collectionName);
     await collection.data.update({
       id: memory_id,
@@ -4792,6 +5576,405 @@ async function executeDeleteMemory(request, userId) {
     throw error;
   }
 }
+async function executeRetractMemory(request, userId, authContext) {
+  const debug = createDebugLogger({
+    tool: "remember_confirm",
+    userId,
+    operation: "execute_retract"
+  });
+  try {
+    const spaces = request.payload.spaces || [];
+    const groups = request.payload.groups || [];
+    debug.debug("Executing retract memory action", {
+      memoryId: request.payload.memory_id,
+      spaces,
+      groups
+    });
+    logger.info("Executing retract memory action", {
+      function: "executeRetractMemory",
+      userId,
+      memoryId: request.payload.memory_id,
+      spaces,
+      groups,
+      spaceCount: spaces.length,
+      groupCount: groups.length
+    });
+    const weaviateClient = getWeaviateClient();
+    const userCollectionName = getMemoryCollectionName(userId);
+    const userCollection = weaviateClient.collections.get(userCollectionName);
+    const sourceMemory = await fetchMemoryWithAllProperties(
+      userCollection,
+      request.payload.memory_id
+    );
+    if (!sourceMemory) {
+      logger.info("Source memory not found for retraction", {
+        function: "executeRetractMemory",
+        memoryId: request.payload.memory_id
+      });
+      return JSON.stringify(
+        {
+          success: false,
+          error: "Memory not found",
+          message: `Source memory ${request.payload.memory_id} no longer exists`
+        },
+        null,
+        2
+      );
+    }
+    const currentSpaceIds = Array.isArray(sourceMemory.properties.space_ids) ? sourceMemory.properties.space_ids : [];
+    const currentGroupIds = Array.isArray(sourceMemory.properties.group_ids) ? sourceMemory.properties.group_ids : [];
+    const compositeId = generateCompositeId(userId, request.payload.memory_id);
+    const retractionResults = { groups: [] };
+    if (spaces.length > 0) {
+      try {
+        const publicCollection = weaviateClient.collections.get(
+          getCollectionName("SPACES" /* SPACES */)
+        );
+        const publishedMemory = await fetchMemoryWithAllProperties(publicCollection, compositeId);
+        if (publishedMemory) {
+          const newSpaceIds = currentSpaceIds.filter((id) => !spaces.includes(id));
+          await publicCollection.data.update({
+            id: compositeId,
+            properties: {
+              space_ids: newSpaceIds,
+              retracted_at: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          });
+          retractionResults.spaces = { success: true };
+          logger.info("Memory retracted from spaces (orphaned)", {
+            function: "executeRetractMemory",
+            compositeId,
+            retractedSpaces: spaces,
+            remainingSpaces: newSpaceIds,
+            isOrphaned: newSpaceIds.length === 0 && currentGroupIds.length === 0
+          });
+        } else {
+          retractionResults.spaces = {
+            success: false,
+            error: "Memory not found in spaces collection"
+          };
+          logger.warn("Memory not found in spaces collection", {
+            function: "executeRetractMemory",
+            compositeId
+          });
+        }
+      } catch (spaceError) {
+        logger.error("Failed to retract from spaces", {
+          function: "executeRetractMemory",
+          error: spaceError instanceof Error ? spaceError.message : String(spaceError)
+        });
+        retractionResults.spaces = {
+          success: false,
+          error: spaceError instanceof Error ? spaceError.message : String(spaceError)
+        };
+      }
+    }
+    for (const groupId of groups) {
+      const groupCollectionName = getCollectionName("GROUPS" /* GROUPS */, groupId);
+      try {
+        const groupCollection = weaviateClient.collections.get(groupCollectionName);
+        const groupMemory = await fetchMemoryWithAllProperties(groupCollection, compositeId);
+        if (groupMemory) {
+          const groupMemoryGroupIds = Array.isArray(groupMemory.properties.group_ids) ? groupMemory.properties.group_ids : [];
+          const newGroupIds = groupMemoryGroupIds.filter((id) => id !== groupId);
+          await groupCollection.data.update({
+            id: compositeId,
+            properties: {
+              group_ids: newGroupIds,
+              retracted_at: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          });
+          retractionResults.groups.push({ groupId, success: true });
+          logger.info("Memory retracted from group (orphaned)", {
+            function: "executeRetractMemory",
+            compositeId,
+            groupId,
+            remainingGroups: newGroupIds,
+            isOrphaned: newGroupIds.length === 0
+          });
+        } else {
+          retractionResults.groups.push({
+            groupId,
+            success: false,
+            error: "Memory not found in group"
+          });
+          logger.warn("Memory not found in group collection", {
+            function: "executeRetractMemory",
+            compositeId,
+            groupId
+          });
+        }
+      } catch (groupError) {
+        logger.error("Failed to retract from group", {
+          function: "executeRetractMemory",
+          groupId,
+          error: groupError instanceof Error ? groupError.message : String(groupError)
+        });
+        retractionResults.groups.push({
+          groupId,
+          success: false,
+          error: groupError instanceof Error ? groupError.message : String(groupError)
+        });
+      }
+    }
+    const finalSpaceIds = retractionResults.spaces?.success ? currentSpaceIds.filter((id) => !spaces.includes(id)) : currentSpaceIds;
+    const successfulGroupRetractions = retractionResults.groups.filter((g) => g.success).map((g) => g.groupId);
+    const finalGroupIds = currentGroupIds.filter((id) => !successfulGroupRetractions.includes(id));
+    try {
+      await userCollection.data.update({
+        id: request.payload.memory_id,
+        properties: {
+          space_ids: finalSpaceIds,
+          group_ids: finalGroupIds
+        }
+      });
+      logger.info("Updated source memory tracking arrays after retraction", {
+        function: "executeRetractMemory",
+        memoryId: request.payload.memory_id,
+        spaceIds: finalSpaceIds,
+        groupIds: finalGroupIds
+      });
+    } catch (updateError) {
+      logger.warn("Failed to update source memory tracking arrays after retraction", {
+        function: "executeRetractMemory",
+        memoryId: request.payload.memory_id,
+        error: updateError instanceof Error ? updateError.message : String(updateError)
+      });
+    }
+    const successfulRetractions = [];
+    const failedRetractions = [];
+    if (spaces.length > 0) {
+      if (retractionResults.spaces?.success) {
+        successfulRetractions.push(`spaces: ${spaces.join(", ")}`);
+      } else {
+        failedRetractions.push(`spaces: ${retractionResults.spaces?.error || "unknown error"}`);
+      }
+    }
+    for (const groupResult of retractionResults.groups) {
+      if (groupResult.success) {
+        successfulRetractions.push(`group: ${groupResult.groupId}`);
+      } else {
+        failedRetractions.push(`group ${groupResult.groupId}: ${groupResult.error || "unknown error"}`);
+      }
+    }
+    if (successfulRetractions.length > 0) {
+      return JSON.stringify(
+        {
+          success: true,
+          composite_id: compositeId,
+          retracted_from: successfulRetractions,
+          failed: failedRetractions.length > 0 ? failedRetractions : void 0,
+          space_ids: finalSpaceIds,
+          group_ids: finalGroupIds,
+          is_orphaned: finalSpaceIds.length === 0 && finalGroupIds.length === 0
+        },
+        null,
+        2
+      );
+    } else {
+      return JSON.stringify(
+        {
+          success: false,
+          error: "Retraction failed",
+          message: "Failed to retract from any destination",
+          details: failedRetractions
+        },
+        null,
+        2
+      );
+    }
+  } catch (error) {
+    debug.error("Execute retract failed", {
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : void 0
+    });
+    handleToolError(error, {
+      toolName: "remember_confirm",
+      userId,
+      operation: "execute retract_memory",
+      action: "retract_memory"
+    });
+  }
+}
+async function executeReviseMemory(request, userId, authContext) {
+  const debug = createDebugLogger({
+    tool: "remember_confirm",
+    userId,
+    operation: "execute_revise"
+  });
+  try {
+    const { memory_id, space_ids = [], group_ids = [] } = request.payload;
+    debug.debug("Executing revise memory action", {
+      memoryId: memory_id,
+      spaceIds: space_ids,
+      groupIds: group_ids
+    });
+    logger.info("Executing revise memory action", {
+      function: "executeReviseMemory",
+      userId,
+      memoryId: memory_id,
+      spaceCount: space_ids.length,
+      groupCount: group_ids.length
+    });
+    const weaviateClient = getWeaviateClient();
+    const userCollectionName = getMemoryCollectionName(userId);
+    const userCollection = weaviateClient.collections.get(userCollectionName);
+    const sourceMemory = await fetchMemoryWithAllProperties(
+      userCollection,
+      memory_id
+    );
+    if (!sourceMemory) {
+      return JSON.stringify(
+        {
+          success: false,
+          error: "Memory not found",
+          message: `Source memory ${memory_id} no longer exists`
+        },
+        null,
+        2
+      );
+    }
+    if (sourceMemory.properties.user_id !== userId) {
+      return JSON.stringify(
+        {
+          success: false,
+          error: "Permission denied",
+          message: "You can only revise your own memories"
+        },
+        null,
+        2
+      );
+    }
+    const newContent = String(sourceMemory.properties.content ?? "");
+    const revisedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const compositeId = generateCompositeId(userId, memory_id);
+    const results = [];
+    logger.info("Revising published copies", {
+      function: "executeReviseMemory",
+      compositeId,
+      spaceCount: space_ids.length > 0 ? 1 : 0,
+      groupCount: group_ids.length
+    });
+    async function reviseInCollection(collectionName, locationLabel) {
+      try {
+        const collection = weaviateClient.collections.get(collectionName);
+        const publishedMemory = await fetchMemoryWithAllProperties(
+          collection,
+          compositeId
+        );
+        if (!publishedMemory) {
+          results.push({
+            location: locationLabel,
+            status: "skipped",
+            error: "Published copy not found (may have been deleted)"
+          });
+          logger.warn("Published copy not found in collection", {
+            function: "executeReviseMemory",
+            collectionName,
+            compositeId
+          });
+          return;
+        }
+        const oldContent = String(publishedMemory.properties.content ?? "");
+        let revisionHistory = parseRevisionHistory(
+          publishedMemory.properties.revision_history
+        );
+        if (oldContent !== newContent) {
+          revisionHistory = buildRevisionHistory(
+            revisionHistory,
+            oldContent,
+            revisedAt
+          );
+        }
+        const currentRevisionCount = typeof publishedMemory.properties.revision_count === "number" ? publishedMemory.properties.revision_count : 0;
+        await collection.data.update({
+          id: compositeId,
+          properties: {
+            content: newContent,
+            revised_at: revisedAt,
+            revision_count: currentRevisionCount + 1,
+            revision_history: JSON.stringify(revisionHistory)
+          }
+        });
+        results.push({ location: locationLabel, status: "success" });
+        logger.info("Revised published memory in collection", {
+          function: "executeReviseMemory",
+          collectionName,
+          compositeId,
+          revisionCount: currentRevisionCount + 1,
+          contentChanged: oldContent !== newContent
+        });
+      } catch (err) {
+        results.push({
+          location: locationLabel,
+          status: "failed",
+          error: err instanceof Error ? err.message : String(err)
+        });
+        logger.error("Failed to revise in collection", {
+          function: "executeReviseMemory",
+          collectionName,
+          compositeId,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    if (space_ids.length > 0) {
+      await reviseInCollection(
+        getCollectionName("SPACES" /* SPACES */),
+        "Memory_spaces_public"
+      );
+    }
+    for (const groupId of group_ids) {
+      await reviseInCollection(
+        getCollectionName("GROUPS" /* GROUPS */, groupId),
+        `Memory_groups_${groupId}`
+      );
+    }
+    const successCount = results.filter((r) => r.status === "success").length;
+    const failedCount = results.filter((r) => r.status === "failed").length;
+    const skippedCount = results.filter((r) => r.status === "skipped").length;
+    logger.info("Revise execution complete", {
+      function: "executeReviseMemory",
+      userId,
+      memoryId: memory_id,
+      successCount,
+      failedCount,
+      skippedCount
+    });
+    return JSON.stringify(
+      {
+        success: successCount > 0,
+        composite_id: compositeId,
+        revised_at: revisedAt,
+        summary: {
+          total: results.length,
+          success: successCount,
+          failed: failedCount,
+          skipped: skippedCount
+        },
+        results,
+        ...failedCount > 0 ? {
+          warnings: [
+            `Failed to revise ${failedCount} of ${results.length} location(s)`
+          ]
+        } : {}
+      },
+      null,
+      2
+    );
+  } catch (error) {
+    debug.error("Execute revise failed", {
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : void 0
+    });
+    handleToolError(error, {
+      toolName: "remember_confirm",
+      userId,
+      operation: "execute revise_memory",
+      action: "revise_memory"
+    });
+  }
+}
 
 // src/tools/deny.ts
 var denyTool = {
@@ -4818,8 +6001,11 @@ This ensures proper user consent workflow is followed.`,
     required: ["token"]
   }
 };
-async function handleDeny(args, userId) {
+async function handleDeny(args, userId, authContext) {
+  const debug = createDebugLogger({ tool: "remember_deny", userId, operation: "deny action" });
   try {
+    debug.info("Tool invoked");
+    debug.trace("Arguments", { args });
     const success = await confirmationTokenService.denyRequest(userId, args.token);
     if (!success) {
       return JSON.stringify(
@@ -4840,6 +6026,7 @@ async function handleDeny(args, userId) {
       2
     );
   } catch (error) {
+    debug.error("Tool failed", { error: error instanceof Error ? error.message : String(error) });
     handleToolError(error, {
       toolName: "remember_deny",
       userId,
@@ -4852,9 +6039,32 @@ async function handleDeny(args, userId) {
 // src/tools/search-space.ts
 import { Filters as Filters4 } from "weaviate-client";
 init_space_memory();
+init_logger();
+
+// src/utils/auth-helpers.ts
+function canModerate(authContext, groupId) {
+  if (!authContext?.credentials)
+    return false;
+  const membership = authContext.credentials.group_memberships.find((m) => m.group_id === groupId);
+  return membership?.permissions.can_moderate ?? false;
+}
+function canModerateAny(authContext) {
+  if (!authContext?.credentials)
+    return false;
+  return authContext.credentials.group_memberships.some((m) => m.permissions.can_moderate);
+}
+
+// src/tools/search-space.ts
 var searchSpaceTool = {
   name: "remember_search_space",
-  description: `Search one or more shared spaces to discover thoughts, ideas, and memories. By default, excludes comments to keep discovery clean. Set include_comments: true to include threaded discussions. Can search multiple spaces in a single query.
+  description: `Search shared spaces and/or groups to discover memories from other users.
+
+Destinations:
+- Spaces: Public shared areas (e.g., "the_void", "dogs") \u2014 queries Memory_spaces_public filtered by space_ids
+- Groups: Private group collections \u2014 queries Memory_groups_{groupId} for each specified group
+- Neither specified: Searches all public memories across Memory_spaces_public
+
+Results from multiple sources are merged and deduplicated by composite ID, sorted by relevance.
 
 \u26A0\uFE0F **CRITICAL - CONTENT TYPE FILTERING**: Do NOT add content_type filter unless the user explicitly requests filtering by type.
 - \u2705 CORRECT: User says "search The Void for hiking" \u2192 { spaces: ["the_void"], query: "hiking" }
@@ -4867,7 +6077,7 @@ Let the search algorithm find ALL relevant memories regardless of type unless ex
     properties: {
       query: {
         type: "string",
-        description: "Search query (semantic + keyword hybrid)"
+        description: "Search query"
       },
       spaces: {
         type: "array",
@@ -4875,9 +6085,20 @@ Let the search algorithm find ALL relevant memories regardless of type unless ex
           type: "string",
           enum: SUPPORTED_SPACES
         },
-        description: 'Spaces to search (e.g., ["the_void", "dogs"]). Can search multiple spaces at once.',
-        minItems: 1,
-        default: ["the_void"]
+        description: 'Spaces to search (e.g., ["the_void", "dogs"]). Omit to search all public spaces.',
+        minItems: 1
+      },
+      groups: {
+        type: "array",
+        items: { type: "string" },
+        description: 'Group IDs to search (e.g., ["group-123"]). Searches Memory_groups_{groupId} for each.',
+        minItems: 1
+      },
+      search_type: {
+        type: "string",
+        enum: ["hybrid", "bm25", "semantic"],
+        description: 'Search algorithm: "hybrid" (default), "bm25" (keyword only), or "semantic" (vector only)',
+        default: "hybrid"
       },
       content_type: {
         type: "string",
@@ -4908,6 +6129,12 @@ Let the search algorithm find ALL relevant memories regardless of type unless ex
         type: "string",
         description: "Filter memories created before this date (ISO 8601)"
       },
+      moderation_filter: {
+        type: "string",
+        enum: ["approved", "pending", "rejected", "removed", "all"],
+        description: 'Filter by moderation status. Default: "approved" (only shows approved/unmoderated). Non-approved filters require moderator permissions.',
+        default: "approved"
+      },
       include_comments: {
         type: "boolean",
         description: "Include comments in search results (default: false)",
@@ -4924,10 +6151,73 @@ Let the search algorithm find ALL relevant memories regardless of type unless ex
         description: "Offset for pagination"
       }
     },
-    required: ["query", "spaces"]
+    required: ["query"]
+  }
+};
+function buildModerationFilter(collection, moderationFilter = "approved") {
+  if (moderationFilter === "all") {
+    return null;
+  }
+  if (moderationFilter === "approved") {
+    return Filters4.or(
+      collection.filter.byProperty("moderation_status").equal("approved"),
+      collection.filter.byProperty("moderation_status").isNull(true)
+    );
+  }
+  return collection.filter.byProperty("moderation_status").equal(moderationFilter);
+}
+function buildBaseFilters(collection, args) {
+  const filterList = [];
+  filterList.push(collection.filter.byProperty("deleted_at").isNull(true));
+  filterList.push(collection.filter.byProperty("doc_type").equal("memory"));
+  const moderationFilter = buildModerationFilter(collection, args.moderation_filter);
+  if (moderationFilter) {
+    filterList.push(moderationFilter);
+  }
+  if (args.content_type) {
+    filterList.push(collection.filter.byProperty("content_type").equal(args.content_type));
+  }
+  if (!args.include_comments && !args.content_type) {
+    filterList.push(collection.filter.byProperty("content_type").notEqual("comment"));
+  }
+  if (!args.content_type) {
+    filterList.push(collection.filter.byProperty("content_type").notEqual("ghost"));
+  }
+  if (args.tags && args.tags.length > 0) {
+    args.tags.forEach((tag) => {
+      filterList.push(collection.filter.byProperty("tags").containsAny([tag]));
+    });
+  }
+  if (args.min_weight !== void 0) {
+    filterList.push(collection.filter.byProperty("weight").greaterOrEqual(args.min_weight));
+  }
+  if (args.max_weight !== void 0) {
+    filterList.push(collection.filter.byProperty("weight").lessOrEqual(args.max_weight));
+  }
+  if (args.date_from) {
+    filterList.push(collection.filter.byProperty("created_at").greaterOrEqual(new Date(args.date_from)));
+  }
+  if (args.date_to) {
+    filterList.push(collection.filter.byProperty("created_at").lessOrEqual(new Date(args.date_to)));
   }
-};
-async function handleSearchSpace(args, userId) {
+  return filterList;
+}
+async function executeSearch(collection, query, searchType, whereFilter, limit) {
+  const opts = {
+    limit,
+    ...whereFilter && { where: whereFilter }
+  };
+  switch (searchType) {
+    case "bm25":
+      return (await collection.query.bm25(query, opts)).objects;
+    case "semantic":
+      return (await collection.query.nearText([query], opts)).objects;
+    case "hybrid":
+    default:
+      return (await collection.query.hybrid(query, opts)).objects;
+  }
+}
+async function handleSearchSpace(args, userId, authContext) {
   const debug = createDebugLogger({
     tool: "remember_search_space",
     userId,
@@ -4936,96 +6226,167 @@ async function handleSearchSpace(args, userId) {
   try {
     debug.info("Tool invoked");
     debug.trace("Arguments", { args });
-    debug.debug("Validating space IDs", { spaces: args.spaces });
-    const invalidSpaces = args.spaces.filter((s) => !isValidSpaceId(s));
-    if (invalidSpaces.length > 0) {
-      return JSON.stringify(
-        {
-          success: false,
-          error: "Invalid space IDs",
-          message: `Invalid spaces: ${invalidSpaces.join(", ")}. Supported spaces: ${SUPPORTED_SPACES.join(", ")}`,
-          context: {
-            invalid_spaces: invalidSpaces,
-            provided_spaces: args.spaces,
-            supported_spaces: SUPPORTED_SPACES
-          }
-        },
-        null,
-        2
-      );
-    }
-    if (args.spaces.length === 0) {
-      return JSON.stringify(
-        {
-          success: false,
-          error: "Empty spaces array",
-          message: "Must specify at least one space to search"
-        },
-        null,
-        2
-      );
+    const spaces = args.spaces || [];
+    const groups = args.groups || [];
+    const searchType = args.search_type || "hybrid";
+    const limit = args.limit || 10;
+    const offset = args.offset || 0;
+    if (spaces.length > 0) {
+      const invalidSpaces = spaces.filter((s) => !isValidSpaceId(s));
+      if (invalidSpaces.length > 0) {
+        return JSON.stringify(
+          {
+            success: false,
+            error: "Invalid space IDs",
+            message: `Invalid spaces: ${invalidSpaces.join(", ")}. Supported spaces: ${SUPPORTED_SPACES.join(", ")}`,
+            context: {
+              invalid_spaces: invalidSpaces,
+              provided_spaces: spaces,
+              supported_spaces: SUPPORTED_SPACES
+            }
+          },
+          null,
+          2
+        );
+      }
     }
-    const weaviateClient = getWeaviateClient();
-    const publicCollection = await ensurePublicCollection(weaviateClient);
-    const filterList = [];
-    filterList.push(publicCollection.filter.byProperty("spaces").containsAny(args.spaces));
-    filterList.push(publicCollection.filter.byProperty("doc_type").equal("memory"));
-    if (args.content_type) {
-      filterList.push(publicCollection.filter.byProperty("type").equal(args.content_type));
+    if (groups.length > 0) {
+      const invalidGroups = groups.filter((g) => !g || g.includes(".") || g.trim() === "");
+      if (invalidGroups.length > 0) {
+        return JSON.stringify(
+          {
+            success: false,
+            error: "Invalid group IDs",
+            message: "Group IDs cannot be empty or contain dots",
+            context: { invalid_groups: invalidGroups }
+          },
+          null,
+          2
+        );
+      }
     }
-    if (!args.include_comments && !args.content_type) {
-      filterList.push(publicCollection.filter.byProperty("type").notEqual("comment"));
+    const moderationFilter = args.moderation_filter || "approved";
+    if (moderationFilter !== "approved") {
+      for (const groupId of groups) {
+        if (!canModerate(authContext, groupId)) {
+          return JSON.stringify(
+            {
+              success: false,
+              error: "Permission denied",
+              message: `Moderator access required to view ${moderationFilter} memories in group ${groupId}`
+            },
+            null,
+            2
+          );
+        }
+      }
+      if ((spaces.length > 0 || groups.length === 0) && !canModerateAny(authContext)) {
+        return JSON.stringify(
+          {
+            success: false,
+            error: "Permission denied",
+            message: `Moderator access required to view ${moderationFilter} memories in spaces`
+          },
+          null,
+          2
+        );
+      }
     }
-    if (args.tags && args.tags.length > 0) {
-      args.tags.forEach((tag) => {
-        filterList.push(publicCollection.filter.byProperty("tags").containsAny([tag]));
+    const weaviateClient = getWeaviateClient();
+    const fetchLimit = (limit + offset) * Math.max(1, groups.length + (spaces.length > 0 || groups.length === 0 ? 1 : 0));
+    const allObjects = [];
+    logger.info("Starting space/group search", {
+      tool: "remember_search_space",
+      userId,
+      spaces,
+      groups,
+      searchType,
+      query: args.query
+    });
+    if (spaces.length > 0 || groups.length === 0) {
+      const spacesCollectionName = getCollectionName("SPACES" /* SPACES */);
+      const spacesCollection = weaviateClient.collections.get(spacesCollectionName);
+      const filterList = buildBaseFilters(spacesCollection, args);
+      if (spaces.length > 0) {
+        filterList.push(spacesCollection.filter.byProperty("space_ids").containsAny(spaces));
+      }
+      const whereFilter = filterList.length > 0 ? Filters4.and(...filterList) : void 0;
+      debug.debug("Searching Memory_spaces_public", {
+        filterCount: filterList.length,
+        spaces,
+        allPublic: spaces.length === 0,
+        searchType
+      });
+      const spaceObjects = await debug.time("Space collection search", async () => {
+        return await executeSearch(spacesCollection, args.query, searchType, whereFilter, fetchLimit);
+      });
+      allObjects.push(...spaceObjects);
+      logger.info("Space collection search complete", {
+        tool: "remember_search_space",
+        collectionName: spacesCollectionName,
+        resultCount: spaceObjects.length
       });
     }
-    if (args.min_weight !== void 0) {
-      filterList.push(publicCollection.filter.byProperty("weight").greaterOrEqual(args.min_weight));
-    }
-    if (args.max_weight !== void 0) {
-      filterList.push(publicCollection.filter.byProperty("weight").lessOrEqual(args.max_weight));
-    }
-    if (args.date_from) {
-      filterList.push(publicCollection.filter.byProperty("created_at").greaterOrEqual(new Date(args.date_from)));
-    }
-    if (args.date_to) {
-      filterList.push(publicCollection.filter.byProperty("created_at").lessOrEqual(new Date(args.date_to)));
-    }
-    const whereFilter = filterList.length > 0 ? Filters4.and(...filterList) : void 0;
-    debug.debug("Executing hybrid search", {
-      query: args.query,
-      filterCount: filterList.length,
-      limit: args.limit || 10,
-      offset: args.offset || 0
-    });
-    const searchResults = await debug.time("Hybrid search query", async () => {
-      return await publicCollection.query.hybrid(args.query, {
-        limit: args.limit || 10,
-        offset: args.offset || 0,
-        ...whereFilter && { where: whereFilter }
+    for (const groupId of groups) {
+      const groupCollectionName = getCollectionName("GROUPS" /* GROUPS */, groupId);
+      const exists = await weaviateClient.collections.exists(groupCollectionName);
+      if (!exists) {
+        debug.warn("Group collection not found, skipping", { groupId, groupCollectionName });
+        continue;
+      }
+      const groupCollection = weaviateClient.collections.get(groupCollectionName);
+      const filterList = buildBaseFilters(groupCollection, args);
+      const whereFilter = filterList.length > 0 ? Filters4.and(...filterList) : void 0;
+      debug.debug("Searching group collection", {
+        groupId,
+        groupCollectionName,
+        filterCount: filterList.length,
+        searchType
+      });
+      const groupObjects = await debug.time(`Group collection search: ${groupId}`, async () => {
+        return await executeSearch(groupCollection, args.query, searchType, whereFilter, fetchLimit);
       });
+      allObjects.push(...groupObjects);
+      logger.info("Group collection search complete", {
+        tool: "remember_search_space",
+        groupId,
+        collectionName: groupCollectionName,
+        resultCount: groupObjects.length
+      });
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const deduplicated = allObjects.filter((obj) => {
+      if (seen.has(obj.uuid))
+        return false;
+      seen.add(obj.uuid);
+      return true;
     });
-    debug.debug("Search completed", {
-      resultCount: searchResults.objects.length
+    deduplicated.sort((a, b) => {
+      const scoreA = a.metadata?.score ?? 0;
+      const scoreB = b.metadata?.score ?? 0;
+      return scoreB - scoreA;
     });
-    const memories = searchResults.objects.map((obj) => ({
+    const paginated = deduplicated.slice(offset, offset + limit);
+    const memories = paginated.map((obj) => ({
       id: obj.uuid,
       ...obj.properties,
       _score: obj.metadata?.score
     }));
+    const isAllPublic = spaces.length === 0 && groups.length === 0;
     const result = {
-      spaces_searched: args.spaces,
+      spaces_searched: isAllPublic ? "all_public" : spaces,
+      groups_searched: groups,
       query: args.query,
+      search_type: searchType,
       memories,
       total: memories.length,
-      offset: args.offset || 0,
-      limit: args.limit || 10
+      offset,
+      limit
     };
     debug.info("Tool completed successfully", {
       resultCount: memories.length,
-      spaces: args.spaces
+      spaces,
+      groups
     });
     return JSON.stringify(result, null, 2);
   } catch (error) {
@@ -5037,6 +6398,7 @@ async function handleSearchSpace(args, userId) {
       toolName: "remember_search_space",
       operation: "search spaces",
       spaces: args.spaces,
+      groups: args.groups,
       query: args.query
     });
   }
@@ -5095,6 +6457,12 @@ Let the query algorithm find ALL relevant memories regardless of type unless exp
         type: "string",
         description: "Filter memories created before this date (ISO 8601)"
       },
+      moderation_filter: {
+        type: "string",
+        enum: ["approved", "pending", "rejected", "removed", "all"],
+        description: 'Filter by moderation status. Default: "approved" (only shows approved/unmoderated). Non-approved filters require moderator permissions.',
+        default: "approved"
+      },
       include_comments: {
         type: "boolean",
         description: "Include comments in query results (default: false)",
@@ -5115,7 +6483,7 @@ Let the query algorithm find ALL relevant memories regardless of type unless exp
     required: ["question", "spaces"]
   }
 };
-async function handleQuerySpace(args, userId) {
+async function handleQuerySpace(args, userId, authContext) {
   const debug = createDebugLogger({
     tool: "remember_query_space",
     userId,
@@ -5148,16 +6516,35 @@ async function handleQuerySpace(args, userId) {
         2
       );
     }
+    const moderationFilterValue = args.moderation_filter || "approved";
+    if (moderationFilterValue !== "approved" && !canModerateAny(authContext)) {
+      return JSON.stringify(
+        {
+          success: false,
+          error: "Permission denied",
+          message: `Moderator access required to view ${moderationFilterValue} memories in spaces`
+        },
+        null,
+        2
+      );
+    }
     const weaviateClient = getWeaviateClient();
     const publicCollection = await ensurePublicCollection(weaviateClient);
     const filterList = [];
     filterList.push(publicCollection.filter.byProperty("spaces").containsAny(args.spaces));
     filterList.push(publicCollection.filter.byProperty("doc_type").equal("memory"));
+    const moderationFilter = buildModerationFilter(publicCollection, args.moderation_filter);
+    if (moderationFilter) {
+      filterList.push(moderationFilter);
+    }
     if (args.content_type) {
-      filterList.push(publicCollection.filter.byProperty("type").equal(args.content_type));
+      filterList.push(publicCollection.filter.byProperty("content_type").equal(args.content_type));
     }
     if (!args.include_comments && !args.content_type) {
-      filterList.push(publicCollection.filter.byProperty("type").notEqual("comment"));
+      filterList.push(publicCollection.filter.byProperty("content_type").notEqual("comment"));
+    }
+    if (!args.content_type) {
+      filterList.push(publicCollection.filter.byProperty("content_type").notEqual("ghost"));
     }
     if (args.tags && args.tags.length > 0) {
       args.tags.forEach((tag) => {
@@ -5236,6 +6623,353 @@ async function handleQuerySpace(args, userId) {
   }
 }
 
+// src/tools/moderate.ts
+init_logger();
+var ACTION_TO_STATUS = {
+  approve: "approved",
+  reject: "rejected",
+  remove: "removed"
+};
+var moderateTool = {
+  name: "remember_moderate",
+  description: `Approve, reject, or remove a published memory. Requires moderator permissions (can_moderate).
+
+Actions:
+- approve: Mark a pending memory as approved (visible in default searches)
+- reject: Reject a pending memory (hidden from default searches)
+- remove: Remove a previously approved memory (hidden from default searches)
+
+Must specify either space_id or group_id to identify where the memory is published.`,
+  inputSchema: {
+    type: "object",
+    properties: {
+      memory_id: {
+        type: "string",
+        description: "UUID or composite ID of the published memory"
+      },
+      space_id: {
+        type: "string",
+        description: "Space containing the memory (searches Memory_spaces_public filtered by space_ids)"
+      },
+      group_id: {
+        type: "string",
+        description: "Group containing the memory (searches Memory_groups_{groupId})"
+      },
+      action: {
+        type: "string",
+        enum: ["approve", "reject", "remove"],
+        description: "Moderation action to perform"
+      },
+      reason: {
+        type: "string",
+        description: "Optional reason for the moderation action"
+      }
+    },
+    required: ["memory_id", "action"]
+  }
+};
+async function handleModerate(args, userId, authContext) {
+  const debug = createDebugLogger({
+    tool: "remember_moderate",
+    userId,
+    operation: "moderate"
+  });
+  try {
+    debug.info("Tool invoked");
+    debug.trace("Arguments", { args });
+    const { memory_id, space_id, group_id, action, reason } = args;
+    if (!space_id && !group_id) {
+      return JSON.stringify(
+        {
+          success: false,
+          error: "Missing destination",
+          message: "Must specify either space_id or group_id"
+        },
+        null,
+        2
+      );
+    }
+    if (!ACTION_TO_STATUS[action]) {
+      return JSON.stringify(
+        {
+          success: false,
+          error: "Invalid action",
+          message: `Action must be one of: approve, reject, remove`
+        },
+        null,
+        2
+      );
+    }
+    if (group_id) {
+      if (!canModerate(authContext, group_id)) {
+        return JSON.stringify(
+          {
+            success: false,
+            error: "Permission denied",
+            message: `Moderator access required for group ${group_id}`
+          },
+          null,
+          2
+        );
+      }
+    } else if (space_id) {
+      if (!canModerateAny(authContext)) {
+        return JSON.stringify(
+          {
+            success: false,
+            error: "Permission denied",
+            message: `Moderator access required to moderate memories in spaces`
+          },
+          null,
+          2
+        );
+      }
+    }
+    const weaviateClient = getWeaviateClient();
+    let collection;
+    if (group_id) {
+      const collectionName = getCollectionName("GROUPS" /* GROUPS */, group_id);
+      collection = weaviateClient.collections.get(collectionName);
+    } else {
+      collection = await ensurePublicCollection(weaviateClient);
+    }
+    const memory = await fetchMemoryWithAllProperties(collection, memory_id);
+    if (!memory) {
+      return JSON.stringify(
+        {
+          success: false,
+          error: "Memory not found",
+          message: `Published memory ${memory_id} not found in ${group_id ? `group ${group_id}` : `space ${space_id}`}`
+        },
+        null,
+        2
+      );
+    }
+    const newStatus = ACTION_TO_STATUS[action];
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await collection.data.update({
+      id: memory_id,
+      properties: {
+        moderation_status: newStatus,
+        moderated_by: userId,
+        moderated_at: now
+      }
+    });
+    logger.info("Memory moderated", {
+      tool: "remember_moderate",
+      userId,
+      memoryId: memory_id,
+      action,
+      newStatus,
+      spaceId: space_id,
+      groupId: group_id,
+      reason
+    });
+    return JSON.stringify(
+      {
+        success: true,
+        memory_id,
+        action,
+        moderation_status: newStatus,
+        moderated_by: userId,
+        moderated_at: now,
+        reason: reason || void 0,
+        location: group_id ? `group:${group_id}` : `space:${space_id}`
+      },
+      null,
+      2
+    );
+  } catch (error) {
+    debug.error("Tool failed", {
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : void 0
+    });
+    return handleToolError(error, {
+      toolName: "remember_moderate",
+      operation: "moderate memory",
+      memoryId: args.memory_id,
+      action: args.action
+    });
+  }
+}
+
+// src/tools/ghost-config.ts
+init_ghost_config_service();
+var ghostConfigTool = {
+  name: "remember_ghost_config",
+  description: `Manage ghost/persona configuration. Controls who can interact with your ghost and at what trust level.
+
+Actions:
+- get: View current ghost configuration
+- set: Update ghost settings (enabled, trust defaults, enforcement mode)
+- set_trust: Set a per-user trust level override (0-1)
+- remove_trust: Remove a per-user trust override (revert to default)
+- block: Block a user from ghost access entirely
+- unblock: Unblock a previously blocked user
+
+Trust levels control what information your ghost can share:
+- 0.0: Existence only ("A memory exists about this")
+- 0.25: Metadata only (tags, type, dates \u2014 no content)
+- 0.5: Summary only (AI-generated summary, no raw content)
+- 0.75: Partial access (content with sensitive fields redacted)
+- 1.0: Full access (all content revealed)
+
+Ghost is disabled by default. Enable it to allow others to chat with your AI representation.`,
+  inputSchema: {
+    type: "object",
+    properties: {
+      action: {
+        type: "string",
+        enum: ["get", "set", "set_trust", "remove_trust", "block", "unblock"],
+        description: "Action to perform"
+      },
+      // For 'set' action
+      enabled: {
+        type: "boolean",
+        description: 'Enable/disable ghost conversations (for "set" action)'
+      },
+      public_ghost_enabled: {
+        type: "boolean",
+        description: 'Allow non-friends to chat with ghost (for "set" action)'
+      },
+      default_friend_trust: {
+        type: "number",
+        description: 'Default trust level for friends (0-1, for "set" action)',
+        minimum: 0,
+        maximum: 1
+      },
+      default_public_trust: {
+        type: "number",
+        description: 'Default trust level for strangers (0-1, for "set" action)',
+        minimum: 0,
+        maximum: 1
+      },
+      enforcement_mode: {
+        type: "string",
+        enum: ["query", "prompt", "hybrid"],
+        description: 'Trust enforcement mode (for "set" action). "query" (default) is most secure.'
+      },
+      // For 'set_trust' / 'remove_trust' / 'block' / 'unblock' actions
+      target_user_id: {
+        type: "string",
+        description: "Target user ID (for set_trust, remove_trust, block, unblock)"
+      },
+      trust_level: {
+        type: "number",
+        description: 'Trust level to assign (0-1, for "set_trust" action)',
+        minimum: 0,
+        maximum: 1
+      }
+    },
+    required: ["action"]
+  }
+};
+async function handleGhostConfig(args, userId, authContext) {
+  const debug = createDebugLogger({ tool: "remember_ghost_config", userId, operation: args.action });
+  try {
+    debug.info("Tool invoked");
+    debug.trace("Arguments", { args });
+    switch (args.action) {
+      case "get": {
+        const config2 = await getGhostConfig(userId);
+        return JSON.stringify({
+          success: true,
+          config: config2,
+          trust_tier_guide: {
+            "0.0": "Existence only",
+            "0.25": "Metadata only (default friend trust)",
+            "0.5": "Summary only",
+            "0.75": "Partial access",
+            "1.0": "Full access"
+          }
+        }, null, 2);
+      }
+      case "set": {
+        const updates = {};
+        if (args.enabled !== void 0)
+          updates.enabled = args.enabled;
+        if (args.public_ghost_enabled !== void 0)
+          updates.public_ghost_enabled = args.public_ghost_enabled;
+        if (args.default_friend_trust !== void 0)
+          updates.default_friend_trust = args.default_friend_trust;
+        if (args.default_public_trust !== void 0)
+          updates.default_public_trust = args.default_public_trust;
+        if (args.enforcement_mode !== void 0)
+          updates.enforcement_mode = args.enforcement_mode;
+        if (Object.keys(updates).length === 0) {
+          throw new Error("No fields to update. Provide at least one of: enabled, public_ghost_enabled, default_friend_trust, default_public_trust, enforcement_mode");
+        }
+        validateGhostConfigUpdate(updates);
+        const config2 = await setGhostConfigFields(userId, updates);
+        return JSON.stringify({
+          success: true,
+          message: "Ghost configuration updated",
+          updated_fields: Object.keys(updates),
+          config: config2
+        }, null, 2);
+      }
+      case "set_trust": {
+        if (!args.target_user_id) {
+          throw new Error("target_user_id is required for set_trust action");
+        }
+        if (args.trust_level === void 0) {
+          throw new Error("trust_level is required for set_trust action");
+        }
+        await setUserTrust(userId, args.target_user_id, args.trust_level);
+        return JSON.stringify({
+          success: true,
+          message: `Trust level for ${args.target_user_id} set to ${args.trust_level}`,
+          target_user_id: args.target_user_id,
+          trust_level: args.trust_level
+        }, null, 2);
+      }
+      case "remove_trust": {
+        if (!args.target_user_id) {
+          throw new Error("target_user_id is required for remove_trust action");
+        }
+        await removeUserTrust(userId, args.target_user_id);
+        return JSON.stringify({
+          success: true,
+          message: `Trust override for ${args.target_user_id} removed (reverted to default)`,
+          target_user_id: args.target_user_id
+        }, null, 2);
+      }
+      case "block": {
+        if (!args.target_user_id) {
+          throw new Error("target_user_id is required for block action");
+        }
+        await blockUser(userId, args.target_user_id);
+        return JSON.stringify({
+          success: true,
+          message: `${args.target_user_id} blocked from ghost access`,
+          target_user_id: args.target_user_id
+        }, null, 2);
+      }
+      case "unblock": {
+        if (!args.target_user_id) {
+          throw new Error("target_user_id is required for unblock action");
+        }
+        await unblockUser(userId, args.target_user_id);
+        return JSON.stringify({
+          success: true,
+          message: `${args.target_user_id} unblocked from ghost access`,
+          target_user_id: args.target_user_id
+        }, null, 2);
+      }
+      default:
+        throw new Error(`Unknown action: ${args.action}. Valid actions: get, set, set_trust, remove_trust, block, unblock`);
+    }
+  } catch (error) {
+    debug.error("Tool failed", { error: error instanceof Error ? error.message : String(error) });
+    handleToolError(error, {
+      toolName: "remember_ghost_config",
+      operation: args.action,
+      userId
+    });
+    throw error;
+  }
+}
+
 // src/server-factory.ts
 var databasesInitialized = false;
 var initializationPromise = null;
@@ -5285,10 +7019,27 @@ async function createServer(accessToken, userId, options = {}) {
       }
     }
   );
-  registerHandlers(server, userId, accessToken);
+  let resolvedGhostMode;
+  if (options.ghostMode) {
+    const { getGhostConfig: getGhostConfig2 } = await Promise.resolve().then(() => (init_ghost_config_service(), ghost_config_service_exports));
+    const { resolveAccessorTrustLevel: resolveAccessorTrustLevel2 } = await Promise.resolve().then(() => (init_access_control(), access_control_exports));
+    const ghostConfig = await getGhostConfig2(options.ghostMode.owner_user_id);
+    const trustLevel = resolveAccessorTrustLevel2(ghostConfig, options.ghostMode.accessor_user_id);
+    resolvedGhostMode = {
+      owner_user_id: options.ghostMode.owner_user_id,
+      accessor_user_id: options.ghostMode.accessor_user_id,
+      accessor_trust_level: trustLevel
+    };
+    logger.info("Ghost mode resolved", {
+      ownerUserId: resolvedGhostMode.owner_user_id,
+      accessorUserId: resolvedGhostMode.accessor_user_id,
+      trustLevel: resolvedGhostMode.accessor_trust_level
+    });
+  }
+  registerHandlers(server, userId, accessToken, resolvedGhostMode);
   return server;
 }
-function registerHandlers(server, userId, accessToken) {
+function registerHandlers(server, userId, accessToken, ghostMode) {
   server.setRequestHandler(ListToolsRequestSchema, async () => {
     return {
       tools: [
@@ -5309,68 +7060,86 @@ function registerHandlers(server, userId, accessToken) {
         getPreferencesTool,
         // Space tools
         publishTool,
+        retractTool,
+        reviseTool,
         confirmTool,
         denyTool,
         searchSpaceTool,
-        querySpaceTool
+        querySpaceTool,
+        moderateTool,
+        ghostConfigTool
       ]
     };
   });
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     try {
+      const credentials = await credentialsProvider.getCredentials(accessToken, userId);
+      const authContext = { accessToken, credentials, ghostMode };
       let result;
       switch (name) {
         case "remember_create_memory":
-          result = await handleCreateMemory(args, userId);
+          result = await handleCreateMemory(args, userId, authContext);
           break;
         case "remember_search_memory":
-          result = await handleSearchMemory(args, userId);
+          result = await handleSearchMemory(args, userId, authContext);
           break;
         case "remember_delete_memory":
-          result = await handleDeleteMemory(args, userId);
+          result = await handleDeleteMemory(args, userId, authContext);
           break;
         case "remember_update_memory":
-          result = await handleUpdateMemory(args, userId);
+          result = await handleUpdateMemory(args, userId, authContext);
           break;
         case "remember_find_similar":
-          result = await handleFindSimilar(args, userId);
+          result = await handleFindSimilar(args, userId, authContext);
           break;
         case "remember_query_memory":
-          result = await handleQueryMemory(args, userId);
+          result = await handleQueryMemory(args, userId, authContext);
           break;
         case "remember_create_relationship":
-          result = await handleCreateRelationship(args, userId);
+          result = await handleCreateRelationship(args, userId, authContext);
           break;
         case "remember_update_relationship":
-          result = await handleUpdateRelationship(args, userId);
+          result = await handleUpdateRelationship(args, userId, authContext);
           break;
         case "remember_search_relationship":
-          result = await handleSearchRelationship(args, userId);
+          result = await handleSearchRelationship(args, userId, authContext);
           break;
         case "remember_delete_relationship":
-          result = await handleDeleteRelationship(args, userId);
+          result = await handleDeleteRelationship(args, userId, authContext);
           break;
         case "remember_set_preference":
-          result = await handleSetPreference(args, userId);
+          result = await handleSetPreference(args, userId, authContext);
           break;
         case "remember_get_preferences":
-          result = await handleGetPreferences(args, userId);
+          result = await handleGetPreferences(args, userId, authContext);
           break;
         case "remember_publish":
-          result = await handlePublish(args, userId);
+          result = await handlePublish(args, userId, authContext);
+          break;
+        case "remember_retract":
+          result = await handleRetract(args, userId, authContext);
+          break;
+        case "remember_revise":
+          result = await handleRevise(args, userId, authContext);
           break;
         case "remember_confirm":
-          result = await handleConfirm(args, userId);
+          result = await handleConfirm(args, userId, authContext);
           break;
         case "remember_deny":
-          result = await handleDeny(args, userId);
+          result = await handleDeny(args, userId, authContext);
           break;
         case "remember_search_space":
-          result = await handleSearchSpace(args, userId);
+          result = await handleSearchSpace(args, userId, authContext);
           break;
         case "remember_query_space":
-          result = await handleQuerySpace(args, userId);
+          result = await handleQuerySpace(args, userId, authContext);
+          break;
+        case "remember_moderate":
+          result = await handleModerate(args, userId, authContext);
+          break;
+        case "remember_ghost_config":
+          result = await handleGhostConfig(args, userId, authContext);
           break;
         default:
           throw new McpError(