@prmichaelsen/remember-mcp 2.8.0 → 3.0.0

package/dist/server.js

@@ -790,7 +790,11 @@ var ALL_MEMORY_PROPERTIES = [
   "attribution",
   "published_at",
   "discovery_count",
-  "space_memory_id"
+  "space_memory_id",
+  // Soft delete fields
+  "deleted_at",
+  "deleted_by",
+  "deletion_reason"
 ];
 async function fetchMemoryWithAllProperties(collection, memoryId) {
   const debug = createDebugLogger({
@@ -1128,6 +1132,22 @@ async function createMemoryCollection(userId) {
         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"
       }
     ]
   });
@@ -1831,6 +1851,14 @@ function combineFiltersWithOr(filters) {
   }
   return Filters.or(...validFilters);
 }
+function buildDeletedFilter(collection, deletedFilter = "exclude") {
+  if (deletedFilter === "exclude") {
+    return collection.filter.byProperty("deleted_at").isNull(true);
+  } else if (deletedFilter === "only") {
+    return collection.filter.byProperty("deleted_at").isNull(false);
+  }
+  return null;
+}
 
 // src/tools/search-memory.ts
 var searchMemoryTool = {
@@ -1931,6 +1959,12 @@ var searchMemoryTool = {
         type: "boolean",
         description: "Include relationships in results. Default: true (searches both memories and relationships)",
         default: true
+      },
+      deleted_filter: {
+        type: "string",
+        enum: ["exclude", "include", "only"],
+        default: "exclude",
+        description: 'Filter deleted memories: "exclude" (default, hide deleted), "include" (show all), "only" (show only deleted)'
       }
     },
     required: ["query"]
@@ -1951,19 +1985,22 @@ async function handleSearchMemory(args, userId) {
     const alpha = args.alpha ?? 0.7;
     const limit = args.limit ?? 10;
     const offset = args.offset ?? 0;
-    const filters = includeRelationships ? buildCombinedSearchFilters(collection, args.filters) : buildMemoryOnlyFilters(collection, args.filters);
+    const deletedFilter = buildDeletedFilter(collection, args.deleted_filter || "exclude");
+    const searchFilters = includeRelationships ? buildCombinedSearchFilters(collection, args.filters) : buildMemoryOnlyFilters(collection, args.filters);
+    const combinedFilters = combineFiltersWithAnd([deletedFilter, searchFilters].filter((f) => f !== null));
     const searchOptions = {
       alpha,
       limit: limit + offset
       // Get extra for offset
     };
-    if (filters) {
-      searchOptions.filters = filters;
+    if (combinedFilters) {
+      searchOptions.filters = combinedFilters;
     }
     logger.info("Weaviate query", {
       query: args.query,
       searchOptions: JSON.stringify(searchOptions, null, 2),
-      hasFilters: !!filters
+      hasFilters: !!combinedFilters,
+      deletedFilter: args.deleted_filter || "exclude"
     });
     const results = await collection.query.hybrid(args.query, searchOptions);
     const paginatedResults = results.objects.slice(offset);
@@ -2007,142 +2044,407 @@ async function handleSearchMemory(args, userId) {
 }
 
 // src/tools/delete-memory.ts
+import { Filters as Filters2 } from "weaviate-client";
+
+// src/services/confirmation-token.service.ts
+import { randomUUID } from "crypto";
 init_logger();
-var deleteMemoryTool = {
-  name: "remember_delete_memory",
-  description: `Delete a memory from your collection.
-  
-  Optionally delete connected relationships as well.
-  This action cannot be undone.
-  
-  Examples:
-  - "Delete that old camping note"
-  - "Remove the recipe I saved yesterday"
-  `,
-  inputSchema: {
-    type: "object",
-    properties: {
-      memory_id: {
-        type: "string",
-        description: "ID of the memory to delete"
-      },
-      delete_relationships: {
-        type: "boolean",
-        description: "Also delete connected relationships. Default: false",
-        default: false
+var ConfirmationTokenService = class {
+  EXPIRY_MINUTES = 5;
+  /**
+   * Create a new confirmation request
+   * 
+   * @param userId - User ID who initiated the request
+   * @param action - Action type (e.g., 'publish_memory')
+   * @param payload - Data to store with the request
+   * @param targetCollection - Optional target collection (e.g., 'the_void')
+   * @returns Request ID and token
+   */
+  async createRequest(userId, action, payload, targetCollection) {
+    try {
+      const token = randomUUID();
+      const now = /* @__PURE__ */ new Date();
+      const expiresAt = new Date(now.getTime() + this.EXPIRY_MINUTES * 60 * 1e3);
+      const request = {
+        user_id: userId,
+        token,
+        action,
+        target_collection: targetCollection,
+        payload,
+        created_at: now.toISOString(),
+        expires_at: expiresAt.toISOString(),
+        status: "pending"
+      };
+      const collectionPath = `users/${userId}/requests`;
+      logger.info("Creating confirmation request", {
+        service: "ConfirmationTokenService",
+        userId,
+        action,
+        targetCollection,
+        collectionPath,
+        payloadKeys: Object.keys(payload)
+      });
+      logger.debug("Calling Firestore addDocument", {
+        service: "ConfirmationTokenService",
+        collectionPath
+      });
+      const docRef = await addDocument(collectionPath, request);
+      logger.debug("Firestore addDocument returned", {
+        service: "ConfirmationTokenService",
+        hasDocRef: !!docRef,
+        hasId: !!docRef?.id,
+        docRefId: docRef?.id
+      });
+      if (!docRef) {
+        const error = new Error("Firestore addDocument returned null/undefined");
+        logger.error("CRITICAL: addDocument returned null", {
+          service: "ConfirmationTokenService",
+          userId,
+          collectionPath
+        });
+        throw error;
       }
-    },
-    required: ["memory_id"]
-  }
-};
-async function handleDeleteMemory(args, userId) {
-  try {
-    logger.info("Deleting memory", { userId, memoryId: args.memory_id });
-    const collection = getMemoryCollection(userId);
-    const memory = await collection.query.fetchObjectById(args.memory_id, {
-      returnProperties: ["user_id", "doc_type", "relationships"]
-    });
-    if (!memory) {
-      throw new Error(`Memory not found: ${args.memory_id}`);
-    }
-    if (memory.properties.user_id !== userId) {
-      throw new Error("Unauthorized: Cannot delete another user's memory");
-    }
-    if (memory.properties.doc_type !== "memory") {
-      throw new Error("Cannot delete relationships using this tool. Use remember_delete_relationship instead.");
-    }
-    let relationshipsDeleted = 0;
-    if (args.delete_relationships && memory.properties.relationships) {
-      const relationshipIds = memory.properties.relationships;
-      for (const relId of relationshipIds) {
-        try {
-          await collection.data.deleteById(relId);
-          relationshipsDeleted++;
-        } catch (error) {
-          logger.warn(`Failed to delete relationship ${relId}:`, error);
-        }
+      if (!docRef.id) {
+        const error = new Error("Firestore addDocument returned docRef without ID");
+        logger.error("CRITICAL: docRef has no ID", {
+          service: "ConfirmationTokenService",
+          userId,
+          collectionPath,
+          docRef
+        });
+        throw error;
       }
+      logger.info("Confirmation request created successfully", {
+        service: "ConfirmationTokenService",
+        requestId: docRef.id,
+        token,
+        expiresAt: request.expires_at
+      });
+      return { requestId: docRef.id, token };
+    } catch (error) {
+      logger.error("Failed to create confirmation request", {
+        service: "ConfirmationTokenService",
+        error: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : void 0,
+        userId,
+        action,
+        collectionPath: `users/${userId}/requests`
+      });
+      throw error;
     }
-    await collection.data.deleteById(args.memory_id);
-    logger.info("Memory deleted successfully", {
+  }
+  /**
+   * Validate and retrieve a confirmation request
+   * 
+   * @param userId - User ID
+   * @param token - Confirmation token
+   * @returns Request with request_id if valid, null otherwise
+   */
+  async validateToken(userId, token) {
+    const collectionPath = `users/${userId}/requests`;
+    logger.debug("Validating confirmation token", {
+      service: "ConfirmationTokenService",
       userId,
-      memoryId: args.memory_id,
-      relationshipsDeleted
+      token,
+      collectionPath
     });
-    const result = {
-      memory_id: args.memory_id,
-      deleted: true,
-      relationships_deleted: relationshipsDeleted,
-      message: `Memory deleted successfully${relationshipsDeleted > 0 ? ` (${relationshipsDeleted} relationships also deleted)` : ""}`
+    const queryOptions = {
+      where: [
+        { field: "token", op: "==", value: token },
+        { field: "status", op: "==", value: "pending" }
+      ],
+      limit: 1
     };
-    return JSON.stringify(result, null, 2);
-  } catch (error) {
-    handleToolError(error, {
-      toolName: "remember_delete_memory",
-      operation: "delete memory",
-      userId,
-      memoryId: args.memory_id,
-      deleteRelationships: args.delete_relationships
+    const results = await queryDocuments(collectionPath, queryOptions);
+    logger.debug("Token query results", {
+      service: "ConfirmationTokenService",
+      resultsFound: results.length,
+      hasResults: results.length > 0
+    });
+    if (results.length === 0) {
+      logger.info("Token not found or not pending", {
+        service: "ConfirmationTokenService",
+        userId
+      });
+      return null;
+    }
+    const doc = results[0];
+    const request = doc.data;
+    logger.info("Confirmation request found", {
+      service: "ConfirmationTokenService",
+      requestId: doc.id,
+      action: request.action,
+      status: request.status,
+      expiresAt: request.expires_at
     });
+    const expiresAt = new Date(request.expires_at);
+    if (expiresAt.getTime() < Date.now()) {
+      logger.info("Token expired", {
+        service: "ConfirmationTokenService",
+        requestId: doc.id,
+        expiresAt: request.expires_at
+      });
+      await this.updateStatus(userId, doc.id, "expired");
+      return null;
+    }
+    return {
+      ...request,
+      request_id: doc.id
+    };
   }
-}
-
-// src/tools/update-memory.ts
-init_logger();
-var updateMemoryTool = {
-  name: "remember_update_memory",
-  description: `Update an existing memory with partial updates.
-  
-  Supports updating any field except id, user_id, doc_type, created_at.
-  Version number is automatically incremented and updated_at is set.
-  Only provided fields are updated (partial updates supported).
-  
-  Examples:
-  - "Update that camping note to add more details"
-  - "Change the weight of my recipe memory"
-  - "Add tags to the meeting note from yesterday"
-  `,
-  inputSchema: {
-    type: "object",
-    properties: {
-      memory_id: {
-        type: "string",
-        description: "ID of the memory to update"
-      },
-      content: {
-        type: "string",
-        description: "Updated memory content"
-      },
-      title: {
-        type: "string",
-        description: "Updated title"
-      },
-      type: {
-        type: "string",
-        description: "Updated content type"
-      },
-      weight: {
-        type: "number",
-        description: "Updated significance/priority (0-1)",
-        minimum: 0,
-        maximum: 1
-      },
-      trust: {
-        type: "number",
-        description: "Updated access control level (0-1)",
-        minimum: 0,
-        maximum: 1
-      },
-      tags: {
-        type: "array",
-        items: { type: "string" },
-        description: "Updated tags (replaces existing tags)"
-      },
-      references: {
-        type: "array",
-        items: { type: "string" },
-        description: "Updated source URLs (replaces existing references)"
-      },
+  /**
+   * Confirm a request
+   * 
+   * @param userId - User ID
+   * @param token - Confirmation token
+   * @returns Confirmed request if valid, null otherwise
+   */
+  async confirmRequest(userId, token) {
+    const request = await this.validateToken(userId, token);
+    if (!request) {
+      return null;
+    }
+    await this.updateStatus(userId, request.request_id, "confirmed");
+    return {
+      ...request,
+      status: "confirmed",
+      confirmed_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Deny a request
+   * 
+   * @param userId - User ID
+   * @param token - Confirmation token
+   * @returns True if denied successfully, false otherwise
+   */
+  async denyRequest(userId, token) {
+    const request = await this.validateToken(userId, token);
+    if (!request) {
+      return false;
+    }
+    await this.updateStatus(userId, request.request_id, "denied");
+    return true;
+  }
+  /**
+   * Retract a request
+   * 
+   * @param userId - User ID
+   * @param token - Confirmation token
+   * @returns True if retracted successfully, false otherwise
+   */
+  async retractRequest(userId, token) {
+    const request = await this.validateToken(userId, token);
+    if (!request) {
+      return false;
+    }
+    await this.updateStatus(userId, request.request_id, "retracted");
+    return true;
+  }
+  /**
+   * Update request status
+   * 
+   * @param userId - User ID
+   * @param requestId - Request document ID
+   * @param status - New status
+   */
+  async updateStatus(userId, requestId, status) {
+    const collectionPath = `users/${userId}/requests`;
+    const updateData = {
+      status
+    };
+    if (status === "confirmed") {
+      updateData.confirmed_at = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    await updateDocument(collectionPath, requestId, updateData);
+  }
+  /**
+   * Clean up expired requests (optional - Firestore TTL handles deletion)
+   * 
+   * Note: Configure Firestore TTL policy on 'requests' collection group
+   * with 'expires_at' field for automatic deletion within 24 hours.
+   * 
+   * This method is optional for immediate cleanup if needed.
+   * 
+   * @returns Count of deleted requests
+   */
+  async cleanupExpired() {
+    logger.warn("cleanupExpired not implemented - relying on Firestore TTL", {
+      service: "ConfirmationTokenService",
+      note: "Configure Firestore TTL policy on requests collection group"
+    });
+    return 0;
+  }
+};
+var confirmationTokenService = new ConfirmationTokenService();
+
+// src/tools/delete-memory.ts
+init_logger();
+var deleteMemoryTool = {
+  name: "remember_delete_memory",
+  description: `Request to delete a memory. Requires confirmation via remember_confirm.
+  
+\u26A0\uFE0F **IMPORTANT**: This is a two-step process:
+1. Call remember_delete_memory to request deletion (returns token)
+2. User must confirm via remember_confirm with the token
+
+The memory will be soft-deleted (marked as deleted but not removed from database).
+
+Examples:
+- "Delete that old camping note"
+- "Remove the recipe I saved yesterday"
+`,
+  inputSchema: {
+    type: "object",
+    properties: {
+      memory_id: {
+        type: "string",
+        description: "ID of the memory to delete"
+      },
+      reason: {
+        type: "string",
+        description: "Optional reason for deletion"
+      }
+    },
+    required: ["memory_id"]
+  }
+};
+async function handleDeleteMemory(args, userId) {
+  try {
+    logger.info("Requesting memory deletion", {
+      userId,
+      memoryId: args.memory_id,
+      hasReason: !!args.reason
+    });
+    const { memory_id, reason } = args;
+    const client2 = getWeaviateClient();
+    const collectionName = `Memory_${sanitizeUserId(userId)}`;
+    const collection = client2.collections.get(collectionName);
+    const memory = await fetchMemoryWithAllProperties(collection, memory_id);
+    if (!memory) {
+      throw new Error(`Memory not found: ${memory_id}`);
+    }
+    if (memory.properties.user_id !== userId) {
+      throw new Error(`Cannot delete memory: not owned by user ${userId}`);
+    }
+    if (memory.properties.doc_type !== "memory") {
+      throw new Error("Cannot delete relationships using this tool. Use remember_delete_relationship instead.");
+    }
+    if (memory.properties.deleted_at) {
+      throw new Error(`Memory ${memory_id} is already deleted`);
+    }
+    const relationshipsResult = await collection.query.fetchObjects({
+      filters: Filters2.and(
+        collection.filter.byProperty("doc_type").equal("relationship"),
+        collection.filter.byProperty("memory_ids").containsAny([memory_id])
+      ),
+      limit: 100
+    });
+    const orphanedRelationships = relationshipsResult.objects.map((r) => r.uuid);
+    logger.info("Found relationships to orphan", {
+      userId,
+      memoryId: memory_id,
+      relationshipCount: orphanedRelationships.length
+    });
+    const { requestId, token } = await confirmationTokenService.createRequest(
+      userId,
+      "delete_memory",
+      {
+        memory_id,
+        reason: reason || null
+      }
+    );
+    const expiresAt = new Date(Date.now() + 5 * 60 * 1e3);
+    logger.info("Delete confirmation token created", {
+      userId,
+      memoryId: memory_id,
+      requestId,
+      token,
+      expiresAt: expiresAt.toISOString()
+    });
+    return JSON.stringify(
+      {
+        success: true,
+        token,
+        expires_at: expiresAt.toISOString(),
+        preview: {
+          memory_id,
+          content: memory.properties.content?.substring(0, 200) + (memory.properties.content?.length > 200 ? "..." : ""),
+          type: memory.properties.type,
+          relationships_count: orphanedRelationships.length,
+          will_orphan: orphanedRelationships
+        },
+        message: `Deletion requested. Use remember_confirm with token to complete deletion. Token expires in 5 minutes.`
+      },
+      null,
+      2
+    );
+  } catch (error) {
+    handleToolError(error, {
+      toolName: "remember_delete_memory",
+      userId,
+      operation: "request delete",
+      memoryId: args.memory_id
+    });
+  }
+}
+
+// src/tools/update-memory.ts
+init_logger();
+var updateMemoryTool = {
+  name: "remember_update_memory",
+  description: `Update an existing memory with partial updates.
+  
+  Supports updating any field except id, user_id, doc_type, created_at.
+  Version number is automatically incremented and updated_at is set.
+  Only provided fields are updated (partial updates supported).
+  
+  Examples:
+  - "Update that camping note to add more details"
+  - "Change the weight of my recipe memory"
+  - "Add tags to the meeting note from yesterday"
+  `,
+  inputSchema: {
+    type: "object",
+    properties: {
+      memory_id: {
+        type: "string",
+        description: "ID of the memory to update"
+      },
+      content: {
+        type: "string",
+        description: "Updated memory content"
+      },
+      title: {
+        type: "string",
+        description: "Updated title"
+      },
+      type: {
+        type: "string",
+        description: "Updated content type"
+      },
+      weight: {
+        type: "number",
+        description: "Updated significance/priority (0-1)",
+        minimum: 0,
+        maximum: 1
+      },
+      trust: {
+        type: "number",
+        description: "Updated access control level (0-1)",
+        minimum: 0,
+        maximum: 1
+      },
+      tags: {
+        type: "array",
+        items: { type: "string" },
+        description: "Updated tags (replaces existing tags)"
+      },
+      references: {
+        type: "array",
+        items: { type: "string" },
+        description: "Updated source URLs (replaces existing references)"
+      },
       structured_content: {
         type: "object",
         description: "Updated structured content"
@@ -2190,6 +2492,10 @@ async function handleUpdateMemory(args, userId) {
     if (existingMemory.properties.doc_type !== "memory") {
       throw new Error("Cannot update relationships using this tool. Use remember_update_relationship instead.");
     }
+    if (existingMemory.properties.deleted_at) {
+      const deletedAt = typeof existingMemory.properties.deleted_at === "string" ? existingMemory.properties.deleted_at : new Date(existingMemory.properties.deleted_at).toISOString();
+      throw new Error(`Cannot update deleted memory: ${args.memory_id}. Memory was deleted on ${deletedAt}.`);
+    }
     const updates = {};
     const updatedFields = [];
     if (args.content !== void 0) {
@@ -2357,6 +2663,12 @@ var findSimilarTool = {
         type: "boolean",
         description: "Include relationships in results. Default: false",
         default: false
+      },
+      deleted_filter: {
+        type: "string",
+        enum: ["exclude", "include", "only"],
+        default: "exclude",
+        description: 'Filter deleted memories: "exclude" (default, hide deleted), "include" (show all), "only" (show only deleted)'
       }
     }
   }
@@ -2373,6 +2685,7 @@ async function handleFindSimilar(args, userId) {
     const collection = getMemoryCollection(userId);
     const limit = args.limit ?? 10;
     const minSimilarity = args.min_similarity ?? 0.7;
+    const deletedFilter = buildDeletedFilter(collection, args.deleted_filter || "exclude");
     let results;
     if (args.memory_id) {
       const memory = await collection.query.fetchObjectById(args.memory_id, {
@@ -2387,20 +2700,28 @@ async function handleFindSimilar(args, userId) {
       if (memory.properties.doc_type !== "memory") {
         throw new Error("Can only find similar memories for memory documents, not relationships");
       }
-      results = await collection.query.nearObject(args.memory_id, {
+      const searchOptions = {
         limit: limit + 1,
         // +1 to exclude the source memory itself
         distance: 1 - minSimilarity,
         // Convert similarity to distance
         returnMetadata: ["distance"]
-      });
+      };
+      if (deletedFilter) {
+        searchOptions.filters = deletedFilter;
+      }
+      results = await collection.query.nearObject(args.memory_id, searchOptions);
       results.objects = results.objects.filter((obj) => obj.uuid !== args.memory_id);
     } else {
-      results = await collection.query.nearText(args.text, {
+      const searchOptions = {
         limit,
         distance: 1 - minSimilarity,
         returnMetadata: ["distance"]
-      });
+      };
+      if (deletedFilter) {
+        searchOptions.filters = deletedFilter;
+      }
+      results = await collection.query.nearText(args.text, searchOptions);
     }
     if (!args.include_relationships) {
       results.objects = results.objects.filter(
@@ -2547,6 +2868,12 @@ var queryMemoryTool = {
         description: 'Output format: "detailed" (full objects) or "compact" (text summary). Default: detailed',
         enum: ["detailed", "compact"],
         default: "detailed"
+      },
+      deleted_filter: {
+        type: "string",
+        enum: ["exclude", "include", "only"],
+        default: "exclude",
+        description: 'Filter deleted memories: "exclude" (default, hide deleted), "include" (show all), "only" (show only deleted)'
       }
     },
     required: ["query"]
@@ -2563,15 +2890,17 @@ async function handleQueryMemory(args, userId) {
     const minRelevance = args.min_relevance ?? 0.6;
     const includeContext = args.include_context ?? true;
     const format = args.format ?? "detailed";
-    const filters = buildCombinedSearchFilters(collection, args.filters);
+    const deletedFilter = buildDeletedFilter(collection, args.deleted_filter || "exclude");
+    const searchFilters = buildCombinedSearchFilters(collection, args.filters);
+    const combinedFilters = combineFiltersWithAnd([deletedFilter, searchFilters].filter((f) => f !== null));
     const searchOptions = {
       limit,
       distance: 1 - minRelevance,
       // Convert relevance to distance
       returnMetadata: ["distance"]
     };
-    if (filters) {
-      searchOptions.filters = filters;
+    if (combinedFilters) {
+      searchOptions.filters = combinedFilters;
     }
     const results = await collection.query.nearText(args.query, searchOptions);
     const relevantMemories = results.objects.map((obj) => {
@@ -2702,7 +3031,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"]
+            returnProperties: ["user_id", "doc_type", "relationships", "deleted_at"]
           });
           if (!memory) {
             logger.warn("Memory not found", { userId, memoryId });
@@ -2724,6 +3053,15 @@ async function handleCreateRelationship(args, userId, context) {
             });
             return { memoryId, error: "Cannot create relationship with non-memory document" };
           }
+          if (memory.properties.deleted_at) {
+            const deletedAt = typeof memory.properties.deleted_at === "string" ? memory.properties.deleted_at : new Date(memory.properties.deleted_at).toISOString();
+            logger.warn("Attempt to create relationship with deleted memory", {
+              userId,
+              memoryId,
+              deletedAt
+            });
+            return { memoryId, error: `Memory is deleted (deleted on ${deletedAt})` };
+          }
           return {
             memoryId,
             memory,
@@ -2970,7 +3308,7 @@ async function handleUpdateRelationship(args, userId) {
 }
 
 // src/tools/search-relationship.ts
-import { Filters as Filters2 } from "weaviate-client";
+import { Filters as Filters3 } from "weaviate-client";
 init_logger();
 var searchRelationshipTool = {
   name: "remember_search_relationship",
@@ -3024,6 +3362,12 @@ var searchRelationshipTool = {
         type: "number",
         description: "Offset for pagination (default: 0)",
         minimum: 0
+      },
+      deleted_filter: {
+        type: "string",
+        enum: ["exclude", "include", "only"],
+        default: "exclude",
+        description: 'Filter deleted memories: "exclude" (default, hide deleted), "include" (show all), "only" (show only deleted)'
       }
     },
     required: ["query"]
@@ -3039,7 +3383,11 @@ async function handleSearchRelationship(args, userId) {
     const collection = getMemoryCollection(userId);
     const limit = args.limit ?? 10;
     const offset = args.offset ?? 0;
+    const deletedFilter = buildDeletedFilter(collection, args.deleted_filter || "exclude");
     const filterList = [];
+    if (deletedFilter) {
+      filterList.push(deletedFilter);
+    }
     filterList.push(
       collection.filter.byProperty("doc_type").equal("relationship")
     );
@@ -3052,7 +3400,7 @@ async function handleSearchRelationship(args, userId) {
         const typeFilters = args.relationship_types.map(
           (type) => collection.filter.byProperty("relationship_type").equal(type)
         );
-        filterList.push(Filters2.or(...typeFilters));
+        filterList.push(Filters3.or(...typeFilters));
       }
     }
     if (args.strength_min !== void 0) {
@@ -3070,7 +3418,7 @@ async function handleSearchRelationship(args, userId) {
         collection.filter.byProperty("tags").containsAny(args.tags)
       );
     }
-    const combinedFilters = filterList.length > 1 ? Filters2.and(...filterList) : filterList[0];
+    const combinedFilters = combineFiltersWithAnd(filterList);
     const searchOptions = {
       alpha: 1,
       // Pure semantic search for relationships
@@ -3540,369 +3888,137 @@ Common examples:
     type: "object",
     properties: {
       preferences: {
-        ...getPreferencesSchema(),
-        description: "Partial preferences object with fields to update"
-      }
-    },
-    required: ["preferences"]
-  }
-};
-function formatPreferenceChangeMessage(updates) {
-  const changes = [];
-  if (updates.templates) {
-    if (updates.templates.auto_suggest !== void 0) {
-      changes.push(
-        updates.templates.auto_suggest ? "Template suggestions enabled" : "Template suggestions disabled"
-      );
-    }
-    if (updates.templates.suppressed_categories) {
-      changes.push(`Suppressed categories: ${updates.templates.suppressed_categories.join(", ")}`);
-    }
-  }
-  if (updates.search) {
-    if (updates.search.default_limit !== void 0) {
-      changes.push(`Search limit set to ${updates.search.default_limit}`);
-    }
-    if (updates.search.default_alpha !== void 0) {
-      changes.push(`Search alpha set to ${updates.search.default_alpha}`);
-    }
-  }
-  if (updates.privacy) {
-    if (updates.privacy.default_trust_level !== void 0) {
-      changes.push(`Default trust level set to ${updates.privacy.default_trust_level}`);
-    }
-  }
-  if (updates.location) {
-    if (updates.location.auto_capture !== void 0) {
-      changes.push(
-        updates.location.auto_capture ? "Location auto-capture enabled" : "Location auto-capture disabled"
-      );
-    }
-  }
-  if (changes.length === 0) {
-    return "Preferences updated successfully";
-  }
-  return `Preferences updated: ${changes.join(", ")}`;
-}
-async function handleSetPreference(args, userId) {
-  try {
-    const { preferences } = args;
-    logger.info("Setting preferences", { userId, updates: Object.keys(preferences) });
-    const updatedPreferences = await PreferencesDatabaseService.updatePreferences(
-      userId,
-      preferences
-    );
-    const message = formatPreferenceChangeMessage(preferences);
-    const result = {
-      success: true,
-      updated_preferences: updatedPreferences,
-      message
-    };
-    logger.info("Preferences set successfully", { userId });
-    return JSON.stringify(result, null, 2);
-  } catch (error) {
-    handleToolError(error, {
-      toolName: "remember_set_preference",
-      operation: "set preference",
-      userId,
-      preferencesProvided: Object.keys(args.preferences || {}).length
-    });
-  }
-}
-
-// src/tools/get-preferences.ts
-init_logger();
-var getPreferencesTool = {
-  name: "remember_get_preferences",
-  description: `Get current user preferences.
-
-Use this to understand user's current settings before suggesting changes
-or to explain why system is behaving a certain way.
-
-Returns the complete preferences object or filtered by category.
-If preferences don't exist, returns defaults.
-
-${getPreferenceDescription()}
-`,
-  inputSchema: {
-    type: "object",
-    properties: {
-      category: {
-        type: "string",
-        enum: ["templates", "search", "location", "privacy", "notifications", "display"],
-        description: "Optional category to filter preferences"
-      }
-    }
-  }
-};
-async function handleGetPreferences(args, userId) {
-  try {
-    const { category } = args;
-    logger.info("Getting preferences", { userId, category });
-    const preferences = await PreferencesDatabaseService.getPreferences(userId);
-    const isDefault = !preferences.created_at || preferences.created_at === preferences.updated_at;
-    let result;
-    let message;
-    if (category) {
-      if (!PREFERENCE_CATEGORIES.includes(category)) {
-        throw new Error(`Invalid category: ${category}. Valid categories: ${PREFERENCE_CATEGORIES.join(", ")}`);
-      }
-      result = {
-        [category]: preferences[category]
-      };
-      message = isDefault ? `Showing default ${category} preferences (user has not customized preferences yet).` : `Showing current ${category} preferences.`;
-    } else {
-      result = preferences;
-      message = isDefault ? "Showing default preferences (user has not customized preferences yet)." : "Showing current user preferences.";
-    }
-    const response = {
-      preferences: result,
-      is_default: isDefault,
-      message
-    };
-    logger.info("Preferences retrieved successfully", { userId, category, isDefault });
-    return JSON.stringify(response, null, 2);
-  } catch (error) {
-    handleToolError(error, {
-      toolName: "remember_get_preferences",
-      operation: "get preferences",
-      userId,
-      category: args.category
-    });
-  }
-}
-
-// src/services/confirmation-token.service.ts
-import { randomUUID } from "crypto";
-init_logger();
-var ConfirmationTokenService = class {
-  EXPIRY_MINUTES = 5;
-  /**
-   * Create a new confirmation request
-   * 
-   * @param userId - User ID who initiated the request
-   * @param action - Action type (e.g., 'publish_memory')
-   * @param payload - Data to store with the request
-   * @param targetCollection - Optional target collection (e.g., 'the_void')
-   * @returns Request ID and token
-   */
-  async createRequest(userId, action, payload, targetCollection) {
-    try {
-      const token = randomUUID();
-      const now = /* @__PURE__ */ new Date();
-      const expiresAt = new Date(now.getTime() + this.EXPIRY_MINUTES * 60 * 1e3);
-      const request = {
-        user_id: userId,
-        token,
-        action,
-        target_collection: targetCollection,
-        payload,
-        created_at: now.toISOString(),
-        expires_at: expiresAt.toISOString(),
-        status: "pending"
-      };
-      const collectionPath = `users/${userId}/requests`;
-      logger.info("Creating confirmation request", {
-        service: "ConfirmationTokenService",
-        userId,
-        action,
-        targetCollection,
-        collectionPath,
-        payloadKeys: Object.keys(payload)
-      });
-      logger.debug("Calling Firestore addDocument", {
-        service: "ConfirmationTokenService",
-        collectionPath
-      });
-      const docRef = await addDocument(collectionPath, request);
-      logger.debug("Firestore addDocument returned", {
-        service: "ConfirmationTokenService",
-        hasDocRef: !!docRef,
-        hasId: !!docRef?.id,
-        docRefId: docRef?.id
-      });
-      if (!docRef) {
-        const error = new Error("Firestore addDocument returned null/undefined");
-        logger.error("CRITICAL: addDocument returned null", {
-          service: "ConfirmationTokenService",
-          userId,
-          collectionPath
-        });
-        throw error;
-      }
-      if (!docRef.id) {
-        const error = new Error("Firestore addDocument returned docRef without ID");
-        logger.error("CRITICAL: docRef has no ID", {
-          service: "ConfirmationTokenService",
-          userId,
-          collectionPath,
-          docRef
-        });
-        throw error;
-      }
-      logger.info("Confirmation request created successfully", {
-        service: "ConfirmationTokenService",
-        requestId: docRef.id,
-        token,
-        expiresAt: request.expires_at
-      });
-      return { requestId: docRef.id, token };
-    } catch (error) {
-      logger.error("Failed to create confirmation request", {
-        service: "ConfirmationTokenService",
-        error: error instanceof Error ? error.message : String(error),
-        stack: error instanceof Error ? error.stack : void 0,
-        userId,
-        action,
-        collectionPath: `users/${userId}/requests`
-      });
-      throw error;
-    }
-  }
-  /**
-   * Validate and retrieve a confirmation request
-   * 
-   * @param userId - User ID
-   * @param token - Confirmation token
-   * @returns Request with request_id if valid, null otherwise
-   */
-  async validateToken(userId, token) {
-    const collectionPath = `users/${userId}/requests`;
-    logger.debug("Validating confirmation token", {
-      service: "ConfirmationTokenService",
-      userId,
-      token,
-      collectionPath
-    });
-    const queryOptions = {
-      where: [
-        { field: "token", op: "==", value: token },
-        { field: "status", op: "==", value: "pending" }
-      ],
-      limit: 1
-    };
-    const results = await queryDocuments(collectionPath, queryOptions);
-    logger.debug("Token query results", {
-      service: "ConfirmationTokenService",
-      resultsFound: results.length,
-      hasResults: results.length > 0
-    });
-    if (results.length === 0) {
-      logger.info("Token not found or not pending", {
-        service: "ConfirmationTokenService",
-        userId
-      });
-      return null;
+        ...getPreferencesSchema(),
+        description: "Partial preferences object with fields to update"
+      }
+    },
+    required: ["preferences"]
+  }
+};
+function formatPreferenceChangeMessage(updates) {
+  const changes = [];
+  if (updates.templates) {
+    if (updates.templates.auto_suggest !== void 0) {
+      changes.push(
+        updates.templates.auto_suggest ? "Template suggestions enabled" : "Template suggestions disabled"
+      );
     }
-    const doc = results[0];
-    const request = doc.data;
-    logger.info("Confirmation request found", {
-      service: "ConfirmationTokenService",
-      requestId: doc.id,
-      action: request.action,
-      status: request.status,
-      expiresAt: request.expires_at
-    });
-    const expiresAt = new Date(request.expires_at);
-    if (expiresAt.getTime() < Date.now()) {
-      logger.info("Token expired", {
-        service: "ConfirmationTokenService",
-        requestId: doc.id,
-        expiresAt: request.expires_at
-      });
-      await this.updateStatus(userId, doc.id, "expired");
-      return null;
+    if (updates.templates.suppressed_categories) {
+      changes.push(`Suppressed categories: ${updates.templates.suppressed_categories.join(", ")}`);
     }
-    return {
-      ...request,
-      request_id: doc.id
-    };
   }
-  /**
-   * Confirm a request
-   * 
-   * @param userId - User ID
-   * @param token - Confirmation token
-   * @returns Confirmed request if valid, null otherwise
-   */
-  async confirmRequest(userId, token) {
-    const request = await this.validateToken(userId, token);
-    if (!request) {
-      return null;
+  if (updates.search) {
+    if (updates.search.default_limit !== void 0) {
+      changes.push(`Search limit set to ${updates.search.default_limit}`);
+    }
+    if (updates.search.default_alpha !== void 0) {
+      changes.push(`Search alpha set to ${updates.search.default_alpha}`);
     }
-    await this.updateStatus(userId, request.request_id, "confirmed");
-    return {
-      ...request,
-      status: "confirmed",
-      confirmed_at: (/* @__PURE__ */ new Date()).toISOString()
-    };
   }
-  /**
-   * Deny a request
-   * 
-   * @param userId - User ID
-   * @param token - Confirmation token
-   * @returns True if denied successfully, false otherwise
-   */
-  async denyRequest(userId, token) {
-    const request = await this.validateToken(userId, token);
-    if (!request) {
-      return false;
+  if (updates.privacy) {
+    if (updates.privacy.default_trust_level !== void 0) {
+      changes.push(`Default trust level set to ${updates.privacy.default_trust_level}`);
     }
-    await this.updateStatus(userId, request.request_id, "denied");
-    return true;
   }
-  /**
-   * Retract a request
-   * 
-   * @param userId - User ID
-   * @param token - Confirmation token
-   * @returns True if retracted successfully, false otherwise
-   */
-  async retractRequest(userId, token) {
-    const request = await this.validateToken(userId, token);
-    if (!request) {
-      return false;
+  if (updates.location) {
+    if (updates.location.auto_capture !== void 0) {
+      changes.push(
+        updates.location.auto_capture ? "Location auto-capture enabled" : "Location auto-capture disabled"
+      );
     }
-    await this.updateStatus(userId, request.request_id, "retracted");
-    return true;
   }
-  /**
-   * Update request status
-   * 
-   * @param userId - User ID
-   * @param requestId - Request document ID
-   * @param status - New status
-   */
-  async updateStatus(userId, requestId, status) {
-    const collectionPath = `users/${userId}/requests`;
-    const updateData = {
-      status
+  if (changes.length === 0) {
+    return "Preferences updated successfully";
+  }
+  return `Preferences updated: ${changes.join(", ")}`;
+}
+async function handleSetPreference(args, userId) {
+  try {
+    const { preferences } = args;
+    logger.info("Setting preferences", { userId, updates: Object.keys(preferences) });
+    const updatedPreferences = await PreferencesDatabaseService.updatePreferences(
+      userId,
+      preferences
+    );
+    const message = formatPreferenceChangeMessage(preferences);
+    const result = {
+      success: true,
+      updated_preferences: updatedPreferences,
+      message
     };
-    if (status === "confirmed") {
-      updateData.confirmed_at = (/* @__PURE__ */ new Date()).toISOString();
+    logger.info("Preferences set successfully", { userId });
+    return JSON.stringify(result, null, 2);
+  } catch (error) {
+    handleToolError(error, {
+      toolName: "remember_set_preference",
+      operation: "set preference",
+      userId,
+      preferencesProvided: Object.keys(args.preferences || {}).length
+    });
+  }
+}
+
+// src/tools/get-preferences.ts
+init_logger();
+var getPreferencesTool = {
+  name: "remember_get_preferences",
+  description: `Get current user preferences.
+
+Use this to understand user's current settings before suggesting changes
+or to explain why system is behaving a certain way.
+
+Returns the complete preferences object or filtered by category.
+If preferences don't exist, returns defaults.
+
+${getPreferenceDescription()}
+`,
+  inputSchema: {
+    type: "object",
+    properties: {
+      category: {
+        type: "string",
+        enum: ["templates", "search", "location", "privacy", "notifications", "display"],
+        description: "Optional category to filter preferences"
+      }
     }
-    await updateDocument(collectionPath, requestId, updateData);
   }
-  /**
-   * Clean up expired requests (optional - Firestore TTL handles deletion)
-   * 
-   * Note: Configure Firestore TTL policy on 'requests' collection group
-   * with 'expires_at' field for automatic deletion within 24 hours.
-   * 
-   * This method is optional for immediate cleanup if needed.
-   * 
-   * @returns Count of deleted requests
-   */
-  async cleanupExpired() {
-    logger.warn("cleanupExpired not implemented - relying on Firestore TTL", {
-      service: "ConfirmationTokenService",
-      note: "Configure Firestore TTL policy on requests collection group"
+};
+async function handleGetPreferences(args, userId) {
+  try {
+    const { category } = args;
+    logger.info("Getting preferences", { userId, category });
+    const preferences = await PreferencesDatabaseService.getPreferences(userId);
+    const isDefault = !preferences.created_at || preferences.created_at === preferences.updated_at;
+    let result;
+    let message;
+    if (category) {
+      if (!PREFERENCE_CATEGORIES.includes(category)) {
+        throw new Error(`Invalid category: ${category}. Valid categories: ${PREFERENCE_CATEGORIES.join(", ")}`);
+      }
+      result = {
+        [category]: preferences[category]
+      };
+      message = isDefault ? `Showing default ${category} preferences (user has not customized preferences yet).` : `Showing current ${category} preferences.`;
+    } else {
+      result = preferences;
+      message = isDefault ? "Showing default preferences (user has not customized preferences yet)." : "Showing current user preferences.";
+    }
+    const response = {
+      preferences: result,
+      is_default: isDefault,
+      message
+    };
+    logger.info("Preferences retrieved successfully", { userId, category, isDefault });
+    return JSON.stringify(response, null, 2);
+  } catch (error) {
+    handleToolError(error, {
+      toolName: "remember_get_preferences",
+      operation: "get preferences",
+      userId,
+      category: args.category
     });
-    return 0;
   }
-};
-var confirmationTokenService = new ConfirmationTokenService();
+}
 
 // src/weaviate/space-schema.ts
 init_space_memory();
@@ -3944,11 +4060,6 @@ async function createSpaceCollection(client2, spaceId) {
         dataType: "text[]",
         description: 'Spaces this memory is published to (e.g., ["the_void", "dogs"])'
       },
-      {
-        name: "space_id",
-        dataType: "text",
-        description: "DEPRECATED: Use spaces array instead. Will be removed in v3.0.0."
-      },
       {
         name: "author_id",
         dataType: "text",
@@ -4173,6 +4284,22 @@ async function createSpaceCollection(client2, spaceId) {
         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"
       }
     ]
   });
@@ -4472,6 +4599,9 @@ async function handleConfirm(args, userId) {
     if (request.action === "publish_memory") {
       return await executePublishMemory(request, userId);
     }
+    if (request.action === "delete_memory") {
+      return await executeDeleteMemory(request, userId);
+    }
     throw new Error(`Unknown action type: ${request.action}`);
   } catch (error) {
     debug.error("Tool failed", {
@@ -4684,6 +4814,52 @@ async function executePublishMemory(request, userId) {
     });
   }
 }
+async function executeDeleteMemory(request, userId) {
+  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 collection = client2.collections.get(collectionName);
+    await collection.data.update({
+      id: memory_id,
+      properties: {
+        deleted_at: (/* @__PURE__ */ new Date()).toISOString(),
+        deleted_by: userId,
+        deletion_reason: reason || null
+      }
+    });
+    logger.info("Memory soft-deleted successfully", {
+      function: "executeDeleteMemory",
+      userId,
+      memoryId: memory_id,
+      deletedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return JSON.stringify(
+      {
+        success: true,
+        memory_id,
+        message: "Memory deleted successfully"
+      },
+      null,
+      2
+    );
+  } catch (error) {
+    logger.error("Failed to execute delete memory", {
+      function: "executeDeleteMemory",
+      userId,
+      memoryId: request.payload.memory_id,
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : void 0
+    });
+    throw error;
+  }
+}
 
 // src/tools/deny.ts
 var denyTool = {
@@ -4742,7 +4918,7 @@ async function handleDeny(args, userId) {
 }
 
 // src/tools/search-space.ts
-import { Filters as Filters3 } from "weaviate-client";
+import { Filters as Filters4 } from "weaviate-client";
 init_space_memory();
 var searchSpaceTool = {
   name: "remember_search_space",
@@ -4885,7 +5061,7 @@ async function handleSearchSpace(args, userId) {
     if (args.date_to) {
       filterList.push(publicCollection.filter.byProperty("created_at").lessOrEqual(new Date(args.date_to)));
     }
-    const whereFilter = filterList.length > 0 ? Filters3.and(...filterList) : void 0;
+    const whereFilter = filterList.length > 0 ? Filters4.and(...filterList) : void 0;
     debug.debug("Executing hybrid search", {
       query: args.query,
       filterCount: filterList.length,
@@ -4935,7 +5111,7 @@ async function handleSearchSpace(args, userId) {
 }
 
 // src/tools/query-space.ts
-import { Filters as Filters4 } from "weaviate-client";
+import { Filters as Filters5 } from "weaviate-client";
 init_space_memory();
 var querySpaceTool = {
   name: "remember_query_space",
@@ -5065,7 +5241,7 @@ async function handleQuerySpace(args, userId) {
     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;
+    const whereFilter = filterList.length > 0 ? Filters5.and(...filterList) : void 0;
     debug.debug("Executing semantic query", {
       question: args.question,
       filterCount: filterList.length,