@prmichaelsen/remember-mcp 2.7.11 → 3.0.0

package/dist/server.js

@@ -479,12 +479,36 @@ function validateConfig() {
     });
   });
 }
-var import_dotenv, config;
+var import_dotenv, debugConfig, config;
 var init_config = __esm({
   "src/config.ts"() {
     "use strict";
     import_dotenv = __toESM(require_main(), 1);
     import_dotenv.default.config();
+    debugConfig = {
+      level: (() => {
+        const level = process.env.REMEMBER_MCP_DEBUG_LEVEL?.toUpperCase();
+        switch (level) {
+          case "TRACE":
+            return 5 /* TRACE */;
+          case "DEBUG":
+            return 4 /* DEBUG */;
+          case "INFO":
+            return 3 /* INFO */;
+          case "WARN":
+            return 2 /* WARN */;
+          case "ERROR":
+            return 1 /* ERROR */;
+          case "NONE":
+            return 0 /* NONE */;
+          default:
+            return 0 /* NONE */;
+        }
+      })(),
+      enabled: (level) => {
+        return debugConfig.level >= level;
+      }
+    };
     config = {
       // Weaviate
       weaviate: {
@@ -538,6 +562,103 @@ import {
 init_config();
 init_logger();
 import weaviate from "weaviate-client";
+
+// src/utils/debug.ts
+init_config();
+init_logger();
+var DebugLogger = class {
+  context;
+  constructor(context) {
+    this.context = context;
+  }
+  trace(message, data) {
+    if (debugConfig.enabled(5 /* TRACE */)) {
+      logger.debug(`[TRACE] ${message}`, {
+        ...this.context,
+        ...data,
+        debugLevel: "TRACE"
+      });
+    }
+  }
+  debug(message, data) {
+    if (debugConfig.enabled(4 /* DEBUG */)) {
+      logger.debug(`[DEBUG] ${message}`, {
+        ...this.context,
+        ...data,
+        debugLevel: "DEBUG"
+      });
+    }
+  }
+  info(message, data) {
+    if (debugConfig.enabled(3 /* INFO */)) {
+      logger.info(`[INFO] ${message}`, {
+        ...this.context,
+        ...data,
+        debugLevel: "INFO"
+      });
+    }
+  }
+  warn(message, data) {
+    if (debugConfig.enabled(2 /* WARN */)) {
+      logger.warn(`[WARN] ${message}`, {
+        ...this.context,
+        ...data,
+        debugLevel: "WARN"
+      });
+    }
+  }
+  error(message, data) {
+    if (debugConfig.enabled(1 /* ERROR */)) {
+      logger.error(`[ERROR] ${message}`, {
+        ...this.context,
+        ...data,
+        debugLevel: "ERROR"
+      });
+    }
+  }
+  /**
+   * Dump full object (TRACE only)
+   * Use with caution - may expose sensitive data
+   */
+  dump(label, obj) {
+    if (debugConfig.enabled(5 /* TRACE */)) {
+      logger.debug(`[DUMP] ${label}`, {
+        ...this.context,
+        dump: JSON.stringify(obj, null, 2),
+        debugLevel: "TRACE"
+      });
+    }
+  }
+  /**
+   * Time an async operation (DEBUG and above)
+   * Logs start, completion, and duration
+   */
+  async time(label, fn) {
+    if (!debugConfig.enabled(4 /* DEBUG */)) {
+      return fn();
+    }
+    const start = Date.now();
+    this.debug(`${label} - Starting`);
+    try {
+      const result = await fn();
+      const duration = Date.now() - start;
+      this.debug(`${label} - Completed`, { durationMs: duration });
+      return result;
+    } catch (error) {
+      const duration = Date.now() - start;
+      this.error(`${label} - Failed`, {
+        durationMs: duration,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+};
+function createDebugLogger(context) {
+  return new DebugLogger(context);
+}
+
+// src/weaviate/client.ts
 var client = null;
 async function initWeaviateClient() {
   if (client) {
@@ -660,20 +781,56 @@ var ALL_MEMORY_PROPERTIES = [
   // Comment/threading fields
   "parent_id",
   "thread_root_id",
-  "moderation_flags"
+  "moderation_flags",
+  // Space/publishing fields (for Memory_public collection)
+  "spaces",
+  "space_id",
+  "author_id",
+  "ghost_id",
+  "attribution",
+  "published_at",
+  "discovery_count",
+  "space_memory_id",
+  // Soft delete fields
+  "deleted_at",
+  "deleted_by",
+  "deletion_reason"
 ];
 async function fetchMemoryWithAllProperties(collection, memoryId) {
+  const debug = createDebugLogger({
+    tool: "weaviate-client",
+    operation: "fetchMemoryWithAllProperties"
+  });
+  debug.debug("Fetching memory", {
+    memoryId,
+    collectionName: collection.name,
+    propertyCount: ALL_MEMORY_PROPERTIES.length
+  });
   try {
-    return await collection.query.fetchObjectById(memoryId, {
-      returnProperties: ALL_MEMORY_PROPERTIES
+    const result = await debug.time("Fetch with all properties", async () => {
+      return await collection.query.fetchObjectById(memoryId, {
+        returnProperties: ALL_MEMORY_PROPERTIES
+      });
+    });
+    debug.trace("Fetch result", {
+      found: !!result,
+      propertyCount: result?.properties ? Object.keys(result.properties).length : 0,
+      hasSpaces: !!result?.properties?.spaces,
+      hasAuthorId: !!result?.properties?.author_id
     });
+    return result;
   } catch (error) {
+    debug.warn("Fetch with all properties failed, falling back", {
+      error: error instanceof Error ? error.message : String(error)
+    });
     logger.warn("Failed to fetch with all properties, falling back to unspecified fetch", {
       module: "weaviate-client",
       memoryId,
       error: error instanceof Error ? error.message : String(error)
     });
-    return await collection.query.fetchObjectById(memoryId);
+    return await debug.time("Fetch without property specification", async () => {
+      return await collection.query.fetchObjectById(memoryId);
+    });
   }
 }
 
@@ -975,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"
       }
     ]
   });
@@ -1678,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 = {
@@ -1778,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"]
@@ -1798,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);
@@ -1854,95 +2044,360 @@ 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).
+  /**
+   * 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"
@@ -2037,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) {
@@ -2204,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)'
       }
     }
   }
@@ -2220,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, {
@@ -2234,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(
@@ -2394,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"]
@@ -2410,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) => {
@@ -2549,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 });
@@ -2571,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,
@@ -2817,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",
@@ -2871,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"]
@@ -2886,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")
     );
@@ -2899,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) {
@@ -2917,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
@@ -3519,238 +4020,6 @@ async function handleGetPreferences(args, userId) {
   }
 }
 
-// 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;
-    }
-    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
-    };
-  }
-  /**
-   * 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/weaviate/space-schema.ts
 init_space_memory();
 init_logger();
@@ -3791,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",
@@ -4020,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"
       }
     ]
   });
@@ -4073,7 +4353,14 @@ var publishTool = {
   }
 };
 async function handlePublish(args, userId) {
+  const debug = createDebugLogger({
+    tool: "remember_publish",
+    userId,
+    operation: "publish_request"
+  });
   try {
+    debug.info("Tool invoked");
+    debug.trace("Arguments", { args });
     logger.info("Starting publish request", {
       tool: "remember_publish",
       userId,
@@ -4082,8 +4369,10 @@ async function handlePublish(args, userId) {
       spaceCount: args.spaces.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,
@@ -4127,7 +4416,9 @@ async function handlePublish(args, userId) {
       memoryId: args.memory_id
     });
     const userCollection = weaviateClient.collections.get(collectionName);
-    const memory = await fetchMemoryWithAllProperties(userCollection, args.memory_id);
+    const memory = await debug.time("Fetch memory from user collection", async () => {
+      return await fetchMemoryWithAllProperties(userCollection, args.memory_id);
+    });
     logger.debug("Memory fetch result", {
       tool: "remember_publish",
       found: !!memory,
@@ -4222,6 +4513,10 @@ async function handlePublish(args, userId) {
       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_publish",
       userId,
@@ -4259,13 +4554,23 @@ Violating these requirements bypasses user consent and is a security violation.`
   }
 };
 async function handleConfirm(args, userId) {
+  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
     });
-    const request = await confirmationTokenService.confirmRequest(userId, 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,
@@ -4294,8 +4599,15 @@ 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", {
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : void 0
+    });
     handleToolError(error, {
       toolName: "remember_confirm",
       userId,
@@ -4305,7 +4617,16 @@ async function handleConfirm(args, userId) {
   }
 }
 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,
@@ -4322,10 +4643,12 @@ async function executePublishMemory(request, userId) {
       collectionName: getMemoryCollectionName(userId),
       memoryId: request.payload.memory_id
     });
-    const originalMemory = await fetchMemoryWithAllProperties(
-      userCollection,
-      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,
@@ -4435,14 +4758,20 @@ async function executePublishMemory(request, userId) {
       contentLength: publishedMemory.content?.length || 0,
       titleValue: publishedMemory.title || "NO_TITLE"
     });
-    const result = await publicCollection.data.insert({
-      properties: publishedMemory
+    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
+    });
     try {
       await userCollection.data.update({
         id: request.payload.memory_id,
@@ -4473,6 +4802,10 @@ async function executePublishMemory(request, userId) {
       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,
@@ -4481,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 = {
@@ -4539,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",
@@ -4617,7 +4996,15 @@ Let the search algorithm find ALL relevant memories regardless of type unless ex
   }
 };
 async function handleSearchSpace(args, userId) {
+  const debug = createDebugLogger({
+    tool: "remember_search_space",
+    userId,
+    operation: "search_spaces"
+  });
   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(
@@ -4674,11 +5061,22 @@ 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 searchResults = await publicCollection.query.hybrid(args.query, {
+    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,
-      ...whereFilter && { where: whereFilter }
+      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 }
+      });
+    });
+    debug.debug("Search completed", {
+      resultCount: searchResults.objects.length
     });
     const memories = searchResults.objects.map((obj) => ({
       id: obj.uuid,
@@ -4693,8 +5091,16 @@ async function handleSearchSpace(args, userId) {
       offset: args.offset || 0,
       limit: args.limit || 10
     };
+    debug.info("Tool completed successfully", {
+      resultCount: memories.length,
+      spaces: args.spaces
+    });
     return JSON.stringify(result, 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_search_space",
       operation: "search spaces",
@@ -4705,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",
@@ -4778,7 +5184,15 @@ Let the query algorithm find ALL relevant memories regardless of type unless exp
   }
 };
 async function handleQuerySpace(args, userId) {
+  const debug = createDebugLogger({
+    tool: "remember_query_space",
+    userId,
+    operation: "query_spaces"
+  });
   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(
@@ -4827,10 +5241,21 @@ 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 searchResults = await publicCollection.query.nearText(args.question, {
-      limit: args.limit || 10,
-      ...whereFilter && { where: whereFilter }
+    const whereFilter = filterList.length > 0 ? Filters5.and(...filterList) : void 0;
+    debug.debug("Executing semantic query", {
+      question: args.question,
+      filterCount: filterList.length,
+      limit: args.limit || 10
+    });
+    const searchResults = await debug.time("Semantic query", async () => {
+      return await publicCollection.query.nearText(args.question, {
+        limit: args.limit || 10,
+        ...whereFilter && { where: whereFilter }
+      });
+    });
+    debug.debug("Query completed", {
+      resultCount: searchResults.objects.length,
+      format: args.format || "detailed"
     });
     const format = args.format || "detailed";
     if (format === "compact") {
@@ -4859,9 +5284,17 @@ async function handleQuerySpace(args, userId) {
         memories,
         total: memories.length
       };
+      debug.info("Tool completed successfully", {
+        resultCount: memories.length,
+        format: "detailed"
+      });
       return JSON.stringify(result, 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_query_space",
       operation: "query spaces",